diff --git a/compiled/facebook-www/REVISION b/compiled/facebook-www/REVISION
index 219cda440ac83..cb5c649f6e87e 100644
--- a/compiled/facebook-www/REVISION
+++ b/compiled/facebook-www/REVISION
@@ -1 +1 @@
-d310d654a7c7aab6c8213da84ef36dfba82711b0
+cfc1274e3be5a93a4c93f8fb87f2109993afe1dd
diff --git a/compiled/facebook-www/React-dev.modern.js b/compiled/facebook-www/React-dev.modern.js
index 6b5154eef5b4b..7446ca9d7e3a2 100644
--- a/compiled/facebook-www/React-dev.modern.js
+++ b/compiled/facebook-www/React-dev.modern.js
@@ -27,7 +27,7 @@ if (
 }
           "use strict";
 
-var ReactVersion = "18.3.0-www-modern-9bafe2f6";
+var ReactVersion = "18.3.0-www-modern-addde25e";
 
 // ATTENTION
 // When adding new symbols to this file,
diff --git a/compiled/facebook-www/ReactART-dev.classic.js b/compiled/facebook-www/ReactART-dev.classic.js
index f5da1f8b17577..6ac85abd1cdc7 100644
--- a/compiled/facebook-www/ReactART-dev.classic.js
+++ b/compiled/facebook-www/ReactART-dev.classic.js
@@ -69,7 +69,7 @@ function _assertThisInitialized(self) {
   return self;
 }
 
-var ReactVersion = "18.3.0-www-classic-d10ee72f";
+var ReactVersion = "18.3.0-www-classic-773bb029";
 
 var LegacyRoot = 0;
 var ConcurrentRoot = 1;
diff --git a/compiled/facebook-www/ReactART-prod.modern.js b/compiled/facebook-www/ReactART-prod.modern.js
index 73465e7309f95..dbeb8785b1d29 100644
--- a/compiled/facebook-www/ReactART-prod.modern.js
+++ b/compiled/facebook-www/ReactART-prod.modern.js
@@ -9555,7 +9555,7 @@ var slice = Array.prototype.slice,
       return null;
     },
     bundleType: 0,
-    version: "18.3.0-www-modern-ce2970c7",
+    version: "18.3.0-www-modern-990522b1",
     rendererPackageName: "react-art"
   };
 var internals$jscomp$inline_1283 = {
@@ -9586,7 +9586,7 @@ var internals$jscomp$inline_1283 = {
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-modern-ce2970c7"
+  reconcilerVersion: "18.3.0-www-modern-990522b1"
 };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
   var hook$jscomp$inline_1284 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
diff --git a/compiled/facebook-www/ReactDOM-dev.classic.js b/compiled/facebook-www/ReactDOM-dev.classic.js
index 9f6d6acd56338..139223ff5502c 100644
--- a/compiled/facebook-www/ReactDOM-dev.classic.js
+++ b/compiled/facebook-www/ReactDOM-dev.classic.js
@@ -37,6 +37,7 @@ var dynamicFeatureFlags = require("ReactFeatureFlags");
 
 var disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   replayFailedUnitOfWorkWithInvokeGuardedCallback =
@@ -5412,7 +5413,8 @@ var canDiffStyleForHydrationWarning;
   // in that browser completely in favor of doing all that work.
   // See https://github.com/facebook/react/issues/11807
 
-  canDiffStyleForHydrationWarning = canUseDOM && !document.documentMode;
+  canDiffStyleForHydrationWarning =
+    disableIEWorkarounds || (canUseDOM && !document.documentMode);
 }
 
 function validatePropertiesInDevelopment(type, props) {
@@ -5605,7 +5607,11 @@ function setInitialDOMProperties(
       var nextHtml = nextProp ? nextProp[HTML] : undefined;
 
       if (nextHtml != null) {
-        setInnerHTML$1(domElement, nextHtml);
+        if (disableIEWorkarounds) {
+          domElement.innerHTML = nextHtml;
+        } else {
+          setInnerHTML$1(domElement, nextHtml);
+        }
       }
     } else if (propKey === CHILDREN) {
       if (typeof nextProp === "string") {
@@ -5661,7 +5667,11 @@ function updateDOMProperties(
     if (propKey === STYLE$1) {
       setValueForStyles(domElement, propValue);
     } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      setInnerHTML$1(domElement, propValue);
+      if (disableIEWorkarounds) {
+        domElement.innerHTML = propValue;
+      } else {
+        setInnerHTML$1(domElement, propValue);
+      }
     } else if (propKey === CHILDREN) {
       setTextContent(domElement, propValue);
     } else {
@@ -9028,7 +9038,7 @@ var ContinuousEventPriority = InputContinuousLane;
 var DefaultEventPriority = DefaultLane;
 var IdleEventPriority = IdleLane;
 var currentUpdatePriority = NoLane;
-function getCurrentUpdatePriority$1() {
+function getCurrentUpdatePriority() {
   return currentUpdatePriority;
 }
 function setCurrentUpdatePriority(newPriority) {
@@ -12057,7 +12067,6 @@ function isOwnedInstance(node) {
   return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
 }
 
-var restoreImpl = null;
 var restoreTarget = null;
 var restoreQueue = null;
 
@@ -12071,24 +12080,18 @@ function restoreStateOfTarget(target) {
     return;
   }
 
-  if (typeof restoreImpl !== "function") {
-    throw new Error(
-      "setRestoreImplementation() needs to be called to handle a target for controlled " +
-        "events. This error is likely caused by a bug in React. Please file an issue."
-    );
-  }
-
   var stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
 
   if (stateNode) {
     var props = getFiberCurrentPropsFromNode(stateNode);
-    restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+    restoreControlledState(
+      internalInstance.stateNode,
+      internalInstance.type,
+      props
+    );
   }
 }
 
-function setRestoreImplementation(impl) {
-  restoreImpl = impl;
-}
 function enqueueStateRestore(target) {
   if (restoreTarget) {
     if (restoreQueue) {
@@ -12121,6681 +12124,5740 @@ function restoreStateIfNeeded() {
   }
 }
 
-// the renderer. Such as when we're dispatching events or if third party
-// libraries need to call batchedUpdates. Eventually, this API will go away when
-// everything is batched by default. We'll then have a similar API to opt-out of
-// scheduled work and instead do synchronous work.
-// Defaults
+var loggedTypeFailures = {};
+var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
 
-var batchedUpdatesImpl = function (fn, bookkeeping) {
-  return fn(bookkeeping);
-};
+function setCurrentlyValidatingElement(element) {
+  {
+    if (element) {
+      var owner = element._owner;
+      var stack = describeUnknownElementTypeFrameInDEV(
+        element.type,
+        element._source,
+        owner ? owner.type : null
+      );
+      ReactDebugCurrentFrame.setExtraStackFrame(stack);
+    } else {
+      ReactDebugCurrentFrame.setExtraStackFrame(null);
+    }
+  }
+}
 
-var flushSyncImpl = function () {};
+function checkPropTypes(typeSpecs, values, location, componentName, element) {
+  {
+    // $FlowFixMe This is okay but Flow doesn't know it.
+    var has = Function.call.bind(hasOwnProperty);
 
-var isInsideEventHandler = false;
+    for (var typeSpecName in typeSpecs) {
+      if (has(typeSpecs, typeSpecName)) {
+        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
 
-function finishEventHandler() {
-  // Here we wait until all updates have propagated, which is important
-  // when using controlled components within layers:
-  // https://github.com/facebook/react/issues/1698
-  // Then we restore state of any controlled component.
-  var controlledComponentsHavePendingUpdates = needsStateRestore();
+        try {
+          // This is intentionally an invariant that gets caught. It's the same
+          // behavior as without this statement except with a better message.
+          if (typeof typeSpecs[typeSpecName] !== "function") {
+            // eslint-disable-next-line react-internal/prod-error-codes
+            var err = Error(
+              (componentName || "React class") +
+                ": " +
+                location +
+                " type `" +
+                typeSpecName +
+                "` is invalid; " +
+                "it must be a function, usually from the `prop-types` package, but received `" +
+                typeof typeSpecs[typeSpecName] +
+                "`." +
+                "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+            );
+            err.name = "Invariant Violation";
+            throw err;
+          }
 
-  if (controlledComponentsHavePendingUpdates) {
-    // If a controlled event was fired, we may need to restore the state of
-    // the DOM node back to the controlled value. This is necessary when React
-    // bails out of the update without touching the DOM.
-    // TODO: Restore state in the microtask, after the discrete updates flush,
-    // instead of early flushing them here.
-    flushSyncImpl();
-    restoreStateIfNeeded();
-  }
-}
+          error$1 = typeSpecs[typeSpecName](
+            values,
+            typeSpecName,
+            componentName,
+            location,
+            null,
+            "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
+          );
+        } catch (ex) {
+          error$1 = ex;
+        }
 
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) {
-    // If we are currently inside another batch, we need to wait until it
-    // fully completes before restoring state.
-    return fn(a, b);
-  }
+        if (error$1 && !(error$1 instanceof Error)) {
+          setCurrentlyValidatingElement(element);
 
-  isInsideEventHandler = true;
+          error(
+            "%s: type specification of %s" +
+              " `%s` is invalid; the type checker " +
+              "function must return `null` or an `Error` but returned a %s. " +
+              "You may have forgotten to pass an argument to the type checker " +
+              "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
+              "shape all require an argument).",
+            componentName || "React class",
+            location,
+            typeSpecName,
+            typeof error$1
+          );
 
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    isInsideEventHandler = false;
-    finishEventHandler();
-  }
-} // TODO: Replace with flushSync
-function setBatchingImplementation(
-  _batchedUpdatesImpl,
-  _discreteUpdatesImpl,
-  _flushSyncImpl
-) {
-  batchedUpdatesImpl = _batchedUpdatesImpl;
-  flushSyncImpl = _flushSyncImpl;
-}
+          setCurrentlyValidatingElement(null);
+        }
 
-function isInteractive(tag) {
-  return (
-    tag === "button" ||
-    tag === "input" ||
-    tag === "select" ||
-    tag === "textarea"
-  );
-}
+        if (
+          error$1 instanceof Error &&
+          !(error$1.message in loggedTypeFailures)
+        ) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error$1.message] = true;
+          setCurrentlyValidatingElement(element);
 
-function shouldPreventMouseEvent(name, type, props) {
-  switch (name) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      return !!(props.disabled && isInteractive(type));
+          error("Failed %s type: %s", location, error$1.message);
 
-    default:
-      return false;
+          setCurrentlyValidatingElement(null);
+        }
+      }
+    }
   }
 }
-/**
- * @param {object} inst The instance, which is the source of events.
- * @param {string} registrationName Name of listener (e.g. `onClick`).
- * @return {?function} The stored callback.
- */
 
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-
-  if (stateNode === null) {
-    // Work in progress (ex: onload events in incremental mode).
-    return null;
-  }
+var warnedAboutMissingGetChildContext;
 
-  var props = getFiberCurrentPropsFromNode(stateNode);
+{
+  warnedAboutMissingGetChildContext = {};
+}
 
-  if (props === null) {
-    // Work in progress.
-    return null;
-  }
+var emptyContextObject = {};
 
-  var listener = props[registrationName];
+{
+  Object.freeze(emptyContextObject);
+} // A cursor to the current merged context object on the stack.
 
-  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
-    return null;
-  }
+var contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
 
-  if (listener && typeof listener !== "function") {
-    throw new Error(
-      "Expected `" +
-        registrationName +
-        "` listener to be a function, instead got a value of `" +
-        typeof listener +
-        "` type."
-    );
-  }
+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.
 
-  return listener;
-}
+var previousContext = emptyContextObject;
 
-var passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
-// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+function getUnmaskedContext(
+  workInProgress,
+  Component,
+  didPushOwnContextIfProvider
+) {
+  {
+    if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+      // If the fiber is a context provider itself, when we read its context
+      // we may have already pushed its own child context on the stack. A context
+      // provider should not "see" its own child context. Therefore we read the
+      // previous (parent) context instead for a context provider.
+      return previousContext;
+    }
 
-if (canUseDOM) {
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = true;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = false;
+    return contextStackCursor.current;
   }
 }
 
-// Provided by www
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-
-if (typeof ReactFbErrorUtils.invokeGuardedCallback !== "function") {
-  throw new Error(
-    "Expected ReactFbErrorUtils.invokeGuardedCallback to be a function."
-  );
+function cacheContext(workInProgress, unmaskedContext, maskedContext) {
+  {
+    var instance = workInProgress.stateNode;
+    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
+    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
+  }
 }
 
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  // This will call `this.onError(err)` if an error was caught.
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
-}
+function getMaskedContext(workInProgress, unmaskedContext) {
+  {
+    var type = workInProgress.type;
+    var contextTypes = type.contextTypes;
 
-var hasError = false;
-var caughtError = null; // Used by event system to capture/rethrow the first error.
+    if (!contextTypes) {
+      return emptyContextObject;
+    } // Avoid recreating masked context unless unmasked context has changed.
+    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.
+    // This may trigger infinite loops if componentWillReceiveProps calls setState.
 
-var hasRethrowError = false;
-var rethrowError = null;
-var reporter = {
-  onError: function (error) {
-    hasError = true;
-    caughtError = error;
-  }
-};
-/**
- * Call a function while guarding against errors that happens within it.
- * Returns an error if it throws, otherwise null.
- *
- * In production, this is implemented using a try-catch. The reason we don't
- * use a try-catch directly is so that we can swap out a different
- * implementation in DEV mode.
- *
- * @param {String} name of the guard to use for logging or debugging
- * @param {Function} func The function to invoke
- * @param {*} context The context to use when calling the function
- * @param {...*} args Arguments for function
- */
+    var instance = workInProgress.stateNode;
 
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = false;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
-}
-/**
- * Same as invokeGuardedCallback, but instead of returning an error, it stores
- * it in a global so it can be rethrown by `rethrowCaughtError` later.
- * TODO: See if caughtError and rethrowError can be unified.
- *
- * @param {String} name of the guard to use for logging or debugging
- * @param {Function} func The function to invoke
- * @param {*} context The context to use when calling the function
- * @param {...*} args Arguments for function
- */
+    if (
+      instance &&
+      instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
+    ) {
+      return instance.__reactInternalMemoizedMaskedChildContext;
+    }
 
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
+    var context = {};
 
-  if (hasError) {
-    var error = clearCaughtError();
+    for (var key in contextTypes) {
+      context[key] = unmaskedContext[key];
+    }
 
-    if (!hasRethrowError) {
-      hasRethrowError = true;
-      rethrowError = error;
+    {
+      var name = getComponentNameFromFiber(workInProgress) || "Unknown";
+      checkPropTypes(contextTypes, context, "context", name);
+    } // Cache unmasked context so we can avoid recreating masked context unless necessary.
+    // Context is created before the class component is instantiated so check for instance.
+
+    if (instance) {
+      cacheContext(workInProgress, unmaskedContext, context);
     }
+
+    return context;
   }
 }
-/**
- * During execution of guarded functions we will capture the first error which
- * we will rethrow to be handled by the top level error handler.
- */
 
-function rethrowCaughtError() {
-  if (hasRethrowError) {
-    var error = rethrowError;
-    hasRethrowError = false;
-    rethrowError = null;
-    throw error;
+function hasContextChanged() {
+  {
+    return didPerformWorkStackCursor.current;
   }
 }
-function hasCaughtError() {
-  return hasError;
-}
-function clearCaughtError() {
-  if (hasError) {
-    var error = caughtError;
-    hasError = false;
-    caughtError = null;
-    return error;
-  } else {
-    throw new Error(
-      "clearCaughtError was called but no error was captured. This error " +
-        "is likely caused by a bug in React. Please file an issue."
-    );
+
+function isContextProvider(type) {
+  {
+    var childContextTypes = type.childContextTypes;
+    return childContextTypes !== null && childContextTypes !== undefined;
   }
 }
 
-var EventListenerWWW = require("EventListener");
-
-function addEventBubbleListener(target, eventType, listener) {
-  return EventListenerWWW.listen(target, eventType, listener);
-}
-function addEventCaptureListener(target, eventType, listener) {
-  return EventListenerWWW.capture(target, eventType, listener);
-}
-function addEventCaptureListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  return EventListenerWWW.captureWithPassiveFlag(
-    target,
-    eventType,
-    listener,
-    passive
-  );
-}
-function addEventBubbleListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  return EventListenerWWW.bubbleWithPassiveFlag(
-    target,
-    eventType,
-    listener,
-    passive
-  );
+function popContext(fiber) {
+  {
+    pop(didPerformWorkStackCursor, fiber);
+    pop(contextStackCursor, fiber);
+  }
 }
-function removeEventListener(target, eventType, listener, capture) {
-  listener.remove();
-} // Flow magic to verify the exports of this file match the original version.
 
-/**
- * These variables store information about text content of a target node,
- * allowing comparison of content before and after a given event.
- *
- * Identify the node where selection currently begins, then observe
- * both its text content and its current position in the DOM. Since the
- * browser may natively replace the target node during composition, we can
- * use its position to find its replacement.
- *
- *
- */
-var root = null;
-var startText = null;
-var fallbackText = null;
-function initialize(nativeEventTarget) {
-  root = nativeEventTarget;
-  startText = getText();
-  return true;
-}
-function reset() {
-  root = null;
-  startText = null;
-  fallbackText = null;
+function popTopLevelContextObject(fiber) {
+  {
+    pop(didPerformWorkStackCursor, fiber);
+    pop(contextStackCursor, fiber);
+  }
 }
-function getData() {
-  if (fallbackText) {
-    return fallbackText;
+
+function pushTopLevelContextObject(fiber, context, didChange) {
+  {
+    if (contextStackCursor.current !== emptyContextObject) {
+      throw new Error(
+        "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);
   }
+}
 
-  var start;
-  var startValue = startText;
-  var startLength = startValue.length;
-  var end;
-  var endValue = getText();
-  var endLength = endValue.length;
+function processChildContext(fiber, type, parentContext) {
+  {
+    var instance = fiber.stateNode;
+    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.
 
-  for (start = 0; start < startLength; start++) {
-    if (startValue[start] !== endValue[start]) {
-      break;
+    if (typeof instance.getChildContext !== "function") {
+      {
+        var componentName = getComponentNameFromFiber(fiber) || "Unknown";
+
+        if (!warnedAboutMissingGetChildContext[componentName]) {
+          warnedAboutMissingGetChildContext[componentName] = true;
+
+          error(
+            "%s.childContextTypes is specified but there is no getChildContext() method " +
+              "on the instance. You can either define getChildContext() on %s or remove " +
+              "childContextTypes from it.",
+            componentName,
+            componentName
+          );
+        }
+      }
+
+      return parentContext;
     }
-  }
 
-  var minEnd = startLength - start;
+    var childContext = instance.getChildContext();
 
-  for (end = 1; end <= minEnd; end++) {
-    if (startValue[startLength - end] !== endValue[endLength - end]) {
-      break;
+    for (var contextKey in childContext) {
+      if (!(contextKey in childContextTypes)) {
+        throw new Error(
+          (getComponentNameFromFiber(fiber) || "Unknown") +
+            '.getChildContext(): key "' +
+            contextKey +
+            '" is not defined in childContextTypes.'
+        );
+      }
     }
-  }
 
-  var sliceTail = end > 1 ? 1 - end : undefined;
-  fallbackText = endValue.slice(start, sliceTail);
-  return fallbackText;
-}
-function getText() {
-  if ("value" in root) {
-    return root.value;
-  }
+    {
+      var name = getComponentNameFromFiber(fiber) || "Unknown";
+      checkPropTypes(childContextTypes, childContext, "child context", name);
+    }
 
-  return root.textContent;
+    return assign({}, parentContext, childContext);
+  }
 }
 
-/**
- * `charCode` represents the actual "character code" and is safe to use with
- * `String.fromCharCode`. As such, only keys that correspond to printable
- * characters produce a valid `charCode`, the only exception to this is Enter.
- * The Tab-key is considered non-printable and does not have a `charCode`,
- * presumably because it does not produce a tab-character in browsers.
- *
- * @param {object} nativeEvent Native browser event.
- * @return {number} Normalized `charCode` property.
- */
-function getEventCharCode(nativeEvent) {
-  var charCode;
-  var keyCode = nativeEvent.keyCode;
-
-  if ("charCode" in nativeEvent) {
-    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
-
-    if (charCode === 0 && keyCode === 13) {
-      charCode = 13;
-    }
-  } else {
-    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
-    charCode = keyCode;
-  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
-  // report Enter as charCode 10 when ctrl is pressed.
+function pushContextProvider(workInProgress) {
+  {
+    var instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
+    // If the instance does not exist yet, we will push null at first,
+    // and replace it on the stack later when invalidating the context.
 
-  if (charCode === 10) {
-    charCode = 13;
-  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
-  // Must not discard the (non-)printable Enter-key.
+    var memoizedMergedChildContext =
+      (instance && instance.__reactInternalMemoizedMergedChildContext) ||
+      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.
 
-  if (charCode >= 32 || charCode === 13) {
-    return charCode;
+    previousContext = contextStackCursor.current;
+    push(contextStackCursor, memoizedMergedChildContext, workInProgress);
+    push(
+      didPerformWorkStackCursor,
+      didPerformWorkStackCursor.current,
+      workInProgress
+    );
+    return true;
   }
-
-  return 0;
 }
 
-function functionThatReturnsTrue() {
-  return true;
-}
-
-function functionThatReturnsFalse() {
-  return false;
-} // This is intentionally a factory so that we have different returned constructors.
-// If we had a single constructor, it would be megamorphic and engines would deopt.
-
-function createSyntheticEvent(Interface) {
-  /**
-   * Synthetic events are dispatched by event plugins, typically in response to a
-   * top-level event delegation handler.
-   *
-   * These systems should generally use pooling to reduce the frequency of garbage
-   * collection. The system should check `isPersistent` to determine whether the
-   * event should be released into the pool after being dispatched. Users that
-   * need a persisted event should invoke `persist`.
-   *
-   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
-   * normalizing browser quirks. Subclasses do not necessarily have to implement a
-   * DOM interface; custom application-specific events can also subclass this.
-   */
-  // $FlowFixMe[missing-this-annot]
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-
-    for (var propName in Interface) {
-      if (!Interface.hasOwnProperty(propName)) {
-        continue;
-      }
-
-      var normalize = Interface[propName];
+function invalidateContextProvider(workInProgress, type, didChange) {
+  {
+    var instance = workInProgress.stateNode;
 
-      if (normalize) {
-        this[propName] = normalize(nativeEvent);
-      } else {
-        this[propName] = nativeEvent[propName];
-      }
+    if (!instance) {
+      throw new Error(
+        "Expected to have an instance by this point. " +
+          "This error is likely caused by a bug in React. Please file an issue."
+      );
     }
 
-    var defaultPrevented =
-      nativeEvent.defaultPrevented != null
-        ? nativeEvent.defaultPrevented
-        : nativeEvent.returnValue === false;
+    if (didChange) {
+      // Merge parent and own context.
+      // Skip this if we're not updating due to sCU.
+      // This avoids unnecessarily recomputing memoized values.
+      var mergedContext = processChildContext(
+        workInProgress,
+        type,
+        previousContext
+      );
+      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
+      // It is important to unwind the context in the reverse order.
 
-    if (defaultPrevented) {
-      this.isDefaultPrevented = functionThatReturnsTrue;
+      pop(didPerformWorkStackCursor, workInProgress);
+      pop(contextStackCursor, workInProgress); // Now push the new context and mark that it has changed.
+
+      push(contextStackCursor, mergedContext, workInProgress);
+      push(didPerformWorkStackCursor, didChange, workInProgress);
     } else {
-      this.isDefaultPrevented = functionThatReturnsFalse;
+      pop(didPerformWorkStackCursor, workInProgress);
+      push(didPerformWorkStackCursor, didChange, workInProgress);
     }
+  }
+}
 
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  } // $FlowFixMe[prop-missing] found when upgrading Flow
+function findCurrentUnmaskedContext(fiber) {
+  {
+    // Currently this is only used with renderSubtreeIntoContainer; not sure if it
+    // makes sense elsewhere
+    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {
+      throw new Error(
+        "Expected subtree parent to be a mounted class component. " +
+          "This error is likely caused by a bug in React. Please file an issue."
+      );
+    }
 
-  assign(SyntheticBaseEvent.prototype, {
-    // $FlowFixMe[missing-this-annot]
-    preventDefault: function () {
-      this.defaultPrevented = true;
-      var event = this.nativeEvent;
+    var node = fiber;
 
-      if (!event) {
-        return;
-      }
+    do {
+      switch (node.tag) {
+        case HostRoot:
+          return node.stateNode.context;
 
-      if (event.preventDefault) {
-        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.returnValue !== "unknown") {
-        event.returnValue = false;
-      }
+        case ClassComponent: {
+          var Component = node.type;
 
-      this.isDefaultPrevented = functionThatReturnsTrue;
-    },
-    // $FlowFixMe[missing-this-annot]
-    stopPropagation: function () {
-      var event = this.nativeEvent;
+          if (isContextProvider(Component)) {
+            return node.stateNode.__reactInternalMemoizedMergedChildContext;
+          }
 
-      if (!event) {
-        return;
-      }
+          break;
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-      if (event.stopPropagation) {
-        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.cancelBubble !== "unknown") {
-        // The ChangeEventPlugin registers a "propertychange" event for
-        // IE. This event does not support bubbling or cancelling, and
-        // any references to cancelBubble throw "Member not found".  A
-        // typeof check of "unknown" circumvents this issue (and is also
-        // IE specific).
-        event.cancelBubble = true;
-      }
+      node = node.return;
+    } while (node !== null);
 
-      this.isPropagationStopped = functionThatReturnsTrue;
-    },
+    throw new Error(
+      "Found unexpected detached subtree parent. " +
+        "This error is likely caused by a bug in React. Please file an issue."
+    );
+  }
+}
 
-    /**
-     * We release all dispatched `SyntheticEvent`s after each event loop, adding
-     * them back into the pool. This allows a way to hold onto a reference that
-     * won't be added back into the pool.
-     */
-    persist: function () {
-      // Modern event system doesn't use pooling.
-    },
+var LegacyRoot = 0;
+var ConcurrentRoot = 1;
 
-    /**
-     * Checks if this event should be released back into the pool.
-     *
-     * @return {boolean} True if this should not be released, false otherwise.
-     */
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+var OffscreenVisible =
+  /*                     */
+  1;
+var OffscreenDetached =
+  /*                    */
+  2;
+var OffscreenPassiveEffectsConnected =
+  /*     */
+  4;
+function isOffscreenManual(offscreenFiber) {
+  return (
+    offscreenFiber.memoizedProps !== null &&
+    offscreenFiber.memoizedProps.mode === "manual"
+  );
 }
+
 /**
- * @interface Event
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  */
+function is(x, y) {
+  return (
+    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
+  );
+}
 
-var EventInterface = {
-  eventPhase: 0,
-  bubbles: 0,
-  cancelable: 0,
-  timeStamp: function (event) {
-    return event.timeStamp || Date.now();
-  },
-  defaultPrevented: 0,
-  isTrusted: 0
-};
-var SyntheticEvent = createSyntheticEvent(EventInterface);
-
-var UIEventInterface = assign({}, EventInterface, {
-  view: 0,
-  detail: 0
-});
+var objectIs = typeof Object.is === "function" ? Object.is : is; // $FlowFixMe[method-unbinding]
 
-var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
-var lastMovementX;
-var lastMovementY;
-var lastMouseEvent;
+var syncQueue = null;
+var includesLegacySyncCallbacks = false;
+var isFlushingSyncQueue = false;
+function scheduleSyncCallback(callback) {
+  // Push this callback into an internal queue. We'll flush these either in
+  // the next tick, or earlier if something calls `flushSyncCallbackQueue`.
+  if (syncQueue === null) {
+    syncQueue = [callback];
+  } else {
+    // Push onto existing queue. Don't need to schedule a callback because
+    // we already scheduled one when we created the queue.
+    syncQueue.push(callback);
+  }
+}
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = true;
+  scheduleSyncCallback(callback);
+}
+function flushSyncCallbacksOnlyInLegacyMode() {
+  // Only flushes the queue if there's a legacy sync callback scheduled.
+  // TODO: There's only a single type of callback: performSyncOnWorkOnRoot. So
+  // it might make more sense for the queue to be a list of roots instead of a
+  // list of generic callbacks. Then we can have two: one for legacy roots, one
+  // for concurrent roots. And this method would only flush the legacy ones.
+  if (includesLegacySyncCallbacks) {
+    flushSyncCallbacks();
+  }
+}
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && syncQueue !== null) {
+    // Prevent re-entrance.
+    isFlushingSyncQueue = true; // Set the event priority to discrete
+    // TODO: Is this necessary anymore? The only user code that runs in this
+    // queue is in the render or commit phases, which already set the
+    // event priority. Should be able to remove.
 
-function updateMouseMovementPolyfillState(event) {
-  if (event !== lastMouseEvent) {
-    if (lastMouseEvent && event.type === "mousemove") {
-      // $FlowFixMe assuming this is a number
-      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe assuming this is a number
+    var previousUpdatePriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    var errors = null;
+    var queue = syncQueue; // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-      lastMovementY = event.screenY - lastMouseEvent.screenY;
-    } else {
-      lastMovementX = 0;
-      lastMovementY = 0;
-    }
+    for (var i = 0; i < queue.length; i++) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      var callback = queue[i];
 
-    lastMouseEvent = event;
-  }
-}
-/**
- * @interface MouseEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+      try {
+        do {
+          var isSync = true; // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-var MouseEventInterface = assign({}, UIEventInterface, {
-  screenX: 0,
-  screenY: 0,
-  clientX: 0,
-  clientY: 0,
-  pageX: 0,
-  pageY: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  altKey: 0,
-  metaKey: 0,
-  getModifierState: getEventModifierState,
-  button: 0,
-  buttons: 0,
-  relatedTarget: function (event) {
-    if (event.relatedTarget === undefined)
-      return event.fromElement === event.srcElement
-        ? event.toElement
-        : event.fromElement;
-    return event.relatedTarget;
-  },
-  movementX: function (event) {
-    if ("movementX" in event) {
-      return event.movementX;
+          callback = callback(isSync);
+        } while (callback !== null);
+      } catch (error) {
+        // Collect errors so we can rethrow them at the end
+        if (errors === null) {
+          errors = [error];
+        } else {
+          errors.push(error);
+        }
+      }
     }
 
-    updateMouseMovementPolyfillState(event);
-    return lastMovementX;
-  },
-  movementY: function (event) {
-    if ("movementY" in event) {
-      return event.movementY;
-    } // Don't need to call updateMouseMovementPolyfillState() here
-    // because it's guaranteed to have already run when movementX
-    // was copied.
+    syncQueue = null;
+    includesLegacySyncCallbacks = false;
+    setCurrentUpdatePriority(previousUpdatePriority);
+    isFlushingSyncQueue = false;
 
-    return lastMovementY;
+    if (errors !== null) {
+      if (errors.length > 1) {
+        if (typeof AggregateError === "function") {
+          // eslint-disable-next-line no-undef
+          throw new AggregateError(errors);
+        } else {
+          for (var _i = 1; _i < errors.length; _i++) {
+            scheduleCallback$2(
+              ImmediatePriority,
+              throwError.bind(null, errors[_i])
+            );
+          }
+
+          var firstError = errors[0];
+          throw firstError;
+        }
+      } else {
+        var error = errors[0];
+        throw error;
+      }
+    }
   }
-});
 
-var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
-/**
- * @interface DragEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+  return null;
+}
 
-var DragEventInterface = assign({}, MouseEventInterface, {
-  dataTransfer: 0
-});
+function throwError(error) {
+  throw error;
+}
 
-var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
-/**
- * @interface FocusEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+var nativeConsole = console;
+var nativeConsoleLog = null;
+var pendingGroupArgs = [];
+var printedGroupIndex = -1;
 
-var FocusEventInterface = assign({}, UIEventInterface, {
-  relatedTarget: 0
-});
+function formatLanes(laneOrLanes) {
+  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
+}
 
-var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
- * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
- */
+function group() {
+  for (
+    var _len = arguments.length, groupArgs = new Array(_len), _key = 0;
+    _key < _len;
+    _key++
+  ) {
+    groupArgs[_key] = arguments[_key];
+  }
 
-var AnimationEventInterface = assign({}, EventInterface, {
-  animationName: 0,
-  elapsedTime: 0,
-  pseudoElement: 0
-});
+  pendingGroupArgs.push(groupArgs);
 
-var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/clipboard-apis/
- */
+  if (nativeConsoleLog === null) {
+    nativeConsoleLog = nativeConsole.log;
+    nativeConsole.log = log;
+  }
+}
 
-var ClipboardEventInterface = assign({}, EventInterface, {
-  clipboardData: function (event) {
-    return "clipboardData" in event
-      ? event.clipboardData
-      : window.clipboardData;
+function groupEnd() {
+  pendingGroupArgs.pop();
+
+  while (printedGroupIndex >= pendingGroupArgs.length) {
+    nativeConsole.groupEnd();
+    printedGroupIndex--;
   }
-});
 
-var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
- */
+  if (pendingGroupArgs.length === 0) {
+    nativeConsole.log = nativeConsoleLog;
+    nativeConsoleLog = null;
+  }
+}
 
-var CompositionEventInterface = assign({}, EventInterface, {
-  data: 0
-});
+function log() {
+  if (printedGroupIndex < pendingGroupArgs.length - 1) {
+    for (var i = printedGroupIndex + 1; i < pendingGroupArgs.length; i++) {
+      var groupArgs = pendingGroupArgs[i];
+      nativeConsole.group.apply(nativeConsole, groupArgs);
+    }
 
-var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
- *      /#events-inputevents
- */
-// Happens to share the same list for now.
+    printedGroupIndex = pendingGroupArgs.length - 1;
+  }
 
-var SyntheticInputEvent = SyntheticCompositionEvent;
-/**
- * Normalization of deprecated HTML5 `key` values
- * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
- */
+  if (typeof nativeConsoleLog === "function") {
+    nativeConsoleLog.apply(void 0, arguments);
+  } else {
+    nativeConsole.log.apply(nativeConsole, arguments);
+  }
+}
 
-var normalizeKey = {
-  Esc: "Escape",
-  Spacebar: " ",
-  Left: "ArrowLeft",
-  Up: "ArrowUp",
-  Right: "ArrowRight",
-  Down: "ArrowDown",
-  Del: "Delete",
-  Win: "OS",
-  Menu: "ContextMenu",
-  Apps: "ContextMenu",
-  Scroll: "ScrollLock",
-  MozPrintableKey: "Unidentified"
-};
-/**
- * Translation from legacy `keyCode` to HTML5 `key`
- * Only special keys supported, all others depend on keyboard layout or browser
- * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
- */
-
-var translateToKey = {
-  "8": "Backspace",
-  "9": "Tab",
-  "12": "Clear",
-  "13": "Enter",
-  "16": "Shift",
-  "17": "Control",
-  "18": "Alt",
-  "19": "Pause",
-  "20": "CapsLock",
-  "27": "Escape",
-  "32": " ",
-  "33": "PageUp",
-  "34": "PageDown",
-  "35": "End",
-  "36": "Home",
-  "37": "ArrowLeft",
-  "38": "ArrowUp",
-  "39": "ArrowRight",
-  "40": "ArrowDown",
-  "45": "Insert",
-  "46": "Delete",
-  "112": "F1",
-  "113": "F2",
-  "114": "F3",
-  "115": "F4",
-  "116": "F5",
-  "117": "F6",
-  "118": "F7",
-  "119": "F8",
-  "120": "F9",
-  "121": "F10",
-  "122": "F11",
-  "123": "F12",
-  "144": "NumLock",
-  "145": "ScrollLock",
-  "224": "Meta"
-};
-/**
- * @param {object} nativeEvent Native browser event.
- * @return {string} Normalized `key` property.
- */
-
-function getEventKey(nativeEvent) {
-  if (nativeEvent.key) {
-    // Normalize inconsistent values reported by browsers due to
-    // implementations of a working draft specification.
-    // FireFox implements `key` but returns `MozPrintableKey` for all
-    // printable characters (normalized to `Unidentified`), ignore it.
-    var key = normalizeKey[nativeEvent.key] || nativeEvent.key; // $FlowFixMe unable to index with a `mixed` value
-
-    if (key !== "Unidentified") {
-      return key;
+var REACT_LOGO_STYLE =
+  "background-color: #20232a; color: #61dafb; padding: 0 2px;";
+function logCommitStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c commit%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
     }
-  } // Browser does not implement `key`, polyfill as much of it as we can.
-
-  if (nativeEvent.type === "keypress") {
-    var charCode = getEventCharCode(
-      // $FlowFixMe unable to narrow to `KeyboardEvent`
-      nativeEvent
-    ); // The enter-key is technically both printable and non-printable and can
-    // thus be captured by `keypress`, no other non-printable key should.
-
-    return charCode === 13 ? "Enter" : String.fromCharCode(charCode);
   }
-
-  if (nativeEvent.type === "keydown" || nativeEvent.type === "keyup") {
-    // While user keyboard layout determines the actual meaning of each
-    // `keyCode` value, almost all function keys have a universal value.
-    // $FlowFixMe unable to index with a `mixed` value
-    return translateToKey[nativeEvent.keyCode] || "Unidentified";
+}
+function logCommitStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
   }
-
-  return "";
 }
-/**
- * Translation from modifier key to the associated property in the event.
- * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
- */
-
-var modifierKeyToProp = {
-  Alt: "altKey",
-  Control: "ctrlKey",
-  Meta: "metaKey",
-  Shift: "shiftKey"
-}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
-// getModifierState. If getModifierState is not supported, we map it to a set of
-// modifier keys exposed by the event. In this case, Lock-keys are not supported.
-// $FlowFixMe[missing-local-annot]
-// $FlowFixMe[missing-this-annot]
+var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
 
-function modifierStateGetter(keyArg) {
-  var syntheticEvent = this;
-  var nativeEvent = syntheticEvent.nativeEvent;
+var wakeableIDs = new PossiblyWeakMap$1();
+var wakeableID = 0;
 
-  if (nativeEvent.getModifierState) {
-    return nativeEvent.getModifierState(keyArg);
+function getWakeableID(wakeable) {
+  if (!wakeableIDs.has(wakeable)) {
+    wakeableIDs.set(wakeable, wakeableID++);
   }
 
-  var keyProp = modifierKeyToProp[keyArg];
-  return keyProp ? !!nativeEvent[keyProp] : false;
+  return wakeableIDs.get(wakeable);
 }
 
-function getEventModifierState(nativeEvent) {
-  return modifierStateGetter;
+function logComponentSuspended(componentName, wakeable) {
+  {
+    if (enableDebugTracing) {
+      var id = getWakeableID(wakeable);
+      var display = wakeable.displayName || wakeable;
+      log(
+        "%c\u269B\uFE0F%c " + componentName + " suspended",
+        REACT_LOGO_STYLE,
+        "color: #80366d; font-weight: bold;",
+        id,
+        display
+      );
+      wakeable.then(
+        function () {
+          log(
+            "%c\u269B\uFE0F%c " + componentName + " resolved",
+            REACT_LOGO_STYLE,
+            "color: #80366d; font-weight: bold;",
+            id,
+            display
+          );
+        },
+        function () {
+          log(
+            "%c\u269B\uFE0F%c " + componentName + " rejected",
+            REACT_LOGO_STYLE,
+            "color: #80366d; font-weight: bold;",
+            id,
+            display
+          );
+        }
+      );
+    }
+  }
 }
-/**
- * @interface KeyboardEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
-
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-  key: getEventKey,
-  code: 0,
-  location: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  altKey: 0,
-  metaKey: 0,
-  repeat: 0,
-  locale: 0,
-  getModifierState: getEventModifierState,
-  // Legacy Interface
-  charCode: function (event) {
-    // `charCode` is the result of a KeyPress event and represents the value of
-    // the actual printable character.
-    // KeyPress is deprecated, but its replacement is not yet final and not
-    // implemented in any major browser. Only KeyPress has charCode.
-    if (event.type === "keypress") {
-      return getEventCharCode(
-        // $FlowFixMe unable to narrow to `KeyboardEvent`
-        event
+function logLayoutEffectsStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c layout effects%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
       );
     }
-
-    return 0;
-  },
-  keyCode: function (event) {
-    // `keyCode` is the result of a KeyDown/Up event and represents the value of
-    // physical keyboard key.
-    // The actual meaning of the value depends on the users' keyboard layout
-    // which cannot be detected. Assuming that it is a US keyboard layout
-    // provides a surprisingly accurate mapping for US and European users.
-    // Due to this, it is left to the user to implement at this time.
-    if (event.type === "keydown" || event.type === "keyup") {
-      return event.keyCode;
+  }
+}
+function logLayoutEffectsStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
     }
-
-    return 0;
-  },
-  which: function (event) {
-    // `which` is an alias for either `keyCode` or `charCode` depending on the
-    // type of the event.
-    if (event.type === "keypress") {
-      return getEventCharCode(
-        // $FlowFixMe unable to narrow to `KeyboardEvent`
-        event
+  }
+}
+function logPassiveEffectsStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c passive effects%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
       );
     }
-
-    if (event.type === "keydown" || event.type === "keyup") {
-      return event.keyCode;
+  }
+}
+function logPassiveEffectsStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
     }
-
-    return 0;
   }
-});
+}
+function logRenderStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c render%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
+    }
+  }
+}
+function logRenderStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
+  }
+}
+function logForceUpdateScheduled(componentName, lane) {
+  {
+    if (enableDebugTracing) {
+      log(
+        "%c\u269B\uFE0F%c " +
+          componentName +
+          " forced update %c(" +
+          formatLanes(lane) +
+          ")",
+        REACT_LOGO_STYLE,
+        "color: #db2e1f; font-weight: bold;",
+        ""
+      );
+    }
+  }
+}
+function logStateUpdateScheduled(componentName, lane, payloadOrAction) {
+  {
+    if (enableDebugTracing) {
+      log(
+        "%c\u269B\uFE0F%c " +
+          componentName +
+          " updated state %c(" +
+          formatLanes(lane) +
+          ")",
+        REACT_LOGO_STYLE,
+        "color: #01a252; font-weight: bold;",
+        "",
+        payloadOrAction
+      );
+    }
+  }
+}
 
-var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
-/**
- * @interface PointerEvent
- * @see http://www.w3.org/TR/pointerevents/
- */
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  var currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
 
-var PointerEventInterface = assign({}, MouseEventInterface, {
-  pointerId: 0,
-  width: 0,
-  height: 0,
-  pressure: 0,
-  tangentialPressure: 0,
-  tiltX: 0,
-  tiltY: 0,
-  twist: 0,
-  pointerType: 0,
-  isPrimary: 0
-});
+// Intentionally not using it yet to derisk the initial implementation, because
+// the way we push/pop these values is a bit unusual. If there's a mistake, I'd
+// rather the ids be wrong than crash the whole reconciler.
 
-var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
-/**
- * @interface TouchEvent
- * @see http://www.w3.org/TR/touch-events/
- */
+var forkStack = [];
+var forkStackIndex = 0;
+var treeForkProvider = null;
+var treeForkCount = 0;
+var idStack = [];
+var idStackIndex = 0;
+var treeContextProvider = null;
+var treeContextId = 1;
+var treeContextOverflow = "";
+function isForkedChild(workInProgress) {
+  warnIfNotHydrating();
+  return (workInProgress.flags & Forked) !== NoFlags$1;
+}
+function getForksAtLevel(workInProgress) {
+  warnIfNotHydrating();
+  return treeForkCount;
+}
+function getTreeId() {
+  var overflow = treeContextOverflow;
+  var idWithLeadingBit = treeContextId;
+  var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  // This is called right after we reconcile an array (or iterator) of child
+  // fibers, because that's the only place where we know how many children in
+  // the whole set without doing extra work later, or storing addtional
+  // information on the fiber.
+  //
+  // That's why this function is separate from pushTreeId — it's called during
+  // the render phase of the fork parent, not the child, which is where we push
+  // the other context values.
+  //
+  // In the Fizz implementation this is much simpler because the child is
+  // rendered in the same callstack as the parent.
+  //
+  // It might be better to just add a `forks` field to the Fiber type. It would
+  // make this module simpler.
+  warnIfNotHydrating();
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  warnIfNotHydrating();
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  var baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
 
-var TouchEventInterface = assign({}, UIEventInterface, {
-  touches: 0,
-  targetTouches: 0,
-  changedTouches: 0,
-  altKey: 0,
-  metaKey: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  getModifierState: getEventModifierState
-});
+  var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  var slot = index + 1;
+  var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
 
-var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
- * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
- */
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    var numberOfOverflowBits = baseLength - (baseLength % 5); // Then create a bitmask that selects only those bits.
 
-var TransitionEventInterface = assign({}, EventInterface, {
-  propertyName: 0,
-  elapsedTime: 0,
-  pseudoElement: 0
-});
+    var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
 
-var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
-/**
- * @interface WheelEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+    var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
 
-var WheelEventInterface = assign({}, MouseEventInterface, {
-  deltaX: function (event) {
-    return "deltaX" in event
-      ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
-      : "wheelDeltaX" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDeltaX
-      : 0;
-  },
-  deltaY: function (event) {
-    return "deltaY" in event
-      ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
-      : "wheelDeltaY" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
-      : "wheelDelta" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDelta
-      : 0;
-  },
-  deltaZ: 0,
-  // Browsers without "deltaMode" is reporting in raw wheel delta where one
-  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
-  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
-  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
-  deltaMode: 0
-});
+    var restOfBaseId = baseId >> numberOfOverflowBits;
+    var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
 
-var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+    var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    var restOfNewBits = slot << restOfBaseLength;
+    var id = restOfNewBits | restOfBaseId;
+    var overflow = newOverflow + baseOverflow;
+    treeContextId = (1 << restOfLength) | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    var newBits = slot << baseLength;
 
-var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+    var _id = newBits | baseId;
 
-var START_KEYCODE = 229;
-var canUseCompositionEvent = canUseDOM && "CompositionEvent" in window;
-var documentMode = null;
+    var _overflow = baseOverflow;
+    treeContextId = (1 << length) | _id;
+    treeContextOverflow = _overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  warnIfNotHydrating(); // This component materialized an id. This will affect any ids that appear
+  // in its children.
 
-if (canUseDOM && "documentMode" in document) {
-  documentMode = document.documentMode;
-} // Webkit offers a very useful `textInput` event that can be used to
-// directly represent `beforeInput`. The IE `textinput` event is not as
-// useful, so we don't use it.
+  var returnFiber = workInProgress.return;
 
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
-// by the native compositionend event may be incorrect. Japanese ideographic
-// spaces, for instance (\u3000) are not recorded correctly.
+  if (returnFiber !== null) {
+    var numberOfForks = 1;
+    var slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
 
-var useFallbackCompositionData =
-  canUseDOM &&
-  (!canUseCompositionEvent ||
-    (documentMode && documentMode > 8 && documentMode <= 11));
-var SPACEBAR_CODE = 32;
-var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
 
-function registerEvents$3() {
-  registerTwoPhaseEvent("onBeforeInput", [
-    "compositionend",
-    "keypress",
-    "textInput",
-    "paste"
-  ]);
-  registerTwoPhaseEvent("onCompositionEnd", [
-    "compositionend",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-  registerTwoPhaseEvent("onCompositionStart", [
-    "compositionstart",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-  registerTwoPhaseEvent("onCompositionUpdate", [
-    "compositionupdate",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-} // Track whether we've ever handled a keypress on the space key.
-
-var hasSpaceKeypress = false;
-/**
- * Return whether a native keypress event is assumed to be a command.
- * This is required because Firefox fires `keypress` events for key commands
- * (cut, copy, select-all, etc.) even though no character is inserted.
- */
-
-function isKeypressCommand(nativeEvent) {
-  return (
-    (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
-    !(nativeEvent.ctrlKey && nativeEvent.altKey)
-  );
+function getLeadingBit(id) {
+  return 1 << (getBitLength(id) - 1);
 }
-/**
- * Translate native top level events into event types.
- */
 
-function getCompositionEventType(domEventName) {
-  switch (domEventName) {
-    case "compositionstart":
-      return "onCompositionStart";
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
 
-    case "compositionend":
-      return "onCompositionEnd";
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+  warnIfNotHydrating();
 
-    case "compositionupdate":
-      return "onCompositionUpdate";
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
   }
 }
-/**
- * Does our fallback best-guess model think this event signifies that
- * composition has begun?
- */
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  warnIfNotHydrating();
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
 
-function isFallbackCompositionStart(domEventName, nativeEvent) {
-  return domEventName === "keydown" && nativeEvent.keyCode === START_KEYCODE;
+function warnIfNotHydrating() {
+  {
+    if (!getIsHydrating()) {
+      error(
+        "Expected to be hydrating. This is a bug in React. Please file " +
+          "an issue."
+      );
+    }
+  }
 }
-/**
- * Does our fallback mode think that this event is the end of composition?
- */
 
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      // Command keys insert or clear IME input.
-      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+// This may have been an insertion or a hydration.
 
-    case "keydown":
-      // Expect IME keyCode on each keydown. If we get any other
-      // code we must have exited earlier.
-      return nativeEvent.keyCode !== START_KEYCODE;
+var hydrationParentFiber = null;
+var nextHydratableInstance = null;
+var isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+// due to earlier mismatches or a suspended fiber.
 
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      // Events are not possible without cancelling IME.
-      return true;
+var didSuspendOrErrorDEV = false; // Hydration errors that were thrown inside this boundary
 
-    default:
-      return false;
+var hydrationErrors = null;
+var rootOrSingletonContext = false;
+
+function warnIfHydrating() {
+  {
+    if (isHydrating) {
+      error(
+        "We should not be hydrating here. This is a bug in React. Please file a bug."
+      );
+    }
   }
 }
-/**
- * Google Input Tools provides composition data via a CustomEvent,
- * with the `data` property populated in the `detail` object. If this
- * is available on the event object, use it. If not, this is a plain
- * composition event and we have nothing special to extract.
- *
- * @param {object} nativeEvent
- * @return {?string}
- */
-
-function getDataFromCustomEvent(nativeEvent) {
-  var detail = nativeEvent.detail;
 
-  if (typeof detail === "object" && "data" in detail) {
-    return detail.data;
+function markDidThrowWhileHydratingDEV() {
+  {
+    didSuspendOrErrorDEV = true;
+  }
+}
+function didSuspendOrErrorWhileHydratingDEV() {
+  {
+    return didSuspendOrErrorDEV;
   }
-
-  return null;
 }
-/**
- * Check if a composition event was triggered by Korean IME.
- * Our fallback mode does not work well with IE's Korean IME,
- * so just use native composition events when Korean IME is used.
- * Although CompositionEvent.locale property is deprecated,
- * it is available in IE, where our fallback mode is enabled.
- *
- * @param {object} nativeEvent
- * @return {boolean}
- */
-
-function isUsingKoreanIME(nativeEvent) {
-  return nativeEvent.locale === "ko";
-} // Track the current IME composition status, if any.
 
-var isComposing = false;
-/**
- * @return {?object} A SyntheticCompositionEvent.
- */
+function enterHydrationState(fiber) {
+  var parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance =
+    getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  didSuspendOrErrorDEV = false;
+  rootOrSingletonContext = true;
+  return true;
+}
 
-function extractCompositionEvent(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget
+function reenterHydrationStateFromDehydratedSuspenseInstance(
+  fiber,
+  suspenseInstance,
+  treeContext
 ) {
-  var eventType;
-  var fallbackData;
+  nextHydratableInstance =
+    getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  didSuspendOrErrorDEV = false;
+  rootOrSingletonContext = false;
 
-  if (canUseCompositionEvent) {
-    eventType = getCompositionEventType(domEventName);
-  } else if (!isComposing) {
-    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
-      eventType = "onCompositionStart";
-    }
-  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
-    eventType = "onCompositionEnd";
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
   }
 
-  if (!eventType) {
-    return null;
-  }
+  return true;
+}
 
-  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
-    // The current composition is stored statically and must not be
-    // overwritten while composition continues.
-    if (!isComposing && eventType === "onCompositionStart") {
-      isComposing = initialize(nativeEventTarget);
-    } else if (eventType === "onCompositionEnd") {
-      if (isComposing) {
-        fallbackData = getData();
+function warnUnhydratedInstance(returnFiber, instance) {
+  {
+    switch (returnFiber.tag) {
+      case HostRoot: {
+        didNotHydrateInstanceWithinContainer(
+          returnFiber.stateNode.containerInfo,
+          instance
+        );
+        break;
       }
-    }
-  }
-
-  var listeners = accumulateTwoPhaseListeners(targetInst, eventType);
-
-  if (listeners.length > 0) {
-    var event = new SyntheticCompositionEvent(
-      eventType,
-      domEventName,
-      null,
-      nativeEvent,
-      nativeEventTarget
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
 
-    if (fallbackData) {
-      // Inject data generated from fallback path into the synthetic event.
-      // This matches the property of native CompositionEventInterface.
-      // $FlowFixMe[incompatible-use]
-      event.data = fallbackData;
-    } else {
-      var customData = getDataFromCustomEvent(nativeEvent);
+      case HostSingleton:
+      case HostComponent: {
+        var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+        didNotHydrateInstance(
+          returnFiber.type,
+          returnFiber.memoizedProps,
+          returnFiber.stateNode,
+          instance, // TODO: Delete this argument when we remove the legacy root API.
+          isConcurrentMode
+        );
+        break;
+      }
 
-      if (customData !== null) {
-        // $FlowFixMe[incompatible-use]
-        event.data = customData;
+      case SuspenseComponent: {
+        var suspenseState = returnFiber.memoizedState;
+        if (suspenseState.dehydrated !== null)
+          didNotHydrateInstanceWithinSuspenseInstance(
+            suspenseState.dehydrated,
+            instance
+          );
+        break;
       }
     }
   }
 }
 
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
+function deleteHydratableInstance(returnFiber, instance) {
+  warnUnhydratedInstance(returnFiber, instance);
+  var childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  var deletions = returnFiber.deletions;
 
-    case "keypress":
-      /**
-       * If native `textInput` events are available, our goal is to make
-       * use of them. However, there is a special case: the spacebar key.
-       * In Webkit, preventing default on a spacebar `textInput` event
-       * cancels character insertion, but it *also* causes the browser
-       * to fall back to its default spacebar behavior of scrolling the
-       * page.
-       *
-       * Tracking at:
-       * https://code.google.com/p/chromium/issues/detail?id=355103
-       *
-       * To avoid this issue, use the keypress event as if no `textInput`
-       * event is available.
-       */
-      var which = nativeEvent.which;
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
 
-      if (which !== SPACEBAR_CODE) {
-        return null;
-      }
+function warnNonhydratedInstance(returnFiber, fiber) {
+  {
+    if (didSuspendOrErrorDEV) {
+      // Inside a boundary that already suspended. We're currently rendering the
+      // siblings of a suspended node. The mismatch may be due to the missing
+      // data, so it's probably a false positive.
+      return;
+    }
 
-      hasSpaceKeypress = true;
-      return SPACEBAR_CHAR;
+    switch (returnFiber.tag) {
+      case HostRoot: {
+        var parentContainer = returnFiber.stateNode.containerInfo;
 
-    case "textInput":
-      // Record the characters to be added to the DOM.
-      var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
-      // it at the keypress level and bail immediately. Android Chrome
-      // doesn't give us keycodes, so we need to ignore it.
+        switch (fiber.tag) {
+          case HostSingleton:
+          case HostComponent:
+            var type = fiber.type;
+            didNotFindHydratableInstanceWithinContainer(parentContainer, type);
+            break;
 
-      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
-        return null;
-      }
+          case HostText:
+            var text = fiber.pendingProps;
+            didNotFindHydratableTextInstanceWithinContainer(
+              parentContainer,
+              text
+            );
+            break;
+        }
 
-      return chars;
+        break;
+      }
 
-    default:
-      // For other native event types, do nothing.
-      return null;
-  }
-}
-/**
- * For browsers that do not provide the `textInput` event, extract the
- * appropriate string to use for SyntheticInputEvent.
- */
+      case HostSingleton:
+      case HostComponent: {
+        var parentType = returnFiber.type;
+        var parentProps = returnFiber.memoizedProps;
+        var parentInstance = returnFiber.stateNode;
 
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  // If we are currently composing (IME) and using a fallback to do so,
-  // try to extract the composed characters from the fallback object.
-  // If composition event is available, we extract a string only at
-  // compositionevent, otherwise extract it at fallback events.
-  if (isComposing) {
-    if (
-      domEventName === "compositionend" ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-    ) {
-      var chars = getData();
-      reset();
-      isComposing = false;
-      return chars;
-    }
+        switch (fiber.tag) {
+          case HostSingleton:
+          case HostComponent: {
+            var _type = fiber.type;
+            var _props = fiber.pendingProps;
+            var isConcurrentMode =
+              (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotFindHydratableInstance(
+              parentType,
+              parentProps,
+              parentInstance,
+              _type,
+              _props, // TODO: Delete this argument when we remove the legacy root API.
+              isConcurrentMode
+            );
+            break;
+          }
 
-    return null;
-  }
+          case HostText: {
+            var _text = fiber.pendingProps;
 
-  switch (domEventName) {
-    case "paste":
-      // If a paste event occurs after a keypress, throw out the input
-      // chars. Paste events should not lead to BeforeInput events.
-      return null;
+            var _isConcurrentMode =
+              (returnFiber.mode & ConcurrentMode) !== NoMode;
 
-    case "keypress":
-      /**
-       * As of v27, Firefox may fire keypress events even when no character
-       * will be inserted. A few possibilities:
-       *
-       * - `which` is `0`. Arrow keys, Esc key, etc.
-       *
-       * - `which` is the pressed key code, but no char is available.
-       *   Ex: 'AltGr + d` in Polish. There is no modified character for
-       *   this key combination and no character is inserted into the
-       *   document, but FF fires the keypress for char code `100` anyway.
-       *   No `input` event will occur.
-       *
-       * - `which` is the pressed key code, but a command combination is
-       *   being used. Ex: `Cmd+C`. No character is inserted, and no
-       *   `input` event will occur.
-       */
-      if (!isKeypressCommand(nativeEvent)) {
-        // IE fires the `keypress` event when a user types an emoji via
-        // Touch keyboard of Windows.  In such a case, the `char` property
-        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
-        // is 2, the property `which` does not represent an emoji correctly.
-        // In such a case, we directly return the `char` property instead of
-        // using `which`.
-        if (nativeEvent.char && nativeEvent.char.length > 1) {
-          return nativeEvent.char;
-        } else if (nativeEvent.which) {
-          return String.fromCharCode(nativeEvent.which);
+            didNotFindHydratableTextInstance(
+              parentType,
+              parentProps,
+              parentInstance,
+              _text, // TODO: Delete this argument when we remove the legacy root API.
+              _isConcurrentMode
+            );
+            break;
+          }
         }
+
+        break;
       }
 
-      return null;
+      case SuspenseComponent: {
+        var suspenseState = returnFiber.memoizedState;
+        var _parentInstance = suspenseState.dehydrated;
+        if (_parentInstance !== null)
+          switch (fiber.tag) {
+            case HostSingleton:
+            case HostComponent:
+              var _type2 = fiber.type;
+              didNotFindHydratableInstanceWithinSuspenseInstance(
+                _parentInstance,
+                _type2
+              );
+              break;
 
-    case "compositionend":
-      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)
-        ? null
-        : nativeEvent.data;
+            case HostText:
+              var _text2 = fiber.pendingProps;
+              didNotFindHydratableTextInstanceWithinSuspenseInstance(
+                _parentInstance,
+                _text2
+              );
+              break;
+          }
+        break;
+      }
 
-    default:
-      return null;
+      default:
+        return;
+    }
   }
 }
-/**
- * Extract a SyntheticInputEvent for `beforeInput`, based on either native
- * `textInput` or fallback behavior.
- *
- * @return {?object} A SyntheticInputEvent.
- */
 
-function extractBeforeInputEvent(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget
-) {
-  var chars;
-
-  if (canUseTextInputEvent) {
-    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
-  } else {
-    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
-  } // If no characters are being inserted, no BeforeInput event should
-  // be fired.
-
-  if (!chars) {
-    return null;
-  }
-
-  var listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & ~Hydrating) | Placement;
+  warnNonhydratedInstance(returnFiber, fiber);
+}
 
-  if (listeners.length > 0) {
-    var event = new SyntheticInputEvent(
-      "onBeforeInput",
-      "beforeinput",
-      null,
-      nativeEvent,
-      nativeEventTarget
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    }); // $FlowFixMe[incompatible-use]
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  var instance = canHydrateInstance(nextInstance, fiber.type);
 
-    event.data = chars;
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
   }
-}
-/**
- * Create an `onBeforeInput` event to match
- * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
- *
- * This event plugin is based on the native `textInput` event
- * available in Chrome, Safari, Opera, and IE. This event fires after
- * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
- *
- * `beforeInput` is spec'd but not implemented in any browsers, and
- * the `input` event does not provide any useful information about what has
- * actually been added, contrary to the spec. Thus, `textInput` is the best
- * available event to identify the characters that have actually been inserted
- * into the target node.
- *
- * This plugin is also responsible for emitting `composition` events, thus
- * allowing us to share composition fallback code for both `beforeInput` and
- * `composition` event types.
- */
 
-function extractEvents$5(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  extractCompositionEvent(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  );
-  extractBeforeInputEvent(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  );
+  return false;
 }
 
-/**
- * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
- */
-var supportedInputTypes = {
-  color: true,
-  date: true,
-  datetime: true,
-  "datetime-local": true,
-  email: true,
-  month: true,
-  number: true,
-  password: true,
-  range: true,
-  search: true,
-  tel: true,
-  text: true,
-  time: true,
-  url: true,
-  week: true
-};
-
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  var text = fiber.pendingProps;
+  var textInstance = canHydrateTextInstance(nextInstance, text);
 
-  if (nodeName === "input") {
-    return !!supportedInputTypes[elem.type];
-  }
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
 
-  if (nodeName === "textarea") {
+    nextHydratableInstance = null;
     return true;
   }
 
   return false;
 }
 
-/**
- * Checks if an event is supported in the current execution environment.
- *
- * NOTE: This will not work correctly for non-generic events such as `change`,
- * `reset`, `load`, `error`, and `select`.
- *
- * Borrows from Modernizr.
- *
- * @param {string} eventNameSuffix Event name, e.g. "click".
- * @return {boolean} True if the event is supported.
- * @internal
- * @license Modernizr 3.0.0pre (Custom Build) | MIT
- */
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
 
-function isEventSupported(eventNameSuffix) {
-  if (!canUseDOM) {
-    return false;
-  }
+  if (suspenseInstance !== null) {
+    var suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
 
-  var eventName = "on" + eventNameSuffix;
-  var isSupported = eventName in document;
+    var dehydratedFragment =
+      createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
 
-  if (!isSupported) {
-    var element = document.createElement("div");
-    element.setAttribute(eventName, "return;");
-    isSupported = typeof element[eventName] === "function";
+    nextHydratableInstance = null;
+    return true;
   }
 
-  return isSupported;
-}
-
-function registerEvents$2() {
-  registerTwoPhaseEvent("onChange", [
-    "change",
-    "click",
-    "focusin",
-    "focusout",
-    "input",
-    "keydown",
-    "keyup",
-    "selectionchange"
-  ]);
+  return false;
 }
 
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
-) {
-  // Flag this event loop as needing state restore.
-  enqueueStateRestore(target);
-  var listeners = accumulateTwoPhaseListeners(inst, "onChange");
-
-  if (listeners.length > 0) {
-    var event = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
-  }
+function shouldClientRenderOnMismatch(fiber) {
+  return (
+    (fiber.mode & ConcurrentMode) !== NoMode &&
+    (fiber.flags & DidCapture) === NoFlags$1
+  );
 }
-/**
- * For IE shims
- */
-
-var activeElement$1 = null;
-var activeElementInst$1 = null;
-/**
- * SECTION: handle `change` event
- */
 
-function shouldUseChangeEvent(elem) {
-  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName === "select" || (nodeName === "input" && elem.type === "file")
+function throwOnHydrationMismatch(fiber) {
+  throw new Error(
+    "Hydration failed because the initial UI does not match what was " +
+      "rendered on the server."
   );
 }
 
-function manualDispatchChangeEvent(nativeEvent) {
-  var dispatchQueue = [];
-  createAndAccumulateChangeEvent(
-    dispatchQueue,
-    activeElementInst$1,
-    nativeEvent,
-    getEventTarget(nativeEvent)
-  ); // If change and propertychange bubbled, we'd just bind to it like all the
-  // other events and have it go through ReactBrowserEventEmitter. Since it
-  // doesn't, we manually listen for the events and so we have to enqueue and
-  // process the abstract event manually.
-  //
-  // Batching is necessary here in order to ensure that all event handlers run
-  // before the next rerender (including event handlers attached to ancestor
-  // elements instead of directly on the input). Without this, controlled
-  // components don't work properly in conjunction with event bubbling because
-  // the component is rerendered and the value reverted before all the event
-  // handlers can run. See https://github.com/facebook/react/issues/708.
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
 
-  batchedUpdates$1(runEventInBatch, dispatchQueue);
+    var currentRootContainer = getRootHostContainer();
+    var currentHostContext = getHostContext();
+    var instance = (fiber.stateNode = resolveSingletonInstance(
+      fiber.type,
+      fiber.pendingProps,
+      currentRootContainer,
+      currentHostContext,
+      false
+    ));
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+  }
 }
 
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
+function advanceToFirstAttemptableInstance(fiber) {
+  // fiber is HostComponent Fiber
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    )
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
+  }
 }
 
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
-
-  if (updateValueIfChanged(targetNode)) {
-    return targetInst;
+function advanceToFirstAttemptableTextInstance() {
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForTextInstance(nextHydratableInstance)
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
   }
 }
 
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if (domEventName === "change") {
-    return targetInst;
+function advanceToFirstAttemptableSuspenseInstance() {
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForSuspenseInstance(nextHydratableInstance)
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
   }
 }
-/**
- * SECTION: handle `input` event
- */
 
-var isInputEventSupported = false;
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-if (canUseDOM) {
-  // IE9 claims to support the input event but fails to trigger it when
-  // deleting text, so we ignore its input events.
-  isInputEventSupported =
-    isEventSupported("input") &&
-    (!document.documentMode || document.documentMode > 9);
-}
-/**
- * (For IE <=9) Starts tracking propertychange events on the passed-in element
- * and override the value property so that we can distinguish user events from
- * value changes in JS.
- */
+  {
+    if (!isHydratableType(fiber.type, fiber.pendingProps)) {
+      // This fiber never hydrates from the DOM and always does an insert
+      fiber.flags = (fiber.flags & ~Hydrating) | Placement;
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      return;
+    }
+  }
 
-function startWatchingForValueChange(target, targetInst) {
-  activeElement$1 = target;
-  activeElementInst$1 = targetInst;
-  activeElement$1.attachEvent("onpropertychange", handlePropertyChange);
-}
-/**
- * (For IE <=9) Removes the event listeners from the currently-tracked element,
- * if any exists.
- */
+  var initialInstance = nextHydratableInstance;
 
-function stopWatchingForValueChange() {
-  if (!activeElement$1) {
-    return;
+  if (rootOrSingletonContext) {
+    // We may need to skip past certain nodes in these contexts
+    advanceToFirstAttemptableInstance(fiber);
   }
 
-  activeElement$1.detachEvent("onpropertychange", handlePropertyChange);
-  activeElement$1 = null;
-  activeElementInst$1 = null;
-}
-/**
- * (For IE <=9) Handles a propertychange event, sending a `change` event if
- * the value of the active element has changed.
- */
-// $FlowFixMe[missing-local-annot]
+  var nextInstance = nextHydratableInstance;
 
-function handlePropertyChange(nativeEvent) {
-  if (nativeEvent.propertyName !== "value") {
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
     return;
   }
 
-  if (getInstIfValueChanged(activeElementInst$1)) {
-    manualDispatchChangeEvent(nativeEvent);
-  }
-}
+  var firstAttemptedInstance = nextInstance;
 
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  if (domEventName === "focusin") {
-    // In IE9, propertychange fires for most input events but is buggy and
-    // doesn't fire when text is deleted, but conveniently, selectionchange
-    // appears to fire in all of the remaining cases so we catch those and
-    // forward the event if the value has changed
-    // In either case, we don't want to call the event handler if the value
-    // is changed from JS so we redefine a setter for `.value` that updates
-    // our activeElementValue variable, allowing us to ignore those changes
-    //
-    // stopWatching() should be a noop here but we call it just in case we
-    // missed a blur event somehow.
-    stopWatchingForValueChange();
-    startWatchingForValueChange(target, targetInst);
-  } else if (domEventName === "focusout") {
-    stopWatchingForValueChange();
-  }
-} // For IE8 and IE9.
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
-  if (
-    domEventName === "selectionchange" ||
-    domEventName === "keyup" ||
-    domEventName === "keydown"
-  ) {
-    // On the selectionchange event, the target is just document which isn't
-    // helpful for us so just check activeElement instead.
-    //
-    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
-    // propertychange on the first input event after setting `value` from a
-    // script and fires only keydown, keypress, keyup. Catching keyup usually
-    // gets it and catching keydown lets us fire an event for the first
-    // keystroke if user does a key repeat (it'll be a little delayed: right
-    // before the second keystroke). Other input methods (e.g., paste) seem to
-    // fire selectionchange normally.
-    return getInstIfValueChanged(activeElementInst$1);
-  }
-}
-/**
- * SECTION: handle `click` event
- */
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
 
-function shouldUseClickEvent(elem) {
-  // Use the `click` event to detect changes to checkbox and radio inputs.
-  // This approach works across all browsers, whereas `change` does not fire
-  // until `blur` in IE8.
-  var nodeName = elem.nodeName;
-  return (
-    nodeName &&
-    nodeName.toLowerCase() === "input" &&
-    (elem.type === "checkbox" || elem.type === "radio")
-  );
-}
+    if (rootOrSingletonContext) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableInstance(fiber);
+    }
 
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if (domEventName === "click") {
-    return getInstIfValueChanged(targetInst);
-  }
-}
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateInstance(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if (domEventName === "input" || domEventName === "change") {
-    return getInstIfValueChanged(targetInst);
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
   }
 }
 
-function handleControlledInputBlur(node) {
-  var state = node._wrapperState;
-
-  if (!state || !state.controlled || node.type !== "number") {
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
     return;
   }
 
-  if (!disableInputAttributeSyncing) {
-    // If controlled, assign the value attribute to the current value on blur
-    setDefaultValue(node, "number", node.value);
+  var text = fiber.pendingProps;
+  var isHydratable = isHydratableText(text);
+  var initialInstance = nextHydratableInstance;
+
+  if (rootOrSingletonContext && isHydratable) {
+    // We may need to skip past certain nodes in these contexts.
+    // We don't skip if the text is not hydratable because we know no hydratables
+    // exist which could match this Fiber
+    advanceToFirstAttemptableTextInstance();
   }
-}
-/**
- * This plugin creates an `onChange` event that normalizes change events
- * across form elements. This event fires at a time when it's possible to
- * change the element's value without seeing a flicker.
- *
- * Supported elements are:
- * - input (see `isTextInputElement`)
- * - textarea
- * - select
- */
 
-function extractEvents$4(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
-  var getTargetInstFunc, handleEventFunc;
+  var nextInstance = nextHydratableInstance;
 
-  if (shouldUseChangeEvent(targetNode)) {
-    getTargetInstFunc = getTargetInstForChangeEvent;
-  } else if (isTextInputElement(targetNode)) {
-    if (isInputEventSupported) {
-      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-    } else {
-      getTargetInstFunc = getTargetInstForInputEventPolyfill;
-      handleEventFunc = handleEventsForInputEventPolyfill;
-    }
-  } else if (shouldUseClickEvent(targetNode)) {
-    getTargetInstFunc = getTargetInstForClickEvent;
-  } else if (
-    enableCustomElementPropertySupport &&
-    targetInst &&
-    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
-  ) {
-    getTargetInstFunc = getTargetInstForChangeEvent;
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
   }
 
-  if (getTargetInstFunc) {
-    var inst = getTargetInstFunc(domEventName, targetInst);
+  var firstAttemptedInstance = nextInstance;
 
-    if (inst) {
-      createAndAccumulateChangeEvent(
-        dispatchQueue,
-        inst,
-        nativeEvent,
-        nativeEventTarget
-      );
-      return;
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
+
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
+
+    if (rootOrSingletonContext && isHydratable) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableTextInstance();
     }
-  }
 
-  if (handleEventFunc) {
-    handleEventFunc(domEventName, targetNode, targetInst);
-  } // When blurring, set the value attribute for number inputs
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateText(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-  if (domEventName === "focusout") {
-    handleControlledInputBlur(targetNode);
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
   }
 }
 
-function registerEvents$1() {
-  registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-  registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-  registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-  registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
-}
-/**
- * For almost every interaction we care about, there will be both a top-level
- * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
- * we do not extract duplicate events. However, moving the mouse into the
- * browser from outside will not fire a `mouseout` event. In this case, we use
- * the `mouseover` top-level event.
- */
-
-function extractEvents$3(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var isOverEvent =
-    domEventName === "mouseover" || domEventName === "pointerover";
-  var isOutEvent = domEventName === "mouseout" || domEventName === "pointerout";
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
-    // If this is an over event with a target, we might have already dispatched
-    // the event in the out event of the other target. If this is replayed,
-    // then it's because we couldn't dispatch against this target previously
-    // so we have to do it now instead.
-    var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+  var initialInstance = nextHydratableInstance;
 
-    if (related) {
-      // If the related node is managed by React, we can assume that we have
-      // already dispatched the corresponding events during its mouseout.
-      if (
-        getClosestInstanceFromNode(related) ||
-        isContainerMarkedAsRoot(related)
-      ) {
-        return;
-      }
-    }
+  if (rootOrSingletonContext) {
+    // We may need to skip past certain nodes in these contexts
+    advanceToFirstAttemptableSuspenseInstance();
   }
 
-  if (!isOutEvent && !isOverEvent) {
-    // Must not be a mouse or pointer in or out - ignoring.
+  var nextInstance = nextHydratableInstance;
+
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
+
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
     return;
   }
 
-  var win; // TODO: why is this nullable in the types but we read from it?
+  var firstAttemptedInstance = nextInstance;
 
-  if (nativeEventTarget.window === nativeEventTarget) {
-    // `nativeEventTarget` is probably a window object.
-    win = nativeEventTarget;
-  } else {
-    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
-    var doc = nativeEventTarget.ownerDocument;
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-    if (doc) {
-      win = doc.defaultView || doc.parentWindow;
-    } else {
-      win = window;
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
+
+    if (rootOrSingletonContext) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableSuspenseInstance();
     }
+
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateSuspense(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
+
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
   }
+}
 
-  var from;
-  var to;
+function prepareToHydrateHostInstance(fiber, hostContext) {
+  var instance = fiber.stateNode;
+  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
+  var updatePayload = hydrateInstance(
+    instance,
+    fiber.type,
+    fiber.memoizedProps,
+    hostContext,
+    fiber,
+    shouldWarnIfMismatchDev
+  ); // TODO: Type this specific to this type of component.
 
-  if (isOutEvent) {
-    var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
+  fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
+  // is a new ref we mark this as an update.
 
-    from = targetInst;
-    to = _related ? getClosestInstanceFromNode(_related) : null;
+  if (updatePayload !== null) {
+    return true;
+  }
 
-    if (to !== null) {
-      var nearestMounted = getNearestMountedFiber(to);
-      var tag = to.tag;
+  return false;
+}
 
-      if (
-        to !== nearestMounted ||
-        (tag !== HostComponent && tag !== HostSingleton && tag !== HostText)
-      ) {
-        to = null;
+function prepareToHydrateHostTextInstance(fiber) {
+  var textInstance = fiber.stateNode;
+  var textContent = fiber.memoizedProps;
+  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
+  var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    var returnFiber = hydrationParentFiber;
+
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot: {
+          var parentContainer = returnFiber.stateNode.containerInfo;
+          var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+          didNotMatchHydratedContainerTextInstance(
+            parentContainer,
+            textInstance,
+            textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode,
+            shouldWarnIfMismatchDev
+          );
+          break;
+        }
+
+        case HostSingleton:
+        case HostComponent: {
+          var parentType = returnFiber.type;
+          var parentProps = returnFiber.memoizedProps;
+          var parentInstance = returnFiber.stateNode;
+
+          var _isConcurrentMode2 =
+            (returnFiber.mode & ConcurrentMode) !== NoMode;
+
+          didNotMatchHydratedTextInstance(
+            parentType,
+            parentProps,
+            parentInstance,
+            textInstance,
+            textContent, // TODO: Delete this argument when we remove the legacy root API.
+            _isConcurrentMode2,
+            shouldWarnIfMismatchDev
+          );
+          break;
+        }
       }
     }
-  } else {
-    // Moving to a node from outside the window.
-    from = null;
-    to = targetInst;
   }
 
-  if (from === to) {
-    // Nothing pertains to our managed components.
-    return;
-  }
+  return shouldUpdate;
+}
 
-  var SyntheticEventCtor = SyntheticMouseEvent;
-  var leaveEventType = "onMouseLeave";
-  var enterEventType = "onMouseEnter";
-  var eventTypePrefix = "mouse";
+function prepareToHydrateHostSuspenseInstance(fiber) {
+  var suspenseState = fiber.memoizedState;
+  var suspenseInstance =
+    suspenseState !== null ? suspenseState.dehydrated : null;
 
-  if (domEventName === "pointerout" || domEventName === "pointerover") {
-    SyntheticEventCtor = SyntheticPointerEvent;
-    leaveEventType = "onPointerLeave";
-    enterEventType = "onPointerEnter";
-    eventTypePrefix = "pointer";
+  if (!suspenseInstance) {
+    throw new Error(
+      "Expected to have a hydrated suspense instance. " +
+        "This error is likely caused by a bug in React. Please file an issue."
+    );
   }
 
-  var fromNode = from == null ? win : getNodeFromInstance(from);
-  var toNode = to == null ? win : getNodeFromInstance(to);
-  var leave = new SyntheticEventCtor(
-    leaveEventType,
-    eventTypePrefix + "leave",
-    from,
-    nativeEvent,
-    nativeEventTarget
-  );
-  leave.target = fromNode;
-  leave.relatedTarget = toNode;
-  var enter = null; // We should only process this nativeEvent if we are processing
-  // the first ancestor. Next time, we will ignore the event.
+  hydrateSuspenseInstance(suspenseInstance, fiber);
+}
 
-  var nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+function skipPastDehydratedSuspenseInstance(fiber) {
+  var suspenseState = fiber.memoizedState;
+  var suspenseInstance =
+    suspenseState !== null ? suspenseState.dehydrated : null;
 
-  if (nativeTargetInst === targetInst) {
-    var enterEvent = new SyntheticEventCtor(
-      enterEventType,
-      eventTypePrefix + "enter",
-      to,
-      nativeEvent,
-      nativeEventTarget
+  if (!suspenseInstance) {
+    throw new Error(
+      "Expected to have a hydrated suspense instance. " +
+        "This error is likely caused by a bug in React. Please file an issue."
     );
-    enterEvent.target = toNode;
-    enterEvent.relatedTarget = fromNode;
-    enter = enterEvent;
   }
 
-  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
 }
 
-/**
- * inlined Object.is polyfill to avoid requiring consumers ship their own
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
- */
-function is(x, y) {
-  return (
-    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
-  );
-}
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
 
-var objectIs = typeof Object.is === "function" ? Object.is : is; // $FlowFixMe[method-unbinding]
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
 
-/**
- * Performs equality by iterating through keys on an object and returning false
- * when any key has values which are not strictly equal between the arguments.
- * Returns true when the values of all keys are strictly equal.
- */
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
 
-function shallowEqual(objA, objB) {
-  if (objectIs(objA, objB)) {
-    return true;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
   }
+}
 
-  if (
-    typeof objA !== "object" ||
-    objA === null ||
-    typeof objB !== "object" ||
-    objB === null
-  ) {
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
     return false;
   }
 
-  var keysA = Object.keys(objA);
-  var keysB = Object.keys(objB);
-
-  if (keysA.length !== keysB.length) {
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
     return false;
-  } // Test for A's keys different from B.
+  }
 
-  for (var i = 0; i < keysA.length; i++) {
-    var currentKey = keysA[i];
+  var shouldClear = false;
 
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
     if (
-      !hasOwnProperty.call(objB, currentKey) ||
-      !objectIs(objA[currentKey], objB[currentKey])
+      fiber.tag !== HostRoot &&
+      fiber.tag !== HostSingleton &&
+      !(
+        fiber.tag === HostComponent &&
+        shouldSetTextContent(fiber.type, fiber.memoizedProps)
+      )
     ) {
-      return false;
+      shouldClear = true;
     }
   }
 
+  if (shouldClear) {
+    var nextInstance = nextHydratableInstance;
+
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes(fiber);
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
+
+  popToNextHostParent(fiber);
+
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratableSibling(fiber.stateNode)
+      : null;
+  }
+
   return true;
 }
 
-var skipSelectionChangeEvent =
-  canUseDOM && "documentMode" in document && document.documentMode <= 11;
-
-function registerEvents() {
-  registerTwoPhaseEvent("onSelect", [
-    "focusout",
-    "contextmenu",
-    "dragend",
-    "focusin",
-    "keydown",
-    "keyup",
-    "mousedown",
-    "mouseup",
-    "selectionchange"
-  ]);
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
 }
 
-var activeElement = null;
-var activeElementInst = null;
-var lastSelection = null;
-var mouseDown = false;
-/**
- * Get an object which is a unique representation of the current selection.
- *
- * The return value will not be consistent across nodes or browsers, but
- * two identical selections on the same node will return identical objects.
- */
+function warnIfUnhydratedTailNodes(fiber) {
+  var nextInstance = nextHydratableInstance;
 
-function getSelection(node) {
-  if ("selectionStart" in node && hasSelectionCapabilities(node)) {
-    return {
-      start: node.selectionStart,
-      end: node.selectionEnd
-    };
-  } else {
-    var win = (node.ownerDocument && node.ownerDocument.defaultView) || window;
-    var selection = win.getSelection();
-    return {
-      anchorNode: selection.anchorNode,
-      anchorOffset: selection.anchorOffset,
-      focusNode: selection.focusNode,
-      focusOffset: selection.focusOffset
-    };
+  while (nextInstance) {
+    warnUnhydratedInstance(fiber, nextInstance);
+    nextInstance = getNextHydratableSibling(nextInstance);
   }
 }
-/**
- * Get document associated with the event target.
- */
 
-function getEventTargetDocument(eventTarget) {
-  return eventTarget.window === eventTarget
-    ? eventTarget.document
-    : eventTarget.nodeType === DOCUMENT_NODE
-    ? eventTarget
-    : eventTarget.ownerDocument;
+function resetHydrationState() {
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+  didSuspendOrErrorDEV = false;
 }
-/**
- * Poll selection to see whether it's changed.
- *
- * @param {object} nativeEvent
- * @param {object} nativeEventTarget
- * @return {?SyntheticEvent}
- */
 
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  // Ensure we have the right element, and that the user is not dragging a
-  // selection (this matches native `select` event behavior). In HTML5, select
-  // fires only on input and textarea thus if there's no focused element we
-  // won't dispatch.
-  var doc = getEventTargetDocument(nativeEventTarget);
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
+  }
+}
 
-  if (
-    mouseDown ||
-    activeElement == null ||
-    activeElement !== getActiveElement(doc)
-  ) {
-    return;
-  } // Only fire when selection has actually changed.
+function getIsHydrating() {
+  return isHydrating;
+}
 
-  var currentSelection = getSelection(activeElement);
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
+  }
+}
 
-  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
-    lastSelection = currentSelection;
-    var listeners = accumulateTwoPhaseListeners(activeElementInst, "onSelect");
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
 
-    if (listeners.length > 0) {
-      var event = new SyntheticEvent(
-        "onSelect",
-        "select",
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
-      dispatchQueue.push({
-        event: event,
-        listeners: listeners
-      });
-      event.target = activeElement;
-    }
-  }
-}
-/**
- * This plugin creates an `onSelect` event that normalizes select events
- * across form elements.
- *
- * Supported elements are:
- * - input (see `isTextInputElement`)
- * - textarea
- * - contentEditable
- *
- * This differs from native browser implementations in the following ways:
- * - Fires on contentEditable fields as well as inputs.
- * - Fires for collapsed selection.
- * - Fires after user input.
- */
+var concurrentQueues = [];
+var concurrentQueuesIndex = 0;
+var concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  var endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  var i = 0;
 
-function extractEvents$2(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  while (i < endIndex) {
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
 
-  switch (domEventName) {
-    // Track the input node that has focus.
-    case "focusin":
-      if (
-        isTextInputElement(targetNode) ||
-        targetNode.contentEditable === "true"
-      ) {
-        activeElement = targetNode;
-        activeElementInst = targetInst;
-        lastSelection = null;
+    if (queue !== null && update !== null) {
+      var pending = queue.pending;
+
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
       }
 
-      break;
+      queue.pending = update;
+    }
 
-    case "focusout":
-      activeElement = null;
-      activeElementInst = null;
-      lastSelection = null;
-      break;
-    // Don't fire the event while the user is dragging. This matches the
-    // semantics of the native select event.
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+}
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
+}
 
-    case "mousedown":
-      mouseDown = true;
-      break;
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
 
-    case "contextmenu":
-    case "mouseup":
-    case "dragend":
-      mouseDown = false;
-      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-      break;
-    // Chrome and IE fire non-standard event when selection is changed (and
-    // sometimes when it hasn't). IE's event fires out of order with respect
-    // to key and input events on deletion, so we discard it.
-    //
-    // Firefox doesn't support selectionchange, so check selection status
-    // after each key entry. The selection changes after keydown and before
-    // keyup, but we check on keydown as well in the case of holding down a
-    // key, when multiple keydown events are fired but only one keyup is.
-    // This is also our approach for IE handling, for the reason above.
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  var alternate = fiber.alternate;
 
-    case "selectionchange":
-      if (skipSelectionChangeEvent) {
-        break;
-      }
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
+}
 
-    // falls through
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  var lane = NoLane;
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
 
-    case "keydown":
-    case "keyup":
-      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  var isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
   }
 }
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
 
-/**
- * Generate a mapping of standard vendor prefixes using the defined style property and event name.
- *
- * @param {string} styleProp
- * @param {string} eventName
- * @returns {object}
- */
-
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  var root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
 }
-/**
- * A list of event names to a configurable list of vendor prefixes.
- */
 
-var vendorPrefixes = {
-  animationend: makePrefixMap("Animation", "AnimationEnd"),
-  animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-  animationstart: makePrefixMap("Animation", "AnimationStart"),
-  transitionend: makePrefixMap("Transition", "TransitionEnd")
-};
-/**
- * Event names that have already been detected and prefixed (if applicable).
- */
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  var alternate = sourceFiber.alternate;
 
-var prefixedEventNames = {};
-/**
- * Element to check for prefixes on.
- */
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
 
-var style = {};
-/**
- * Bootstrap if a DOM exists.
- */
+  var isHidden = false;
+  var parent = sourceFiber.return;
+  var node = sourceFiber;
 
-if (canUseDOM) {
-  style = document.createElement("div").style; // On some platforms, in particular some releases of Android 4.x,
-  // the un-prefixed "animation" and "transition" properties are defined on the
-  // style object but the events that fire will still be prefixed, so we need
-  // to check if the un-prefixed events are usable, and if not remove them from the map.
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
 
-  if (!("AnimationEvent" in window)) {
-    delete vendorPrefixes.animationend.animation;
-    delete vendorPrefixes.animationiteration.animation;
-    delete vendorPrefixes.animationstart.animation;
-  } // Same as above
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
 
-  if (!("TransitionEvent" in window)) {
-    delete vendorPrefixes.transitionend.transition;
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      var offscreenInstance = parent.stateNode;
+
+      if (
+        offscreenInstance !== null &&
+        !(offscreenInstance._visibility & OffscreenVisible)
+      ) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
   }
-}
-/**
- * Attempts to determine the correct vendor prefixed event name.
- *
- * @param {string} eventName
- * @returns {string}
- */
 
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) {
-    return prefixedEventNames[eventName];
-  } else if (!vendorPrefixes[eventName]) {
-    return eventName;
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    var root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
   }
+}
 
-  var prefixMap = vendorPrefixes[eventName];
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  // update queues do not have a backpointer to the root, the only way to do
+  // this currently is to walk up the return path. This used to not be a big
+  // deal because we would have to walk up the return path to set
+  // the `childLanes`, anyway, but now those two traversals happen at
+  // different times.
+  // TODO: Consider adding a `root` backpointer on the update queue.
 
-  for (var styleProp in prefixMap) {
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
-    }
+  detectUpdateOnUnmountedFiber(sourceFiber, sourceFiber);
+  var node = sourceFiber;
+  var parent = node.return;
+
+  while (parent !== null) {
+    detectUpdateOnUnmountedFiber(sourceFiber, node);
+    node = parent;
+    parent = node.return;
   }
 
-  return eventName;
+  return node.tag === HostRoot ? node.stateNode : null;
 }
 
-var ANIMATION_END = getVendorPrefixedEventName("animationend");
-var ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration");
-var ANIMATION_START = getVendorPrefixedEventName("animationstart");
-var TRANSITION_END = getVendorPrefixedEventName("transitionend");
+function detectUpdateOnUnmountedFiber(sourceFiber, parent) {
+  {
+    var alternate = parent.alternate;
 
-var topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
-//
-// E.g. it needs "pointerDown", not "pointerdown".
-// This is because we derive both React name ("onPointerDown")
-// and DOM name ("pointerdown") from the same list.
-//
-// Exceptions that don't match this convention are listed separately.
-//
-// prettier-ignore
+    if (
+      alternate === null &&
+      (parent.flags & (Placement | Hydrating)) !== NoFlags$1
+    ) {
+      warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
+    }
+  }
+}
 
-var simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'toggle', 'touchMove', 'waiting', 'wheel'];
+var UpdateState = 0;
+var ReplaceState = 1;
+var ForceUpdate = 2;
+var CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
+
+var hasForceUpdate = false;
+var didWarnUpdateInsideUpdate;
+var currentlyProcessingQueue;
 
 {
-  // Special case: these two events don't have on* React handler
-  // and are only accessible via the createEventHandle API.
-  topLevelEventsToReactNames.set("beforeblur", null);
-  topLevelEventsToReactNames.set("afterblur", null);
+  didWarnUpdateInsideUpdate = false;
+  currentlyProcessingQueue = null;
 }
 
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
+function initializeUpdateQueue(fiber) {
+  var queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
 }
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  var queue = workInProgress.updateQueue;
+  var currentQueue = current.updateQueue;
 
-function registerSimpleEvents() {
-  for (var i = 0; i < simpleEventPluginEvents.length; i++) {
-    var eventName = simpleEventPluginEvents[i];
-    var domEventName = eventName.toLowerCase();
-    var capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
-    registerSimpleEvent(domEventName, "on" + capitalizedEvent);
-  } // Special cases where event names don't match.
-
-  registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-  registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-  registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-  registerSimpleEvent("dblclick", "onDoubleClick");
-  registerSimpleEvent("focusin", "onFocus");
-  registerSimpleEvent("focusout", "onBlur");
-  registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+  if (queue === currentQueue) {
+    var clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
+  }
 }
+function createUpdate(lane) {
+  var update = {
+    lane: lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
 
-function extractEvents$1(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var reactName = topLevelEventsToReactNames.get(domEventName);
-
-  if (reactName === undefined) {
-    return;
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
   }
 
-  var SyntheticEventCtor = SyntheticEvent;
-  var reactEventType = domEventName;
+  var sharedQueue = updateQueue.shared;
 
-  switch (domEventName) {
-    case "keypress":
-      // Firefox creates a keypress event for function keys too. This removes
-      // the unwanted keypress events. Enter is however both printable and
-      // non-printable. One would expect Tab to be as well (but it isn't).
-      if (getEventCharCode(nativeEvent) === 0) {
-        return;
-      }
+  {
+    if (
+      currentlyProcessingQueue === sharedQueue &&
+      !didWarnUpdateInsideUpdate
+    ) {
+      var componentName = getComponentNameFromFiber(fiber);
 
-    /* falls through */
+      error(
+        "An update (setState, replaceState, or forceUpdate) was scheduled " +
+          "from inside an update function. Update functions should be pure, " +
+          "with zero side-effects. Consider using componentDidUpdate or a " +
+          "callback.\n\nPlease update the following component: %s",
+        componentName
+      );
 
-    case "keydown":
-    case "keyup":
-      SyntheticEventCtor = SyntheticKeyboardEvent;
-      break;
+      didWarnUpdateInsideUpdate = true;
+    }
+  }
 
-    case "focusin":
-      reactEventType = "focus";
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+  if (isUnsafeClassRenderPhaseUpdate(fiber)) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    var pending = sharedQueue.pending;
 
-    case "focusout":
-      reactEventType = "blur";
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
 
-    case "beforeblur":
-    case "afterblur":
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
 
-    case "click":
-      // Firefox creates a click event on right mouse clicks. This removes the
-      // unwanted click events.
-      if (nativeEvent.button === 2) {
-        return;
-      }
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
+  } else {
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+  }
+}
+function entangleTransitions(root, fiber, lane) {
+  var updateQueue = fiber.updateQueue;
 
-    /* falls through */
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return;
+  }
 
-    case "auxclick":
-    case "dblclick":
-    case "mousedown":
-    case "mousemove":
-    case "mouseup": // TODO: Disabled elements should not respond to mouse events
+  var sharedQueue = updateQueue.shared;
 
-    /* falls through */
+  if (isTransitionLane(lane)) {
+    var queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
 
-    case "mouseout":
-    case "mouseover":
-    case "contextmenu":
-      SyntheticEventCtor = SyntheticMouseEvent;
-      break;
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
 
-    case "drag":
-    case "dragend":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "dragstart":
-    case "drop":
-      SyntheticEventCtor = SyntheticDragEvent;
-      break;
+    var newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
 
-    case "touchcancel":
-    case "touchend":
-    case "touchmove":
-    case "touchstart":
-      SyntheticEventCtor = SyntheticTouchEvent;
-      break;
+    markRootEntangled(root, newQueueLanes);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  var queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
 
-    case ANIMATION_END:
-    case ANIMATION_ITERATION:
-    case ANIMATION_START:
-      SyntheticEventCtor = SyntheticAnimationEvent;
-      break;
+  var current = workInProgress.alternate;
 
-    case TRANSITION_END:
-      SyntheticEventCtor = SyntheticTransitionEvent;
-      break;
+  if (current !== null) {
+    var currentQueue = current.updateQueue;
 
-    case "scroll":
-      SyntheticEventCtor = SyntheticUIEvent;
-      break;
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      var newFirst = null;
+      var newLast = null;
+      var firstBaseUpdate = queue.firstBaseUpdate;
 
-    case "wheel":
-      SyntheticEventCtor = SyntheticWheelEvent;
-      break;
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        var update = firstBaseUpdate;
 
-    case "copy":
-    case "cut":
-    case "paste":
-      SyntheticEventCtor = SyntheticClipboardEvent;
-      break;
+        do {
+          var clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
 
-    case "gotpointercapture":
-    case "lostpointercapture":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "pointerup":
-      SyntheticEventCtor = SyntheticPointerEvent;
-      break;
-  }
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
 
-  if (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) {
-    var listeners = accumulateEventHandleNonManagedNodeListeners(
-      // TODO: this cast may not make sense for events like
-      // "focus" where React listens to e.g. "focusin".
-      reactEventType,
-      targetContainer,
-      inCapturePhase
-    );
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
 
-    if (listeners.length > 0) {
-      // Intentionally create event lazily.
-      var event = new SyntheticEventCtor(
-        reactName,
-        reactEventType,
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
-      dispatchQueue.push({
-        event: event,
-        listeners: listeners
-      });
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
     }
-  } else {
-    // Some events don't bubble in the browser.
-    // In the past, React has always bubbled them, but this can be surprising.
-    // We're going to try aligning closer to the browser behavior by not bubbling
-    // them in React either. We'll start by not bubbling onScroll, and then expand.
-    var accumulateTargetOnly =
-      !inCapturePhase && // TODO: ideally, we'd eventually add all events from
-      // nonDelegatedEvents list in DOMPluginEventSystem.
-      // Then we can remove this special list.
-      // This is a breaking change that can wait until React 18.
-      domEventName === "scroll";
-
-    var _listeners = accumulateSinglePhaseListeners(
-      targetInst,
-      reactName,
-      nativeEvent.type,
-      inCapturePhase,
-      accumulateTargetOnly,
-      nativeEvent
-    );
+  } // Append the update to the end of the list.
 
-    if (_listeners.length > 0) {
-      // Intentionally create event lazily.
-      var _event = new SyntheticEventCtor(
-        reactName,
-        reactEventType,
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
+  var lastBaseUpdate = queue.lastBaseUpdate;
 
-      dispatchQueue.push({
-        event: _event,
-        listeners: _listeners
-      });
-    }
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
   }
-}
 
-registerSimpleEvents();
-registerEvents$1();
-registerEvents$2();
-registerEvents();
-registerEvents$3();
+  queue.lastBaseUpdate = capturedUpdate;
+}
 
-function extractEvents(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
+function getStateFromUpdate(
+  workInProgress,
+  queue,
+  update,
+  prevState,
+  nextProps,
+  instance
 ) {
-  // TODO: we should remove the concept of a "SimpleEventPlugin".
-  // This is the basic functionality of the event system. All
-  // the other plugins are essentially polyfills. So the plugin
-  // should probably be inlined somewhere and have its logic
-  // be core the to event system. This would potentially allow
-  // us to ship builds of React without the polyfilled plugins below.
-  extractEvents$1(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget,
-    eventSystemFlags,
-    targetContainer
-  );
-  var shouldProcessPolyfillPlugins =
-    (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
-  // event's native "bubble" phase, which means that we're
-  // not in the capture phase. That's because we emulate
-  // the capture phase here still. This is a trade-off,
-  // because in an ideal world we would not emulate and use
-  // the phases properly, like we do with the SimpleEvent
-  // plugin. However, the plugins below either expect
-  // emulation (EnterLeave) or use state localized to that
-  // plugin (BeforeInput, Change, Select). The state in
-  // these modules complicates things, as you'll essentially
-  // get the case where the capture phase event might change
-  // state, only for the following bubble event to come in
-  // later and not trigger anything as the state now
-  // invalidates the heuristics of the event plugin. We
-  // could alter all these plugins to work in such ways, but
-  // that might cause other unknown side-effects that we
-  // can't foresee right now.
+  switch (update.tag) {
+    case ReplaceState: {
+      var payload = update.payload;
 
-  if (shouldProcessPolyfillPlugins) {
-    extractEvents$3(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$4(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$2(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$5(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-  }
-} // List of events that need to be individually attached to media elements.
+      if (typeof payload === "function") {
+        // Updater function
+        {
+          enterDisallowedContextReadInDEV();
+        }
 
-var mediaEventTypes = [
-  "abort",
-  "canplay",
-  "canplaythrough",
-  "durationchange",
-  "emptied",
-  "encrypted",
-  "ended",
-  "error",
-  "loadeddata",
-  "loadedmetadata",
-  "loadstart",
-  "pause",
-  "play",
-  "playing",
-  "progress",
-  "ratechange",
-  "resize",
-  "seeked",
-  "seeking",
-  "stalled",
-  "suspend",
-  "timeupdate",
-  "volumechange",
-  "waiting"
-]; // We should not delegate these events to the container, but rather
-// set them on the actual target element itself. This is primarily
-// because these events do not consistently bubble in the DOM.
+        var nextState = payload.call(instance, prevState, nextProps);
 
-var nonDelegatedEvents = new Set(
-  ["cancel", "close", "invalid", "load", "scroll", "toggle"].concat(
-    mediaEventTypes
-  )
-);
+        {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
 
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
-  event.currentTarget = null;
-}
+            try {
+              payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
 
-function processDispatchQueueItemsInOrder(
-  event,
-  dispatchListeners,
-  inCapturePhase
-) {
-  var previousInstance;
+          exitDisallowedContextReadInDEV();
+        }
 
-  if (inCapturePhase) {
-    for (var i = dispatchListeners.length - 1; i >= 0; i--) {
-      var _dispatchListeners$i = dispatchListeners[i],
-        instance = _dispatchListeners$i.instance,
-        currentTarget = _dispatchListeners$i.currentTarget,
-        listener = _dispatchListeners$i.listener;
+        return nextState;
+      } // State object
 
-      if (instance !== previousInstance && event.isPropagationStopped()) {
-        return;
-      }
+      return payload;
+    }
 
-      executeDispatch(event, listener, currentTarget);
-      previousInstance = instance;
+    case CaptureUpdate: {
+      workInProgress.flags =
+        (workInProgress.flags & ~ShouldCapture) | DidCapture;
     }
-  } else {
-    for (var _i = 0; _i < dispatchListeners.length; _i++) {
-      var _dispatchListeners$_i = dispatchListeners[_i],
-        _instance = _dispatchListeners$_i.instance,
-        _currentTarget = _dispatchListeners$_i.currentTarget,
-        _listener = _dispatchListeners$_i.listener;
+    // Intentional fallthrough
 
-      if (_instance !== previousInstance && event.isPropagationStopped()) {
-        return;
-      }
+    case UpdateState: {
+      var _payload = update.payload;
+      var partialState;
 
-      executeDispatch(event, _listener, _currentTarget);
-      previousInstance = _instance;
-    }
-  }
-}
+      if (typeof _payload === "function") {
+        // Updater function
+        {
+          enterDisallowedContextReadInDEV();
+        }
 
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+        partialState = _payload.call(instance, prevState, nextProps);
 
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event,
-      listeners = _dispatchQueue$i.listeners;
-    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
-  } // This would be a good time to rethrow if any of the event handlers threw.
+        {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
 
-  rethrowCaughtError();
-}
+            try {
+              _payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
 
-function dispatchEventsForPlugins(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst,
-  targetContainer
-) {
-  var nativeEventTarget = getEventTarget(nativeEvent);
-  var dispatchQueue = [];
-  extractEvents(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget,
-    eventSystemFlags,
-    targetContainer
-  );
-  processDispatchQueue(dispatchQueue, eventSystemFlags);
-}
+          exitDisallowedContextReadInDEV();
+        }
+      } else {
+        // Partial state object
+        partialState = _payload;
+      }
 
-function listenToNonDelegatedEvent(domEventName, targetElement) {
-  {
-    if (!nonDelegatedEvents.has(domEventName)) {
-      error(
-        'Did not expect a listenToNonDelegatedEvent() call for "%s". ' +
-          "This is a bug in React. Please file an issue.",
-        domEventName
-      );
-    }
-  }
+      if (partialState === null || partialState === undefined) {
+        // Null and undefined are treated as no-ops.
+        return prevState;
+      } // Merge the partial state and the previous state.
 
-  var isCapturePhaseListener = false;
-  var listenerSet = getEventListenerSet(targetElement);
-  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+      return assign({}, prevState, partialState);
+    }
 
-  if (!listenerSet.has(listenerSetKey)) {
-    addTrappedEventListener(
-      targetElement,
-      domEventName,
-      IS_NON_DELEGATED,
-      isCapturePhaseListener
-    );
-    listenerSet.add(listenerSetKey);
-  }
-}
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
-  {
-    if (nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener) {
-      error(
-        'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. ' +
-          "This is a bug in React. Please file an issue.",
-        domEventName
-      );
+    case ForceUpdate: {
+      hasForceUpdate = true;
+      return prevState;
     }
   }
 
-  var eventSystemFlags = 0;
+  return prevState;
+}
 
-  if (isCapturePhaseListener) {
-    eventSystemFlags |= IS_CAPTURE_PHASE;
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  var queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
+
+  {
+    currentlyProcessingQueue = queue.shared;
   }
 
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
-} // This is only used by createEventHandle when the
-// target is not a DOM element. E.g. window.
+  var firstBaseUpdate = queue.firstBaseUpdate;
+  var lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
 
-function listenToNativeEventForNonManagedEventTarget(
-  domEventName,
-  isCapturePhaseListener,
-  target
-) {
-  var eventSystemFlags = IS_EVENT_HANDLE_NON_MANAGED_NODE;
-  var listenerSet = getEventListenerSet(target);
-  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+  var pendingQueue = queue.shared.pending;
 
-  if (!listenerSet.has(listenerSetKey)) {
-    if (isCapturePhaseListener) {
-      eventSystemFlags |= IS_CAPTURE_PHASE;
-    }
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
 
-    addTrappedEventListener(
-      target,
-      domEventName,
-      eventSystemFlags,
-      isCapturePhaseListener
-    );
-    listenerSet.add(listenerSetKey);
-  }
-}
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = true;
-    allNativeEvents.forEach(function (domEventName) {
-      // We handle selectionchange separately because it
-      // doesn't bubble and needs to be on the document.
-      if (domEventName !== "selectionchange") {
-        if (!nonDelegatedEvents.has(domEventName)) {
-          listenToNativeEvent(domEventName, false, rootContainerElement);
-        }
-
-        listenToNativeEvent(domEventName, true, rootContainerElement);
-      }
-    });
-    var ownerDocument =
-      rootContainerElement.nodeType === DOCUMENT_NODE
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
+    var lastPendingUpdate = pendingQueue;
+    var firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
 
-    if (ownerDocument !== null) {
-      // The selectionchange event also needs deduplication
-      // but it is attached to the document.
-      if (!ownerDocument[listeningMarker]) {
-        ownerDocument[listeningMarker] = true;
-        listenToNativeEvent("selectionchange", false, ownerDocument);
-      }
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
+    } else {
+      lastBaseUpdate.next = firstPendingUpdate;
     }
-  }
-}
 
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  var listener = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  ); // If passive option is not supported, then the event will be
-  // active and not passive.
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
 
-  var isPassiveListener = undefined;
+    var current = workInProgress.alternate;
 
-  if (passiveBrowserEventsSupported) {
-    // Browsers introduced an intervention, making these events
-    // passive by default on document. React doesn't bind them
-    // to document anymore, but changing this now would undo
-    // the performance wins from the change. So we emulate
-    // the existing behavior manually on the roots now.
-    // https://github.com/facebook/react/issues/19651
-    if (
-      domEventName === "touchstart" ||
-      domEventName === "touchmove" ||
-      domEventName === "wheel"
-    ) {
-      isPassiveListener = true;
-    }
-  }
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      var currentQueue = current.updateQueue;
+      var currentLastBaseUpdate = currentQueue.lastBaseUpdate;
 
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  var unsubscribeListener; // When legacyFBSupport is enabled, it's for when we
-  // want to add a one time event listener to a container.
-  // This should only be used with enableLegacyFBSupport
-  // due to requirement to provide compatibility with
-  // internal FB www event tooling. This works by removing
-  // the event listener as soon as it is invoked. We could
-  // also attempt to use the {once: true} param on
-  // addEventListener, but that requires support and some
-  // browsers do not support this today, and given this is
-  // to support legacy code patterns, it's likely they'll
-  // need support for such browsers.
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
 
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = listener; // $FlowFixMe[missing-this-annot]
-    // $FlowFixMe[definition-cycle]
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
+    }
+  } // These values may change as we process the queue.
 
-    listener = function () {
-      removeEventListener(targetContainer, domEventName, unsubscribeListener);
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    var newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
 
-      for (
-        var _len = arguments.length, p = new Array(_len), _key = 0;
-        _key < _len;
-        _key++
-      ) {
-        p[_key] = arguments[_key];
-      }
+    var newLanes = NoLanes;
+    var newBaseState = null;
+    var newFirstBaseUpdate = null;
+    var newLastBaseUpdate = null;
+    var update = firstBaseUpdate;
 
-      return originalListener.apply(this, p);
-    };
-  } // TODO: There are too many combinations here. Consolidate them.
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      var updateLane = removeLanes(update.lane, OffscreenLane);
+      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
 
-  if (isCapturePhaseListener) {
-    if (isPassiveListener !== undefined) {
-      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        listener,
-        isPassiveListener
-      );
-    } else {
-      unsubscribeListener = addEventCaptureListener(
-        targetContainer,
-        domEventName,
-        listener
-      );
-    }
-  } else {
-    if (isPassiveListener !== undefined) {
-      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        listener,
-        isPassiveListener
-      );
-    } else {
-      unsubscribeListener = addEventBubbleListener(
-        targetContainer,
-        domEventName,
-        listener
-      );
-    }
-  }
-}
+      var shouldSkipUpdate = isHiddenUpdate
+        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
+        : !isSubsetOfLanes(renderLanes, updateLane);
 
-function deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer) {
-  // We defer all click events with legacy FB support mode on.
-  // This means we add a one time event listener to trigger
-  // after the FB delegated listeners fire.
-  var isDeferredListenerForLegacyFBSupport = true;
-  addTrappedEventListener(
-    targetContainer,
-    domEventName,
-    IS_LEGACY_FB_SUPPORT_MODE,
-    false,
-    isDeferredListenerForLegacyFBSupport
-  );
-}
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        var clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
 
-function isMatchingRootContainer(grandContainer, targetContainer) {
-  return (
-    grandContainer === targetContainer ||
-    (grandContainer.nodeType === COMMENT_NODE &&
-      grandContainer.parentNode === targetContainer)
-  );
-}
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
 
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst,
-  targetContainer
-) {
-  var ancestorInst = targetInst;
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          var _clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = _clone;
+        } // Process this update.
 
-  if (
-    (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 &&
-    (eventSystemFlags & IS_NON_DELEGATED) === 0
-  ) {
-    var targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
-    // defer the event to the null with a one
-    // time event listener so we can defer the event.
+        newState = getStateFromUpdate(
+          workInProgress,
+          queue,
+          update,
+          newState,
+          props,
+          instance
+        );
+        var callback = update.callback;
 
-    if (
-      enableLegacyFBSupport && // If our event flags match the required flags for entering
-      // FB legacy mode and we are processing the "click" event,
-      // then we can defer the event to the "document", to allow
-      // for legacy FB support, where the expected behavior was to
-      // match React < 16 behavior of delegated clicks to the doc.
-      domEventName === "click" &&
-      (eventSystemFlags & SHOULD_NOT_DEFER_CLICK_FOR_FB_SUPPORT_MODE) === 0 &&
-      !isReplayingEvent(nativeEvent)
-    ) {
-      deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer);
-      return;
-    }
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
 
-    if (targetInst !== null) {
-      // The below logic attempts to work out if we need to change
-      // the target fiber to a different ancestor. We had similar logic
-      // in the legacy event system, except the big difference between
-      // systems is that the modern event system now has an event listener
-      // attached to each React Root and React Portal Root. Together,
-      // the DOM nodes representing these roots are the "rootContainer".
-      // To figure out which ancestor instance we should use, we traverse
-      // up the fiber tree from the target instance and attempt to find
-      // root boundaries that match that of our current "rootContainer".
-      // If we find that "rootContainer", we find the parent fiber
-      // sub-tree for that root and make that our ancestor instance.
-      var node = targetInst;
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
 
-      mainLoop: while (true) {
-        if (node === null) {
-          return;
+          var callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
         }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-        var nodeTag = node.tag;
+      update = update.next;
 
-        if (nodeTag === HostRoot || nodeTag === HostPortal) {
-          var container = node.stateNode.containerInfo;
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
 
-          if (isMatchingRootContainer(container, targetContainerNode)) {
-            break;
-          }
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          var _lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
 
-          if (nodeTag === HostPortal) {
-            // The target is a portal, but it's not the rootContainer we're looking for.
-            // Normally portals handle their own events all the way down to the root.
-            // So we should be able to stop now. However, we don't know if this portal
-            // was part of *our* root.
-            var grandNode = node.return;
+          var _firstPendingUpdate = _lastPendingUpdate.next;
+          _lastPendingUpdate.next = null;
+          update = _firstPendingUpdate;
+          queue.lastBaseUpdate = _lastPendingUpdate;
+          queue.shared.pending = null;
+        }
+      }
+    } while (true);
 
-            while (grandNode !== null) {
-              var grandTag = grandNode.tag;
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
+    }
 
-              if (grandTag === HostRoot || grandTag === HostPortal) {
-                var grandContainer = grandNode.stateNode.containerInfo;
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
 
-                if (
-                  isMatchingRootContainer(grandContainer, targetContainerNode)
-                ) {
-                  // This is the rootContainer we're looking for and we found it as
-                  // a parent of the Portal. That means we can ignore it because the
-                  // Portal will bubble through to us.
-                  return;
-                }
-              }
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // 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.
 
-              grandNode = grandNode.return;
-            }
-          } // Now we need to find it's corresponding host fiber in the other
-          // tree. To do this we can use getClosestInstanceFromNode, but we
-          // need to validate that the fiber is a host instance, otherwise
-          // we need to traverse up through the DOM till we find the correct
-          // node that is from the other tree.
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
+  }
 
-          while (container !== null) {
-            var parentNode = getClosestInstanceFromNode(container);
+  {
+    currentlyProcessingQueue = null;
+  }
+}
 
-            if (parentNode === null) {
-              return;
-            }
+function callCallback(callback, context) {
+  if (typeof callback !== "function") {
+    throw new Error(
+      "Invalid argument passed as callback. Expected a function. Instead " +
+        ("received: " + callback)
+    );
+  }
 
-            var parentTag = parentNode.tag;
+  callback.call(context);
+}
 
-            if (
-              parentTag === HostComponent ||
-              parentTag === HostText ||
-              parentTag === HostHoistable ||
-              parentTag === HostSingleton
-            ) {
-              node = ancestorInst = parentNode;
-              continue mainLoop;
-            }
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  var newHiddenCallbacks = updateQueue.callbacks;
 
-            container = container.parentNode;
-          }
-        }
+  if (newHiddenCallbacks !== null) {
+    var existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
 
-        node = node.return;
-      }
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks =
+        existingHiddenCallbacks.concat(newHiddenCallbacks);
     }
   }
+}
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
 
-  batchedUpdates$1(function () {
-    return dispatchEventsForPlugins(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      ancestorInst,
-      targetContainer
-    );
-  });
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
+
+    for (var i = 0; i < hiddenCallbacks.length; i++) {
+      var callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
 }
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
 
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
+
+    for (var i = 0; i < callbacks.length; i++) {
+      var callback = callbacks[i];
+      callCallback(callback, context);
+    }
+  }
 }
 
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  var captureName = reactName !== null ? reactName + "Capture" : null;
-  var reactEventName = inCapturePhase ? captureName : reactName;
-  var listeners = [];
-  var instance = targetFiber;
-  var lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
+/**
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
+ */
 
-  while (instance !== null) {
-    var _instance2 = instance,
-      stateNode = _instance2.stateNode,
-      tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
+
+  if (
+    typeof objA !== "object" ||
+    objA === null ||
+    typeof objB !== "object" ||
+    objB === null
+  ) {
+    return false;
+  }
+
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
+
+  for (var i = 0; i < keysA.length; i++) {
+    var currentKey = keysA[i];
 
     if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
+      !hasOwnProperty.call(objB, currentKey) ||
+      !objectIs(objA[currentKey], objB[currentKey])
     ) {
-      lastHostComponent = stateNode; // createEventHandle listeners
+      return false;
+    }
+  }
 
-      {
-        var eventHandlerListeners = getEventHandlerListeners(lastHostComponent);
+  return true;
+}
 
-        if (eventHandlerListeners !== null) {
-          eventHandlerListeners.forEach(function (entry) {
-            if (
-              entry.type === nativeEventType &&
-              entry.capture === inCapturePhase
-            ) {
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-            }
-          });
-        }
-      } // Standard React on* listeners, i.e. onClick or onClickCapture
+var ReactStrictModeWarnings = {
+  recordUnsafeLifecycleWarnings: function (fiber, instance) {},
+  flushPendingUnsafeLifecycleWarnings: function () {},
+  recordLegacyContextWarning: function (fiber, instance) {},
+  flushLegacyContextWarning: function () {},
+  discardPendingWarnings: function () {}
+};
 
-      if (reactEventName !== null) {
-        var listener = getListener(instance, reactEventName);
+{
+  var findStrictRoot = function (fiber) {
+    var maybeStrictRoot = null;
+    var node = fiber;
 
-        if (listener != null) {
-          listeners.push(
-            createDispatchListener(instance, listener, lastHostComponent)
-          );
-        }
+    while (node !== null) {
+      if (node.mode & StrictLegacyMode) {
+        maybeStrictRoot = node;
       }
-    } else if (
-      tag === ScopeComponent &&
-      lastHostComponent !== null &&
-      stateNode !== null
-    ) {
-      // Scopes
-      var reactScopeInstance = stateNode;
 
-      var _eventHandlerListeners = getEventHandlerListeners(reactScopeInstance);
+      node = node.return;
+    }
 
-      if (_eventHandlerListeners !== null) {
-        _eventHandlerListeners.forEach(function (entry) {
-          if (
-            entry.type === nativeEventType &&
-            entry.capture === inCapturePhase
-          ) {
-            listeners.push(
-              createDispatchListener(
-                instance,
-                entry.callback,
-                lastHostComponent
-              )
-            );
-          }
-        });
-      }
-    } // If we are only accumulating events for the target, then we don't
-    // continue to propagate through the React fiber tree to find other
-    // listeners.
+    return maybeStrictRoot;
+  };
 
-    if (accumulateTargetOnly) {
-      break;
-    } // If we are processing the onBeforeBlur event, then we need to take
-    // into consideration that part of the React tree might have been hidden
-    // or deleted (as we're invoking this event during commit). We can find
-    // this out by checking if intercept fiber set on the event matches the
-    // current instance fiber. In which case, we should clear all existing
-    // listeners.
+  var setToSortedString = function (set) {
+    var array = [];
+    set.forEach(function (value) {
+      array.push(value);
+    });
+    return array.sort().join(", ");
+  };
 
-    if (nativeEvent.type === "beforeblur") {
-      // $FlowFixMe[prop-missing] internal field
-      var detachedInterceptFiber = nativeEvent._detachedInterceptFiber;
+  var pendingComponentWillMountWarnings = [];
+  var pendingUNSAFE_ComponentWillMountWarnings = [];
+  var pendingComponentWillReceivePropsWarnings = [];
+  var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+  var pendingComponentWillUpdateWarnings = [];
+  var pendingUNSAFE_ComponentWillUpdateWarnings = []; // Tracks components we have already warned about.
 
-      if (
-        detachedInterceptFiber !== null &&
-        (detachedInterceptFiber === instance ||
-          detachedInterceptFiber === instance.alternate)
-      ) {
-        listeners = [];
-      }
+  var didWarnAboutUnsafeLifecycles = new Set();
+
+  ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (
+    fiber,
+    instance
+  ) {
+    // Dedupe strategy: Warn once per component.
+    if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
+      return;
     }
 
-    instance = instance.return;
-  }
+    if (
+      typeof instance.componentWillMount === "function" && // Don't warn about react-lifecycles-compat polyfilled components.
+      instance.componentWillMount.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillMountWarnings.push(fiber);
+    }
 
-  return listeners;
-} // We should only use this function for:
-// - BeforeInputEventPlugin
-// - ChangeEventPlugin
-// - SelectEventPlugin
-// This is because we only process these plugins
-// in the bubble phase, so we need to accumulate two
-// phase event listeners (via emulation).
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillMount === "function"
+    ) {
+      pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
+    }
 
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  var captureName = reactName + "Capture";
-  var listeners = [];
-  var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+    if (
+      typeof instance.componentWillReceiveProps === "function" &&
+      instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillReceivePropsWarnings.push(fiber);
+    }
 
-  while (instance !== null) {
-    var _instance3 = instance,
-      stateNode = _instance3.stateNode,
-      tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillReceiveProps === "function"
+    ) {
+      pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
+    }
 
     if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
+      typeof instance.componentWillUpdate === "function" &&
+      instance.componentWillUpdate.__suppressDeprecationWarning !== true
     ) {
-      var currentTarget = stateNode;
-      var captureListener = getListener(instance, captureName);
+      pendingComponentWillUpdateWarnings.push(fiber);
+    }
 
-      if (captureListener != null) {
-        listeners.unshift(
-          createDispatchListener(instance, captureListener, currentTarget)
-        );
-      }
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillUpdate === "function"
+    ) {
+      pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
+    }
+  };
 
-      var bubbleListener = getListener(instance, reactName);
+  ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
+    // We do an initial pass to gather component names
+    var componentWillMountUniqueNames = new Set();
 
-      if (bubbleListener != null) {
-        listeners.push(
-          createDispatchListener(instance, bubbleListener, currentTarget)
+    if (pendingComponentWillMountWarnings.length > 0) {
+      pendingComponentWillMountWarnings.forEach(function (fiber) {
+        componentWillMountUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
         );
-      }
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillMountWarnings = [];
     }
 
-    instance = instance.return;
-  }
+    var UNSAFE_componentWillMountUniqueNames = new Set();
 
-  return listeners;
-}
+    if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillMountUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillMountWarnings = [];
+    }
 
-function getParent(inst) {
-  if (inst === null) {
-    return null;
-  }
+    var componentWillReceivePropsUniqueNames = new Set();
 
-  do {
-    // $FlowFixMe[incompatible-use] found when upgrading Flow
-    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
-    // That is depending on if we want nested subtrees (layers) to bubble
-    // events to their parent. We could also go through parentNode on the
-    // host node but that wouldn't work for React Native and doesn't let us
-    // do the portal feature.
-  } while (inst && inst.tag !== HostComponent && inst.tag !== HostSingleton);
+    if (pendingComponentWillReceivePropsWarnings.length > 0) {
+      pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        componentWillReceivePropsUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillReceivePropsWarnings = [];
+    }
 
-  if (inst) {
-    return inst;
-  }
+    var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
 
-  return null;
-}
-/**
- * Return the lowest common ancestor of A and B, or null if they are in
- * different trees.
- */
+    if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillReceivePropsUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+    }
 
-function getLowestCommonAncestor(instA, instB) {
-  var nodeA = instA;
-  var nodeB = instB;
-  var depthA = 0;
+    var componentWillUpdateUniqueNames = new Set();
 
-  for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
-    depthA++;
-  }
+    if (pendingComponentWillUpdateWarnings.length > 0) {
+      pendingComponentWillUpdateWarnings.forEach(function (fiber) {
+        componentWillUpdateUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillUpdateWarnings = [];
+    }
 
-  var depthB = 0;
+    var UNSAFE_componentWillUpdateUniqueNames = new Set();
 
-  for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
-    depthB++;
-  } // If A is deeper, crawl up.
+    if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillUpdateUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillUpdateWarnings = [];
+    } // Finally, we flush all the warnings
+    // UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
 
-  while (depthA - depthB > 0) {
-    nodeA = getParent(nodeA);
-    depthA--;
-  } // If B is deeper, crawl up.
+    if (UNSAFE_componentWillMountUniqueNames.size > 0) {
+      var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
 
-  while (depthB - depthA > 0) {
-    nodeB = getParent(nodeB);
-    depthB--;
-  } // Walk in lockstep until we find a match.
+      error(
+        "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
+          "\nPlease update the following components: %s",
+        sortedNames
+      );
+    }
 
-  var depth = depthA;
+    if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
+      var _sortedNames = setToSortedString(
+        UNSAFE_componentWillReceivePropsUniqueNames
+      );
 
-  while (depth--) {
-    if (nodeA === nodeB || (nodeB !== null && nodeA === nodeB.alternate)) {
-      return nodeA;
+      error(
+        "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " +
+          "and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* If you're updating state whenever props change, " +
+          "refactor your code to use memoization techniques or move it to " +
+          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames
+      );
     }
 
-    nodeA = getParent(nodeA);
-    nodeB = getParent(nodeB);
-  }
+    if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
+      var _sortedNames2 = setToSortedString(
+        UNSAFE_componentWillUpdateUniqueNames
+      );
 
-  return null;
-}
+      error(
+        "Using UNSAFE_componentWillUpdate in strict mode is not recommended " +
+          "and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames2
+      );
+    }
 
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  var registrationName = event._reactName;
-  var listeners = [];
-  var instance = target;
+    if (componentWillMountUniqueNames.size > 0) {
+      var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);
 
-  while (instance !== null) {
-    if (instance === common) {
-      break;
+      warn(
+        "componentWillMount has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
+          "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames3
+      );
     }
 
-    var _instance4 = instance,
-      alternate = _instance4.alternate,
-      stateNode = _instance4.stateNode,
-      tag = _instance4.tag;
+    if (componentWillReceivePropsUniqueNames.size > 0) {
+      var _sortedNames4 = setToSortedString(
+        componentWillReceivePropsUniqueNames
+      );
 
-    if (alternate !== null && alternate === common) {
-      break;
+      warn(
+        "componentWillReceiveProps has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* If you're updating state whenever props change, refactor your " +
+          "code to use memoization techniques or move it to " +
+          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
+          "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames4
+      );
     }
 
-    if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
-    ) {
-      var currentTarget = stateNode;
+    if (componentWillUpdateUniqueNames.size > 0) {
+      var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);
 
-      if (inCapturePhase) {
-        var captureListener = getListener(instance, registrationName);
+      warn(
+        "componentWillUpdate has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames5
+      );
+    }
+  };
 
-        if (captureListener != null) {
-          listeners.unshift(
-            createDispatchListener(instance, captureListener, currentTarget)
-          );
-        }
-      } else if (!inCapturePhase) {
-        var bubbleListener = getListener(instance, registrationName);
+  var pendingLegacyContextWarning = new Map(); // Tracks components we have already warned about.
 
-        if (bubbleListener != null) {
-          listeners.push(
-            createDispatchListener(instance, bubbleListener, currentTarget)
-          );
-        }
-      }
-    }
+  var didWarnAboutLegacyContext = new Set();
 
-    instance = instance.return;
-  }
+  ReactStrictModeWarnings.recordLegacyContextWarning = function (
+    fiber,
+    instance
+  ) {
+    var strictRoot = findStrictRoot(fiber);
 
-  if (listeners.length !== 0) {
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
-  }
-} // We should only use this function for:
-// - EnterLeaveEventPlugin
-// This is because we only process this plugin
-// in the bubble phase, so we need to accumulate two
-// phase event listeners.
+    if (strictRoot === null) {
+      error(
+        "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."
+      );
 
-function accumulateEnterLeaveTwoPhaseListeners(
-  dispatchQueue,
-  leaveEvent,
-  enterEvent,
-  from,
-  to
-) {
-  var common = from && to ? getLowestCommonAncestor(from, to) : null;
+      return;
+    } // Dedup strategy: Warn once per component.
 
-  if (from !== null) {
-    accumulateEnterLeaveListenersForEvent(
-      dispatchQueue,
-      leaveEvent,
-      from,
-      common,
-      false
-    );
-  }
+    if (didWarnAboutLegacyContext.has(fiber.type)) {
+      return;
+    }
 
-  if (to !== null && enterEvent !== null) {
-    accumulateEnterLeaveListenersForEvent(
-      dispatchQueue,
-      enterEvent,
-      to,
-      common,
-      true
-    );
-  }
-}
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [];
-  var eventListeners = getEventHandlerListeners(currentTarget);
+    var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
 
-  if (eventListeners !== null) {
-    eventListeners.forEach(function (entry) {
-      if (entry.type === reactEventType && entry.capture === inCapturePhase) {
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
-        );
+    if (
+      fiber.type.contextTypes != null ||
+      fiber.type.childContextTypes != null ||
+      (instance !== null && typeof instance.getChildContext === "function")
+    ) {
+      if (warningsForRoot === undefined) {
+        warningsForRoot = [];
+        pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
       }
-    });
-  }
 
-  return listeners;
-}
-function getListenerSetKey(domEventName, capture) {
-  return domEventName + "__" + (capture ? "capture" : "bubble");
-}
+      warningsForRoot.push(fiber);
+    }
+  };
 
-// This is imported by the event replaying implementation in React DOM. It's
-// in a separate file to break a circular dependency between the renderer and
-// the reconciler.
-function isRootDehydrated(root) {
-  var currentState = root.current.memoizedState;
-  return currentState.isDehydrated;
-}
-
-var _attemptSynchronousHydration;
+  ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+    pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
+      if (fiberArray.length === 0) {
+        return;
+      }
 
-function setAttemptSynchronousHydration(fn) {
-  _attemptSynchronousHydration = fn;
-}
-function attemptSynchronousHydration$1(fiber) {
-  _attemptSynchronousHydration(fiber);
-}
-var attemptDiscreteHydration$1;
-function setAttemptDiscreteHydration(fn) {
-  attemptDiscreteHydration$1 = fn;
-}
-var attemptContinuousHydration$1;
-function setAttemptContinuousHydration(fn) {
-  attemptContinuousHydration$1 = fn;
-}
-var attemptHydrationAtCurrentPriority$1;
-function setAttemptHydrationAtCurrentPriority(fn) {
-  attemptHydrationAtCurrentPriority$1 = fn;
-}
-var getCurrentUpdatePriority;
-function setGetCurrentUpdatePriority(fn) {
-  getCurrentUpdatePriority = fn;
-}
-var attemptHydrationAtPriority;
-function setAttemptHydrationAtPriority(fn) {
-  attemptHydrationAtPriority = fn;
-} // TODO: Upgrade this definition once we're on a newer version of Flow that
-// has this definition built-in.
+      var firstFiber = fiberArray[0];
+      var uniqueNames = new Set();
+      fiberArray.forEach(function (fiber) {
+        uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutLegacyContext.add(fiber.type);
+      });
+      var sortedNames = setToSortedString(uniqueNames);
 
-var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
+      try {
+        setCurrentFiber(firstFiber);
 
-var queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.
-// if the last target was dehydrated.
+        error(
+          "Legacy context API has been detected within a strict-mode tree." +
+            "\n\nThe old API will be supported in all 16.x releases, but applications " +
+            "using it should migrate to the new version." +
+            "\n\nPlease update the following components: %s" +
+            "\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context",
+          sortedNames
+        );
+      } finally {
+        resetCurrentFiber();
+      }
+    });
+  };
 
-var queuedFocus = null;
-var queuedDrag = null;
-var queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+  ReactStrictModeWarnings.discardPendingWarnings = function () {
+    pendingComponentWillMountWarnings = [];
+    pendingUNSAFE_ComponentWillMountWarnings = [];
+    pendingComponentWillReceivePropsWarnings = [];
+    pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+    pendingComponentWillUpdateWarnings = [];
+    pendingUNSAFE_ComponentWillUpdateWarnings = [];
+    pendingLegacyContextWarning = new Map();
+  };
+}
 
-var queuedPointers = new Map();
-var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+var ReactCurrentActQueue$2 = ReactSharedInternals.ReactCurrentActQueue; // An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
 
-var queuedExplicitHydrationTargets = [];
-function hasQueuedDiscreteEvents() {
-  return queuedDiscreteEvents.length > 0;
+var SuspenseException = new Error(
+  "Suspense Exception: This is not a real error! It's an implementation " +
+    "detail of `use` to interrupt the current render. You must either " +
+    "rethrow it immediately, or move the `use` call outside of the " +
+    "`try/catch` block. Capturing without rethrowing will lead to " +
+    "unexpected behavior.\n\n" +
+    "To handle async errors, wrap your component in an error boundary, or " +
+    "call the promise's `.catch` method and pass the result to `use`"
+);
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
 }
-var discreteReplayableEvents = [
-  "mousedown",
-  "mouseup",
-  "touchcancel",
-  "touchend",
-  "touchstart",
-  "auxclick",
-  "dblclick",
-  "pointercancel",
-  "pointerdown",
-  "pointerup",
-  "dragend",
-  "dragstart",
-  "drop",
-  "compositionend",
-  "compositionstart",
-  "keydown",
-  "keypress",
-  "keyup",
-  "input",
-  "textInput", // Intentionally camelCase
-  "copy",
-  "cut",
-  "paste",
-  "click",
-  "change",
-  "contextmenu",
-  "reset",
-  "submit"
-];
-function isDiscreteEventThatRequiresHydration(eventType) {
-  return discreteReplayableEvents.indexOf(eventType) > -1;
+function isThenableResolved(thenable) {
+  var status = thenable.status;
+  return status === "fulfilled" || status === "rejected";
 }
 
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
-}
+function noop() {}
 
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    return;
+function trackUsedThenable(thenableState, thenable, index) {
+  if (ReactCurrentActQueue$2.current !== null) {
+    ReactCurrentActQueue$2.didUsePromise = true;
   }
 
-  var queuedEvent = createQueuedReplayableEvent(
-    blockedOn,
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-  queuedDiscreteEvents.push(queuedEvent);
-
-  if (queuedDiscreteEvents.length === 1) {
-    // If this was the first discrete event, we might be able to
-    // synchronously unblock it so that preventDefault still works.
-    while (queuedEvent.blockedOn !== null) {
-      var fiber = getInstanceFromNode(queuedEvent.blockedOn);
+  var previous = thenableState[index];
 
-      if (fiber === null) {
-        break;
-      }
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop, noop);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
 
-      attemptSynchronousHydration$1(fiber);
+  switch (thenable.status) {
+    case "fulfilled": {
+      var fulfilledValue = thenable.value;
+      return fulfilledValue;
+    }
 
-      if (queuedEvent.blockedOn === null) {
-        // We got unblocked by hydration. Let's try again.
-        replayUnblockedEvents(); // If we're reblocked, on an inner boundary, we might need
-        // to attempt hydrating that one.
+    case "rejected": {
+      var rejectedError = thenable.reason;
+      throw rejectedError;
+    }
 
-        continue;
+    default: {
+      if (typeof thenable.status === "string") {
+        // Only instrument the thenable if the status if not defined. If
+        // it's defined, but an unknown value, assume it's been instrumented by
+        // some custom userspace implementation. We treat it as "pending".
+        // Attach a dummy listener, to ensure that any lazy initialization can
+        // happen. Flight lazily parses JSON when the value is actually awaited.
+        thenable.then(noop, noop);
       } else {
-        // We're still blocked from hydration, we have to give up
-        // and replay later.
-        break;
-      }
-    }
-  }
-} // Resets the replaying for this type of continuous event to no event.
+        var pendingThenable = thenable;
+        pendingThenable.status = "pending";
+        pendingThenable.then(
+          function (fulfilledValue) {
+            if (thenable.status === "pending") {
+              var fulfilledThenable = thenable;
+              fulfilledThenable.status = "fulfilled";
+              fulfilledThenable.value = fulfilledValue;
+            }
+          },
+          function (error) {
+            if (thenable.status === "pending") {
+              var rejectedThenable = thenable;
+              rejectedThenable.status = "rejected";
+              rejectedThenable.reason = error;
+            }
+          }
+        );
+      } // Check one more time in case the thenable resolved synchronously.
 
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
+      switch (thenable.status) {
+        case "fulfilled": {
+          var fulfilledThenable = thenable;
+          return fulfilledThenable.value;
+        }
 
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
+        case "rejected": {
+          var rejectedThenable = thenable;
+          throw rejectedThenable.reason;
+        }
+      } // Suspend.
+      //
+      // Throwing here is an implementation detail that allows us to unwind the
+      // call stack. But we shouldn't allow it to leak into userspace. Throw an
+      // opaque placeholder value instead of the actual thenable. If it doesn't
+      // get captured by the work loop, log a warning, because that means
+      // something in userspace must have caught it.
 
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
+      suspendedThenable = thenable;
 
-    case "pointerover":
-    case "pointerout": {
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.delete(pointerId);
-      break;
-    }
+      {
+        needsToResetSuspendedThenableDEV = true;
+      }
 
-    case "gotpointercapture":
-    case "lostpointercapture": {
-      var _pointerId = nativeEvent.pointerId;
-      queuedPointerCaptures.delete(_pointerId);
-      break;
+      throw SuspenseException;
     }
   }
-}
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
 
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    existingQueuedEvent === null ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
-  ) {
-    var queuedEvent = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
+var suspendedThenable = null;
+var needsToResetSuspendedThenableDEV = false;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error(
+      "Expected a suspended thenable. This is a bug in React. Please file " +
+        "an issue."
     );
+  }
 
-    if (blockedOn !== null) {
-      var fiber = getInstanceFromNode(blockedOn);
-
-      if (fiber !== null) {
-        // Attempt to increase the priority of this target.
-        attemptContinuousHydration$1(fiber);
-      }
-    }
-
-    return queuedEvent;
-  } // If we have already queued this exact event, then it's because
-  // the different event systems have different DOM event listeners.
-  // We can accumulate the flags, and the targetContainers, and
-  // store a single event to be replayed.
-
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  var targetContainers = existingQueuedEvent.targetContainers;
+  var thenable = suspendedThenable;
+  suspendedThenable = null;
 
-  if (
-    targetContainer !== null &&
-    targetContainers.indexOf(targetContainer) === -1
-  ) {
-    targetContainers.push(targetContainer);
+  {
+    needsToResetSuspendedThenableDEV = false;
   }
 
-  return existingQueuedEvent;
+  return thenable;
 }
-
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // These set relatedTarget to null because the replayed event will be treated as if we
-  // moved from outside the window (no target) onto the target once it hydrates.
-  // Instead of mutating we could clone the event.
-  switch (domEventName) {
-    case "focusin": {
-      var focusEvent = nativeEvent;
-      queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedFocus,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        focusEvent
-      );
+function checkIfUseWrappedInTryCatch() {
+  {
+    // This was set right before SuspenseException was thrown, and it should
+    // have been cleared when the exception was handled. If it wasn't,
+    // it must have been caught by userspace.
+    if (needsToResetSuspendedThenableDEV) {
+      needsToResetSuspendedThenableDEV = false;
       return true;
     }
+  }
 
-    case "dragenter": {
-      var dragEvent = nativeEvent;
-      queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedDrag,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        dragEvent
-      );
-      return true;
-    }
+  return false;
+}
 
-    case "mouseover": {
-      var mouseEvent = nativeEvent;
-      queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedMouse,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        mouseEvent
-      );
-      return true;
-    }
+var thenableState$1 = null;
+var thenableIndexCounter$1 = 0;
+var didWarnAboutMaps;
+var didWarnAboutGenerators;
+var didWarnAboutStringRefs;
+var ownerHasKeyUseWarning;
+var ownerHasFunctionTypeWarning;
 
-    case "pointerover": {
-      var pointerEvent = nativeEvent;
-      var pointerId = pointerEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          pointerEvent
-        )
-      );
-      return true;
+var warnForMissingKey = function (child, returnFiber) {};
+
+{
+  didWarnAboutMaps = false;
+  didWarnAboutGenerators = false;
+  didWarnAboutStringRefs = {};
+  /**
+   * Warn if there's no key explicitly set on dynamic arrays of children or
+   * object keys are not valid. This allows us to keep track of children between
+   * updates.
+   */
+
+  ownerHasKeyUseWarning = {};
+  ownerHasFunctionTypeWarning = {};
+
+  warnForMissingKey = function (child, returnFiber) {
+    if (child === null || typeof child !== "object") {
+      return;
     }
 
-    case "gotpointercapture": {
-      var _pointerEvent = nativeEvent;
-      var _pointerId2 = _pointerEvent.pointerId;
-      queuedPointerCaptures.set(
-        _pointerId2,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointerCaptures.get(_pointerId2) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          _pointerEvent
-        )
-      );
-      return true;
+    if (!child._store || child._store.validated || child.key != null) {
+      return;
     }
-  }
 
-  return false;
-} // Check if this target is unblocked. Returns true if it's unblocked.
+    if (typeof child._store !== "object") {
+      throw new Error(
+        "React Component in warnForMissingKey should have a _store. " +
+          "This error is likely caused by a bug in React. Please file an issue."
+      );
+    } // $FlowFixMe unable to narrow type from mixed to writable object
 
-function attemptExplicitHydrationTarget(queuedTarget) {
-  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
-  // Try to unify them. It's a bit tricky since it would require two return
-  // values.
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
+    child._store.validated = true;
+    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
 
-  if (targetInst !== null) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
+    if (ownerHasKeyUseWarning[componentName]) {
+      return;
+    }
 
-    if (nearestMounted !== null) {
-      var tag = nearestMounted.tag;
+    ownerHasKeyUseWarning[componentName] = true;
 
-      if (tag === SuspenseComponent) {
-        var instance = getSuspenseInstanceFromFiber(nearestMounted);
+    error(
+      "Each child in a list should have a unique " +
+        '"key" prop. See https://reactjs.org/link/warning-keys for ' +
+        "more information."
+    );
+  };
+}
 
-        if (instance !== null) {
-          // We're blocked on hydrating this boundary.
-          // Increase its priority.
-          queuedTarget.blockedOn = instance;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (tag === HostRoot) {
-        var root = nearestMounted.stateNode;
+function isReactClass(type) {
+  return type.prototype && type.prototype.isReactComponent;
+}
 
-        if (isRootDehydrated(root)) {
-          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
-          // a root other than sync.
+function unwrapThenable(thenable) {
+  var index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
 
-          return;
-        }
-      }
-    }
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
   }
 
-  queuedTarget.blockedOn = null;
+  return trackUsedThenable(thenableState$1, thenable, index);
 }
 
-function queueExplicitHydrationTarget(target) {
-  // TODO: This will read the priority if it's dispatched by the React
-  // event system but not native events. Should read window.event.type, like
-  // we do for updates (getCurrentEventPriority).
-  var updatePriority = getCurrentUpdatePriority();
-  var queuedTarget = {
-    blockedOn: null,
-    target: target,
-    priority: updatePriority
-  };
-  var i = 0;
+function coerceRef(returnFiber, current, element) {
+  var mixedRef = element.ref;
 
-  for (; i < queuedExplicitHydrationTargets.length; i++) {
-    // Stop once we hit the first target with lower priority than
-    if (
-      !isHigherEventPriority(
-        updatePriority,
-        queuedExplicitHydrationTargets[i].priority
-      )
-    ) {
-      break;
-    }
-  }
-
-  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
-
-  if (i === 0) {
-    attemptExplicitHydrationTarget(queuedTarget);
-  }
-}
-
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (queuedEvent.blockedOn !== null) {
-    return false;
-  }
-
-  var targetContainers = queuedEvent.targetContainers;
-
-  while (targetContainers.length > 0) {
-    var targetContainer = targetContainers[0];
-    var nextBlockedOn = findInstanceBlockingEvent(
-      queuedEvent.domEventName,
-      queuedEvent.eventSystemFlags,
-      targetContainer,
-      queuedEvent.nativeEvent
-    );
+  if (
+    mixedRef !== null &&
+    typeof mixedRef !== "function" &&
+    typeof mixedRef !== "object"
+  ) {
+    {
+      if (
+        // We warn in ReactElement.js if owner and self are equal for string refs
+        // because these cannot be automatically converted to an arrow function
+        // using a codemod. Therefore, we don't have to warn about string refs again.
+        !(
+          element._owner &&
+          element._self &&
+          element._owner.stateNode !== element._self
+        ) && // Will already throw with "Function components cannot have string refs"
+        !(element._owner && element._owner.tag !== ClassComponent) && // Will already warn with "Function components cannot be given refs"
+        !(typeof element.type === "function" && !isReactClass(element.type)) && // Will already throw with "Element ref was specified as a string (someStringRef) but no owner was set"
+        element._owner
+      ) {
+        var componentName =
+          getComponentNameFromFiber(returnFiber) || "Component";
 
-    if (nextBlockedOn === null) {
-      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-        var nativeEvent = queuedEvent.nativeEvent;
-        var nativeEventClone = new nativeEvent.constructor(
-          nativeEvent.type,
-          nativeEvent
-        );
-        setReplayingEvent(nativeEventClone);
-        nativeEvent.target.dispatchEvent(nativeEventClone);
-        resetReplayingEvent();
-      } else {
-        setReplayingEvent(queuedEvent.nativeEvent);
-        dispatchEventForPluginEventSystem(
-          queuedEvent.domEventName,
-          queuedEvent.eventSystemFlags,
-          queuedEvent.nativeEvent,
-          return_targetInst,
-          targetContainer
-        );
-        resetReplayingEvent();
-      }
-    } else {
-      // We're still blocked. Try again later.
-      var fiber = getInstanceFromNode(nextBlockedOn);
+        if (!didWarnAboutStringRefs[componentName]) {
+          error(
+            'Component "%s" contains the string ref "%s". Support for string refs ' +
+              "will be removed in a future major release. We recommend using " +
+              "useRef() or createRef() instead. " +
+              "Learn more about using refs safely here: " +
+              "https://reactjs.org/link/strict-mode-string-ref",
+            componentName,
+            mixedRef
+          );
 
-      if (fiber !== null) {
-        attemptContinuousHydration$1(fiber);
+          didWarnAboutStringRefs[componentName] = true;
+        }
       }
+    }
 
-      queuedEvent.blockedOn = nextBlockedOn;
-      return false;
-    } // This target container was successfully dispatched. Try the next.
+    if (element._owner) {
+      var owner = element._owner;
+      var inst;
 
-    targetContainers.shift();
-  }
+      if (owner) {
+        var ownerFiber = owner;
 
-  return true;
-}
+        if (ownerFiber.tag !== ClassComponent) {
+          throw new Error(
+            "Function components cannot have string refs. " +
+              "We recommend using useRef() instead. " +
+              "Learn more about using refs safely here: " +
+              "https://reactjs.org/link/strict-mode-string-ref"
+          );
+        }
 
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
-    map.delete(key);
-  }
-}
+        inst = ownerFiber.stateNode;
+      }
 
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = false;
+      if (!inst) {
+        throw new Error(
+          "Missing owner for string ref " +
+            mixedRef +
+            ". This error is likely caused by a " +
+            "bug in React. Please file an issue."
+        );
+      } // Assigning this to a const so Flow knows it won't change in the closure
 
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    // First replay discrete events.
-    while (queuedDiscreteEvents.length > 0) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
+      var resolvedInst = inst;
 
-      if (nextDiscreteEvent.blockedOn !== null) {
-        // We're still blocked.
-        // Increase the priority of this boundary to unblock
-        // the next discrete event.
-        var fiber = getInstanceFromNode(nextDiscreteEvent.blockedOn);
+      {
+        checkPropStringCoercion(mixedRef, "ref");
+      }
 
-        if (fiber !== null) {
-          attemptDiscreteHydration$1(fiber);
-        }
+      var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
 
-        break;
+      if (
+        current !== null &&
+        current.ref !== null &&
+        typeof current.ref === "function" &&
+        current.ref._stringRef === stringRef
+      ) {
+        return current.ref;
       }
 
-      var targetContainers = nextDiscreteEvent.targetContainers;
-
-      while (targetContainers.length > 0) {
-        var targetContainer = targetContainers[0];
-        var nextBlockedOn = findInstanceBlockingEvent(
-          nextDiscreteEvent.domEventName,
-          nextDiscreteEvent.eventSystemFlags,
-          targetContainer,
-          nextDiscreteEvent.nativeEvent
-        );
+      var ref = function (value) {
+        var refs = resolvedInst.refs;
 
-        if (nextBlockedOn === null) {
-          // This whole function is in !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
-          // so we don't need the new replay behavior code branch.
-          setReplayingEvent(nextDiscreteEvent.nativeEvent);
-          dispatchEventForPluginEventSystem(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            nextDiscreteEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          );
-          resetReplayingEvent();
+        if (value === null) {
+          delete refs[stringRef];
         } else {
-          // We're still blocked. Try again later.
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        } // This target container was successfully dispatched. Try the next.
+          refs[stringRef] = value;
+        }
+      };
 
-        targetContainers.shift();
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== "string") {
+        throw new Error(
+          "Expected ref to be a function, a string, an object returned by React.createRef(), or null."
+        );
       }
 
-      if (nextDiscreteEvent.blockedOn === null) {
-        // We've successfully replayed the first event. Let's try the next one.
-        queuedDiscreteEvents.shift();
+      if (!element._owner) {
+        throw new Error(
+          "Element ref was specified as a string (" +
+            mixedRef +
+            ") but no owner was set. This could happen for one of" +
+            " the following reasons:\n" +
+            "1. You may be adding a ref to a function component\n" +
+            "2. You may be adding a ref to a component that was not created inside a component's render method\n" +
+            "3. You have multiple copies of React loaded\n" +
+            "See https://reactjs.org/link/refs-must-have-owner for more information."
+        );
       }
     }
-  } // Next replay any continuous events.
-
-  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
-    queuedFocus = null;
-  }
-
-  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
-    queuedDrag = null;
-  }
-
-  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
-    queuedMouse = null;
   }
 
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+  return mixedRef;
 }
 
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  if (queuedEvent.blockedOn === unblocked) {
-    queuedEvent.blockedOn = null;
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  var childString = Object.prototype.toString.call(newChild);
+  throw new Error(
+    "Objects are not valid as a React child (found: " +
+      (childString === "[object Object]"
+        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
+        : childString) +
+      "). " +
+      "If you meant to render a collection of children, use an array " +
+      "instead."
+  );
+}
 
-    if (!hasScheduledReplayAttempt) {
-      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
-      // now unblocked. This first might not actually be unblocked yet.
-      // We could check it early to avoid scheduling an unnecessary callback.
+function warnOnFunctionType(returnFiber) {
+  {
+    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
 
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      );
+    if (ownerHasFunctionTypeWarning[componentName]) {
+      return;
     }
+
+    ownerHasFunctionTypeWarning[componentName] = true;
+
+    error(
+      "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."
+    );
   }
 }
 
-function retryIfBlockedOn(unblocked) {
-  // Mark anything that was blocked on this as no longer blocked
-  // and eligible for a replay.
-  if (queuedDiscreteEvents.length > 0) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
-    // worth it because we expect very few discrete events to queue up and once
-    // we are actually fully unblocked it will be fast to replay them.
+function resolveLazy(lazyType) {
+  var payload = lazyType._payload;
+  var init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
 
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent = queuedDiscreteEvents[i];
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
 
-      if (queuedEvent.blockedOn === unblocked) {
-        queuedEvent.blockedOn = null;
-      }
+    var deletions = returnFiber.deletions;
+
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
     }
   }
 
-  if (queuedFocus !== null) {
-    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  }
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
 
-  if (queuedDrag !== null) {
-    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
-  }
+    var childToDelete = currentFirstChild;
 
-  if (queuedMouse !== null) {
-    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
-  }
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
+    }
 
-  var unblock = function (queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
-  };
+    return null;
+  }
 
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    var existingChildren = new Map();
+    var existingChild = currentFirstChild;
 
-  for (var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++) {
-    var queuedTarget = queuedExplicitHydrationTargets[_i];
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
+      }
 
-    if (queuedTarget.blockedOn === unblocked) {
-      queuedTarget.blockedOn = null;
+      existingChild = existingChild.sibling;
     }
+
+    return existingChildren;
   }
 
-  while (queuedExplicitHydrationTargets.length > 0) {
-    var nextExplicitTarget = queuedExplicitHydrationTargets[0];
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    var clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
+  }
 
-    if (nextExplicitTarget.blockedOn !== null) {
-      // We're still blocked.
-      break;
-    } else {
-      attemptExplicitHydrationTarget(nextExplicitTarget);
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
 
-      if (nextExplicitTarget.blockedOn === null) {
-        // We're unblocked.
-        queuedExplicitHydrationTargets.shift();
-      }
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
     }
-  }
-}
 
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
+    var current = newFiber.alternate;
 
-var _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
-// We'd like to remove this but it's not clear if this is safe.
+    if (current !== null) {
+      var oldIndex = current.index;
 
-function setEnabled(enabled) {
-  _enabled = !!enabled;
-}
-function isEnabled() {
-  return _enabled;
-}
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  var eventPriority = getEventPriority(domEventName);
-  var listenerWrapper;
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
+  }
 
-  switch (eventPriority) {
-    case DiscreteEventPriority:
-      listenerWrapper = dispatchDiscreteEvent;
-      break;
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
 
-    case ContinuousEventPriority:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
+    return newFiber;
+  }
 
-    case DefaultEventPriority:
-    default:
-      listenerWrapper = dispatchEvent;
-      break;
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      var created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
   }
 
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
-}
+  function updateElement(returnFiber, current, element, lanes) {
+    var elementType = element.type;
 
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(
+        returnFiber,
+        current,
+        element.props.children,
+        lanes,
+        element.key
+      );
+    }
 
-  try {
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$3.transition = prevTransition;
-  }
-}
+    if (current !== null) {
+      if (
+        current.elementType === elementType || // Keep this check inline so it only runs on the false path:
+        isCompatibleFamilyForHotReloading(current, element) || // Lazy types should reconcile their resolved type.
+        // We need to do this after the Hot Reloading check above,
+        // because hot reloading has different semantics than prod because
+        // it doesn't resuspend. So we can't let the call below suspend.
+        (typeof elementType === "object" &&
+          elementType !== null &&
+          elementType.$$typeof === REACT_LAZY_TYPE &&
+          resolveLazy(elementType) === current.type)
+      ) {
+        // Move based on index
+        var existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
 
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
+        {
+          existing._debugSource = element._source;
+          existing._debugOwner = element._owner;
+        }
 
-  try {
-    setCurrentUpdatePriority(ContinuousEventPriority);
-    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$3.transition = prevTransition;
-  }
-}
+        return existing;
+      }
+    } // Insert
 
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (!_enabled) {
-    return;
+    var created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
   }
 
-  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-  } else {
-    dispatchEventOriginal(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-  }
-}
-
-function dispatchEventOriginal(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // TODO: replaying capture phase events is currently broken
-  // because we used to do it during top-level native bubble handlers
-  // but now we use different bubble and capture handlers.
-  // In eager mode, we attach capture listeners early, so we need
-  // to filter them out until we fix the logic to handle them correctly.
-  var allowReplay = (eventSystemFlags & IS_CAPTURE_PHASE) === 0;
-
-  if (
-    allowReplay &&
-    hasQueuedDiscreteEvents() &&
-    isDiscreteEventThatRequiresHydration(domEventName)
-  ) {
-    // If we already have a queue of discrete events, and this is another discrete
-    // event, then we can't dispatch it regardless of its target, since they
-    // need to dispatch in order.
-    queueDiscreteEvent(
-      null, // Flags that we're not actually blocked on anything as far as we know.
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-    return;
-  }
-
-  var blockedOn = findInstanceBlockingEvent(
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-
-  if (blockedOn === null) {
-    dispatchEventForPluginEventSystem(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      return_targetInst,
-      targetContainer
-    );
-
-    if (allowReplay) {
-      clearIfContinuousEvent(domEventName, nativeEvent);
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (
+      current === null ||
+      current.tag !== HostPortal ||
+      current.stateNode.containerInfo !== portal.containerInfo ||
+      current.stateNode.implementation !== portal.implementation
+    ) {
+      // Insert
+      var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
     }
-
-    return;
   }
 
-  if (allowReplay) {
-    if (isDiscreteEventThatRequiresHydration(domEventName)) {
-      // This to be replayed later once the target is available.
-      queueDiscreteEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      var created = createFiberFromFragment(
+        fragment,
+        returnFiber.mode,
+        lanes,
+        key
       );
-      return;
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
     }
+  }
 
+  function createChild(returnFiber, newChild, lanes) {
     if (
-      queueIfContinuousEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
     ) {
-      return;
-    } // We need to clear only if we didn't queue because
-    // queueing is accumulative.
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      var created = createFiberFromText("" + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
 
-    clearIfContinuousEvent(domEventName, nativeEvent);
-  } // This is not replayable so we'll invoke it but without a target,
-  // in case the event system needs to trace it.
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          var _created = createFiberFromElement(
+            newChild,
+            returnFiber.mode,
+            lanes
+          );
 
-  dispatchEventForPluginEventSystem(
-    domEventName,
-    eventSystemFlags,
-    nativeEvent,
-    null,
-    targetContainer
-  );
-}
+          _created.ref = coerceRef(returnFiber, null, newChild);
+          _created.return = returnFiber;
+          return _created;
+        }
 
-function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  var blockedOn = findInstanceBlockingEvent(
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
+        case REACT_PORTAL_TYPE: {
+          var _created2 = createFiberFromPortal(
+            newChild,
+            returnFiber.mode,
+            lanes
+          );
 
-  if (blockedOn === null) {
-    dispatchEventForPluginEventSystem(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      return_targetInst,
-      targetContainer
-    );
-    clearIfContinuousEvent(domEventName, nativeEvent);
-    return;
-  }
+          _created2.return = returnFiber;
+          return _created2;
+        }
 
-  if (
-    queueIfContinuousEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )
-  ) {
-    nativeEvent.stopPropagation();
-    return;
-  } // We need to clear only if we didn't queue because
-  // queueing is accumulative.
+        case REACT_LAZY_TYPE: {
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return createChild(returnFiber, init(payload), lanes);
+        }
+      }
 
-  clearIfContinuousEvent(domEventName, nativeEvent);
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        var _created3 = createFiberFromFragment(
+          newChild,
+          returnFiber.mode,
+          lanes,
+          null
+        );
 
-  if (
-    eventSystemFlags & IS_CAPTURE_PHASE &&
-    isDiscreteEventThatRequiresHydration(domEventName)
-  ) {
-    while (blockedOn !== null) {
-      var fiber = getInstanceFromNode(blockedOn);
+        _created3.return = returnFiber;
+        return _created3;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-      if (fiber !== null) {
-        attemptSynchronousHydration$1(fiber);
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
       }
 
-      var nextBlockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
-
-      if (nextBlockedOn === null) {
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return createChild(
+          returnFiber,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
         );
       }
 
-      if (nextBlockedOn === blockedOn) {
-        break;
-      }
-
-      blockedOn = nextBlockedOn;
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
 
-    if (blockedOn !== null) {
-      nativeEvent.stopPropagation();
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
     }
 
-    return;
-  } // This is not replayable so we'll invoke it but without a target,
-  // in case the event system needs to trace it.
+    return null;
+  }
 
-  dispatchEventForPluginEventSystem(
-    domEventName,
-    eventSystemFlags,
-    nativeEvent,
-    null,
-    targetContainer
-  );
-}
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    var key = oldFiber !== null ? oldFiber.key : null;
 
-var return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
-// The return_targetInst field above is conceptually part of the return value.
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
+    ) {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
 
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // TODO: Warn if _enabled is false.
-  return_targetInst = null;
-  var nativeEventTarget = getEventTarget(nativeEvent);
-  var targetInst = getClosestInstanceFromNode(nativeEventTarget);
+      return updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+    }
 
-  if (targetInst !== null) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          if (newChild.key === key) {
+            return updateElement(returnFiber, oldFiber, newChild, lanes);
+          } else {
+            return null;
+          }
+        }
 
-    if (nearestMounted === null) {
-      // This tree has been unmounted already. Dispatch without a target.
-      targetInst = null;
-    } else {
-      var tag = nearestMounted.tag;
+        case REACT_PORTAL_TYPE: {
+          if (newChild.key === key) {
+            return updatePortal(returnFiber, oldFiber, newChild, lanes);
+          } else {
+            return null;
+          }
+        }
 
-      if (tag === SuspenseComponent) {
-        var instance = getSuspenseInstanceFromFiber(nearestMounted);
+        case REACT_LAZY_TYPE: {
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+        }
+      }
 
-        if (instance !== null) {
-          // Queue the event to be replayed later. Abort dispatching since we
-          // don't want this event dispatched twice through the event system.
-          // TODO: If this is the first discrete event in the queue. Schedule an increased
-          // priority for this boundary.
-          return instance;
-        } // This shouldn't happen, something went wrong but to avoid blocking
-        // the whole system, dispatch the event without a target.
-        // TODO: Warn.
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
 
-        targetInst = null;
-      } else if (tag === HostRoot) {
-        var root = nearestMounted.stateNode;
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-        if (isRootDehydrated(root)) {
-          // If this happens during a replay something went wrong and it might block
-          // the whole system.
-          return getContainerFromFiber(nearestMounted);
-        }
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          unwrapThenable(thenable),
+          lanes
+        );
+      }
 
-        targetInst = null;
-      } else if (nearestMounted !== targetInst) {
-        // If we get an event (ex: img onload) before committing that
-        // component's mount, ignore it for now (that is, treat it as if it was an
-        // event on a non-React tree). We might also consider queueing events and
-        // dispatching them after the mount.
-        targetInst = null;
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
       }
+
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-  }
 
-  return_targetInst = targetInst; // We're not blocked on anything.
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    }
 
-  return null;
-}
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    // Used by SimpleEventPlugin:
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange": // Used by polyfills:
-    // eslint-disable-next-line no-fallthrough
+    return null;
+  }
 
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate": // Only enableCreateEventHandleAPI:
-    // eslint-disable-next-line no-fallthrough
+  function updateFromMap(
+    existingChildren,
+    returnFiber,
+    newIdx,
+    newChild,
+    lanes
+  ) {
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
+    ) {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      var matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, "" + newChild, lanes);
+    }
 
-    case "beforeblur":
-    case "afterblur": // Not used by React but could be by user code:
-    // eslint-disable-next-line no-fallthrough
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          var _matchedFiber =
+            existingChildren.get(
+              newChild.key === null ? newIdx : newChild.key
+            ) || null;
 
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return DiscreteEventPriority;
+          return updateElement(returnFiber, _matchedFiber, newChild, lanes);
+        }
 
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel": // Not used by React but could be by user code:
-    // eslint-disable-next-line no-fallthrough
+        case REACT_PORTAL_TYPE: {
+          var _matchedFiber2 =
+            existingChildren.get(
+              newChild.key === null ? newIdx : newChild.key
+            ) || null;
 
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return ContinuousEventPriority;
+          return updatePortal(returnFiber, _matchedFiber2, newChild, lanes);
+        }
 
-    case "message": {
-      // We might be in the Scheduler callback.
-      // Eventually this mechanism will be replaced by a check
-      // of the current priority on the native scheduler.
-      var schedulerPriority = getCurrentPriorityLevel();
-
-      switch (schedulerPriority) {
-        case ImmediatePriority:
-          return DiscreteEventPriority;
-
-        case UserBlockingPriority:
-          return ContinuousEventPriority;
+        case REACT_LAZY_TYPE:
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return updateFromMap(
+            existingChildren,
+            returnFiber,
+            newIdx,
+            init(payload),
+            lanes
+          );
+      }
 
-        case NormalPriority$1:
-        case LowPriority:
-          // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
-          return DefaultEventPriority;
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        var _matchedFiber3 = existingChildren.get(newIdx) || null;
 
-        case IdlePriority:
-          return IdleEventPriority;
+        return updateFragment(
+          returnFiber,
+          _matchedFiber3,
+          newChild,
+          lanes,
+          null
+        );
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-        default:
-          return DefaultEventPriority;
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          unwrapThenable(thenable),
+          lanes
+        );
       }
-    }
 
-    default:
-      return DefaultEventPriority;
-  }
-}
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-var loggedTypeFailures = {};
-var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
 
-function setCurrentlyValidatingElement(element) {
-  {
-    if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(
-        element.type,
-        element._source,
-        owner ? owner.type : null
-      );
-      ReactDebugCurrentFrame.setExtraStackFrame(stack);
-    } else {
-      ReactDebugCurrentFrame.setExtraStackFrame(null);
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
     }
+
+    return null;
   }
-}
+  /**
+   * Warns if there is a duplicate or missing key
+   */
 
-function checkPropTypes(typeSpecs, values, location, componentName, element) {
-  {
-    // $FlowFixMe This is okay but Flow doesn't know it.
-    var has = Function.call.bind(hasOwnProperty);
+  function warnOnInvalidKey(child, knownKeys, returnFiber) {
+    {
+      if (typeof child !== "object" || child === null) {
+        return knownKeys;
+      }
 
-    for (var typeSpecName in typeSpecs) {
-      if (has(typeSpecs, typeSpecName)) {
-        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
-        // fail the render phase where it didn't fail before. So we log it.
-        // After these have been cleaned up, we'll let them throw.
+      switch (child.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+        case REACT_PORTAL_TYPE:
+          warnForMissingKey(child, returnFiber);
+          var key = child.key;
 
-        try {
-          // This is intentionally an invariant that gets caught. It's the same
-          // behavior as without this statement except with a better message.
-          if (typeof typeSpecs[typeSpecName] !== "function") {
-            // eslint-disable-next-line react-internal/prod-error-codes
-            var err = Error(
-              (componentName || "React class") +
-                ": " +
-                location +
-                " type `" +
-                typeSpecName +
-                "` is invalid; " +
-                "it must be a function, usually from the `prop-types` package, but received `" +
-                typeof typeSpecs[typeSpecName] +
-                "`." +
-                "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
-            );
-            err.name = "Invariant Violation";
-            throw err;
+          if (typeof key !== "string") {
+            break;
           }
 
-          error$1 = typeSpecs[typeSpecName](
-            values,
-            typeSpecName,
-            componentName,
-            location,
-            null,
-            "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
-          );
-        } catch (ex) {
-          error$1 = ex;
-        }
+          if (knownKeys === null) {
+            knownKeys = new Set();
+            knownKeys.add(key);
+            break;
+          }
 
-        if (error$1 && !(error$1 instanceof Error)) {
-          setCurrentlyValidatingElement(element);
+          if (!knownKeys.has(key)) {
+            knownKeys.add(key);
+            break;
+          }
 
           error(
-            "%s: type specification of %s" +
-              " `%s` is invalid; the type checker " +
-              "function must return `null` or an `Error` but returned a %s. " +
-              "You may have forgotten to pass an argument to the type checker " +
-              "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
-              "shape all require an argument).",
-            componentName || "React class",
-            location,
-            typeSpecName,
-            typeof error$1
+            "Encountered two children with the same key, `%s`. " +
+              "Keys should be unique so that components maintain their identity " +
+              "across updates. Non-unique keys may cause children to be " +
+              "duplicated and/or omitted — the behavior is unsupported and " +
+              "could change in a future version.",
+            key
           );
 
-          setCurrentlyValidatingElement(null);
-        }
-
-        if (
-          error$1 instanceof Error &&
-          !(error$1.message in loggedTypeFailures)
-        ) {
-          // Only monitor this failure once because there tends to be a lot of the
-          // same error.
-          loggedTypeFailures[error$1.message] = true;
-          setCurrentlyValidatingElement(element);
-
-          error("Failed %s type: %s", location, error$1.message);
+          break;
 
-          setCurrentlyValidatingElement(null);
-        }
+        case REACT_LAZY_TYPE:
+          var payload = child._payload;
+          var init = child._init;
+          warnOnInvalidKey(init(payload), knownKeys, returnFiber);
+          break;
       }
     }
+
+    return knownKeys;
   }
-}
 
-var warnedAboutMissingGetChildContext;
+  function reconcileChildrenArray(
+    returnFiber,
+    currentFirstChild,
+    newChildren,
+    lanes
+  ) {
+    // This algorithm can't optimize by searching from both ends since we
+    // don't have backpointers on fibers. I'm trying to see how far we can get
+    // with that model. If it ends up not being worth the tradeoffs, we can
+    // add it later.
+    // Even with a two ended optimization, we'd want to optimize for the case
+    // where there are few changes and brute force the comparison instead of
+    // going for the Map. It'd like to explore hitting that path first in
+    // forward-only mode and only go for the Map once we notice that we need
+    // lots of look ahead. This doesn't handle reversal as well as two ended
+    // search but that's unusual. Besides, for the two ended optimization to
+    // work on Iterables, we'd need to copy the whole set.
+    // In this first iteration, we'll just live with hitting the bad case
+    // (adding everything to a Map) in for every insert/move.
+    // If you change this code, also update reconcileChildrenIterator() which
+    // uses the same algorithm.
+    {
+      // First, validate keys.
+      var knownKeys = null;
 
-{
-  warnedAboutMissingGetChildContext = {};
-}
+      for (var i = 0; i < newChildren.length; i++) {
+        var child = newChildren[i];
+        knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+      }
+    }
 
-var emptyContextObject = {};
+    var resultingFirstChild = null;
+    var previousNewFiber = null;
+    var oldFiber = currentFirstChild;
+    var lastPlacedIndex = 0;
+    var newIdx = 0;
+    var nextOldFiber = null;
 
-{
-  Object.freeze(emptyContextObject);
-} // A cursor to the current merged context object on the stack.
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
 
-var contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.
+      var newFiber = updateSlot(
+        returnFiber,
+        oldFiber,
+        newChildren[newIdx],
+        lanes
+      );
 
-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.
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
 
-var previousContext = emptyContextObject;
+        break;
+      }
 
-function getUnmaskedContext(
-  workInProgress,
-  Component,
-  didPushOwnContextIfProvider
-) {
-  {
-    if (didPushOwnContextIfProvider && isContextProvider(Component)) {
-      // If the fiber is a context provider itself, when we read its context
-      // we may have already pushed its own child context on the stack. A context
-      // provider should not "see" its own child context. Therefore we read the
-      // previous (parent) context instead for a context provider.
-      return previousContext;
-    }
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
 
-    return contextStackCursor.current;
-  }
-}
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
 
-function cacheContext(workInProgress, unmaskedContext, maskedContext) {
-  {
-    var instance = workInProgress.stateNode;
-    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
-    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
-  }
-}
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
 
-function getMaskedContext(workInProgress, unmaskedContext) {
-  {
-    var type = workInProgress.type;
-    var contextTypes = type.contextTypes;
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
 
-    if (!contextTypes) {
-      return emptyContextObject;
-    } // Avoid recreating masked context unless unmasked context has changed.
-    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.
-    // This may trigger infinite loops if componentWillReceiveProps calls setState.
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
 
-    var instance = workInProgress.stateNode;
+      if (getIsHydrating()) {
+        var numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
 
-    if (
-      instance &&
-      instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
-    ) {
-      return instance.__reactInternalMemoizedMaskedChildContext;
+      return resultingFirstChild;
     }
 
-    var context = {};
-
-    for (var key in contextTypes) {
-      context[key] = unmaskedContext[key];
-    }
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
 
-    {
-      var name = getComponentNameFromFiber(workInProgress) || "Unknown";
-      checkPropTypes(contextTypes, context, "context", name);
-    } // Cache unmasked context so we can avoid recreating masked context unless necessary.
-    // Context is created before the class component is instantiated so check for instance.
+        if (_newFiber === null) {
+          continue;
+        }
 
-    if (instance) {
-      cacheContext(workInProgress, unmaskedContext, context);
-    }
+        lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);
 
-    return context;
-  }
-}
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = _newFiber;
+        } else {
+          previousNewFiber.sibling = _newFiber;
+        }
 
-function hasContextChanged() {
-  {
-    return didPerformWorkStackCursor.current;
-  }
-}
+        previousNewFiber = _newFiber;
+      }
 
-function isContextProvider(type) {
-  {
-    var childContextTypes = type.childContextTypes;
-    return childContextTypes !== null && childContextTypes !== undefined;
-  }
-}
+      if (getIsHydrating()) {
+        var _numberOfForks = newIdx;
+        pushTreeFork(returnFiber, _numberOfForks);
+      }
 
-function popContext(fiber) {
-  {
-    pop(didPerformWorkStackCursor, fiber);
-    pop(contextStackCursor, fiber);
-  }
-}
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
 
-function popTopLevelContextObject(fiber) {
-  {
-    pop(didPerformWorkStackCursor, fiber);
-    pop(contextStackCursor, fiber);
-  }
-}
+    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
 
-function pushTopLevelContextObject(fiber, context, didChange) {
-  {
-    if (contextStackCursor.current !== emptyContextObject) {
-      throw new Error(
-        "Unexpected context found on stack. " +
-          "This error is likely caused by a bug in React. Please file an issue."
+    for (; newIdx < newChildren.length; newIdx++) {
+      var _newFiber2 = updateFromMap(
+        existingChildren,
+        returnFiber,
+        newIdx,
+        newChildren[newIdx],
+        lanes
       );
-    }
-
-    push(contextStackCursor, context, fiber);
-    push(didPerformWorkStackCursor, didChange, fiber);
-  }
-}
-
-function processChildContext(fiber, type, parentContext) {
-  {
-    var instance = fiber.stateNode;
-    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 = getComponentNameFromFiber(fiber) || "Unknown";
+      if (_newFiber2 !== null) {
+        if (shouldTrackSideEffects) {
+          if (_newFiber2.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(
+              _newFiber2.key === null ? newIdx : _newFiber2.key
+            );
+          }
+        }
 
-        if (!warnedAboutMissingGetChildContext[componentName]) {
-          warnedAboutMissingGetChildContext[componentName] = true;
+        lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);
 
-          error(
-            "%s.childContextTypes is specified but there is no getChildContext() method " +
-              "on the instance. You can either define getChildContext() on %s or remove " +
-              "childContextTypes from it.",
-            componentName,
-            componentName
-          );
+        if (previousNewFiber === null) {
+          resultingFirstChild = _newFiber2;
+        } else {
+          previousNewFiber.sibling = _newFiber2;
         }
-      }
 
-      return parentContext;
+        previousNewFiber = _newFiber2;
+      }
     }
 
-    var childContext = instance.getChildContext();
-
-    for (var contextKey in childContext) {
-      if (!(contextKey in childContextTypes)) {
-        throw new Error(
-          (getComponentNameFromFiber(fiber) || "Unknown") +
-            '.getChildContext(): key "' +
-            contextKey +
-            '" is not defined in childContextTypes.'
-        );
-      }
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
     }
 
-    {
-      var name = getComponentNameFromFiber(fiber) || "Unknown";
-      checkPropTypes(childContextTypes, childContext, "child context", name);
+    if (getIsHydrating()) {
+      var _numberOfForks2 = newIdx;
+      pushTreeFork(returnFiber, _numberOfForks2);
     }
 
-    return assign({}, parentContext, childContext);
+    return resultingFirstChild;
   }
-}
 
-function pushContextProvider(workInProgress) {
-  {
-    var instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.
-    // If the instance does not exist yet, we will push null at first,
-    // and replace it on the stack later when invalidating the context.
+  function reconcileChildrenIterator(
+    returnFiber,
+    currentFirstChild,
+    newChildrenIterable,
+    lanes
+  ) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    var iteratorFn = getIteratorFn(newChildrenIterable);
 
-    var memoizedMergedChildContext =
-      (instance && instance.__reactInternalMemoizedMergedChildContext) ||
-      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.
+    if (typeof iteratorFn !== "function") {
+      throw new Error(
+        "An object is not an iterable. This error is likely caused by a bug in " +
+          "React. Please file an issue."
+      );
+    }
 
-    previousContext = contextStackCursor.current;
-    push(contextStackCursor, memoizedMergedChildContext, workInProgress);
-    push(
-      didPerformWorkStackCursor,
-      didPerformWorkStackCursor.current,
-      workInProgress
-    );
-    return true;
-  }
-}
+    {
+      // We don't support rendering Generators because it's a mutation.
+      // See https://github.com/facebook/react/issues/12995
+      if (
+        typeof Symbol === "function" && // $FlowFixMe Flow doesn't know about toStringTag
+        newChildrenIterable[Symbol.toStringTag] === "Generator"
+      ) {
+        if (!didWarnAboutGenerators) {
+          error(
+            "Using Generators as children is unsupported and will likely yield " +
+              "unexpected results because enumerating a generator mutates it. " +
+              "You may convert it to an array with `Array.from()` or the " +
+              "`[...spread]` operator before rendering. Keep in mind " +
+              "you might need to polyfill these features for older browsers."
+          );
+        }
 
-function invalidateContextProvider(workInProgress, type, didChange) {
-  {
-    var instance = workInProgress.stateNode;
+        didWarnAboutGenerators = true;
+      } // Warn about using Maps as children
 
-    if (!instance) {
-      throw new Error(
-        "Expected to have an instance by this point. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
-    }
+      if (newChildrenIterable.entries === iteratorFn) {
+        if (!didWarnAboutMaps) {
+          error(
+            "Using Maps as children is not supported. " +
+              "Use an array of keyed ReactElements instead."
+          );
+        }
 
-    if (didChange) {
-      // Merge parent and own context.
-      // Skip this if we're not updating due to sCU.
-      // This avoids unnecessarily recomputing memoized values.
-      var mergedContext = processChildContext(
-        workInProgress,
-        type,
-        previousContext
-      );
-      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.
-      // It is important to unwind the context in the reverse order.
+        didWarnAboutMaps = true;
+      } // First, validate keys.
+      // We'll get a different iterator later for the main pass.
 
-      pop(didPerformWorkStackCursor, workInProgress);
-      pop(contextStackCursor, workInProgress); // Now push the new context and mark that it has changed.
+      var _newChildren = iteratorFn.call(newChildrenIterable);
 
-      push(contextStackCursor, mergedContext, workInProgress);
-      push(didPerformWorkStackCursor, didChange, workInProgress);
-    } else {
-      pop(didPerformWorkStackCursor, workInProgress);
-      push(didPerformWorkStackCursor, didChange, workInProgress);
+      if (_newChildren) {
+        var knownKeys = null;
+
+        var _step = _newChildren.next();
+
+        for (; !_step.done; _step = _newChildren.next()) {
+          var child = _step.value;
+          knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+        }
+      }
     }
-  }
-}
 
-function findCurrentUnmaskedContext(fiber) {
-  {
-    // Currently this is only used with renderSubtreeIntoContainer; not sure if it
-    // makes sense elsewhere
-    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {
-      throw new Error(
-        "Expected subtree parent to be a mounted class component. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
+    var newChildren = iteratorFn.call(newChildrenIterable);
+
+    if (newChildren == null) {
+      throw new Error("An iterable object provided no iterator.");
     }
 
-    var node = fiber;
+    var resultingFirstChild = null;
+    var previousNewFiber = null;
+    var oldFiber = currentFirstChild;
+    var lastPlacedIndex = 0;
+    var newIdx = 0;
+    var nextOldFiber = null;
+    var step = newChildren.next();
 
-    do {
-      switch (node.tag) {
-        case HostRoot:
-          return node.stateNode.context;
+    for (
+      ;
+      oldFiber !== null && !step.done;
+      newIdx++, step = newChildren.next()
+    ) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
 
-        case ClassComponent: {
-          var Component = node.type;
+      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
 
-          if (isContextProvider(Component)) {
-            return node.stateNode.__reactInternalMemoizedMergedChildContext;
-          }
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
 
-          break;
+        break;
+      }
+
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
         }
-      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      }
 
-      node = node.return;
-    } while (node !== null);
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
 
-    throw new Error(
-      "Found unexpected detached subtree parent. " +
-        "This error is likely caused by a bug in React. Please file an issue."
-    );
-  }
-}
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
 
-var LegacyRoot = 0;
-var ConcurrentRoot = 1;
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
 
-// We use the existence of the state object as an indicator that the component
-// is hidden.
-var OffscreenVisible =
-  /*                     */
-  1;
-var OffscreenDetached =
-  /*                    */
-  2;
-var OffscreenPassiveEffectsConnected =
-  /*     */
-  4;
-function isOffscreenManual(offscreenFiber) {
-  return (
-    offscreenFiber.memoizedProps !== null &&
-    offscreenFiber.memoizedProps.mode === "manual"
-  );
-}
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
 
-var syncQueue = null;
-var includesLegacySyncCallbacks = false;
-var isFlushingSyncQueue = false;
-function scheduleSyncCallback(callback) {
-  // Push this callback into an internal queue. We'll flush these either in
-  // the next tick, or earlier if something calls `flushSyncCallbackQueue`.
-  if (syncQueue === null) {
-    syncQueue = [callback];
-  } else {
-    // Push onto existing queue. Don't need to schedule a callback because
-    // we already scheduled one when we created the queue.
-    syncQueue.push(callback);
-  }
-}
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = true;
-  scheduleSyncCallback(callback);
-}
-function flushSyncCallbacksOnlyInLegacyMode() {
-  // Only flushes the queue if there's a legacy sync callback scheduled.
-  // TODO: There's only a single type of callback: performSyncOnWorkOnRoot. So
-  // it might make more sense for the queue to be a list of roots instead of a
-  // list of generic callbacks. Then we can have two: one for legacy roots, one
-  // for concurrent roots. And this method would only flush the legacy ones.
-  if (includesLegacySyncCallbacks) {
-    flushSyncCallbacks();
-  }
-}
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && syncQueue !== null) {
-    // Prevent re-entrance.
-    isFlushingSyncQueue = true; // Set the event priority to discrete
-    // TODO: Is this necessary anymore? The only user code that runs in this
-    // queue is in the render or commit phases, which already set the
-    // event priority. Should be able to remove.
+      if (getIsHydrating()) {
+        var numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
 
-    var previousUpdatePriority = getCurrentUpdatePriority$1();
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    var errors = null;
-    var queue = syncQueue; // $FlowFixMe[incompatible-use] found when upgrading Flow
+      return resultingFirstChild;
+    }
 
-    for (var i = 0; i < queue.length; i++) {
-      // $FlowFixMe[incompatible-use] found when upgrading Flow
-      var callback = queue[i];
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        var _newFiber3 = createChild(returnFiber, step.value, lanes);
 
-      try {
-        do {
-          var isSync = true; // $FlowFixMe[incompatible-type] we bail out when we get a null
+        if (_newFiber3 === null) {
+          continue;
+        }
 
-          callback = callback(isSync);
-        } while (callback !== null);
-      } catch (error) {
-        // Collect errors so we can rethrow them at the end
-        if (errors === null) {
-          errors = [error];
+        lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = _newFiber3;
         } else {
-          errors.push(error);
+          previousNewFiber.sibling = _newFiber3;
         }
+
+        previousNewFiber = _newFiber3;
       }
-    }
 
-    syncQueue = null;
-    includesLegacySyncCallbacks = false;
-    setCurrentUpdatePriority(previousUpdatePriority);
-    isFlushingSyncQueue = false;
+      if (getIsHydrating()) {
+        var _numberOfForks3 = newIdx;
+        pushTreeFork(returnFiber, _numberOfForks3);
+      }
 
-    if (errors !== null) {
-      if (errors.length > 1) {
-        if (typeof AggregateError === "function") {
-          // eslint-disable-next-line no-undef
-          throw new AggregateError(errors);
-        } else {
-          for (var _i = 1; _i < errors.length; _i++) {
-            scheduleCallback$2(
-              ImmediatePriority,
-              throwError.bind(null, errors[_i])
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
+
+    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      var _newFiber4 = updateFromMap(
+        existingChildren,
+        returnFiber,
+        newIdx,
+        step.value,
+        lanes
+      );
+
+      if (_newFiber4 !== null) {
+        if (shouldTrackSideEffects) {
+          if (_newFiber4.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(
+              _newFiber4.key === null ? newIdx : _newFiber4.key
             );
           }
+        }
 
-          var firstError = errors[0];
-          throw firstError;
+        lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          resultingFirstChild = _newFiber4;
+        } else {
+          previousNewFiber.sibling = _newFiber4;
         }
-      } else {
-        var error = errors[0];
-        throw error;
+
+        previousNewFiber = _newFiber4;
       }
     }
-  }
-
-  return null;
-}
 
-function throwError(error) {
-  throw error;
-}
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    }
 
-var nativeConsole = console;
-var nativeConsoleLog = null;
-var pendingGroupArgs = [];
-var printedGroupIndex = -1;
+    if (getIsHydrating()) {
+      var _numberOfForks4 = newIdx;
+      pushTreeFork(returnFiber, _numberOfForks4);
+    }
 
-function formatLanes(laneOrLanes) {
-  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
-}
+    return resultingFirstChild;
+  }
 
-function group() {
-  for (
-    var _len = arguments.length, groupArgs = new Array(_len), _key = 0;
-    _key < _len;
-    _key++
+  function reconcileSingleTextNode(
+    returnFiber,
+    currentFirstChild,
+    textContent,
+    lanes
   ) {
-    groupArgs[_key] = arguments[_key];
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      var existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    var created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
   }
 
-  pendingGroupArgs.push(groupArgs);
+  function reconcileSingleElement(
+    returnFiber,
+    currentFirstChild,
+    element,
+    lanes
+  ) {
+    var key = element.key;
+    var child = currentFirstChild;
 
-  if (nativeConsoleLog === null) {
-    nativeConsoleLog = nativeConsole.log;
-    nativeConsole.log = log;
-  }
-}
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        var elementType = element.type;
 
-function groupEnd() {
-  pendingGroupArgs.pop();
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            var existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
 
-  while (printedGroupIndex >= pendingGroupArgs.length) {
-    nativeConsole.groupEnd();
-    printedGroupIndex--;
-  }
+            {
+              existing._debugSource = element._source;
+              existing._debugOwner = element._owner;
+            }
 
-  if (pendingGroupArgs.length === 0) {
-    nativeConsole.log = nativeConsoleLog;
-    nativeConsoleLog = null;
-  }
-}
+            return existing;
+          }
+        } else {
+          if (
+            child.elementType === elementType || // Keep this check inline so it only runs on the false path:
+            isCompatibleFamilyForHotReloading(child, element) || // Lazy types should reconcile their resolved type.
+            // We need to do this after the Hot Reloading check above,
+            // because hot reloading has different semantics than prod because
+            // it doesn't resuspend. So we can't let the call below suspend.
+            (typeof elementType === "object" &&
+              elementType !== null &&
+              elementType.$$typeof === REACT_LAZY_TYPE &&
+              resolveLazy(elementType) === child.type)
+          ) {
+            deleteRemainingChildren(returnFiber, child.sibling);
 
-function log() {
-  if (printedGroupIndex < pendingGroupArgs.length - 1) {
-    for (var i = printedGroupIndex + 1; i < pendingGroupArgs.length; i++) {
-      var groupArgs = pendingGroupArgs[i];
-      nativeConsole.group.apply(nativeConsole, groupArgs);
-    }
+            var _existing = useFiber(child, element.props);
 
-    printedGroupIndex = pendingGroupArgs.length - 1;
-  }
+            _existing.ref = coerceRef(returnFiber, child, element);
+            _existing.return = returnFiber;
 
-  if (typeof nativeConsoleLog === "function") {
-    nativeConsoleLog.apply(void 0, arguments);
-  } else {
-    nativeConsole.log.apply(nativeConsole, arguments);
-  }
-}
+            {
+              _existing._debugSource = element._source;
+              _existing._debugOwner = element._owner;
+            }
 
-var REACT_LOGO_STYLE =
-  "background-color: #20232a; color: #61dafb; padding: 0 2px;";
-function logCommitStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c commit%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
-    }
-  }
-}
-function logCommitStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
+            return _existing;
+          }
+        } // Didn't match.
+
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
     }
-  }
-}
-var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
 
-var wakeableIDs = new PossiblyWeakMap$1();
-var wakeableID = 0;
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      var created = createFiberFromFragment(
+        element.props.children,
+        returnFiber.mode,
+        lanes,
+        element.key
+      );
+      created.return = returnFiber;
+      return created;
+    } else {
+      var _created4 = createFiberFromElement(element, returnFiber.mode, lanes);
 
-function getWakeableID(wakeable) {
-  if (!wakeableIDs.has(wakeable)) {
-    wakeableIDs.set(wakeable, wakeableID++);
+      _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
+      _created4.return = returnFiber;
+      return _created4;
+    }
   }
 
-  return wakeableIDs.get(wakeable);
-}
+  function reconcileSinglePortal(
+    returnFiber,
+    currentFirstChild,
+    portal,
+    lanes
+  ) {
+    var key = portal.key;
+    var child = currentFirstChild;
 
-function logComponentSuspended(componentName, wakeable) {
-  {
-    if (enableDebugTracing) {
-      var id = getWakeableID(wakeable);
-      var display = wakeable.displayName || wakeable;
-      log(
-        "%c\u269B\uFE0F%c " + componentName + " suspended",
-        REACT_LOGO_STYLE,
-        "color: #80366d; font-weight: bold;",
-        id,
-        display
-      );
-      wakeable.then(
-        function () {
-          log(
-            "%c\u269B\uFE0F%c " + componentName + " resolved",
-            REACT_LOGO_STYLE,
-            "color: #80366d; font-weight: bold;",
-            id,
-            display
-          );
-        },
-        function () {
-          log(
-            "%c\u269B\uFE0F%c " + componentName + " rejected",
-            REACT_LOGO_STYLE,
-            "color: #80366d; font-weight: bold;",
-            id,
-            display
-          );
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (
+          child.tag === HostPortal &&
+          child.stateNode.containerInfo === portal.containerInfo &&
+          child.stateNode.implementation === portal.implementation
+        ) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          var existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
         }
-      );
-    }
-  }
-}
-function logLayoutEffectsStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c layout effects%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
-    }
-  }
-}
-function logLayoutEffectsStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
-    }
-  }
-}
-function logPassiveEffectsStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c passive effects%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
-    }
-  }
-}
-function logPassiveEffectsStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
-    }
-  }
-}
-function logRenderStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c render%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
-    }
-  }
-}
-function logRenderStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
-    }
-  }
-}
-function logForceUpdateScheduled(componentName, lane) {
-  {
-    if (enableDebugTracing) {
-      log(
-        "%c\u269B\uFE0F%c " +
-          componentName +
-          " forced update %c(" +
-          formatLanes(lane) +
-          ")",
-        REACT_LOGO_STYLE,
-        "color: #db2e1f; font-weight: bold;",
-        ""
-      );
-    }
-  }
-}
-function logStateUpdateScheduled(componentName, lane, payloadOrAction) {
-  {
-    if (enableDebugTracing) {
-      log(
-        "%c\u269B\uFE0F%c " +
-          componentName +
-          " updated state %c(" +
-          formatLanes(lane) +
-          ")",
-        REACT_LOGO_STYLE,
-        "color: #01a252; font-weight: bold;",
-        "",
-        payloadOrAction
-      );
+      } else {
+        deleteChild(returnFiber, child);
+      }
+
+      child = child.sibling;
     }
-  }
-}
 
-// Intentionally not using it yet to derisk the initial implementation, because
-// the way we push/pop these values is a bit unusual. If there's a mistake, I'd
-// rather the ids be wrong than crash the whole reconciler.
+    var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
 
-var forkStack = [];
-var forkStackIndex = 0;
-var treeForkProvider = null;
-var treeForkCount = 0;
-var idStack = [];
-var idStackIndex = 0;
-var treeContextProvider = null;
-var treeContextId = 1;
-var treeContextOverflow = "";
-function isForkedChild(workInProgress) {
-  warnIfNotHydrating();
-  return (workInProgress.flags & Forked) !== NoFlags$1;
-}
-function getForksAtLevel(workInProgress) {
-  warnIfNotHydrating();
-  return treeForkCount;
-}
-function getTreeId() {
-  var overflow = treeContextOverflow;
-  var idWithLeadingBit = treeContextId;
-  var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
-  return id.toString(32) + overflow;
-}
-function pushTreeFork(workInProgress, totalChildren) {
-  // This is called right after we reconcile an array (or iterator) of child
-  // fibers, because that's the only place where we know how many children in
-  // the whole set without doing extra work later, or storing addtional
-  // information on the fiber.
-  //
-  // That's why this function is separate from pushTreeId — it's called during
-  // the render phase of the fork parent, not the child, which is where we push
-  // the other context values.
-  //
-  // In the Fizz implementation this is much simpler because the child is
-  // rendered in the same callstack as the parent.
-  //
-  // It might be better to just add a `forks` field to the Fiber type. It would
-  // make this module simpler.
-  warnIfNotHydrating();
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
-}
-function pushTreeId(workInProgress, totalChildren, index) {
-  warnIfNotHydrating();
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  var baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
-  // of the id; we use it to account for leading 0s.
+  function reconcileChildFibersImpl(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    var isUnkeyedTopLevelFragment =
+      typeof newChild === "object" &&
+      newChild !== null &&
+      newChild.type === REACT_FRAGMENT_TYPE &&
+      newChild.key === null;
 
-  var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
-  var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
-  var slot = index + 1;
-  var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
-  // consideration the leading 1 we use to mark the end of the sequence.
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
 
-  if (length > 30) {
-    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
-    // This branch assumes the length of the base id is greater than 5; it won't
-    // work for smaller ids, because you need 5 bits per character.
-    //
-    // We encode the id in multiple steps: first the base id, then the
-    // remaining digits.
-    //
-    // Each 5 bit sequence corresponds to a single base 32 character. So for
-    // example, if the current id is 23 bits long, we can convert 20 of those
-    // bits into a string of 4 characters, with 3 bits left over.
-    //
-    // First calculate how many bits in the base id represent a complete
-    // sequence of characters.
-    var numberOfOverflowBits = baseLength - (baseLength % 5); // Then create a bitmask that selects only those bits.
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(
+            reconcileSingleElement(
+              returnFiber,
+              currentFirstChild,
+              newChild,
+              lanes
+            )
+          );
 
-    var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(
+            reconcileSinglePortal(
+              returnFiber,
+              currentFirstChild,
+              newChild,
+              lanes
+            )
+          );
 
-    var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+        case REACT_LAZY_TYPE:
+          var payload = newChild._payload;
+          var init = newChild._init; // TODO: This function is supposed to be non-recursive.
 
-    var restOfBaseId = baseId >> numberOfOverflowBits;
-    var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
-    // we made more room, this time it won't overflow.
+          return reconcileChildFibers(
+            returnFiber,
+            currentFirstChild,
+            init(payload),
+            lanes
+          );
+      }
 
-    var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
-    var restOfNewBits = slot << restOfBaseLength;
-    var id = restOfNewBits | restOfBaseId;
-    var overflow = newOverflow + baseOverflow;
-    treeContextId = (1 << restOfLength) | id;
-    treeContextOverflow = overflow;
-  } else {
-    // Normal path
-    var newBits = slot << baseLength;
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      }
 
-    var _id = newBits | baseId;
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
 
-    var _overflow = baseOverflow;
-    treeContextId = (1 << length) | _id;
-    treeContextOverflow = _overflow;
-  }
-}
-function pushMaterializedTreeId(workInProgress) {
-  warnIfNotHydrating(); // This component materialized an id. This will affect any ids that appear
-  // in its children.
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          unwrapThenable(thenable),
+          lanes
+        );
+      }
 
-  var returnFiber = workInProgress.return;
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-  if (returnFiber !== null) {
-    var numberOfForks = 1;
-    var slotIndex = 0;
-    pushTreeFork(workInProgress, numberOfForks);
-    pushTreeId(workInProgress, numberOfForks, slotIndex);
-  }
-}
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
 
-function getBitLength(number) {
-  return 32 - clz32(number);
-}
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
+    ) {
+      return placeSingleChild(
+        reconcileSingleTextNode(
+          returnFiber,
+          currentFirstChild,
+          "" + newChild,
+          lanes
+        )
+      );
+    }
 
-function getLeadingBit(id) {
-  return 1 << (getBitLength(id) - 1);
-}
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    } // Remaining cases are all treated as empty.
 
-function popTreeContext(workInProgress) {
-  // Restore the previous values.
-  // This is a bit more complicated than other context-like modules in Fiber
-  // because the same Fiber may appear on the stack multiple times and for
-  // different reasons. We have to keep popping until the work-in-progress is
-  // no longer at the top of the stack.
-  while (workInProgress === treeForkProvider) {
-    treeForkProvider = forkStack[--forkStackIndex];
-    forkStack[forkStackIndex] = null;
-    treeForkCount = forkStack[--forkStackIndex];
-    forkStack[forkStackIndex] = null;
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
   }
 
-  while (workInProgress === treeContextProvider) {
-    treeContextProvider = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-    treeContextOverflow = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-    treeContextId = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-  }
-}
-function getSuspendedTreeContext() {
-  warnIfNotHydrating();
+  function reconcileChildFibers(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    var firstChildFiber = reconcileChildFibersImpl(
+      returnFiber,
+      currentFirstChild,
+      newChild,
+      lanes
+    );
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
 
-  if (treeContextProvider !== null) {
-    return {
-      id: treeContextId,
-      overflow: treeContextOverflow
-    };
-  } else {
-    return null;
+    return firstChildFiber;
   }
-}
-function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
-  warnIfNotHydrating();
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextId = suspendedContext.id;
-  treeContextOverflow = suspendedContext.overflow;
-  treeContextProvider = workInProgress;
+
+  return reconcileChildFibers;
 }
 
-function warnIfNotHydrating() {
-  {
-    if (!getIsHydrating()) {
-      error(
-        "Expected to be hydrating. This is a bug in React. Please file " +
-          "an issue."
-      );
-    }
-  }
+var reconcileChildFibers = createChildReconciler(true);
+var mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
 }
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw new Error("Resuming work not yet implemented.");
+  }
 
-// This may have been an insertion or a hydration.
+  if (workInProgress.child === null) {
+    return;
+  }
 
-var hydrationParentFiber = null;
-var nextHydratableInstance = null;
-var isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
-// due to earlier mismatches or a suspended fiber.
+  var currentChild = workInProgress.child;
+  var newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
 
-var didSuspendOrErrorDEV = false; // Hydration errors that were thrown inside this boundary
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(
+      currentChild,
+      currentChild.pendingProps
+    );
+    newChild.return = workInProgress;
+  }
 
-var hydrationErrors = null;
-var rootOrSingletonContext = false;
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
 
-function warnIfHydrating() {
-  {
-    if (isHydrating) {
-      error(
-        "We should not be hydrating here. This is a bug in React. Please file a bug."
-      );
-    }
-  }
-}
+function resetChildFibers(workInProgress, lanes) {
+  var child = workInProgress.child;
 
-function markDidThrowWhileHydratingDEV() {
-  {
-    didSuspendOrErrorDEV = true;
-  }
-}
-function didSuspendOrErrorWhileHydratingDEV() {
-  {
-    return didSuspendOrErrorDEV;
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
   }
 }
 
-function enterHydrationState(fiber) {
-  var parentInstance = fiber.stateNode.containerInfo;
-  nextHydratableInstance =
-    getFirstHydratableChildWithinContainer(parentInstance);
-  hydrationParentFiber = fiber;
-  isHydrating = true;
-  hydrationErrors = null;
-  didSuspendOrErrorDEV = false;
-  rootOrSingletonContext = true;
-  return true;
-}
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
 
-function reenterHydrationStateFromDehydratedSuspenseInstance(
-  fiber,
-  suspenseInstance,
-  treeContext
-) {
-  nextHydratableInstance =
-    getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
-  hydrationParentFiber = fiber;
-  isHydrating = true;
-  hydrationErrors = null;
-  didSuspendOrErrorDEV = false;
-  rootOrSingletonContext = false;
+var currentTreeHiddenStackCursor = createCursor(null);
+var prevRenderLanesStackCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  var prevRenderLanes = getRenderLanes();
+  push(prevRenderLanesStackCursor, prevRenderLanes, fiber);
+  push(currentTreeHiddenStackCursor, context, fiber); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
 
-  if (treeContext !== null) {
-    restoreSuspendedTreeContext(fiber, treeContext);
-  }
+  setRenderLanes(mergeLanes(prevRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevRenderLanesStackCursor, getRenderLanes(), fiber);
+  push(
+    currentTreeHiddenStackCursor,
+    currentTreeHiddenStackCursor.current,
+    fiber
+  );
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setRenderLanes(prevRenderLanesStackCursor.current);
+  pop(currentTreeHiddenStackCursor, fiber);
+  pop(prevRenderLanesStackCursor, fiber);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
 
-  return true;
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+var suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+var shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
 }
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  var current = handler.alternate;
+  var props = handler.pendingProps; // Experimental feature: Some Suspense boundaries are marked as having an
+  // undesirable fallback state. These have special behavior where we only
+  // activate the fallback if there's no other boundary on the stack that we can
+  // use instead.
 
-function warnUnhydratedInstance(returnFiber, instance) {
-  {
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        didNotHydrateInstanceWithinContainer(
-          returnFiber.stateNode.containerInfo,
-          instance
-        );
-        break;
-      }
+  if (
+    props.unstable_avoidThisFallback === true && // If an avoided boundary is already visible, it behaves identically to
+    // a regular Suspense boundary.
+    (current === null || isCurrentTreeHidden())
+  ) {
+    if (shellBoundary === null) {
+      // We're rendering in the shell. There's no parent Suspense boundary that
+      // can provide a desirable fallback state. We'll use this boundary.
+      push(suspenseHandlerStackCursor, handler, handler); // However, because this is not a desirable fallback, the children are
+      // still considered part of the shell. So we intentionally don't assign
+      // to `shellBoundary`.
+    } else {
+      // There's already a parent Suspense boundary that can provide a desirable
+      // fallback state. Prefer that one.
+      var handlerOnStack = suspenseHandlerStackCursor.current;
+      push(suspenseHandlerStackCursor, handlerOnStack, handler);
+    }
 
-      case HostSingleton:
-      case HostComponent: {
-        var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
-        didNotHydrateInstance(
-          returnFiber.type,
-          returnFiber.memoizedProps,
-          returnFiber.stateNode,
-          instance, // TODO: Delete this argument when we remove the legacy root API.
-          isConcurrentMode
-        );
-        break;
-      }
+    return;
+  } // TODO: If the parent Suspense handler already suspended, there's no reason
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
 
-      case SuspenseComponent: {
-        var suspenseState = returnFiber.memoizedState;
-        if (suspenseState.dehydrated !== null)
-          didNotHydrateInstanceWithinSuspenseInstance(
-            suspenseState.dehydrated,
-            instance
-          );
-        break;
+  push(suspenseHandlerStackCursor, handler, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      var prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
       }
     }
   }
 }
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    push(suspenseHandlerStackCursor, fiber, fiber);
 
-function deleteHydratableInstance(returnFiber, instance) {
-  warnUnhydratedInstance(returnFiber, instance);
-  var childToDelete = createFiberFromHostInstanceForDeletion();
-  childToDelete.stateNode = instance;
-  childToDelete.return = returnFiber;
-  var deletions = returnFiber.deletions;
+    if (shellBoundary !== null);
+    else {
+      var current = fiber.alternate;
 
-  if (deletions === null) {
-    returnFiber.deletions = [childToDelete];
-    returnFiber.flags |= ChildDeletion;
+      if (current !== null) {
+        var prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
+      }
+    }
   } else {
-    deletions.push(childToDelete);
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
   }
 }
+function reuseSuspenseHandlerOnStack(fiber) {
+  push(suspenseHandlerStackCursor, getSuspenseHandler(), fiber);
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor, fiber);
 
-function warnNonhydratedInstance(returnFiber, fiber) {
-  {
-    if (didSuspendOrErrorDEV) {
-      // Inside a boundary that already suspended. We're currently rendering the
-      // siblings of a suspended node. The mismatch may be due to the missing
-      // data, so it's probably a false positive.
-      return;
-    }
-
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        var parentContainer = returnFiber.stateNode.containerInfo;
-
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent:
-            var type = fiber.type;
-            didNotFindHydratableInstanceWithinContainer(parentContainer, type);
-            break;
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
 
-          case HostText:
-            var text = fiber.pendingProps;
-            didNotFindHydratableTextInstanceWithinContainer(
-              parentContainer,
-              text
-            );
-            break;
-        }
+var DefaultSuspenseContext = 0;
+var SubtreeSuspenseContextMask = 1; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
 
-        break;
-      }
+var ForceSuspenseFallback = 2;
+var suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return (parentContext & SubtreeSuspenseContextMask) | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext, fiber);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor, fiber);
+}
 
-      case HostSingleton:
-      case HostComponent: {
-        var parentType = returnFiber.type;
-        var parentProps = returnFiber.memoizedProps;
-        var parentInstance = returnFiber.stateNode;
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
 
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent: {
-            var _type = fiber.type;
-            var _props = fiber.pendingProps;
-            var isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
-            didNotFindHydratableInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              _type,
-              _props, // TODO: Delete this argument when we remove the legacy root API.
-              isConcurrentMode
-            );
-            break;
-          }
+function findFirstSuspended(row) {
+  var node = row;
 
-          case HostText: {
-            var _text = fiber.pendingProps;
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      var state = node.memoizedState;
 
-            var _isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
+      if (state !== null) {
+        var dehydrated = state.dehydrated;
 
-            didNotFindHydratableTextInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              _text, // TODO: Delete this argument when we remove the legacy root API.
-              _isConcurrentMode
-            );
-            break;
-          }
+        if (
+          dehydrated === null ||
+          isSuspenseInstancePending(dehydrated) ||
+          isSuspenseInstanceFallback(dehydrated)
+        ) {
+          return node;
         }
-
-        break;
       }
+    } else if (
+      node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+      // keep track of whether it suspended or not.
+      node.memoizedProps.revealOrder !== undefined
+    ) {
+      var didSuspend = (node.flags & DidCapture) !== NoFlags$1;
 
-      case SuspenseComponent: {
-        var suspenseState = returnFiber.memoizedState;
-        var _parentInstance = suspenseState.dehydrated;
-        if (_parentInstance !== null)
-          switch (fiber.tag) {
-            case HostSingleton:
-            case HostComponent:
-              var _type2 = fiber.type;
-              didNotFindHydratableInstanceWithinSuspenseInstance(
-                _parentInstance,
-                _type2
-              );
-              break;
-
-            case HostText:
-              var _text2 = fiber.pendingProps;
-              didNotFindHydratableTextInstanceWithinSuspenseInstance(
-                _parentInstance,
-                _text2
-              );
-              break;
-          }
-        break;
+      if (didSuspend) {
+        return node;
       }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
 
-      default:
-        return;
+    if (node === row) {
+      return null;
     }
-  }
-}
 
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-  warnNonhydratedInstance(returnFiber, fiber);
-}
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
 
-function tryHydrateInstance(fiber, nextInstance) {
-  // fiber is a HostComponent Fiber
-  var instance = canHydrateInstance(nextInstance, fiber.type);
+      node = node.return;
+    }
 
-  if (instance !== null) {
-    fiber.stateNode = instance;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = getFirstHydratableChild(instance);
-    rootOrSingletonContext = false;
-    return true;
+    node.sibling.return = node.return;
+    node = node.sibling;
   }
 
-  return false;
+  return null;
 }
 
-function tryHydrateText(fiber, nextInstance) {
-  // fiber is a HostText Fiber
-  var text = fiber.pendingProps;
-  var textInstance = canHydrateTextInstance(nextInstance, text);
+var NoFlags =
+  /*   */
+  0; // Represents whether effect should fire.
 
-  if (textInstance !== null) {
-    fiber.stateNode = textInstance;
-    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+var HasEffect =
+  /* */
+  1; // Represents the phase in which the effect (not the clean-up) fires.
 
-    nextHydratableInstance = null;
-    return true;
-  }
+var Insertion =
+  /* */
+  2;
+var Layout =
+  /*    */
+  4;
+var Passive =
+  /*   */
+  8;
 
-  return false;
-}
+// and should be reset before starting a new render.
+// This tracks which mutable sources need to be reset after a render.
 
-function tryHydrateSuspense(fiber, nextInstance) {
-  // fiber is a SuspenseComponent Fiber
-  var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
+var workInProgressSources = [];
+var rendererSigil$1;
 
-  if (suspenseInstance !== null) {
-    var suspenseState = {
-      dehydrated: suspenseInstance,
-      treeContext: getSuspendedTreeContext(),
-      retryLane: OffscreenLane
-    };
-    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
-    // This simplifies the code for getHostSibling and deleting nodes,
-    // since it doesn't have to consider all Suspense boundaries and
-    // check if they're dehydrated ones or not.
+{
+  // Used to detect multiple renderers using the same mutable source.
+  rendererSigil$1 = {};
+}
 
-    var dehydratedFragment =
-      createFiberFromDehydratedFragment(suspenseInstance);
-    dehydratedFragment.return = fiber;
-    fiber.child = dehydratedFragment;
-    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
-    // it during the first pass. Instead, we'll reenter it later.
+function markSourceAsDirty(mutableSource) {
+  workInProgressSources.push(mutableSource);
+}
+function resetWorkInProgressVersions() {
+  for (var i = 0; i < workInProgressSources.length; i++) {
+    var mutableSource = workInProgressSources[i];
 
-    nextHydratableInstance = null;
-    return true;
+    {
+      mutableSource._workInProgressVersionPrimary = null;
+    }
   }
 
-  return false;
+  workInProgressSources.length = 0;
 }
-
-function shouldClientRenderOnMismatch(fiber) {
-  return (
-    (fiber.mode & ConcurrentMode) !== NoMode &&
-    (fiber.flags & DidCapture) === NoFlags$1
-  );
+function getWorkInProgressVersion(mutableSource) {
+  {
+    return mutableSource._workInProgressVersionPrimary;
+  }
 }
+function setWorkInProgressVersion(mutableSource, version) {
+  {
+    mutableSource._workInProgressVersionPrimary = version;
+  }
 
-function throwOnHydrationMismatch(fiber) {
-  throw new Error(
-    "Hydration failed because the initial UI does not match what was " +
-      "rendered on the server."
-  );
+  workInProgressSources.push(mutableSource);
 }
-
-function claimHydratableSingleton(fiber) {
+function warnAboutMultipleRenderersDEV(mutableSource) {
   {
-    if (!isHydrating) {
-      return;
+    {
+      if (mutableSource._currentPrimaryRenderer == null) {
+        mutableSource._currentPrimaryRenderer = rendererSigil$1;
+      } else if (mutableSource._currentPrimaryRenderer !== rendererSigil$1) {
+        error(
+          "Detected multiple renderers concurrently rendering the " +
+            "same mutable source. This is currently unsupported."
+        );
+      }
     }
-
-    var currentRootContainer = getRootHostContainer();
-    var currentHostContext = getHostContext();
-    var instance = (fiber.stateNode = resolveSingletonInstance(
-      fiber.type,
-      fiber.pendingProps,
-      currentRootContainer,
-      currentHostContext,
-      false
-    ));
-    hydrationParentFiber = fiber;
-    rootOrSingletonContext = true;
-    nextHydratableInstance = getFirstHydratableChild(instance);
-  }
-}
-
-function advanceToFirstAttemptableInstance(fiber) {
-  // fiber is HostComponent Fiber
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    )
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
   }
-}
+} // Eager reads the version of a mutable source and stores it on the root.
+// This ensures that the version used for server rendering matches the one
+// that is eventually read during hydration.
+// If they don't match there's a potential tear and a full deopt render is required.
 
-function advanceToFirstAttemptableTextInstance() {
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForTextInstance(nextHydratableInstance)
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
-  }
-}
+function registerMutableSourceForHydration(root, mutableSource) {
+  var getVersion = mutableSource._getVersion;
+  var version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
+  // Retaining it forever may interfere with GC.
 
-function advanceToFirstAttemptableSuspenseInstance() {
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForSuspenseInstance(nextHydratableInstance)
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
+  if (root.mutableSourceEagerHydrationData == null) {
+    root.mutableSourceEagerHydrationData = [mutableSource, version];
+  } else {
+    root.mutableSourceEagerHydrationData.push(mutableSource, version);
   }
 }
 
-function tryToClaimNextHydratableInstance(fiber) {
-  if (!isHydrating) {
-    return;
-  }
-
-  {
-    if (!isHydratableType(fiber.type, fiber.pendingProps)) {
-      // This fiber never hydrates from the DOM and always does an insert
-      fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      return;
-    }
-  }
-
-  var initialInstance = nextHydratableInstance;
-
-  if (rootOrSingletonContext) {
-    // We may need to skip past certain nodes in these contexts
-    advanceToFirstAttemptableInstance(fiber);
-  }
-
-  var nextInstance = nextHydratableInstance;
-
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
-
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
-
-  var firstAttemptedInstance = nextInstance;
-
-  if (!tryHydrateInstance(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+var didWarnAboutMismatchedHooksForComponent;
+var didWarnUncachedGetSnapshot;
+var didWarnAboutUseWrappedInTryCatch;
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+{
+  didWarnAboutMismatchedHooksForComponent = new Set();
+  didWarnAboutUseWrappedInTryCatch = new Set();
+} // These are set right before calling the component.
 
-    if (rootOrSingletonContext) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableInstance(fiber);
-    }
+var renderLanes$1 = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
 
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateInstance(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
+var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
 
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
-  }
-}
+var currentHook = null;
+var workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
 
-function tryToClaimNextHydratableTextInstance(fiber) {
-  if (!isHydrating) {
-    return;
-  }
+var didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
 
-  var text = fiber.pendingProps;
-  var isHydratable = isHydratableText(text);
-  var initialInstance = nextHydratableInstance;
+var didScheduleRenderPhaseUpdateDuringThisPass = false;
+var shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
 
-  if (rootOrSingletonContext && isHydratable) {
-    // We may need to skip past certain nodes in these contexts.
-    // We don't skip if the text is not hydratable because we know no hydratables
-    // exist which could match this Fiber
-    advanceToFirstAttemptableTextInstance();
-  }
+var localIdCounter = 0; // Counts number of `use`-d thenables
 
-  var nextInstance = nextHydratableInstance;
+var thenableIndexCounter = 0;
+var thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
 
-  if (!nextInstance || !isHydratable) {
-    // We exclude non hydrabable text because we know there are no matching hydratables.
-    // We either throw or insert depending on the render mode.
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
+var globalClientIdCounter = 0;
+var RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
 
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
+var currentHookNameInDev = null; // In DEV, this list ensures that hooks are called in the same order between renders.
+// The list stores the order of hooks used during the initial render (mount).
+// Subsequent renders (updates) reference this list.
 
-  var firstAttemptedInstance = nextInstance;
+var hookTypesDev = null;
+var hookTypesUpdateIndexDev = -1; // In DEV, this tracks whether currently rendering component needs to ignore
+// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
+// When true, such Hooks will always be "remounted". Only used during hot reload.
 
-  if (!tryHydrateText(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+var ignorePreviousDependencies = false;
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+function mountHookTypesDev() {
+  {
+    var hookName = currentHookNameInDev;
 
-    if (rootOrSingletonContext && isHydratable) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableTextInstance();
+    if (hookTypesDev === null) {
+      hookTypesDev = [hookName];
+    } else {
+      hookTypesDev.push(hookName);
     }
-
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateText(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
   }
 }
 
-function tryToClaimNextHydratableSuspenseInstance(fiber) {
-  if (!isHydrating) {
-    return;
-  }
-
-  var initialInstance = nextHydratableInstance;
-
-  if (rootOrSingletonContext) {
-    // We may need to skip past certain nodes in these contexts
-    advanceToFirstAttemptableSuspenseInstance();
-  }
-
-  var nextInstance = nextHydratableInstance;
-
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
-
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
-
-  var firstAttemptedInstance = nextInstance;
-
-  if (!tryHydrateSuspense(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+function updateHookTypesDev() {
+  {
+    var hookName = currentHookNameInDev;
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+    if (hookTypesDev !== null) {
+      hookTypesUpdateIndexDev++;
 
-    if (rootOrSingletonContext) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableSuspenseInstance();
+      if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
+        warnOnHookMismatchInDev(hookName);
+      }
     }
-
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateSuspense(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
   }
 }
 
-function prepareToHydrateHostInstance(fiber, hostContext) {
-  var instance = fiber.stateNode;
-  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  var updatePayload = hydrateInstance(
-    instance,
-    fiber.type,
-    fiber.memoizedProps,
-    hostContext,
-    fiber,
-    shouldWarnIfMismatchDev
-  ); // TODO: Type this specific to this type of component.
-
-  fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
-  // is a new ref we mark this as an update.
-
-  if (updatePayload !== null) {
-    return true;
+function checkDepsAreArrayDev(deps) {
+  {
+    if (deps !== undefined && deps !== null && !isArray(deps)) {
+      // Verify deps, but only on mount to avoid extra checks.
+      // It's unlikely their type would change as usually you define them inline.
+      error(
+        "%s received a final argument that is not an array (instead, received `%s`). When " +
+          "specified, the final argument must be an array.",
+        currentHookNameInDev,
+        typeof deps
+      );
+    }
   }
-
-  return false;
 }
 
-function prepareToHydrateHostTextInstance(fiber) {
-  var textInstance = fiber.stateNode;
-  var textContent = fiber.memoizedProps;
-  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+function warnOnHookMismatchInDev(currentHookName) {
+  {
+    var componentName = getComponentNameFromFiber(currentlyRenderingFiber$1);
 
-  if (shouldUpdate) {
-    // We assume that prepareToHydrateHostTextInstance is called in a context where the
-    // hydration parent is the parent host component of this host text.
-    var returnFiber = hydrationParentFiber;
+    if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
+      didWarnAboutMismatchedHooksForComponent.add(componentName);
 
-    if (returnFiber !== null) {
-      switch (returnFiber.tag) {
-        case HostRoot: {
-          var parentContainer = returnFiber.stateNode.containerInfo;
-          var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
-          didNotMatchHydratedContainerTextInstance(
-            parentContainer,
-            textInstance,
-            textContent, // TODO: Delete this argument when we remove the legacy root API.
-            isConcurrentMode,
-            shouldWarnIfMismatchDev
-          );
-          break;
-        }
+      if (hookTypesDev !== null) {
+        var table = "";
+        var secondColumnStart = 30;
 
-        case HostSingleton:
-        case HostComponent: {
-          var parentType = returnFiber.type;
-          var parentProps = returnFiber.memoizedProps;
-          var parentInstance = returnFiber.stateNode;
+        for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
+          var oldHookName = hookTypesDev[i];
+          var newHookName =
+            i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
+          var row = i + 1 + ". " + oldHookName; // Extra space so second column lines up
+          // lol @ IE not supporting String#repeat
 
-          var _isConcurrentMode2 =
-            (returnFiber.mode & ConcurrentMode) !== NoMode;
+          while (row.length < secondColumnStart) {
+            row += " ";
+          }
 
-          didNotMatchHydratedTextInstance(
-            parentType,
-            parentProps,
-            parentInstance,
-            textInstance,
-            textContent, // TODO: Delete this argument when we remove the legacy root API.
-            _isConcurrentMode2,
-            shouldWarnIfMismatchDev
-          );
-          break;
+          row += newHookName + "\n";
+          table += row;
         }
+
+        error(
+          "React has detected a change in the order of Hooks called by %s. " +
+            "This will lead to bugs and errors if not fixed. " +
+            "For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n" +
+            "   Previous render            Next render\n" +
+            "   ------------------------------------------------------\n" +
+            "%s" +
+            "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+          componentName,
+          table
+        );
       }
     }
   }
-
-  return shouldUpdate;
-}
-
-function prepareToHydrateHostSuspenseInstance(fiber) {
-  var suspenseState = fiber.memoizedState;
-  var suspenseInstance =
-    suspenseState !== null ? suspenseState.dehydrated : null;
-
-  if (!suspenseInstance) {
-    throw new Error(
-      "Expected to have a hydrated suspense instance. " +
-        "This error is likely caused by a bug in React. Please file an issue."
-    );
-  }
-
-  hydrateSuspenseInstance(suspenseInstance, fiber);
 }
 
-function skipPastDehydratedSuspenseInstance(fiber) {
-  var suspenseState = fiber.memoizedState;
-  var suspenseInstance =
-    suspenseState !== null ? suspenseState.dehydrated : null;
-
-  if (!suspenseInstance) {
-    throw new Error(
-      "Expected to have a hydrated suspense instance. " +
-        "This error is likely caused by a bug in React. Please file an issue."
-    );
-  }
-
-  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+function throwInvalidHookError() {
+  throw new Error(
+    "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for" +
+      " one of the following reasons:\n" +
+      "1. You might have mismatching versions of React and the renderer (such as React DOM)\n" +
+      "2. You might be breaking the Rules of Hooks\n" +
+      "3. You might have more than one copy of React in the same app\n" +
+      "See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."
+  );
 }
 
-function popToNextHostParent(fiber) {
-  hydrationParentFiber = fiber.return;
-
-  while (hydrationParentFiber) {
-    switch (hydrationParentFiber.tag) {
-      case HostRoot:
-      case HostSingleton:
-        rootOrSingletonContext = true;
-        return;
-
-      case HostComponent:
-      case SuspenseComponent:
-        rootOrSingletonContext = false;
-        return;
-
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
+function areHookInputsEqual(nextDeps, prevDeps) {
+  {
+    if (ignorePreviousDependencies) {
+      // Only true when this component is being hot reloaded.
+      return false;
     }
   }
-}
 
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) {
-    // We're deeper than the current hydration context, inside an inserted
-    // tree.
-    return false;
-  }
+  if (prevDeps === null) {
+    {
+      error(
+        "%s received a final argument during this render, but not during " +
+          "the previous render. Even though the final argument is optional, " +
+          "its type cannot change between renders.",
+        currentHookNameInDev
+      );
+    }
 
-  if (!isHydrating) {
-    // If we're not currently hydrating but we're in a hydration context, then
-    // we were an insertion and now need to pop up reenter hydration of our
-    // siblings.
-    popToNextHostParent(fiber);
-    isHydrating = true;
     return false;
   }
 
-  var shouldClear = false;
-
   {
-    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
-    // that have singleton text content
-    if (
-      fiber.tag !== HostRoot &&
-      fiber.tag !== HostSingleton &&
-      !(
-        fiber.tag === HostComponent &&
-        shouldSetTextContent(fiber.type, fiber.memoizedProps)
-      )
-    ) {
-      shouldClear = true;
+    // Don't bother comparing lengths in prod because these arrays should be
+    // passed inline.
+    if (nextDeps.length !== prevDeps.length) {
+      error(
+        "The final argument passed to %s changed size between renders. The " +
+          "order and size of this array must remain constant.\n\n" +
+          "Previous: %s\n" +
+          "Incoming: %s",
+        currentHookNameInDev,
+        "[" + prevDeps.join(", ") + "]",
+        "[" + nextDeps.join(", ") + "]"
+      );
     }
-  }
-
-  if (shouldClear) {
-    var nextInstance = nextHydratableInstance;
+  } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-    if (nextInstance) {
-      if (shouldClientRenderOnMismatch(fiber)) {
-        warnIfUnhydratedTailNodes(fiber);
-        throwOnHydrationMismatch();
-      } else {
-        while (nextInstance) {
-          deleteHydratableInstance(fiber, nextInstance);
-          nextInstance = getNextHydratableSibling(nextInstance);
-        }
-      }
+  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
     }
-  }
 
-  popToNextHostParent(fiber);
-
-  if (fiber.tag === SuspenseComponent) {
-    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
-  } else {
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratableSibling(fiber.stateNode)
-      : null;
+    return false;
   }
 
   return true;
 }
 
-function hasUnhydratedTailNodes() {
-  return isHydrating && nextHydratableInstance !== null;
-}
+function renderWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg,
+  nextRenderLanes
+) {
+  renderLanes$1 = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
 
-function warnIfUnhydratedTailNodes(fiber) {
-  var nextInstance = nextHydratableInstance;
+  {
+    hookTypesDev = current !== null ? current._debugHookTypes : null;
+    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
 
-  while (nextInstance) {
-    warnUnhydratedInstance(fiber, nextInstance);
-    nextInstance = getNextHydratableSibling(nextInstance);
+    ignorePreviousDependencies =
+      current !== null && current.type !== workInProgress.type;
   }
-}
-
-function resetHydrationState() {
-  hydrationParentFiber = null;
-  nextHydratableInstance = null;
-  isHydrating = false;
-  didSuspendOrErrorDEV = false;
-}
 
-function upgradeHydrationErrorsToRecoverable() {
-  if (hydrationErrors !== null) {
-    // Successfully completed a forced client render. The errors that occurred
-    // during the hydration attempt are now recovered. We will log them in
-    // commit phase, once the entire tree has finished.
-    queueRecoverableErrors(hydrationErrors);
-    hydrationErrors = null;
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
+
+  {
+    if (current !== null && current.memoizedState !== null) {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
+    } else if (hookTypesDev !== null) {
+      // This dispatcher handles an edge case where a component is updating,
+      // but no stateful hooks have been used.
+      // We want to match the production code behavior (which will use HooksDispatcherOnMount),
+      // but with the extra DEV validation to ensure hooks ordering hasn't changed.
+      // This dispatcher does that.
+      ReactCurrentDispatcher$1.current =
+        HooksDispatcherOnMountWithHookTypesInDEV;
+    } else {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
+    }
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
+
+  var shouldDoubleRenderDEV =
+    (workInProgress.mode & StrictLegacyMode) !== NoMode;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  var children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(
+      workInProgress,
+      Component,
+      props,
+      secondArg
+    );
   }
-}
 
-function getIsHydrating() {
-  return isHydrating;
-}
+  if (shouldDoubleRenderDEV) {
+    // In development, components are invoked twice to help detect side effects.
+    setIsStrictModeForDevtools(true);
 
-function queueHydrationError(error) {
-  if (hydrationErrors === null) {
-    hydrationErrors = [error];
-  } else {
-    hydrationErrors.push(error);
+    try {
+      children = renderWithHooksAgain(
+        workInProgress,
+        Component,
+        props,
+        secondArg
+      );
+    } finally {
+      setIsStrictModeForDevtools(false);
+    }
   }
-}
 
-// we wait until the current render is over (either finished or interrupted)
-// before adding it to the fiber/hook queue. Push to this array so we can
-// access the queue, fiber, update, et al later.
+  finishRenderingHooks(current, workInProgress);
+  return children;
+}
 
-var concurrentQueues = [];
-var concurrentQueuesIndex = 0;
-var concurrentlyUpdatedLanes = NoLanes;
-function finishQueueingConcurrentUpdates() {
-  var endIndex = concurrentQueuesIndex;
-  concurrentQueuesIndex = 0;
-  concurrentlyUpdatedLanes = NoLanes;
-  var i = 0;
+function finishRenderingHooks(current, workInProgress) {
+  // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
 
-  while (i < endIndex) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
+  {
+    workInProgress._debugHookTypes = hookTypesDev;
+  } // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
 
-    if (queue !== null && update !== null) {
-      var pending = queue.pending;
+  var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes$1 = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
 
-      if (pending === null) {
-        // This is the first update. Create a circular list.
-        update.next = update;
-      } else {
-        update.next = pending.next;
-        pending.next = update;
-      }
+  {
+    currentHookNameInDev = null;
+    hookTypesDev = null;
+    hookTypesUpdateIndexDev = -1; // Confirm that a static flag was not added or removed since the last
+    // render. If this fires, it suggests that we incorrectly reset the static
+    // flags in some other part of the codebase. This has happened before, for
+    // example, in the SuspenseList implementation.
 
-      queue.pending = update;
+    if (
+      current !== null &&
+      (current.flags & StaticMask) !== (workInProgress.flags & StaticMask) && // Disable this warning in legacy mode, because legacy Suspense is weird
+      // and creates false positives. To make this work in legacy mode, we'd
+      // need to mark fibers that commit in an incomplete state, somehow. For
+      // now I'll disable the warning that most of the bugs that would trigger
+      // it are either exclusive to concurrent mode or exist in both.
+      (current.mode & ConcurrentMode) !== NoMode
+    ) {
+      error(
+        "Internal React error: Expected static flag was missing. Please " +
+          "notify the React team."
+      );
     }
+  }
 
-    if (lane !== NoLane) {
-      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
+
+  thenableIndexCounter = 0;
+  thenableState = null;
+
+  if (didRenderTooFewHooks) {
+    throw new Error(
+      "Rendered fewer hooks than expected. This may be caused by an accidental " +
+        "early return statement."
+    );
+  }
+
+  if (enableLazyContextPropagation) {
+    if (current !== null) {
+      if (!checkIfWorkInProgressReceivedUpdate()) {
+        // If there were no changes to props or state, we need to check if there
+        // was a context change. We didn't already do this because there's no
+        // 1:1 correspondence between dependencies and hooks. Although, because
+        // there almost always is in the common case (`readContext` is an
+        // internal API), we could compare in there. OTOH, we only hit this case
+        // if everything else bails out, so on the whole it might be better to
+        // keep the comparison out of the common path.
+        var currentDependencies = current.dependencies;
+
+        if (
+          currentDependencies !== null &&
+          checkIfContextChanged(currentDependencies)
+        ) {
+          markWorkInProgressReceivedUpdate();
+        }
+      }
     }
   }
-}
-function getConcurrentlyUpdatedLanes() {
-  return concurrentlyUpdatedLanes;
-}
 
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  // Don't update the `childLanes` on the return path yet. If we already in
-  // the middle of rendering, wait until after it has completed.
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
-  // scheduled, to perform an eager bailout, so we need to update it immediately.
-  // TODO: We should probably move this to the "shared" queue instead.
+  {
+    if (checkIfUseWrappedInTryCatch()) {
+      var componentName =
+        getComponentNameFromFiber(workInProgress) || "Unknown";
 
-  fiber.lanes = mergeLanes(fiber.lanes, lane);
-  var alternate = fiber.alternate;
+      if (!didWarnAboutUseWrappedInTryCatch.has(componentName)) {
+        didWarnAboutUseWrappedInTryCatch.add(componentName);
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, lane);
+        error(
+          "`use` was called from inside a try/catch block. This is not allowed " +
+            "and can lead to unexpected behavior. To handle errors triggered " +
+            "by `use`, wrap your component in a error boundary."
+        );
+      }
+    }
   }
 }
 
-function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
-  // This function is used to queue an update that doesn't need a rerender. The
-  // only reason we queue it is in case there's a subsequent higher priority
-  // update that causes it to be rebased.
-  var lane = NoLane;
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
-  // queue. However, since this is a bail out, we're not scheduling any work
-  // here. So the update we just queued will leak until something else happens
-  // to schedule work (if ever).
+function replaySuspendedComponentWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg
+) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves.
   //
-  // Check if we're currently in the middle of rendering a tree, and if not,
-  // process the queue immediately to prevent a leak.
-
-  var isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+  // It's a simplified version of renderWithHooks, but it doesn't need to do
+  // most of the set up work because they weren't reset when we suspended; they
+  // only get reset when the component either completes (finishRenderingHooks)
+  // or unwinds (resetHooksOnUnwind).
+  {
+    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
 
-  if (!isConcurrentlyRendering) {
-    finishQueueingConcurrentUpdates();
+    ignorePreviousDependencies =
+      current !== null && current.type !== workInProgress.type;
   }
-}
-function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
-} // Calling this function outside this module should only be done for backwards
-// compatibility and should always be accompanied by a warning.
 
-function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
-  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
-  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
-  // undefined behavior and we can change it if we need to; it just so happens
-  // that, at the time of this writing, there's an internal product test that
-  // happens to rely on this.
-  var root = getRootForUpdatedFiber(sourceFiber);
-  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
-  return root;
+  var children = renderWithHooksAgain(
+    workInProgress,
+    Component,
+    props,
+    secondArg
+  );
+  finishRenderingHooks(current, workInProgress);
+  return children;
 }
 
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  // Update the source fiber's lanes
-  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
-  var alternate = sourceFiber.alternate;
-
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, lane);
-  } // Walk the parent path to the root and update the child lanes.
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  var numberOfReRenders = 0;
+  var children;
 
-  var isHidden = false;
-  var parent = sourceFiber.return;
-  var node = sourceFiber;
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
+    }
 
-  while (parent !== null) {
-    parent.childLanes = mergeLanes(parent.childLanes, lane);
-    alternate = parent.alternate;
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
 
-    if (alternate !== null) {
-      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw new Error(
+        "Too many re-renders. React limits the number of renders to prevent " +
+          "an infinite loop."
+      );
     }
 
-    if (parent.tag === OffscreenComponent) {
-      // Check if this offscreen boundary is currently hidden.
-      //
-      // The instance may be null if the Offscreen parent was unmounted. Usually
-      // the parent wouldn't be reachable in that case because we disconnect
-      // fibers from the tree when they are deleted. However, there's a weird
-      // edge case where setState is called on a fiber that was interrupted
-      // before it ever mounted. Because it never mounts, it also never gets
-      // deleted. Because it never gets deleted, its return pointer never gets
-      // disconnected. Which means it may be attached to a deleted Offscreen
-      // parent node. (This discovery suggests it may be better for memory usage
-      // if we don't attach the `return` pointer until the commit phase, though
-      // in order to do that we'd need some other way to track the return
-      // pointer during the initial render, like on the stack.)
-      //
-      // This case is always accompanied by a warning, but we still need to
-      // account for it. (There may be other cases that we haven't discovered,
-      // too.)
-      var offscreenInstance = parent.stateNode;
+    numberOfReRenders += 1;
 
-      if (
-        offscreenInstance !== null &&
-        !(offscreenInstance._visibility & OffscreenVisible)
-      ) {
-        isHidden = true;
-      }
+    {
+      // Even when hot reloading, allow dependencies to stabilize
+      // after first render to prevent infinite render phase updates.
+      ignorePreviousDependencies = false;
+    } // Start over from the beginning of the list
+
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
+
+    {
+      // Also validate hook order for cascading updates.
+      hookTypesUpdateIndexDev = -1;
     }
 
-    node = parent;
-    parent = parent.return;
-  }
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
 
-  if (isHidden && update !== null && node.tag === HostRoot) {
-    var root = node.stateNode;
-    markHiddenUpdate(root, update, lane);
-  }
+  return children;
 }
 
-function getRootForUpdatedFiber(sourceFiber) {
-  // TODO: We will detect and infinite update loop and throw even if this fiber
-  // has already unmounted. This isn't really necessary but it happens to be the
-  // current behavior we've used for several release cycles. Consider not
-  // performing this check if the updated fiber already unmounted, since it's
-  // not possible for that to cause an infinite update loop.
-  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
-  // update queues do not have a backpointer to the root, the only way to do
-  // this currently is to walk up the return path. This used to not be a big
-  // deal because we would have to walk up the return path to set
-  // the `childLanes`, anyway, but now those two traversals happen at
-  // different times.
-  // TODO: Consider adding a `root` backpointer on the update queue.
-
-  detectUpdateOnUnmountedFiber(sourceFiber, sourceFiber);
-  var node = sourceFiber;
-  var parent = node.return;
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  var didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
+}
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
 
-  while (parent !== null) {
-    detectUpdateOnUnmountedFiber(sourceFiber, node);
-    node = parent;
-    parent = node.return;
+  if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+    workInProgress.flags &= ~(
+      MountPassiveDev |
+      MountLayoutDev |
+      Passive$1 |
+      Update
+    );
+  } else {
+    workInProgress.flags &= ~(Passive$1 | Update);
   }
 
-  return node.tag === HostRoot ? node.stateNode : null;
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
 }
+function resetHooksOnUnwind() {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    var hook = currentlyRenderingFiber$1.memoizedState;
 
-function detectUpdateOnUnmountedFiber(sourceFiber, parent) {
-  {
-    var alternate = parent.alternate;
+    while (hook !== null) {
+      var queue = hook.queue;
 
-    if (
-      alternate === null &&
-      (parent.flags & (Placement | Hydrating)) !== NoFlags$1
-    ) {
-      warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
+      if (queue !== null) {
+        queue.pending = null;
+      }
+
+      hook = hook.next;
     }
+
+    didScheduleRenderPhaseUpdate = false;
   }
-}
 
-var UpdateState = 0;
-var ReplaceState = 1;
-var ForceUpdate = 2;
-var CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
-// It should only be read right after calling `processUpdateQueue`, via
-// `checkHasForceUpdateAfterProcessing`.
+  renderLanes$1 = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
 
-var hasForceUpdate = false;
-var didWarnUpdateInsideUpdate;
-var currentlyProcessingQueue;
+  {
+    hookTypesDev = null;
+    hookTypesUpdateIndexDev = -1;
+    currentHookNameInDev = null;
+  }
 
-{
-  didWarnUpdateInsideUpdate = false;
-  currentlyProcessingQueue = null;
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
 }
 
-function initializeUpdateQueue(fiber) {
-  var queue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: {
-      pending: null,
-      lanes: NoLanes,
-      hiddenCallbacks: null
-    },
-    callbacks: null
-  };
-  fiber.updateQueue = queue;
-}
-function cloneUpdateQueue(current, workInProgress) {
-  // Clone the update queue from current. Unless it's already a clone.
-  var queue = workInProgress.updateQueue;
-  var currentQueue = current.updateQueue;
-
-  if (queue === currentQueue) {
-    var clone = {
-      baseState: currentQueue.baseState,
-      firstBaseUpdate: currentQueue.firstBaseUpdate,
-      lastBaseUpdate: currentQueue.lastBaseUpdate,
-      shared: currentQueue.shared,
-      callbacks: null
-    };
-    workInProgress.updateQueue = clone;
-  }
-}
-function createUpdate(lane) {
-  var update = {
-    lane: lane,
-    tag: UpdateState,
-    payload: null,
-    callback: null,
+function mountWorkInProgressHook() {
+  var hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
     next: null
   };
-  return update;
-}
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
 
-  if (updateQueue === null) {
-    // Only occurs if the fiber has been unmounted.
-    return null;
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
   }
 
-  var sharedQueue = updateQueue.shared;
-
-  {
-    if (
-      currentlyProcessingQueue === sharedQueue &&
-      !didWarnUpdateInsideUpdate
-    ) {
-      var componentName = getComponentNameFromFiber(fiber);
-
-      error(
-        "An update (setState, replaceState, or forceUpdate) was scheduled " +
-          "from inside an update function. Update functions should be pure, " +
-          "with zero side-effects. Consider using componentDidUpdate or a " +
-          "callback.\n\nPlease update the following component: %s",
-        componentName
-      );
+  return workInProgressHook;
+}
 
-      didWarnUpdateInsideUpdate = true;
-    }
-  }
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  var nextCurrentHook;
 
-  if (isUnsafeClassRenderPhaseUpdate(fiber)) {
-    // This is an unsafe render phase update. Add directly to the update
-    // queue so we can process it immediately during the current render.
-    var pending = sharedQueue.pending;
+  if (currentHook === null) {
+    var current = currentlyRenderingFiber$1.alternate;
 
-    if (pending === null) {
-      // This is the first update. Create a circular list.
-      update.next = update;
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
     } else {
-      update.next = pending.next;
-      pending.next = update;
+      nextCurrentHook = null;
     }
-
-    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
-    // this fiber. This is for backwards compatibility in the case where you
-    // update a different component during render phase than the one that is
-    // currently renderings (a pattern that is accompanied by a warning).
-
-    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
   } else {
-    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+    nextCurrentHook = currentHook.next;
   }
-}
-function entangleTransitions(root, fiber, lane) {
-  var updateQueue = fiber.updateQueue;
 
-  if (updateQueue === null) {
-    // Only occurs if the fiber has been unmounted.
-    return;
-  }
+  var nextWorkInProgressHook;
 
-  var sharedQueue = updateQueue.shared;
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
 
-  if (isTransitionLane(lane)) {
-    var queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
-    // have finished. We can remove them from the shared queue, which represents
-    // a superset of the actually pending lanes. In some cases we may entangle
-    // more than we need to, but that's OK. In fact it's worse if we *don't*
-    // entangle when we should.
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      var currentFiber = currentlyRenderingFiber$1.alternate;
 
-    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw new Error(
+          "Update hook called on initial render. This is likely a bug in React. Please file an issue."
+        );
+      } else {
+        // This is an update. We should always have a current hook.
+        throw new Error("Rendered more hooks than during the previous render.");
+      }
+    }
 
-    var newQueueLanes = mergeLanes(queueLanes, lane);
-    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
-    // the lane finished since the last time we entangled it. So we need to
-    // entangle it again, just to be sure.
+    currentHook = nextCurrentHook;
+    var newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
 
-    markRootEntangled(root, newQueueLanes);
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
   }
-}
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  // Captured updates are updates that are thrown by a child during the render
-  // phase. They should be discarded if the render is aborted. Therefore,
-  // we should only put them on the work-in-progress queue, not the current one.
-  var queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
 
-  var current = workInProgress.alternate;
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
 
-  if (current !== null) {
-    var currentQueue = current.updateQueue;
+var createFunctionComponentUpdateQueue;
 
-    if (queue === currentQueue) {
-      // The work-in-progress queue is the same as current. This happens when
-      // we bail out on a parent fiber that then captures an error thrown by
-      // a child. Since we want to append the update only to the work-in
-      // -progress queue, we need to clone the updates. We usually clone during
-      // processUpdateQueue, but that didn't happen in this case because we
-      // skipped over the parent when we bailed out.
-      var newFirst = null;
-      var newLast = null;
-      var firstBaseUpdate = queue.firstBaseUpdate;
+{
+  createFunctionComponentUpdateQueue = function () {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  };
+}
 
-      if (firstBaseUpdate !== null) {
-        // Loop through the updates and clone them.
-        var update = firstBaseUpdate;
+function use(usable) {
+  if (usable !== null && typeof usable === "object") {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === "function") {
+      // This is a thenable.
+      var thenable = usable; // Track the position of the thenable within this fiber.
 
-        do {
-          var clone = {
-            lane: update.lane,
-            tag: update.tag,
-            payload: update.payload,
-            // When this update is rebased, we should not fire its
-            // callback again.
-            callback: null,
-            next: null
-          };
+      var index = thenableIndexCounter;
+      thenableIndexCounter += 1;
 
-          if (newLast === null) {
-            newFirst = newLast = clone;
-          } else {
-            newLast.next = clone;
-            newLast = clone;
-          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
 
-          update = update.next;
-        } while (update !== null); // Append the captured update the end of the cloned list.
+      var result = trackUsedThenable(thenableState, thenable, index);
 
-        if (newLast === null) {
-          newFirst = newLast = capturedUpdate;
-        } else {
-          newLast.next = capturedUpdate;
-          newLast = capturedUpdate;
+      if (
+        currentlyRenderingFiber$1.alternate === null &&
+        (workInProgressHook === null
+          ? currentlyRenderingFiber$1.memoizedState === null
+          : workInProgressHook.next === null)
+      ) {
+        // Initial render, and either this is the first time the component is
+        // called, or there were no Hooks called after this use() the previous
+        // time (perhaps because it threw). Subsequent Hook calls should use the
+        // mount dispatcher.
+        {
+          ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
         }
-      } else {
-        // There are no base updates.
-        newFirst = newLast = capturedUpdate;
       }
 
-      queue = {
-        baseState: currentQueue.baseState,
-        firstBaseUpdate: newFirst,
-        lastBaseUpdate: newLast,
-        shared: currentQueue.shared,
-        callbacks: currentQueue.callbacks
-      };
-      workInProgress.updateQueue = queue;
-      return;
+      return result;
+    } else if (
+      usable.$$typeof === REACT_CONTEXT_TYPE ||
+      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    ) {
+      var context = usable;
+      return readContext(context);
     }
-  } // Append the update to the end of the list.
-
-  var lastBaseUpdate = queue.lastBaseUpdate;
-
-  if (lastBaseUpdate === null) {
-    queue.firstBaseUpdate = capturedUpdate;
-  } else {
-    lastBaseUpdate.next = capturedUpdate;
-  }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
 
-  queue.lastBaseUpdate = capturedUpdate;
+  throw new Error("An unsupported type was passed to use(): " + String(usable));
 }
 
-function getStateFromUpdate(
-  workInProgress,
-  queue,
-  update,
-  prevState,
-  nextProps,
-  instance
-) {
-  switch (update.tag) {
-    case ReplaceState: {
-      var payload = update.payload;
-
-      if (typeof payload === "function") {
-        // Updater function
-        {
-          enterDisallowedContextReadInDEV();
-        }
-
-        var nextState = payload.call(instance, prevState, nextProps);
-
-        {
-          if (workInProgress.mode & StrictLegacyMode) {
-            setIsStrictModeForDevtools(true);
-
-            try {
-              payload.call(instance, prevState, nextProps);
-            } finally {
-              setIsStrictModeForDevtools(false);
-            }
-          }
+function useMemoCache(size) {
+  var memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
 
-          exitDisallowedContextReadInDEV();
-        }
+  var updateQueue = currentlyRenderingFiber$1.updateQueue;
 
-        return nextState;
-      } // State object
+  if (updateQueue !== null) {
+    memoCache = updateQueue.memoCache;
+  } // Otherwise clone from the current fiber
 
-      return payload;
-    }
+  if (memoCache == null) {
+    var current = currentlyRenderingFiber$1.alternate;
 
-    case CaptureUpdate: {
-      workInProgress.flags =
-        (workInProgress.flags & ~ShouldCapture) | DidCapture;
-    }
-    // Intentional fallthrough
+    if (current !== null) {
+      var currentUpdateQueue = current.updateQueue;
 
-    case UpdateState: {
-      var _payload = update.payload;
-      var partialState;
+      if (currentUpdateQueue !== null) {
+        var currentMemoCache = currentUpdateQueue.memoCache;
 
-      if (typeof _payload === "function") {
-        // Updater function
-        {
-          enterDisallowedContextReadInDEV();
+        if (currentMemoCache != null) {
+          memoCache = {
+            data: currentMemoCache.data.map(function (array) {
+              return array.slice();
+            }),
+            index: 0
+          };
         }
+      }
+    }
+  } // Finally fall back to allocating a fresh instance of the cache
 
-        partialState = _payload.call(instance, prevState, nextProps);
-
-        {
-          if (workInProgress.mode & StrictLegacyMode) {
-            setIsStrictModeForDevtools(true);
+  if (memoCache == null) {
+    memoCache = {
+      data: [],
+      index: 0
+    };
+  }
 
-            try {
-              _payload.call(instance, prevState, nextProps);
-            } finally {
-              setIsStrictModeForDevtools(false);
-            }
-          }
+  if (updateQueue === null) {
+    updateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = updateQueue;
+  }
 
-          exitDisallowedContextReadInDEV();
-        }
-      } else {
-        // Partial state object
-        partialState = _payload;
-      }
+  updateQueue.memoCache = memoCache;
+  var data = memoCache.data[memoCache.index];
 
-      if (partialState === null || partialState === undefined) {
-        // Null and undefined are treated as no-ops.
-        return prevState;
-      } // Merge the partial state and the previous state.
+  if (data === undefined) {
+    data = memoCache.data[memoCache.index] = new Array(size);
 
-      return assign({}, prevState, partialState);
+    for (var i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
     }
-
-    case ForceUpdate: {
-      hasForceUpdate = true;
-      return prevState;
+  } else if (data.length !== size) {
+    // TODO: consider warning or throwing here
+    {
+      error(
+        "Expected a constant size argument for each invocation of useMemoCache. " +
+          "The previous cache was allocated with size %s but size %s was requested.",
+        data.length,
+        size
+      );
     }
   }
 
-  return prevState;
+  memoCache.index++;
+  return data;
 }
 
-function processUpdateQueue(workInProgress, props, instance, renderLanes) {
-  // This is always non-null on a ClassComponent or HostRoot
-  var queue = workInProgress.updateQueue;
-  hasForceUpdate = false;
-
-  {
-    currentlyProcessingQueue = queue.shared;
-  }
+function basicStateReducer(state, action) {
+  // $FlowFixMe: Flow doesn't like mixed types
+  return typeof action === "function" ? action(state) : action;
+}
 
-  var firstBaseUpdate = queue.firstBaseUpdate;
-  var lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+function mountReducer(reducer, initialArg, init) {
+  var hook = mountWorkInProgressHook();
+  var initialState;
 
-  var pendingQueue = queue.shared.pending;
+  if (init !== undefined) {
+    initialState = init(initialArg);
+  } else {
+    initialState = initialArg;
+  }
 
-  if (pendingQueue !== null) {
-    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
-    // and last so that it's non-circular.
+  hook.memoizedState = hook.baseState = initialState;
+  var queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  var dispatch = (queue.dispatch = dispatchReducerAction.bind(
+    null,
+    currentlyRenderingFiber$1,
+    queue
+  ));
+  return [hook.memoizedState, dispatch];
+}
 
-    var lastPendingUpdate = pendingQueue;
-    var firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null; // Append pending updates to base queue
+function updateReducer(reducer, initialArg, init) {
+  var hook = updateWorkInProgressHook();
+  var queue = hook.queue;
 
-    if (lastBaseUpdate === null) {
-      firstBaseUpdate = firstPendingUpdate;
-    } else {
-      lastBaseUpdate.next = firstPendingUpdate;
-    }
+  if (queue === null) {
+    throw new Error(
+      "Should have a queue. This is likely a bug in React. Please file an issue."
+    );
+  }
 
-    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
-    // we need to transfer the updates to that queue, too. Because the base
-    // queue is a singly-linked list with no cycles, we can append to both
-    // lists and take advantage of structural sharing.
-    // TODO: Pass `current` as argument
+  queue.lastRenderedReducer = reducer;
+  var current = currentHook; // The last rebase update that is NOT part of the base state.
 
-    var current = workInProgress.alternate;
+  var baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.
 
-    if (current !== null) {
-      // This is always non-null on a ClassComponent or HostRoot
-      var currentQueue = current.updateQueue;
-      var currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+  var pendingQueue = queue.pending;
 
-      if (currentLastBaseUpdate !== lastBaseUpdate) {
-        if (currentLastBaseUpdate === null) {
-          currentQueue.firstBaseUpdate = firstPendingUpdate;
-        } else {
-          currentLastBaseUpdate.next = firstPendingUpdate;
-        }
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      var baseFirst = baseQueue.next;
+      var pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
+    }
 
-        currentQueue.lastBaseUpdate = lastPendingUpdate;
+    {
+      if (current.baseQueue !== baseQueue) {
+        // Internal invariant that should never happen, but feasibly could in
+        // the future if we implement resuming, or some form of that.
+        error(
+          "Internal error: Expected work-in-progress queue to be a clone. " +
+            "This is a bug in React."
+        );
       }
     }
-  } // These values may change as we process the queue.
 
-  if (firstBaseUpdate !== null) {
-    // Iterate through the list of updates to compute the result.
-    var newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
-    // from the original lanes.
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
+  }
 
-    var newLanes = NoLanes;
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    var first = baseQueue.next;
+    var newState = current.baseState;
     var newBaseState = null;
-    var newFirstBaseUpdate = null;
-    var newLastBaseUpdate = null;
-    var update = firstBaseUpdate;
+    var newBaseQueueFirst = null;
+    var newBaseQueueLast = null;
+    var update = first;
 
     do {
       // An extra OffscreenLane bit is added to updates that were made to
@@ -18808,7 +17870,7 @@ function processUpdateQueue(workInProgress, props, instance, renderLanes) {
 
       var shouldSkipUpdate = isHiddenUpdate
         ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
-        : !isSubsetOfLanes(renderLanes, updateLane);
+        : !isSubsetOfLanes(renderLanes$1, updateLane);
 
       if (shouldSkipUpdate) {
         // Priority is insufficient. Skip this update. If this is the first
@@ -18816,24473 +17878,25354 @@ function processUpdateQueue(workInProgress, props, instance, renderLanes) {
         // update/state.
         var clone = {
           lane: updateLane,
-          tag: update.tag,
-          payload: update.payload,
-          callback: update.callback,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
           next: null
         };
 
-        if (newLastBaseUpdate === null) {
-          newFirstBaseUpdate = newLastBaseUpdate = clone;
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
           newBaseState = newState;
         } else {
-          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+          newBaseQueueLast = newBaseQueueLast.next = clone;
         } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
 
-        newLanes = mergeLanes(newLanes, updateLane);
+        currentlyRenderingFiber$1.lanes = mergeLanes(
+          currentlyRenderingFiber$1.lanes,
+          updateLane
+        );
+        markSkippedUpdateLanes(updateLane);
       } else {
         // This update does have sufficient priority.
-        if (newLastBaseUpdate !== null) {
+        if (newBaseQueueLast !== null) {
           var _clone = {
             // This update is going to be committed so we never want uncommit
             // it. Using NoLane works because 0 is a subset of all bitmasks, so
             // this will never be skipped by the check above.
             lane: NoLane,
-            tag: update.tag,
-            payload: update.payload,
-            // When this update is rebased, we should not fire its
-            // callback again.
-            callback: null,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
             next: null
           };
-          newLastBaseUpdate = newLastBaseUpdate.next = _clone;
+          newBaseQueueLast = newBaseQueueLast.next = _clone;
         } // Process this update.
 
-        newState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          newState,
-          props,
-          instance
-        );
-        var callback = update.callback;
-
-        if (callback !== null) {
-          workInProgress.flags |= Callback;
-
-          if (isHiddenUpdate) {
-            workInProgress.flags |= Visibility;
-          }
-
-          var callbacks = queue.callbacks;
+        var action = update.action;
 
-          if (callbacks === null) {
-            queue.callbacks = [callback];
-          } else {
-            callbacks.push(callback);
-          }
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
         }
-      } // $FlowFixMe[incompatible-type] we bail out when we get a null
-
-      update = update.next;
-
-      if (update === null) {
-        pendingQueue = queue.shared.pending;
 
-        if (pendingQueue === null) {
-          break;
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
         } else {
-          // An update was scheduled from inside a reducer. Add the new
-          // pending updates to the end of the list and keep processing.
-          var _lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
-          // unravel them when transferring them to the base queue.
-
-          var _firstPendingUpdate = _lastPendingUpdate.next;
-          _lastPendingUpdate.next = null;
-          update = _firstPendingUpdate;
-          queue.lastBaseUpdate = _lastPendingUpdate;
-          queue.shared.pending = null;
+          newState = reducer(newState, action);
         }
       }
-    } while (true);
 
-    if (newLastBaseUpdate === null) {
-      newBaseState = newState;
-    }
+      update = update.next;
+    } while (update !== null && update !== first);
 
-    queue.baseState = newBaseState;
-    queue.firstBaseUpdate = newFirstBaseUpdate;
-    queue.lastBaseUpdate = newLastBaseUpdate;
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
 
-    if (firstBaseUpdate === null) {
-      // `queue.lanes` is used for entangling transitions. We can set it back to
-      // zero once the queue is empty.
-      queue.shared.lanes = NoLanes;
-    } // 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.
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
+    }
 
-    markSkippedUpdateLanes(newLanes);
-    workInProgress.lanes = newLanes;
-    workInProgress.memoizedState = newState;
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
   }
 
-  {
-    currentlyProcessingQueue = null;
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
   }
+
+  var dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
 }
 
-function callCallback(callback, context) {
-  if (typeof callback !== "function") {
+function rerenderReducer(reducer, initialArg, init) {
+  var hook = updateWorkInProgressHook();
+  var queue = hook.queue;
+
+  if (queue === null) {
     throw new Error(
-      "Invalid argument passed as callback. Expected a function. Instead " +
-        ("received: " + callback)
+      "Should have a queue. This is likely a bug in React. Please file an issue."
     );
   }
 
-  callback.call(context);
-}
-
-function resetHasForceUpdateBeforeProcessing() {
-  hasForceUpdate = false;
-}
-function checkHasForceUpdateAfterProcessing() {
-  return hasForceUpdate;
-}
-function deferHiddenCallbacks(updateQueue) {
-  // When an update finishes on a hidden component, its callback should not
-  // be fired until/unless the component is made visible again. Stash the
-  // callback on the shared queue object so it can be fired later.
-  var newHiddenCallbacks = updateQueue.callbacks;
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
 
-  if (newHiddenCallbacks !== null) {
-    var existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+  var dispatch = queue.dispatch;
+  var lastRenderPhaseUpdate = queue.pending;
+  var newState = hook.memoizedState;
 
-    if (existingHiddenCallbacks === null) {
-      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
-    } else {
-      updateQueue.shared.hiddenCallbacks =
-        existingHiddenCallbacks.concat(newHiddenCallbacks);
-    }
-  }
-}
-function commitHiddenCallbacks(updateQueue, context) {
-  // This component is switching from hidden -> visible. Commit any callbacks
-  // that were previously deferred.
-  var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    var update = firstRenderPhaseUpdate;
 
-  if (hiddenCallbacks !== null) {
-    updateQueue.shared.hiddenCallbacks = null;
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      var action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
 
-    for (var i = 0; i < hiddenCallbacks.length; i++) {
-      var callback = hiddenCallbacks[i];
-      callCallback(callback, context);
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
     }
-  }
-}
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
 
-  if (callbacks !== null) {
-    updateQueue.callbacks = null;
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
 
-    for (var i = 0; i < callbacks.length; i++) {
-      var callback = callbacks[i];
-      callCallback(callback, context);
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
     }
-  }
-}
-
-var ReactStrictModeWarnings = {
-  recordUnsafeLifecycleWarnings: function (fiber, instance) {},
-  flushPendingUnsafeLifecycleWarnings: function () {},
-  recordLegacyContextWarning: function (fiber, instance) {},
-  flushLegacyContextWarning: function () {},
-  discardPendingWarnings: function () {}
-};
 
-{
-  var findStrictRoot = function (fiber) {
-    var maybeStrictRoot = null;
-    var node = fiber;
+    queue.lastRenderedState = newState;
+  }
 
-    while (node !== null) {
-      if (node.mode & StrictLegacyMode) {
-        maybeStrictRoot = node;
-      }
+  return [newState, dispatch];
+}
 
-      node = node.return;
-    }
+function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+  {
+    warnAboutMultipleRenderersDEV(source);
+  }
 
-    return maybeStrictRoot;
-  };
+  var getVersion = source._getVersion;
+  var version = getVersion(source._source); // Is it safe for this component to read from this source during the current render?
 
-  var setToSortedString = function (set) {
-    var array = [];
-    set.forEach(function (value) {
-      array.push(value);
-    });
-    return array.sort().join(", ");
-  };
+  var isSafeToReadFromSource = false; // Check the version first.
+  // If this render has already been started with a specific version,
+  // we can use it alone to determine if we can safely read from the source.
 
-  var pendingComponentWillMountWarnings = [];
-  var pendingUNSAFE_ComponentWillMountWarnings = [];
-  var pendingComponentWillReceivePropsWarnings = [];
-  var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-  var pendingComponentWillUpdateWarnings = [];
-  var pendingUNSAFE_ComponentWillUpdateWarnings = []; // Tracks components we have already warned about.
+  var currentRenderVersion = getWorkInProgressVersion(source);
 
-  var didWarnAboutUnsafeLifecycles = new Set();
+  if (currentRenderVersion !== null) {
+    // It's safe to read if the store hasn't been mutated since the last time
+    // we read something.
+    isSafeToReadFromSource = currentRenderVersion === version;
+  } else {
+    // If there's no version, then this is the first time we've read from the
+    // source during the current render pass, so we need to do a bit more work.
+    // What we need to determine is if there are any hooks that already
+    // subscribed to the source, and if so, whether there are any pending
+    // mutations that haven't been synchronized yet.
+    //
+    // If there are no pending mutations, then `root.mutableReadLanes` will be
+    // empty, and we know we can safely read.
+    //
+    // If there *are* pending mutations, we may still be able to safely read
+    // if the currently rendering lanes are inclusive of the pending mutation
+    // lanes, since that guarantees that the value we're about to read from
+    // the source is consistent with the values that we read during the most
+    // recent mutation.
+    isSafeToReadFromSource = isSubsetOfLanes(
+      renderLanes$1,
+      root.mutableReadLanes
+    );
 
-  ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (
-    fiber,
-    instance
-  ) {
-    // Dedupe strategy: Warn once per component.
-    if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
-      return;
+    if (isSafeToReadFromSource) {
+      // If it's safe to read from this source during the current render,
+      // store the version in case other components read from it.
+      // A changed version number will let those components know to throw and restart the render.
+      setWorkInProgressVersion(source, version);
     }
+  }
 
-    if (
-      typeof instance.componentWillMount === "function" && // Don't warn about react-lifecycles-compat polyfilled components.
-      instance.componentWillMount.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillMountWarnings.push(fiber);
-    }
+  if (isSafeToReadFromSource) {
+    var snapshot = getSnapshot(source._source);
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillMount === "function"
-    ) {
-      pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
+    {
+      if (typeof snapshot === "function") {
+        error(
+          "Mutable source should not return a function as the snapshot value. " +
+            "Functions may close over mutable values and cause tearing."
+        );
+      }
     }
 
-    if (
-      typeof instance.componentWillReceiveProps === "function" &&
-      instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillReceivePropsWarnings.push(fiber);
-    }
+    return snapshot;
+  } else {
+    // This handles the special case of a mutable source being shared between renderers.
+    // In that case, if the source is mutated between the first and second renderer,
+    // The second renderer don't know that it needs to reset the WIP version during unwind,
+    // (because the hook only marks sources as dirty if it's written to their WIP version).
+    // That would cause this tear check to throw again and eventually be visible to the user.
+    // We can avoid this infinite loop by explicitly marking the source as dirty.
+    //
+    // This can lead to tearing in the first renderer when it resumes,
+    // but there's nothing we can do about that (short of throwing here and refusing to continue the render).
+    markSourceAsDirty(source); // Intentioally throw an error to force React to retry synchronously. During
+    // the synchronous retry, it will block interleaved mutations, so we should
+    // get a consistent read. Therefore, the following error should never be
+    // visible to the user.
+    // We expect this error not to be thrown during the synchronous retry,
+    // because we blocked interleaved mutations.
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillReceiveProps === "function"
-    ) {
-      pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
-    }
+    throw new Error(
+      "Cannot read from mutable source during the current render without tearing. This may be a bug in React. Please file an issue."
+    );
+  }
+}
 
-    if (
-      typeof instance.componentWillUpdate === "function" &&
-      instance.componentWillUpdate.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillUpdateWarnings.push(fiber);
-    }
+function useMutableSource(hook, source, getSnapshot, subscribe) {
+  var root = getWorkInProgressRoot();
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillUpdate === "function"
-    ) {
-      pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
-    }
-  };
+  if (root === null) {
+    throw new Error(
+      "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+    );
+  }
 
-  ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
-    // We do an initial pass to gather component names
-    var componentWillMountUniqueNames = new Set();
+  var getVersion = source._getVersion;
+  var version = getVersion(source._source);
+  var dispatcher = ReactCurrentDispatcher$1.current; // eslint-disable-next-line prefer-const
 
-    if (pendingComponentWillMountWarnings.length > 0) {
-      pendingComponentWillMountWarnings.forEach(function (fiber) {
-        componentWillMountUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillMountWarnings = [];
-    }
+  var _dispatcher$useState = dispatcher.useState(function () {
+      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    }),
+    currentSnapshot = _dispatcher$useState[0],
+    setSnapshot = _dispatcher$useState[1];
 
-    var UNSAFE_componentWillMountUniqueNames = new Set();
+  var snapshot = currentSnapshot; // Grab a handle to the state hook as well.
+  // We use it to clear the pending update queue if we have a new source.
 
-    if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillMountUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillMountWarnings = [];
-    }
+  var stateHook = workInProgressHook;
+  var memoizedState = hook.memoizedState;
+  var refs = memoizedState.refs;
+  var prevGetSnapshot = refs.getSnapshot;
+  var prevSource = memoizedState.source;
+  var prevSubscribe = memoizedState.subscribe;
+  var fiber = currentlyRenderingFiber$1;
+  hook.memoizedState = {
+    refs: refs,
+    source: source,
+    subscribe: subscribe
+  }; // Sync the values needed by our subscription handler after each commit.
 
-    var componentWillReceivePropsUniqueNames = new Set();
+  dispatcher.useEffect(
+    function () {
+      refs.getSnapshot = getSnapshot; // Normally the dispatch function for a state hook never changes,
+      // but this hook recreates the queue in certain cases  to avoid updates from stale sources.
+      // handleChange() below needs to reference the dispatch function without re-subscribing,
+      // so we use a ref to ensure that it always has the latest version.
 
-    if (pendingComponentWillReceivePropsWarnings.length > 0) {
-      pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
-        componentWillReceivePropsUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillReceivePropsWarnings = [];
-    }
+      refs.setSnapshot = setSnapshot; // Check for a possible change between when we last rendered now.
 
-    var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
+      var maybeNewVersion = getVersion(source._source);
 
-    if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillReceivePropsUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-    }
+      if (!objectIs(version, maybeNewVersion)) {
+        var maybeNewSnapshot = getSnapshot(source._source);
 
-    var componentWillUpdateUniqueNames = new Set();
+        {
+          if (typeof maybeNewSnapshot === "function") {
+            error(
+              "Mutable source should not return a function as the snapshot value. " +
+                "Functions may close over mutable values and cause tearing."
+            );
+          }
+        }
 
-    if (pendingComponentWillUpdateWarnings.length > 0) {
-      pendingComponentWillUpdateWarnings.forEach(function (fiber) {
-        componentWillUpdateUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillUpdateWarnings = [];
-    }
+        if (!objectIs(snapshot, maybeNewSnapshot)) {
+          setSnapshot(maybeNewSnapshot);
+          var lane = requestUpdateLane(fiber);
+          markRootMutableRead(root, lane);
+        } // If the source mutated between render and now,
+        // there may be state updates already scheduled from the old source.
+        // Entangle the updates so that they render in the same batch.
 
-    var UNSAFE_componentWillUpdateUniqueNames = new Set();
+        markRootEntangled(root, root.mutableReadLanes);
+      }
+    },
+    [getSnapshot, source, subscribe]
+  ); // If we got a new source or subscribe function, re-subscribe in a passive effect.
 
-    if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillUpdateUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillUpdateWarnings = [];
-    } // Finally, we flush all the warnings
-    // UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
+  dispatcher.useEffect(
+    function () {
+      var handleChange = function () {
+        var latestGetSnapshot = refs.getSnapshot;
+        var latestSetSnapshot = refs.setSnapshot;
 
-    if (UNSAFE_componentWillMountUniqueNames.size > 0) {
-      var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
+        try {
+          latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
 
-      error(
-        "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
-          "\nPlease update the following components: %s",
-        sortedNames
-      );
-    }
+          var lane = requestUpdateLane(fiber);
+          markRootMutableRead(root, lane);
+        } catch (error) {
+          // A selector might throw after a source mutation.
+          // e.g. it might try to read from a part of the store that no longer exists.
+          // In this case we should still schedule an update with React.
+          // Worst case the selector will throw again and then an error boundary will handle it.
+          latestSetSnapshot(function () {
+            throw error;
+          });
+        }
+      };
 
-    if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
-      var _sortedNames = setToSortedString(
-        UNSAFE_componentWillReceivePropsUniqueNames
-      );
+      var unsubscribe = subscribe(source._source, handleChange);
 
-      error(
-        "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " +
-          "and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* If you're updating state whenever props change, " +
-          "refactor your code to use memoization techniques or move it to " +
-          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames
-      );
-    }
+      {
+        if (typeof unsubscribe !== "function") {
+          error(
+            "Mutable source subscribe function must return an unsubscribe function."
+          );
+        }
+      }
 
-    if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
-      var _sortedNames2 = setToSortedString(
-        UNSAFE_componentWillUpdateUniqueNames
-      );
+      return unsubscribe;
+    },
+    [source, subscribe]
+  ); // If any of the inputs to useMutableSource change, reading is potentially unsafe.
+  //
+  // If either the source or the subscription have changed we can't can't trust the update queue.
+  // Maybe the source changed in a way that the old subscription ignored but the new one depends on.
+  //
+  // If the getSnapshot function changed, we also shouldn't rely on the update queue.
+  // It's possible that the underlying source was mutated between the when the last "change" event fired,
+  // and when the current render (with the new getSnapshot function) is processed.
+  //
+  // In both cases, we need to throw away pending updates (since they are no longer relevant)
+  // and treat reading from the source as we do in the mount case.
 
-      error(
-        "Using UNSAFE_componentWillUpdate in strict mode is not recommended " +
-          "and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames2
-      );
-    }
+  if (
+    !objectIs(prevGetSnapshot, getSnapshot) ||
+    !objectIs(prevSource, source) ||
+    !objectIs(prevSubscribe, subscribe)
+  ) {
+    // Create a new queue and setState method,
+    // So if there are interleaved updates, they get pushed to the older queue.
+    // When this becomes current, the previous queue and dispatch method will be discarded,
+    // including any interleaving updates that occur.
+    var newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: snapshot
+    };
+    newQueue.dispatch = setSnapshot = dispatchSetState.bind(
+      null,
+      currentlyRenderingFiber$1,
+      newQueue
+    );
+    stateHook.queue = newQueue;
+    stateHook.baseQueue = null;
+    snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    stateHook.memoizedState = stateHook.baseState = snapshot;
+  }
 
-    if (componentWillMountUniqueNames.size > 0) {
-      var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);
+  return snapshot;
+}
 
-      warn(
-        "componentWillMount has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
-          "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames3
-      );
-    }
+function mountMutableSource(source, getSnapshot, subscribe) {
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = {
+    refs: {
+      getSnapshot: getSnapshot,
+      setSnapshot: null
+    },
+    source: source,
+    subscribe: subscribe
+  };
+  return useMutableSource(hook, source, getSnapshot, subscribe);
+}
 
-    if (componentWillReceivePropsUniqueNames.size > 0) {
-      var _sortedNames4 = setToSortedString(
-        componentWillReceivePropsUniqueNames
-      );
+function updateMutableSource(source, getSnapshot, subscribe) {
+  var hook = updateWorkInProgressHook();
+  return useMutableSource(hook, source, getSnapshot, subscribe);
+}
 
-      warn(
-        "componentWillReceiveProps has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* If you're updating state whenever props change, refactor your " +
-          "code to use memoization techniques or move it to " +
-          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
-          "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames4
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  var fiber = currentlyRenderingFiber$1;
+  var hook = mountWorkInProgressHook();
+  var nextSnapshot;
+  var isHydrating = getIsHydrating();
+
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw new Error(
+        "Missing getServerSnapshot, which is required for " +
+          "server-rendered content. Will revert to client rendering."
       );
     }
 
-    if (componentWillUpdateUniqueNames.size > 0) {
-      var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);
+    nextSnapshot = getServerSnapshot();
 
-      warn(
-        "componentWillUpdate has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames5
-      );
+    {
+      if (!didWarnUncachedGetSnapshot) {
+        if (nextSnapshot !== getServerSnapshot()) {
+          error(
+            "The result of getServerSnapshot should be cached to avoid an infinite loop"
+          );
+
+          didWarnUncachedGetSnapshot = true;
+        }
+      }
     }
-  };
+  } else {
+    nextSnapshot = getSnapshot();
 
-  var pendingLegacyContextWarning = new Map(); // Tracks components we have already warned about.
+    {
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedSnapshot = getSnapshot();
 
-  var didWarnAboutLegacyContext = new Set();
+        if (!objectIs(nextSnapshot, cachedSnapshot)) {
+          error(
+            "The result of getSnapshot should be cached to avoid an infinite loop"
+          );
 
-  ReactStrictModeWarnings.recordLegacyContextWarning = function (
-    fiber,
-    instance
-  ) {
-    var strictRoot = findStrictRoot(fiber);
+          didWarnUncachedGetSnapshot = true;
+        }
+      }
+    } // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
 
-    if (strictRoot === null) {
-      error(
-        "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."
-      );
+    var root = getWorkInProgressRoot();
 
-      return;
-    } // Dedup strategy: Warn once per component.
+    if (root === null) {
+      throw new Error(
+        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+      );
+    }
 
-    if (didWarnAboutLegacyContext.has(fiber.type)) {
-      return;
+    if (!includesBlockingLane(root, renderLanes$1)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
     }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
 
-    var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
+  hook.memoizedState = nextSnapshot;
+  var inst = {
+    value: nextSnapshot,
+    getSnapshot: getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
 
-    if (
-      fiber.type.contextTypes != null ||
-      fiber.type.childContextTypes != null ||
-      (instance !== null && typeof instance.getChildContext === "function")
-    ) {
-      if (warningsForRoot === undefined) {
-        warningsForRoot = [];
-        pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
-      }
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+  // TODO: We can move this to the passive phase once we add a pre-commit
+  // consistency check. See the next comment.
 
-      warningsForRoot.push(fiber);
-    }
-  };
+  fiber.flags |= Passive$1;
+  pushEffect(
+    HasEffect | Passive,
+    updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
+    undefined,
+    null
+  );
+  return nextSnapshot;
+}
 
-  ReactStrictModeWarnings.flushLegacyContextWarning = function () {
-    pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
-      if (fiberArray.length === 0) {
-        return;
-      }
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  var fiber = currentlyRenderingFiber$1;
+  var hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
 
-      var firstFiber = fiberArray[0];
-      var uniqueNames = new Set();
-      fiberArray.forEach(function (fiber) {
-        uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
-        didWarnAboutLegacyContext.add(fiber.type);
-      });
-      var sortedNames = setToSortedString(uniqueNames);
+  var nextSnapshot = getSnapshot();
 
-      try {
-        setCurrentFiber(firstFiber);
+  {
+    if (!didWarnUncachedGetSnapshot) {
+      var cachedSnapshot = getSnapshot();
 
+      if (!objectIs(nextSnapshot, cachedSnapshot)) {
         error(
-          "Legacy context API has been detected within a strict-mode tree." +
-            "\n\nThe old API will be supported in all 16.x releases, but applications " +
-            "using it should migrate to the new version." +
-            "\n\nPlease update the following components: %s" +
-            "\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context",
-          sortedNames
+          "The result of getSnapshot should be cached to avoid an infinite loop"
         );
-      } finally {
-        resetCurrentFiber();
-      }
-    });
-  };
-
-  ReactStrictModeWarnings.discardPendingWarnings = function () {
-    pendingComponentWillMountWarnings = [];
-    pendingUNSAFE_ComponentWillMountWarnings = [];
-    pendingComponentWillReceivePropsWarnings = [];
-    pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-    pendingComponentWillUpdateWarnings = [];
-    pendingUNSAFE_ComponentWillUpdateWarnings = [];
-    pendingLegacyContextWarning = new Map();
-  };
-}
-
-var ReactCurrentActQueue$2 = ReactSharedInternals.ReactCurrentActQueue; // An error that is thrown (e.g. by `use`) to trigger Suspense. If we
-// detect this is caught by userspace, we'll log a warning in development.
 
-var SuspenseException = new Error(
-  "Suspense Exception: This is not a real error! It's an implementation " +
-    "detail of `use` to interrupt the current render. You must either " +
-    "rethrow it immediately, or move the `use` call outside of the " +
-    "`try/catch` block. Capturing without rethrowing will lead to " +
-    "unexpected behavior.\n\n" +
-    "To handle async errors, wrap your component in an error boundary, or " +
-    "call the promise's `.catch` method and pass the result to `use`"
-);
-function createThenableState() {
-  // The ThenableState is created the first time a component suspends. If it
-  // suspends again, we'll reuse the same state.
-  return [];
-}
-function isThenableResolved(thenable) {
-  var status = thenable.status;
-  return status === "fulfilled" || status === "rejected";
-}
+        didWarnUncachedGetSnapshot = true;
+      }
+    }
+  }
 
-function noop() {}
+  var prevSnapshot = (currentHook || hook).memoizedState;
+  var snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
 
-function trackUsedThenable(thenableState, thenable, index) {
-  if (ReactCurrentActQueue$2.current !== null) {
-    ReactCurrentActQueue$2.didUsePromise = true;
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
   }
 
-  var previous = thenableState[index];
+  var inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [
+    subscribe
+  ]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
 
-  if (previous === undefined) {
-    thenableState.push(thenable);
-  } else {
-    if (previous !== thenable) {
-      // Reuse the previous thenable, and drop the new one. We can assume
-      // they represent the same value, because components are idempotent.
-      // Avoid an unhandled rejection errors for the Promises that we'll
-      // intentionally ignore.
-      thenable.then(noop, noop);
-      thenable = previous;
-    }
-  } // We use an expando to track the status and result of a thenable so that we
-  // can synchronously unwrap the value. Think of this as an extension of the
-  // Promise API, or a custom interface that is a superset of Thenable.
-  //
-  // If the thenable doesn't have a status, set it to "pending" and attach
-  // a listener that will update its status and result when it resolves.
+  if (
+    inst.getSnapshot !== getSnapshot ||
+    snapshotChanged || // Check if the susbcribe function changed. We can save some memory by
+    // checking whether we scheduled a subscription effect above.
+    (workInProgressHook !== null &&
+      workInProgressHook.memoizedState.tag & HasEffect)
+  ) {
+    fiber.flags |= Passive$1;
+    pushEffect(
+      HasEffect | Passive,
+      updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
+      undefined,
+      null
+    ); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
 
-  switch (thenable.status) {
-    case "fulfilled": {
-      var fulfilledValue = thenable.value;
-      return fulfilledValue;
-    }
+    var root = getWorkInProgressRoot();
 
-    case "rejected": {
-      var rejectedError = thenable.reason;
-      throw rejectedError;
+    if (root === null) {
+      throw new Error(
+        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+      );
     }
 
-    default: {
-      if (typeof thenable.status === "string") {
-        // Only instrument the thenable if the status if not defined. If
-        // it's defined, but an unknown value, assume it's been instrumented by
-        // some custom userspace implementation. We treat it as "pending".
-        // Attach a dummy listener, to ensure that any lazy initialization can
-        // happen. Flight lazily parses JSON when the value is actually awaited.
-        thenable.then(noop, noop);
-      } else {
-        var pendingThenable = thenable;
-        pendingThenable.status = "pending";
-        pendingThenable.then(
-          function (fulfilledValue) {
-            if (thenable.status === "pending") {
-              var fulfilledThenable = thenable;
-              fulfilledThenable.status = "fulfilled";
-              fulfilledThenable.value = fulfilledValue;
-            }
-          },
-          function (error) {
-            if (thenable.status === "pending") {
-              var rejectedThenable = thenable;
-              rejectedThenable.status = "rejected";
-              rejectedThenable.reason = error;
-            }
-          }
-        );
-      } // Check one more time in case the thenable resolved synchronously.
-
-      switch (thenable.status) {
-        case "fulfilled": {
-          var fulfilledThenable = thenable;
-          return fulfilledThenable.value;
-        }
+    if (!includesBlockingLane(root, renderLanes$1)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  }
 
-        case "rejected": {
-          var rejectedThenable = thenable;
-          throw rejectedThenable.reason;
-        }
-      } // Suspend.
-      //
-      // Throwing here is an implementation detail that allows us to unwind the
-      // call stack. But we shouldn't allow it to leak into userspace. Throw an
-      // opaque placeholder value instead of the actual thenable. If it doesn't
-      // get captured by the work loop, log a warning, because that means
-      // something in userspace must have caught it.
+  return nextSnapshot;
+}
 
-      suspendedThenable = thenable;
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  var check = {
+    getSnapshot: getSnapshot,
+    value: renderedSnapshot
+  };
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-      {
-        needsToResetSuspendedThenableDEV = true;
-      }
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    var stores = componentUpdateQueue.stores;
 
-      throw SuspenseException;
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
     }
   }
-} // This is used to track the actual thenable that suspended so it can be
-// passed to the rest of the Suspense implementation — which, for historical
-// reasons, expects to receive a thenable.
-
-var suspendedThenable = null;
-var needsToResetSuspendedThenableDEV = false;
-function getSuspendedThenable() {
-  // This is called right after `use` suspends by throwing an exception. `use`
-  // throws an opaque value instead of the thenable itself so that it can't be
-  // caught in userspace. Then the work loop accesses the actual thenable using
-  // this function.
-  if (suspendedThenable === null) {
-    throw new Error(
-      "Expected a suspended thenable. This is a bug in React. Please file " +
-        "an issue."
-    );
-  }
+}
 
-  var thenable = suspendedThenable;
-  suspendedThenable = null;
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
 
-  {
-    needsToResetSuspendedThenableDEV = false;
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
   }
-
-  return thenable;
 }
-function checkIfUseWrappedInTryCatch() {
-  {
-    // This was set right before SuspenseException was thrown, and it should
-    // have been cleared when the exception was handled. If it wasn't,
-    // it must have been caught by userspace.
-    if (needsToResetSuspendedThenableDEV) {
-      needsToResetSuspendedThenableDEV = false;
-      return true;
+
+function subscribeToStore(fiber, inst, subscribe) {
+  var handleStoreChange = function () {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
     }
-  }
+  }; // Subscribe to the store and return a clean-up function.
 
-  return false;
+  return subscribe(handleStoreChange);
 }
 
-var thenableState$1 = null;
-var thenableIndexCounter$1 = 0;
-var didWarnAboutMaps;
-var didWarnAboutGenerators;
-var didWarnAboutStringRefs;
-var ownerHasKeyUseWarning;
-var ownerHasFunctionTypeWarning;
-
-var warnForMissingKey = function (child, returnFiber) {};
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  var prevValue = inst.value;
 
-{
-  didWarnAboutMaps = false;
-  didWarnAboutGenerators = false;
-  didWarnAboutStringRefs = {};
-  /**
-   * Warn if there's no key explicitly set on dynamic arrays of children or
-   * object keys are not valid. This allows us to keep track of children between
-   * updates.
-   */
-
-  ownerHasKeyUseWarning = {};
-  ownerHasFunctionTypeWarning = {};
-
-  warnForMissingKey = function (child, returnFiber) {
-    if (child === null || typeof child !== "object") {
-      return;
-    }
-
-    if (!child._store || child._store.validated || child.key != null) {
-      return;
-    }
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
 
-    if (typeof child._store !== "object") {
-      throw new Error(
-        "React Component in warnForMissingKey should have a _store. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
-    } // $FlowFixMe unable to narrow type from mixed to writable object
+function forceStoreRerender(fiber) {
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-    child._store.validated = true;
-    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
+}
 
-    if (ownerHasKeyUseWarning[componentName]) {
-      return;
-    }
+function mountState(initialState) {
+  var hook = mountWorkInProgressHook();
 
-    ownerHasKeyUseWarning[componentName] = true;
+  if (typeof initialState === "function") {
+    // $FlowFixMe: Flow doesn't like mixed types
+    initialState = initialState();
+  }
 
-    error(
-      "Each child in a list should have a unique " +
-        '"key" prop. See https://reactjs.org/link/warning-keys for ' +
-        "more information."
-    );
+  hook.memoizedState = hook.baseState = initialState;
+  var queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
   };
+  hook.queue = queue;
+  var dispatch = (queue.dispatch = dispatchSetState.bind(
+    null,
+    currentlyRenderingFiber$1,
+    queue
+  ));
+  return [hook.memoizedState, dispatch];
 }
 
-function isReactClass(type) {
-  return type.prototype && type.prototype.isReactComponent;
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
 }
 
-function unwrapThenable(thenable) {
-  var index = thenableIndexCounter$1;
-  thenableIndexCounter$1 += 1;
-
-  if (thenableState$1 === null) {
-    thenableState$1 = createThenableState();
-  }
-
-  return trackUsedThenable(thenableState$1, thenable, index);
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
 }
 
-function coerceRef(returnFiber, current, element) {
-  var mixedRef = element.ref;
-
-  if (
-    mixedRef !== null &&
-    typeof mixedRef !== "function" &&
-    typeof mixedRef !== "object"
-  ) {
-    {
-      if (
-        // We warn in ReactElement.js if owner and self are equal for string refs
-        // because these cannot be automatically converted to an arrow function
-        // using a codemod. Therefore, we don't have to warn about string refs again.
-        !(
-          element._owner &&
-          element._self &&
-          element._owner.stateNode !== element._self
-        ) && // Will already throw with "Function components cannot have string refs"
-        !(element._owner && element._owner.tag !== ClassComponent) && // Will already warn with "Function components cannot be given refs"
-        !(typeof element.type === "function" && !isReactClass(element.type)) && // Will already throw with "Element ref was specified as a string (someStringRef) but no owner was set"
-        element._owner
-      ) {
-        var componentName =
-          getComponentNameFromFiber(returnFiber) || "Component";
+function pushEffect(tag, create, destroy, deps) {
+  var effect = {
+    tag: tag,
+    create: create,
+    destroy: destroy,
+    deps: deps,
+    // Circular
+    next: null
+  };
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-        if (!didWarnAboutStringRefs[componentName]) {
-          error(
-            'Component "%s" contains the string ref "%s". Support for string refs ' +
-              "will be removed in a future major release. We recommend using " +
-              "useRef() or createRef() instead. " +
-              "Learn more about using refs safely here: " +
-              "https://reactjs.org/link/strict-mode-string-ref",
-            componentName,
-            mixedRef
-          );
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    var lastEffect = componentUpdateQueue.lastEffect;
 
-          didWarnAboutStringRefs[componentName] = true;
-        }
-      }
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      var firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
     }
+  }
 
-    if (element._owner) {
-      var owner = element._owner;
-      var inst;
+  return effect;
+}
 
-      if (owner) {
-        var ownerFiber = owner;
+var stackContainsErrorMessage = null;
 
-        if (ownerFiber.tag !== ClassComponent) {
-          throw new Error(
-            "Function components cannot have string refs. " +
-              "We recommend using useRef() instead. " +
-              "Learn more about using refs safely here: " +
-              "https://reactjs.org/link/strict-mode-string-ref"
-          );
-        }
+function getCallerStackFrame() {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  var stackFrames = new Error("Error message").stack.split("\n"); // Some browsers (e.g. Chrome) include the error message in the stack
+  // but others (e.g. Firefox) do not.
 
-        inst = ownerFiber.stateNode;
-      }
+  if (stackContainsErrorMessage === null) {
+    stackContainsErrorMessage = stackFrames[0].includes("Error message");
+  }
 
-      if (!inst) {
-        throw new Error(
-          "Missing owner for string ref " +
-            mixedRef +
-            ". This error is likely caused by a " +
-            "bug in React. Please file an issue."
-        );
-      } // Assigning this to a const so Flow knows it won't change in the closure
+  return stackContainsErrorMessage
+    ? stackFrames.slice(3, 4).join("\n")
+    : stackFrames.slice(2, 3).join("\n");
+}
 
-      var resolvedInst = inst;
+function mountRef(initialValue) {
+  var hook = mountWorkInProgressHook();
 
-      {
-        checkPropStringCoercion(mixedRef, "ref");
-      }
+  if (enableUseRefAccessWarning) {
+    {
+      // Support lazy initialization pattern shown in docs.
+      // We need to store the caller stack frame so that we don't warn on subsequent renders.
+      var hasBeenInitialized = initialValue != null;
+      var lazyInitGetterStack = null;
+      var didCheckForLazyInit = false; // Only warn once per component+hook.
 
-      var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
+      var didWarnAboutRead = false;
+      var didWarnAboutWrite = false;
+      var current = initialValue;
+      var ref = {
+        get current() {
+          if (!hasBeenInitialized) {
+            didCheckForLazyInit = true;
+            lazyInitGetterStack = getCallerStackFrame();
+          } else if (currentlyRenderingFiber$1 !== null && !didWarnAboutRead) {
+            if (
+              lazyInitGetterStack === null ||
+              lazyInitGetterStack !== getCallerStackFrame()
+            ) {
+              didWarnAboutRead = true;
 
-      if (
-        current !== null &&
-        current.ref !== null &&
-        typeof current.ref === "function" &&
-        current.ref._stringRef === stringRef
-      ) {
-        return current.ref;
-      }
+              warn(
+                "%s: Unsafe read of a mutable value during render.\n\n" +
+                  "Reading from a ref during render is only safe if:\n" +
+                  "1. The ref value has not been updated, or\n" +
+                  "2. The ref holds a lazily-initialized value that is only set once.\n",
+                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
+                  "Unknown"
+              );
+            }
+          }
 
-      var ref = function (value) {
-        var refs = resolvedInst.refs;
+          return current;
+        },
 
-        if (value === null) {
-          delete refs[stringRef];
-        } else {
-          refs[stringRef] = value;
+        set current(value) {
+          if (currentlyRenderingFiber$1 !== null && !didWarnAboutWrite) {
+            if (hasBeenInitialized || !didCheckForLazyInit) {
+              didWarnAboutWrite = true;
+
+              warn(
+                "%s: Unsafe write of a mutable value during render.\n\n" +
+                  "Writing to a ref during render is only safe if the ref holds " +
+                  "a lazily-initialized value that is only set once.\n",
+                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
+                  "Unknown"
+              );
+            }
+          }
+
+          hasBeenInitialized = true;
+          current = value;
         }
       };
-
-      ref._stringRef = stringRef;
+      Object.seal(ref);
+      hook.memoizedState = ref;
       return ref;
-    } else {
-      if (typeof mixedRef !== "string") {
-        throw new Error(
-          "Expected ref to be a function, a string, an object returned by React.createRef(), or null."
-        );
-      }
-
-      if (!element._owner) {
-        throw new Error(
-          "Element ref was specified as a string (" +
-            mixedRef +
-            ") but no owner was set. This could happen for one of" +
-            " the following reasons:\n" +
-            "1. You may be adding a ref to a function component\n" +
-            "2. You may be adding a ref to a component that was not created inside a component's render method\n" +
-            "3. You have multiple copies of React loaded\n" +
-            "See https://reactjs.org/link/refs-must-have-owner for more information."
-        );
-      }
     }
+  } else {
+    var _ref2 = {
+      current: initialValue
+    };
+    hook.memoizedState = _ref2;
+    return _ref2;
   }
+}
 
-  return mixedRef;
+function updateRef(initialValue) {
+  var hook = updateWorkInProgressHook();
+  return hook.memoizedState;
 }
 
-function throwOnInvalidObjectType(returnFiber, newChild) {
-  // $FlowFixMe[method-unbinding]
-  var childString = Object.prototype.toString.call(newChild);
-  throw new Error(
-    "Objects are not valid as a React child (found: " +
-      (childString === "[object Object]"
-        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
-        : childString) +
-      "). " +
-      "If you meant to render a collection of children, use an array " +
-      "instead."
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    HasEffect | hookFlags,
+    create,
+    undefined,
+    nextDeps
   );
 }
 
-function warnOnFunctionType(returnFiber) {
-  {
-    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var destroy = undefined; // currentHook is null when rerendering after a render phase state update.
 
-    if (ownerHasFunctionTypeWarning[componentName]) {
-      return;
+  if (currentHook !== null) {
+    var prevEffect = currentHook.memoizedState;
+    destroy = prevEffect.destroy;
+
+    if (nextDeps !== null) {
+      var prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, destroy, nextDeps);
+        return;
+      }
     }
+  }
 
-    ownerHasFunctionTypeWarning[componentName] = true;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    HasEffect | hookFlags,
+    create,
+    destroy,
+    nextDeps
+  );
+}
 
-    error(
-      "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."
+function mountEffect(create, deps) {
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    mountEffectImpl(
+      MountPassiveDev | Passive$1 | PassiveStatic,
+      Passive,
+      create,
+      deps
     );
+  } else {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
   }
 }
 
-function resolveLazy(lazyType) {
-  var payload = lazyType._payload;
-  var init = lazyType._init;
-  return init(payload);
-} // This wrapper function exists because I expect to clone the code in each path
-// to be able to optimize each path individually by branching early. This needs
-// a compiler or we can do it manually. Helpers that don't need this branching
-// live outside of this function.
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
+}
 
-function createChildReconciler(shouldTrackSideEffects) {
-  function deleteChild(returnFiber, childToDelete) {
-    if (!shouldTrackSideEffects) {
-      // Noop.
-      return;
-    }
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-    var deletions = returnFiber.deletions;
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    var events = componentUpdateQueue.events;
 
-    if (deletions === null) {
-      returnFiber.deletions = [childToDelete];
-      returnFiber.flags |= ChildDeletion;
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
     } else {
-      deletions.push(childToDelete);
+      events.push(payload);
     }
   }
+}
 
-  function deleteRemainingChildren(returnFiber, currentFirstChild) {
-    if (!shouldTrackSideEffects) {
-      // Noop.
-      return null;
-    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
-    // assuming that after the first child we've already added everything.
-
-    var childToDelete = currentFirstChild;
+function mountEvent(callback) {
+  var hook = mountWorkInProgressHook();
+  var ref = {
+    impl: callback
+  };
+  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
 
-    while (childToDelete !== null) {
-      deleteChild(returnFiber, childToDelete);
-      childToDelete = childToDelete.sibling;
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw new Error(
+        "A function wrapped in useEffectEvent can't be called during rendering."
+      );
     }
 
-    return null;
-  }
-
-  function mapRemainingChildren(returnFiber, currentFirstChild) {
-    // Add the remaining children to a temporary map so that we can find them by
-    // keys quickly. Implicit (null) keys get added to this set with their index
-    // instead.
-    var existingChildren = new Map();
-    var existingChild = currentFirstChild;
+    return ref.impl.apply(undefined, arguments);
+  };
+}
 
-    while (existingChild !== null) {
-      if (existingChild.key !== null) {
-        existingChildren.set(existingChild.key, existingChild);
-      } else {
-        existingChildren.set(existingChild.index, existingChild);
-      }
+function updateEvent(callback) {
+  var hook = updateWorkInProgressHook();
+  var ref = hook.memoizedState;
+  useEffectEventImpl({
+    ref: ref,
+    nextImpl: callback
+  }); // $FlowIgnore[incompatible-return]
 
-      existingChild = existingChild.sibling;
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw new Error(
+        "A function wrapped in useEffectEvent can't be called during rendering."
+      );
     }
 
-    return existingChildren;
-  }
+    return ref.impl.apply(undefined, arguments);
+  };
+}
 
-  function useFiber(fiber, pendingProps) {
-    // We currently set sibling to null and index to 0 here because it is easy
-    // to forget to do before returning it. E.g. for the single child case.
-    var clone = createWorkInProgress(fiber, pendingProps);
-    clone.index = 0;
-    clone.sibling = null;
-    return clone;
-  }
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
 
-  function placeChild(newFiber, lastPlacedIndex, newIndex) {
-    newFiber.index = newIndex;
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
 
-    if (!shouldTrackSideEffects) {
-      // During hydration, the useId algorithm needs to know which fibers are
-      // part of a list of children (arrays, iterators).
-      newFiber.flags |= Forked;
-      return lastPlacedIndex;
-    }
+function mountLayoutEffect(create, deps) {
+  var fiberFlags = Update | LayoutStatic;
 
-    var current = newFiber.alternate;
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    fiberFlags |= MountLayoutDev;
+  }
 
-    if (current !== null) {
-      var oldIndex = current.index;
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
+}
 
-      if (oldIndex < lastPlacedIndex) {
-        // This is a move.
-        newFiber.flags |= Placement | PlacementDEV;
-        return lastPlacedIndex;
-      } else {
-        // This item can stay in place.
-        return oldIndex;
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
+}
+
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === "function") {
+    var refCallback = ref;
+    var inst = create();
+    refCallback(inst);
+    return function () {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    var refObject = ref;
+
+    {
+      if (!refObject.hasOwnProperty("current")) {
+        error(
+          "Expected useImperativeHandle() first argument to either be a " +
+            "ref callback or React.createRef() object. Instead received: %s.",
+          "an object with keys {" + Object.keys(refObject).join(", ") + "}"
+        );
       }
-    } else {
-      // This is an insertion.
-      newFiber.flags |= Placement | PlacementDEV;
-      return lastPlacedIndex;
     }
-  }
 
-  function placeSingleChild(newFiber) {
-    // This is simpler for the single child case. We only need to do a
-    // placement for inserting new children.
-    if (shouldTrackSideEffects && newFiber.alternate === null) {
-      newFiber.flags |= Placement | PlacementDEV;
-    }
+    var _inst = create();
 
-    return newFiber;
+    refObject.current = _inst;
+    return function () {
+      refObject.current = null;
+    };
   }
+}
 
-  function updateTextNode(returnFiber, current, textContent, lanes) {
-    if (current === null || current.tag !== HostText) {
-      // Insert
-      var created = createFiberFromText(textContent, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, textContent);
-      existing.return = returnFiber;
-      return existing;
+function mountImperativeHandle(ref, create, deps) {
+  {
+    if (typeof create !== "function") {
+      error(
+        "Expected useImperativeHandle() second argument to be a function " +
+          "that creates a handle. Instead received: %s.",
+        create !== null ? typeof create : "null"
+      );
     }
+  } // TODO: If deps are provided, should we skip comparing the ref itself?
+
+  var effectDeps =
+    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  var fiberFlags = Update | LayoutStatic;
+
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    fiberFlags |= MountLayoutDev;
   }
 
-  function updateElement(returnFiber, current, element, lanes) {
-    var elementType = element.type;
+  mountEffectImpl(
+    fiberFlags,
+    Layout,
+    imperativeHandleEffect.bind(null, create, ref),
+    effectDeps
+  );
+}
 
-    if (elementType === REACT_FRAGMENT_TYPE) {
-      return updateFragment(
-        returnFiber,
-        current,
-        element.props.children,
-        lanes,
-        element.key
+function updateImperativeHandle(ref, create, deps) {
+  {
+    if (typeof create !== "function") {
+      error(
+        "Expected useImperativeHandle() second argument to be a function " +
+          "that creates a handle. Instead received: %s.",
+        create !== null ? typeof create : "null"
       );
     }
+  } // TODO: If deps are provided, should we skip comparing the ref itself?
 
-    if (current !== null) {
-      if (
-        current.elementType === elementType || // Keep this check inline so it only runs on the false path:
-        isCompatibleFamilyForHotReloading(current, element) || // Lazy types should reconcile their resolved type.
-        // We need to do this after the Hot Reloading check above,
-        // because hot reloading has different semantics than prod because
-        // it doesn't resuspend. So we can't let the call below suspend.
-        (typeof elementType === "object" &&
-          elementType !== null &&
-          elementType.$$typeof === REACT_LAZY_TYPE &&
-          resolveLazy(elementType) === current.type)
-      ) {
-        // Move based on index
-        var existing = useFiber(current, element.props);
-        existing.ref = coerceRef(returnFiber, current, element);
-        existing.return = returnFiber;
+  var effectDeps =
+    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(
+    Update,
+    Layout,
+    imperativeHandleEffect.bind(null, create, ref),
+    effectDeps
+  );
+}
 
-        {
-          existing._debugSource = element._source;
-          existing._debugOwner = element._owner;
-        }
+function mountDebugValue(value, formatterFn) {
+  // This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
+}
 
-        return existing;
-      }
-    } // Insert
+var updateDebugValue = mountDebugValue;
 
-    var created = createFiberFromElement(element, returnFiber.mode, lanes);
-    created.ref = coerceRef(returnFiber, current, element);
-    created.return = returnFiber;
-    return created;
-  }
+function mountCallback(callback, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
 
-  function updatePortal(returnFiber, current, portal, lanes) {
-    if (
-      current === null ||
-      current.tag !== HostPortal ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
-    ) {
-      // Insert
-      var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, portal.children || []);
-      existing.return = returnFiber;
-      return existing;
-    }
-  }
+function updateCallback(callback, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var prevState = hook.memoizedState;
 
-  function updateFragment(returnFiber, current, fragment, lanes, key) {
-    if (current === null || current.tag !== Fragment) {
-      // Insert
-      var created = createFiberFromFragment(
-        fragment,
-        returnFiber.mode,
-        lanes,
-        key
-      );
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, fragment);
-      existing.return = returnFiber;
-      return existing;
+  if (nextDeps !== null) {
+    var prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
     }
   }
 
-  function createChild(returnFiber, newChild, lanes) {
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys. If the previous node is implicitly keyed
-      // we can continue to replace it without aborting even if it is not a text
-      // node.
-      var created = createFiberFromText("" + newChild, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    }
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          var _created = createFiberFromElement(
-            newChild,
-            returnFiber.mode,
-            lanes
-          );
+function mountMemo(nextCreate, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
 
-          _created.ref = coerceRef(returnFiber, null, newChild);
-          _created.return = returnFiber;
-          return _created;
-        }
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
 
-        case REACT_PORTAL_TYPE: {
-          var _created2 = createFiberFromPortal(
-            newChild,
-            returnFiber.mode,
-            lanes
-          );
+  var nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
 
-          _created2.return = returnFiber;
-          return _created2;
-        }
+function updateMemo(nextCreate, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
 
-        case REACT_LAZY_TYPE: {
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return createChild(returnFiber, init(payload), lanes);
-        }
-      }
+  if (nextDeps !== null) {
+    var prevDeps = prevState[1];
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        var _created3 = createFiberFromFragment(
-          newChild,
-          returnFiber.mode,
-          lanes,
-          null
-        );
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
+  }
 
-        _created3.return = returnFiber;
-        return _created3;
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
 
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return createChild(returnFiber, unwrapThenable(thenable), lanes);
-      }
+  var nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return createChild(
-          returnFiber,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+function mountDeferredValue(value) {
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = value;
+  return value;
+}
 
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
+function updateDeferredValue(value) {
+  var hook = updateWorkInProgressHook();
+  var resolvedCurrentHook = currentHook;
+  var prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value);
+}
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
-    }
+function rerenderDeferredValue(value) {
+  var hook = updateWorkInProgressHook();
 
-    return null;
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    hook.memoizedState = value;
+    return value;
+  } else {
+    // This is a rerender during an update.
+    var prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value);
   }
+}
 
-  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
-    // Update the fiber if the keys match, otherwise return null.
-    var key = oldFiber !== null ? oldFiber.key : null;
+function updateDeferredValueImpl(hook, prevValue, value) {
+  var shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes$1);
 
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys. If the previous node is implicitly keyed
-      // we can continue to replace it without aborting even if it is not a text
-      // node.
-      if (key !== null) {
-        return null;
-      }
+  if (shouldDeferValue) {
+    // This is an urgent update. If the value has changed, keep using the
+    // previous value and spawn a deferred render to update it later.
+    if (!objectIs(value, prevValue)) {
+      // Schedule a deferred render
+      var deferredLane = claimNextTransitionLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(
+        currentlyRenderingFiber$1.lanes,
+        deferredLane
+      );
+      markSkippedUpdateLanes(deferredLane); // Set this to true to indicate that the rendered value is inconsistent
+      // from the latest value. The name "baseState" doesn't really match how we
+      // use it because we're reusing a state hook field instead of creating a
+      // new one.
 
-      return updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
-    }
+      hook.baseState = true;
+    } // Reuse the previous value
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          if (newChild.key === key) {
-            return updateElement(returnFiber, oldFiber, newChild, lanes);
-          } else {
-            return null;
-          }
-        }
+    return prevValue;
+  } else {
+    // This is not an urgent update, so we can use the latest value regardless
+    // of what it is. No need to defer it.
+    // However, if we're currently inside a spawned render, then we need to mark
+    // this as an update to prevent the fiber from bailing out.
+    //
+    // `baseState` is true when the current value is different from the rendered
+    // value. The name doesn't really match how we use it because we're reusing
+    // a state hook field instead of creating a new one.
+    if (hook.baseState) {
+      // Flip this back to false.
+      hook.baseState = false;
+      markWorkInProgressReceivedUpdate();
+    }
 
-        case REACT_PORTAL_TYPE: {
-          if (newChild.key === key) {
-            return updatePortal(returnFiber, oldFiber, newChild, lanes);
-          } else {
-            return null;
-          }
-        }
+    hook.memoizedState = value;
+    return value;
+  }
+}
 
-        case REACT_LAZY_TYPE: {
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return updateSlot(returnFiber, oldFiber, init(payload), lanes);
-        }
-      }
+function startTransition(setPending, callback, options) {
+  var previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(
+    higherEventPriority(previousPriority, ContinuousEventPriority)
+  );
+  setPending(true);
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+  var currentTransition = ReactCurrentBatchConfig$3.transition;
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        if (key !== null) {
-          return null;
-        }
+  if (enableTransitionTracing) {
+    if (options !== undefined && options.name !== undefined) {
+      ReactCurrentBatchConfig$3.transition.name = options.name;
+      ReactCurrentBatchConfig$3.transition.startTime = now$1();
+    }
+  }
 
-        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
+  {
+    ReactCurrentBatchConfig$3.transition._updatedFibers = new Set();
+  }
 
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+  try {
+    setPending(false);
+    callback();
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+    {
+      if (prevTransition === null && currentTransition._updatedFibers) {
+        var updatedFibersCount = currentTransition._updatedFibers.size;
 
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
+        currentTransition._updatedFibers.clear();
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
+        if (updatedFibersCount > 10) {
+          warn(
+            "Detected a large number of updates inside startTransition. " +
+              "If this is due to a subscription please re-write it to use React provided hooks. " +
+              "Otherwise concurrent mode guarantees are off the table."
+          );
+        }
       }
     }
-
-    return null;
   }
+}
 
-  function updateFromMap(
-    existingChildren,
-    returnFiber,
-    newIdx,
-    newChild,
-    lanes
-  ) {
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys, so we neither have to check the old nor
-      // new node for the key. If both are text nodes, they match.
-      var matchedFiber = existingChildren.get(newIdx) || null;
-      return updateTextNode(returnFiber, matchedFiber, "" + newChild, lanes);
-    }
+function mountTransition() {
+  var _mountState = mountState(false),
+    isPending = _mountState[0],
+    setPending = _mountState[1]; // The `start` method never changes.
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          var _matchedFiber =
-            existingChildren.get(
-              newChild.key === null ? newIdx : newChild.key
-            ) || null;
+  var start = startTransition.bind(null, setPending);
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [isPending, start];
+}
 
-          return updateElement(returnFiber, _matchedFiber, newChild, lanes);
-        }
+function updateTransition() {
+  var _updateState = updateState(),
+    isPending = _updateState[0];
 
-        case REACT_PORTAL_TYPE: {
-          var _matchedFiber2 =
-            existingChildren.get(
-              newChild.key === null ? newIdx : newChild.key
-            ) || null;
+  var hook = updateWorkInProgressHook();
+  var start = hook.memoizedState;
+  return [isPending, start];
+}
 
-          return updatePortal(returnFiber, _matchedFiber2, newChild, lanes);
-        }
+function rerenderTransition() {
+  var _rerenderState = rerenderState(),
+    isPending = _rerenderState[0];
 
-        case REACT_LAZY_TYPE:
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return updateFromMap(
-            existingChildren,
-            returnFiber,
-            newIdx,
-            init(payload),
-            lanes
-          );
-      }
+  var hook = updateWorkInProgressHook();
+  var start = hook.memoizedState;
+  return [isPending, start];
+}
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        var _matchedFiber3 = existingChildren.get(newIdx) || null;
+function mountId() {
+  var hook = mountWorkInProgressHook();
+  var root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
 
-        return updateFragment(
-          returnFiber,
-          _matchedFiber3,
-          newChild,
-          lanes,
-          null
-        );
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
+  var identifierPrefix = root.identifierPrefix;
+  var id;
 
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+  if (getIsHydrating()) {
+    var treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+    id = ":" + identifierPrefix + "R" + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
 
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
+    var localId = localIdCounter++;
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
+    if (localId > 0) {
+      id += "H" + localId.toString(32);
     }
 
-    return null;
+    id += ":";
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    var globalClientId = globalClientIdCounter++;
+    id = ":" + identifierPrefix + "r" + globalClientId.toString(32) + ":";
   }
-  /**
-   * Warns if there is a duplicate or missing key
-   */
 
-  function warnOnInvalidKey(child, knownKeys, returnFiber) {
-    {
-      if (typeof child !== "object" || child === null) {
-        return knownKeys;
-      }
+  hook.memoizedState = id;
+  return id;
+}
 
-      switch (child.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-        case REACT_PORTAL_TYPE:
-          warnForMissingKey(child, returnFiber);
-          var key = child.key;
+function updateId() {
+  var hook = updateWorkInProgressHook();
+  var id = hook.memoizedState;
+  return id;
+}
 
-          if (typeof key !== "string") {
-            break;
-          }
+function mountRefresh() {
+  var hook = mountWorkInProgressHook();
+  var refresh = (hook.memoizedState = refreshCache.bind(
+    null,
+    currentlyRenderingFiber$1
+  ));
+  return refresh;
+}
 
-          if (knownKeys === null) {
-            knownKeys = new Set();
-            knownKeys.add(key);
-            break;
-          }
+function updateRefresh() {
+  var hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
 
-          if (!knownKeys.has(key)) {
-            knownKeys.add(key);
-            break;
-          }
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
 
-          error(
-            "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.",
-            key
-          );
+  var provider = fiber.return;
 
-          break;
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot: {
+        // Schedule an update on the cache boundary to trigger a refresh.
+        var lane = requestUpdateLane(provider);
+        var refreshUpdate = createUpdate(lane);
+        var root = enqueueUpdate(provider, refreshUpdate, lane);
 
-        case REACT_LAZY_TYPE:
-          var payload = child._payload;
-          var init = child._init;
-          warnOnInvalidKey(init(payload), knownKeys, returnFiber);
-          break;
-      }
-    }
+        if (root !== null) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, provider, lane, eventTime);
+          entangleTransitions(root, provider, lane);
+        } // TODO: If a refresh never commits, the new cache created here must be
+        // released. A simple case is start refreshing a cache boundary, but then
+        // unmount that boundary before the refresh completes.
 
-    return knownKeys;
-  }
+        var seededCache = createCache();
 
-  function reconcileChildrenArray(
-    returnFiber,
-    currentFirstChild,
-    newChildren,
-    lanes
-  ) {
-    // This algorithm can't optimize by searching from both ends since we
-    // don't have backpointers on fibers. I'm trying to see how far we can get
-    // with that model. If it ends up not being worth the tradeoffs, we can
-    // add it later.
-    // Even with a two ended optimization, we'd want to optimize for the case
-    // where there are few changes and brute force the comparison instead of
-    // going for the Map. It'd like to explore hitting that path first in
-    // forward-only mode and only go for the Map once we notice that we need
-    // lots of look ahead. This doesn't handle reversal as well as two ended
-    // search but that's unusual. Besides, for the two ended optimization to
-    // work on Iterables, we'd need to copy the whole set.
-    // In this first iteration, we'll just live with hitting the bad case
-    // (adding everything to a Map) in for every insert/move.
-    // If you change this code, also update reconcileChildrenIterator() which
-    // uses the same algorithm.
-    {
-      // First, validate keys.
-      var knownKeys = null;
+        if (seedKey !== null && seedKey !== undefined && root !== null) {
+          {
+            // Seed the cache with the value passed by the caller. This could be
+            // from a server mutation, or it could be a streaming response.
+            seededCache.data.set(seedKey, seedValue);
+          }
+        }
 
-      for (var i = 0; i < newChildren.length; i++) {
-        var child = newChildren[i];
-        knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+        var payload = {
+          cache: seededCache
+        };
+        refreshUpdate.payload = payload;
+        return;
       }
     }
 
-    var resultingFirstChild = null;
-    var previousNewFiber = null;
-    var oldFiber = currentFirstChild;
-    var lastPlacedIndex = 0;
-    var newIdx = 0;
-    var nextOldFiber = null;
-
-    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
-      if (oldFiber.index > newIdx) {
-        nextOldFiber = oldFiber;
-        oldFiber = null;
-      } else {
-        nextOldFiber = oldFiber.sibling;
-      }
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
+}
 
-      var newFiber = updateSlot(
-        returnFiber,
-        oldFiber,
-        newChildren[newIdx],
-        lanes
+function dispatchReducerAction(fiber, queue, action) {
+  {
+    if (typeof arguments[3] === "function") {
+      error(
+        "State updates from the useState() and useReducer() Hooks don't support the " +
+          "second callback argument. To execute a side effect after " +
+          "rendering, declare it in the component body with useEffect()."
       );
-
-      if (newFiber === null) {
-        // TODO: This breaks on empty slots like null children. That's
-        // unfortunate because it triggers the slow path all the time. We need
-        // a better way to communicate whether this was a miss or null,
-        // boolean, undefined, etc.
-        if (oldFiber === null) {
-          oldFiber = nextOldFiber;
-        }
-
-        break;
-      }
-
-      if (shouldTrackSideEffects) {
-        if (oldFiber && newFiber.alternate === null) {
-          // We matched the slot, but we didn't reuse the existing fiber, so we
-          // need to delete the existing child.
-          deleteChild(returnFiber, oldFiber);
-        }
-      }
-
-      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
-
-      if (previousNewFiber === null) {
-        // TODO: Move out of the loop. This only happens for the first run.
-        resultingFirstChild = newFiber;
-      } else {
-        // TODO: Defer siblings if we're not at the right index for this slot.
-        // I.e. if we had null values before, then we want to defer this
-        // for each null value. However, we also don't want to call updateSlot
-        // with the previous one.
-        previousNewFiber.sibling = newFiber;
-      }
-
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
     }
+  }
 
-    if (newIdx === newChildren.length) {
-      // We've reached the end of the new children. We can delete the rest.
-      deleteRemainingChildren(returnFiber, oldFiber);
+  var lane = requestUpdateLane(fiber);
+  var update = {
+    lane: lane,
+    action: action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
 
-      if (getIsHydrating()) {
-        var numberOfForks = newIdx;
-        pushTreeFork(returnFiber, numberOfForks);
-      }
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
 
-      return resultingFirstChild;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitionUpdate(root, queue, lane);
     }
+  }
 
-    if (oldFiber === null) {
-      // If we don't have any more existing children we can choose a fast path
-      // since the rest will all be insertions.
-      for (; newIdx < newChildren.length; newIdx++) {
-        var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+  markUpdateInDevTools(fiber, lane, action);
+}
 
-        if (_newFiber === null) {
-          continue;
-        }
+function dispatchSetState(fiber, queue, action) {
+  {
+    if (typeof arguments[3] === "function") {
+      error(
+        "State updates from the useState() and useReducer() Hooks don't support the " +
+          "second callback argument. To execute a side effect after " +
+          "rendering, declare it in the component body with useEffect()."
+      );
+    }
+  }
 
-        lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);
+  var lane = requestUpdateLane(fiber);
+  var update = {
+    lane: lane,
+    action: action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
 
-        if (previousNewFiber === null) {
-          // TODO: Move out of the loop. This only happens for the first run.
-          resultingFirstChild = _newFiber;
-        } else {
-          previousNewFiber.sibling = _newFiber;
-        }
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    var alternate = fiber.alternate;
 
-        previousNewFiber = _newFiber;
-      }
+    if (
+      fiber.lanes === NoLanes &&
+      (alternate === null || alternate.lanes === NoLanes)
+    ) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      var lastRenderedReducer = queue.lastRenderedReducer;
 
-      if (getIsHydrating()) {
-        var _numberOfForks = newIdx;
-        pushTreeFork(returnFiber, _numberOfForks);
-      }
+      if (lastRenderedReducer !== null) {
+        var prevDispatcher;
 
-      return resultingFirstChild;
-    } // Add all children to a key map for quick lookups.
+        {
+          prevDispatcher = ReactCurrentDispatcher$1.current;
+          ReactCurrentDispatcher$1.current =
+            InvalidNestedHooksDispatcherOnUpdateInDEV;
+        }
 
-    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+        try {
+          var currentState = queue.lastRenderedState;
+          var eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
 
-    for (; newIdx < newChildren.length; newIdx++) {
-      var _newFiber2 = updateFromMap(
-        existingChildren,
-        returnFiber,
-        newIdx,
-        newChildren[newIdx],
-        lanes
-      );
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
 
-      if (_newFiber2 !== null) {
-        if (shouldTrackSideEffects) {
-          if (_newFiber2.alternate !== null) {
-            // The new fiber is a work in progress, but if there exists a
-            // current, that means that we reused the fiber. We need to delete
-            // it from the child list so that we don't add it to the deletion
-            // list.
-            existingChildren.delete(
-              _newFiber2.key === null ? newIdx : _newFiber2.key
-            );
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {
+          // Suppress the error. It will throw again in the render phase.
+        } finally {
+          {
+            ReactCurrentDispatcher$1.current = prevDispatcher;
           }
         }
-
-        lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);
-
-        if (previousNewFiber === null) {
-          resultingFirstChild = _newFiber2;
-        } else {
-          previousNewFiber.sibling = _newFiber2;
-        }
-
-        previousNewFiber = _newFiber2;
       }
     }
 
-    if (shouldTrackSideEffects) {
-      // Any existing children that weren't consumed above were deleted. We need
-      // to add them to the deletion list.
-      existingChildren.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    }
+    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
 
-    if (getIsHydrating()) {
-      var _numberOfForks2 = newIdx;
-      pushTreeFork(returnFiber, _numberOfForks2);
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitionUpdate(root, queue, lane);
     }
-
-    return resultingFirstChild;
   }
 
-  function reconcileChildrenIterator(
-    returnFiber,
-    currentFirstChild,
-    newChildrenIterable,
-    lanes
-  ) {
-    // This is the same implementation as reconcileChildrenArray(),
-    // but using the iterator instead.
-    var iteratorFn = getIteratorFn(newChildrenIterable);
+  markUpdateInDevTools(fiber, lane, action);
+}
 
-    if (typeof iteratorFn !== "function") {
-      throw new Error(
-        "An object is not an iterable. This error is likely caused by a bug in " +
-          "React. Please file an issue."
-      );
-    }
+function isRenderPhaseUpdate(fiber) {
+  var alternate = fiber.alternate;
+  return (
+    fiber === currentlyRenderingFiber$1 ||
+    (alternate !== null && alternate === currentlyRenderingFiber$1)
+  );
+}
 
-    {
-      // We don't support rendering Generators because it's a mutation.
-      // See https://github.com/facebook/react/issues/12995
-      if (
-        typeof Symbol === "function" && // $FlowFixMe Flow doesn't know about toStringTag
-        newChildrenIterable[Symbol.toStringTag] === "Generator"
-      ) {
-        if (!didWarnAboutGenerators) {
-          error(
-            "Using Generators as children is unsupported and will likely yield " +
-              "unexpected results because enumerating a generator mutates it. " +
-              "You may convert it to an array with `Array.from()` or the " +
-              "`[...spread]` operator before rendering. Keep in mind " +
-              "you might need to polyfill these features for older browsers."
-          );
-        }
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
+    true;
+  var pending = queue.pending;
 
-        didWarnAboutGenerators = true;
-      } // Warn about using Maps as children
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
 
-      if (newChildrenIterable.entries === iteratorFn) {
-        if (!didWarnAboutMaps) {
-          error(
-            "Using Maps as children is not supported. " +
-              "Use an array of keyed ReactElements instead."
-          );
-        }
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
 
-        didWarnAboutMaps = true;
-      } // First, validate keys.
-      // We'll get a different iterator later for the main pass.
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    var queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
 
-      var _newChildren = iteratorFn.call(newChildrenIterable);
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
 
-      if (_newChildren) {
-        var knownKeys = null;
+    var newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
 
-        var _step = _newChildren.next();
+    markRootEntangled(root, newQueueLanes);
+  }
+}
 
-        for (; !_step.done; _step = _newChildren.next()) {
-          var child = _step.value;
-          knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
-        }
+function markUpdateInDevTools(fiber, lane, action) {
+  {
+    if (enableDebugTracing) {
+      if (fiber.mode & DebugTracingMode) {
+        var name = getComponentNameFromFiber(fiber) || "Unknown";
+        logStateUpdateScheduled(name, lane, action);
       }
     }
+  }
 
-    var newChildren = iteratorFn.call(newChildrenIterable);
+  if (enableSchedulingProfiler) {
+    markStateUpdateScheduled(fiber, lane);
+  }
+}
 
-    if (newChildren == null) {
-      throw new Error("An iterable object provided no iterator.");
-    }
+var ContextOnlyDispatcher = {
+  readContext: readContext,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useMutableSource: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
 
-    var resultingFirstChild = null;
-    var previousNewFiber = null;
-    var oldFiber = currentFirstChild;
-    var lastPlacedIndex = 0;
-    var newIdx = 0;
-    var nextOldFiber = null;
-    var step = newChildren.next();
-
-    for (
-      ;
-      oldFiber !== null && !step.done;
-      newIdx++, step = newChildren.next()
-    ) {
-      if (oldFiber.index > newIdx) {
-        nextOldFiber = oldFiber;
-        oldFiber = null;
-      } else {
-        nextOldFiber = oldFiber.sibling;
-      }
-
-      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+}
 
-      if (newFiber === null) {
-        // TODO: This breaks on empty slots like null children. That's
-        // unfortunate because it triggers the slow path all the time. We need
-        // a better way to communicate whether this was a miss or null,
-        // boolean, undefined, etc.
-        if (oldFiber === null) {
-          oldFiber = nextOldFiber;
-        }
+{
+  ContextOnlyDispatcher.use = throwInvalidHookError;
+}
 
-        break;
-      }
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+}
 
-      if (shouldTrackSideEffects) {
-        if (oldFiber && newFiber.alternate === null) {
-          // We matched the slot, but we didn't reuse the existing fiber, so we
-          // need to delete the existing child.
-          deleteChild(returnFiber, oldFiber);
-        }
-      }
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+}
 
-      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+var HooksDispatcherOnMountInDEV = null;
+var HooksDispatcherOnMountWithHookTypesInDEV = null;
+var HooksDispatcherOnUpdateInDEV = null;
+var HooksDispatcherOnRerenderInDEV = null;
+var InvalidNestedHooksDispatcherOnMountInDEV = null;
+var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
+var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
 
-      if (previousNewFiber === null) {
-        // TODO: Move out of the loop. This only happens for the first run.
-        resultingFirstChild = newFiber;
-      } else {
-        // TODO: Defer siblings if we're not at the right index for this slot.
-        // I.e. if we had null values before, then we want to defer this
-        // for each null value. However, we also don't want to call updateSlot
-        // with the previous one.
-        previousNewFiber.sibling = newFiber;
-      }
+{
+  var warnInvalidContextAccess = function () {
+    error(
+      "Context can only be read while React is rendering. " +
+        "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+        "In function components, you can read it directly in the function body, but not " +
+        "inside Hooks like useReducer() or useMemo()."
+    );
+  };
 
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
-    }
+  var warnInvalidHookAccess = function () {
+    error(
+      "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " +
+        "You can only call Hooks at the top level of your React function. " +
+        "For more information, see " +
+        "https://reactjs.org/link/rules-of-hooks"
+    );
+  };
 
-    if (step.done) {
-      // We've reached the end of the new children. We can delete the rest.
-      deleteRemainingChildren(returnFiber, oldFiber);
+  HooksDispatcherOnMountInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      mountHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      if (getIsHydrating()) {
-        var numberOfForks = newIdx;
-        pushTreeFork(returnFiber, numberOfForks);
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      return resultingFirstChild;
-    }
-
-    if (oldFiber === null) {
-      // If we don't have any more existing children we can choose a fast path
-      // since the rest will all be insertions.
-      for (; !step.done; newIdx++, step = newChildren.next()) {
-        var _newFiber3 = createChild(returnFiber, step.value, lanes);
-
-        if (_newFiber3 === null) {
-          continue;
-        }
-
-        lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);
-
-        if (previousNewFiber === null) {
-          // TODO: Move out of the loop. This only happens for the first run.
-          resultingFirstChild = _newFiber3;
-        } else {
-          previousNewFiber.sibling = _newFiber3;
-        }
-
-        previousNewFiber = _newFiber3;
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      mountHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      if (getIsHydrating()) {
-        var _numberOfForks3 = newIdx;
-        pushTreeFork(returnFiber, _numberOfForks3);
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      mountHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      mountHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      mountHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      mountHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      mountHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      mountHookTypesDev();
+      return mountId();
+    }
+  };
 
-      return resultingFirstChild;
-    } // Add all children to a key map for quick lookups.
-
-    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+  {
+    HooksDispatcherOnMountInDEV.useCacheRefresh = function useCacheRefresh() {
+      currentHookNameInDev = "useCacheRefresh";
+      mountHookTypesDev();
+      return mountRefresh();
+    };
+  }
 
-    for (; !step.done; newIdx++, step = newChildren.next()) {
-      var _newFiber4 = updateFromMap(
-        existingChildren,
-        returnFiber,
-        newIdx,
-        step.value,
-        lanes
-      );
+  {
+    HooksDispatcherOnMountInDEV.use = use;
+  }
 
-      if (_newFiber4 !== null) {
-        if (shouldTrackSideEffects) {
-          if (_newFiber4.alternate !== null) {
-            // The new fiber is a work in progress, but if there exists a
-            // current, that means that we reused the fiber. We need to delete
-            // it from the child list so that we don't add it to the deletion
-            // list.
-            existingChildren.delete(
-              _newFiber4.key === null ? newIdx : _newFiber4.key
-            );
-          }
-        }
+  {
+    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
+  }
 
-        lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);
+  {
+    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      mountHookTypesDev();
+      return mountEvent(callback);
+    };
+  }
 
-        if (previousNewFiber === null) {
-          resultingFirstChild = _newFiber4;
-        } else {
-          previousNewFiber.sibling = _newFiber4;
-        }
+  HooksDispatcherOnMountWithHookTypesInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-        previousNewFiber = _newFiber4;
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-    }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-    if (shouldTrackSideEffects) {
-      // Any existing children that weren't consumed above were deleted. We need
-      // to add them to the deletion list.
-      existingChildren.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    }
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-    if (getIsHydrating()) {
-      var _numberOfForks4 = newIdx;
-      pushTreeFork(returnFiber, _numberOfForks4);
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return mountId();
     }
+  };
 
-    return resultingFirstChild;
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return mountRefresh();
+      };
   }
 
-  function reconcileSingleTextNode(
-    returnFiber,
-    currentFirstChild,
-    textContent,
-    lanes
-  ) {
-    // There's no need to check for keys on text nodes since we don't have a
-    // way to define them.
-    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
-      // We already have an existing node so let's just update it and delete
-      // the rest.
-      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
-      var existing = useFiber(currentFirstChild, textContent);
-      existing.return = returnFiber;
-      return existing;
-    } // The existing first child is not a text node so we need to create one
-    // and delete the existing ones.
-
-    deleteRemainingChildren(returnFiber, currentFirstChild);
-    var created = createFiberFromText(textContent, returnFiber.mode, lanes);
-    created.return = returnFiber;
-    return created;
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.use = use;
   }
 
-  function reconcileSingleElement(
-    returnFiber,
-    currentFirstChild,
-    element,
-    lanes
-  ) {
-    var key = element.key;
-    var child = currentFirstChild;
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
+  }
 
-    while (child !== null) {
-      // TODO: If key === null and child.key === null, then this only applies to
-      // the first item in the list.
-      if (child.key === key) {
-        var elementType = element.type;
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        updateHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
 
-        if (elementType === REACT_FRAGMENT_TYPE) {
-          if (child.tag === Fragment) {
-            deleteRemainingChildren(returnFiber, child.sibling);
-            var existing = useFiber(child, element.props.children);
-            existing.return = returnFiber;
+  HooksDispatcherOnUpdateInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-            {
-              existing._debugSource = element._source;
-              existing._debugOwner = element._owner;
-            }
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-            return existing;
-          }
-        } else {
-          if (
-            child.elementType === elementType || // Keep this check inline so it only runs on the false path:
-            isCompatibleFamilyForHotReloading(child, element) || // Lazy types should reconcile their resolved type.
-            // We need to do this after the Hot Reloading check above,
-            // because hot reloading has different semantics than prod because
-            // it doesn't resuspend. So we can't let the call below suspend.
-            (typeof elementType === "object" &&
-              elementType !== null &&
-              elementType.$$typeof === REACT_LAZY_TYPE &&
-              resolveLazy(elementType) === child.type)
-          ) {
-            deleteRemainingChildren(returnFiber, child.sibling);
-
-            var _existing = useFiber(child, element.props);
-
-            _existing.ref = coerceRef(returnFiber, child, element);
-            _existing.return = returnFiber;
-
-            {
-              _existing._debugSource = element._source;
-              _existing._debugOwner = element._owner;
-            }
-
-            return _existing;
-          }
-        } // Didn't match.
-
-        deleteRemainingChildren(returnFiber, child);
-        break;
-      } else {
-        deleteChild(returnFiber, child);
+      try {
+        return updateReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      child = child.sibling;
-    }
-
-    if (element.type === REACT_FRAGMENT_TYPE) {
-      var created = createFiberFromFragment(
-        element.props.children,
-        returnFiber.mode,
-        lanes,
-        element.key
-      );
-      created.return = returnFiber;
-      return created;
-    } else {
-      var _created4 = createFiberFromElement(element, returnFiber.mode, lanes);
-
-      _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
-      _created4.return = returnFiber;
-      return _created4;
-    }
-  }
-
-  function reconcileSinglePortal(
-    returnFiber,
-    currentFirstChild,
-    portal,
-    lanes
-  ) {
-    var key = portal.key;
-    var child = currentFirstChild;
-
-    while (child !== null) {
-      // TODO: If key === null and child.key === null, then this only applies to
-      // the first item in the list.
-      if (child.key === key) {
-        if (
-          child.tag === HostPortal &&
-          child.stateNode.containerInfo === portal.containerInfo &&
-          child.stateNode.implementation === portal.implementation
-        ) {
-          deleteRemainingChildren(returnFiber, child.sibling);
-          var existing = useFiber(child, portal.children || []);
-          existing.return = returnFiber;
-          return existing;
-        } else {
-          deleteRemainingChildren(returnFiber, child);
-          break;
-        }
-      } else {
-        deleteChild(returnFiber, child);
+      try {
+        return updateState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-
-      child = child.sibling;
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return updateDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return updateTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
-    created.return = returnFiber;
-    return created;
-  } // This API will tag the children with the side-effect of the reconciliation
-  // itself. They will be added to the side-effect list as we pass through the
-  // children and the parent.
-
-  function reconcileChildFibersImpl(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    // This function is not recursive.
-    // If the top level item is an array, we treat it as a set of children,
-    // not as a fragment. Nested arrays on the other hand will be treated as
-    // fragment nodes. Recursion happens at the normal flow.
-    // Handle top level unkeyed fragments as if they were arrays.
-    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
-    // We treat the ambiguous cases above the same.
-    // TODO: Let's use recursion like we do for Usable nodes?
-    var isUnkeyedTopLevelFragment =
-      typeof newChild === "object" &&
-      newChild !== null &&
-      newChild.type === REACT_FRAGMENT_TYPE &&
-      newChild.key === null;
-
-    if (isUnkeyedTopLevelFragment) {
-      newChild = newChild.props.children;
-    } // Handle object types
+  {
+    HooksDispatcherOnUpdateInDEV.useCacheRefresh = function useCacheRefresh() {
+      currentHookNameInDev = "useCacheRefresh";
+      updateHookTypesDev();
+      return updateRefresh();
+    };
+  }
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return placeSingleChild(
-            reconcileSingleElement(
-              returnFiber,
-              currentFirstChild,
-              newChild,
-              lanes
-            )
-          );
+  {
+    HooksDispatcherOnUpdateInDEV.use = use;
+  }
 
-        case REACT_PORTAL_TYPE:
-          return placeSingleChild(
-            reconcileSinglePortal(
-              returnFiber,
-              currentFirstChild,
-              newChild,
-              lanes
-            )
-          );
+  {
+    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
+  }
 
-        case REACT_LAZY_TYPE:
-          var payload = newChild._payload;
-          var init = newChild._init; // TODO: This function is supposed to be non-recursive.
+  {
+    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
 
-          return reconcileChildFibers(
-            returnFiber,
-            currentFirstChild,
-            init(payload),
-            lanes
-          );
-      }
+  HooksDispatcherOnRerenderInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      if (isArray(newChild)) {
-        return reconcileChildrenArray(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      if (getIteratorFn(newChild)) {
-        return reconcileChildrenIterator(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      } // Usables are a valid React node type. When React encounters a Usable in
-      // a child position, it unwraps it using the same algorithm as `use`. For
-      // example, for promises, React will throw an exception to unwind the
-      // stack, then replay the component once the promise resolves.
-      //
-      // A difference from `use` is that React will keep unwrapping the value
-      // until it reaches a non-Usable type.
-      //
-      // e.g. Usable<Usable<Usable<T>>> should resolve to T
-      //
-      // The structure is a bit unfortunate. Ideally, we shouldn't need to
-      // replay the entire begin phase of the parent fiber in order to reconcile
-      // the children again. This would require a somewhat significant refactor,
-      // because reconcilation happens deep within the begin phase, and
-      // depending on the type of work, not always at the end. We should
-      // consider as an future improvement.
-
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          unwrapThenable(thenable),
-          lanes
-        );
+      try {
+        return rerenderReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
+      try {
+        return rerenderState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      return placeSingleChild(
-        reconcileSingleTextNode(
-          returnFiber,
-          currentFirstChild,
-          "" + newChild,
-          lanes
-        )
-      );
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return rerenderDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return rerenderTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
-    } // Remaining cases are all treated as empty.
-
-    return deleteRemainingChildren(returnFiber, currentFirstChild);
-  }
-
-  function reconcileChildFibers(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    // This indirection only exists so we can reset `thenableState` at the end.
-    // It should get inlined by Closure.
-    thenableIndexCounter$1 = 0;
-    var firstChildFiber = reconcileChildFibersImpl(
-      returnFiber,
-      currentFirstChild,
-      newChild,
-      lanes
-    );
-    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
-    // set at the beginning.
-
-    return firstChildFiber;
+  {
+    HooksDispatcherOnRerenderInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
   }
 
-  return reconcileChildFibers;
-}
-
-var reconcileChildFibers = createChildReconciler(true);
-var mountChildFibers = createChildReconciler(false);
-function resetChildReconcilerOnUnwind() {
-  // On unwind, clear any pending thenables that were used.
-  thenableState$1 = null;
-  thenableIndexCounter$1 = 0;
-}
-function cloneChildFibers(current, workInProgress) {
-  if (current !== null && workInProgress.child !== current.child) {
-    throw new Error("Resuming work not yet implemented.");
+  {
+    HooksDispatcherOnRerenderInDEV.use = use;
   }
 
-  if (workInProgress.child === null) {
-    return;
+  {
+    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
   }
 
-  var currentChild = workInProgress.child;
-  var newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
-  workInProgress.child = newChild;
-  newChild.return = workInProgress;
-
-  while (currentChild.sibling !== null) {
-    currentChild = currentChild.sibling;
-    newChild = newChild.sibling = createWorkInProgress(
-      currentChild,
-      currentChild.pendingProps
-    );
-    newChild.return = workInProgress;
+  {
+    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
   }
 
-  newChild.sibling = null;
-} // Reset a workInProgress child set to prepare it for a second pass.
-
-function resetChildFibers(workInProgress, lanes) {
-  var child = workInProgress.child;
+  InvalidNestedHooksDispatcherOnMountInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-  while (child !== null) {
-    resetWorkInProgress(child, lanes);
-    child = child.sibling;
-  }
-}
-
-// TODO: This isn't being used yet, but it's intended to replace the
-// InvisibleParentContext that is currently managed by SuspenseContext.
-
-var currentTreeHiddenStackCursor = createCursor(null);
-var prevRenderLanesStackCursor = createCursor(NoLanes);
-function pushHiddenContext(fiber, context) {
-  var prevRenderLanes = getRenderLanes();
-  push(prevRenderLanesStackCursor, prevRenderLanes, fiber);
-  push(currentTreeHiddenStackCursor, context, fiber); // When rendering a subtree that's currently hidden, we must include all
-  // lanes that would have rendered if the hidden subtree hadn't been deferred.
-  // That is, in order to reveal content from hidden -> visible, we must commit
-  // all the updates that we skipped when we originally hid the tree.
-
-  setRenderLanes(mergeLanes(prevRenderLanes, context.baseLanes));
-}
-function reuseHiddenContextOnStack(fiber) {
-  // This subtree is not currently hidden, so we don't need to add any lanes
-  // to the render lanes. But we still need to push something to avoid a
-  // context mismatch. Reuse the existing context on the stack.
-  push(prevRenderLanesStackCursor, getRenderLanes(), fiber);
-  push(
-    currentTreeHiddenStackCursor,
-    currentTreeHiddenStackCursor.current,
-    fiber
-  );
-}
-function popHiddenContext(fiber) {
-  // Restore the previous render lanes from the stack
-  setRenderLanes(prevRenderLanesStackCursor.current);
-  pop(currentTreeHiddenStackCursor, fiber);
-  pop(prevRenderLanesStackCursor, fiber);
-}
-function isCurrentTreeHidden() {
-  return currentTreeHiddenStackCursor.current !== null;
-}
-
-// suspends, i.e. it's the nearest `catch` block on the stack.
-
-var suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
-// Everything above this is the "shell". When this is null, it means we're
-// rendering in the shell of the app. If it's non-null, it means we're rendering
-// deeper than the shell, inside a new tree that wasn't already visible.
-//
-// The main way we use this concept is to determine whether showing a fallback
-// would result in a desirable or undesirable loading state. Activing a fallback
-// in the shell is considered an undersirable loading state, because it would
-// mean hiding visible (albeit stale) content in the current tree — we prefer to
-// show the stale content, rather than switch to a fallback. But showing a
-// fallback in a new tree is fine, because there's no stale content to
-// prefer instead.
-
-var shellBoundary = null;
-function getShellBoundary() {
-  return shellBoundary;
-}
-function pushPrimaryTreeSuspenseHandler(handler) {
-  // TODO: Pass as argument
-  var current = handler.alternate;
-  var props = handler.pendingProps; // Experimental feature: Some Suspense boundaries are marked as having an
-  // undesirable fallback state. These have special behavior where we only
-  // activate the fallback if there's no other boundary on the stack that we can
-  // use instead.
-
-  if (
-    props.unstable_avoidThisFallback === true && // If an avoided boundary is already visible, it behaves identically to
-    // a regular Suspense boundary.
-    (current === null || isCurrentTreeHidden())
-  ) {
-    if (shellBoundary === null) {
-      // We're rendering in the shell. There's no parent Suspense boundary that
-      // can provide a desirable fallback state. We'll use this boundary.
-      push(suspenseHandlerStackCursor, handler, handler); // However, because this is not a desirable fallback, the children are
-      // still considered part of the shell. So we intentionally don't assign
-      // to `shellBoundary`.
-    } else {
-      // There's already a parent Suspense boundary that can provide a desirable
-      // fallback state. Prefer that one.
-      var handlerOnStack = suspenseHandlerStackCursor.current;
-      push(suspenseHandlerStackCursor, handlerOnStack, handler);
-    }
-
-    return;
-  } // TODO: If the parent Suspense handler already suspended, there's no reason
-  // to push a nested Suspense handler, because it will get replaced by the
-  // outer fallback, anyway. Consider this as a future optimization.
-
-  push(suspenseHandlerStackCursor, handler, handler);
-
-  if (shellBoundary === null) {
-    if (current === null || isCurrentTreeHidden()) {
-      // This boundary is not visible in the current UI.
-      shellBoundary = handler;
-    } else {
-      var prevState = current.memoizedState;
-
-      if (prevState !== null) {
-        // This boundary is showing a fallback in the current UI.
-        shellBoundary = handler;
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-    }
-  }
-}
-function pushFallbackTreeSuspenseHandler(fiber) {
-  // We're about to render the fallback. If something in the fallback suspends,
-  // it's akin to throwing inside of a `catch` block. This boundary should not
-  // capture. Reuse the existing handler on the stack.
-  reuseSuspenseHandlerOnStack(fiber);
-}
-function pushOffscreenSuspenseHandler(fiber) {
-  if (fiber.tag === OffscreenComponent) {
-    push(suspenseHandlerStackCursor, fiber, fiber);
-
-    if (shellBoundary !== null);
-    else {
-      var current = fiber.alternate;
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      if (current !== null) {
-        var prevState = current.memoizedState;
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-        if (prevState !== null) {
-          // This is the first boundary in the stack that's already showing
-          // a fallback. So everything outside is considered the shell.
-          shellBoundary = fiber;
-        }
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountId();
     }
-  } else {
-    // This is a LegacyHidden component.
-    reuseSuspenseHandlerOnStack(fiber);
-  }
-}
-function reuseSuspenseHandlerOnStack(fiber) {
-  push(suspenseHandlerStackCursor, getSuspenseHandler(), fiber);
-}
-function getSuspenseHandler() {
-  return suspenseHandlerStackCursor.current;
-}
-function popSuspenseHandler(fiber) {
-  pop(suspenseHandlerStackCursor, fiber);
+  };
 
-  if (shellBoundary === fiber) {
-    // Popping back into the shell.
-    shellBoundary = null;
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        mountHookTypesDev();
+        return mountRefresh();
+      };
   }
-} // SuspenseList context
-// TODO: Move to a separate module? We may change the SuspenseList
-// implementation to hide/show in the commit phase, anyway.
-
-var DefaultSuspenseContext = 0;
-var SubtreeSuspenseContextMask = 1; // ForceSuspenseFallback can be used by SuspenseList to force newly added
-// items into their fallback state during one of the render passes.
-
-var ForceSuspenseFallback = 2;
-var suspenseStackCursor = createCursor(DefaultSuspenseContext);
-function hasSuspenseListContext(parentContext, flag) {
-  return (parentContext & flag) !== 0;
-}
-function setDefaultShallowSuspenseListContext(parentContext) {
-  return parentContext & SubtreeSuspenseContextMask;
-}
-function setShallowSuspenseListContext(parentContext, shallowContext) {
-  return (parentContext & SubtreeSuspenseContextMask) | shallowContext;
-}
-function pushSuspenseListContext(fiber, newContext) {
-  push(suspenseStackCursor, newContext, fiber);
-}
-function popSuspenseListContext(fiber) {
-  pop(suspenseStackCursor, fiber);
-}
 
-// A non-null SuspenseState means that it is blocked for one reason or another.
-// - A non-null dehydrated field means it's blocked pending hydration.
-//   - A non-null dehydrated field can use isSuspenseInstancePending or
-//     isSuspenseInstanceFallback to query the reason for being dehydrated.
-// - A null dehydrated field means it's blocked by something suspending and
-//   we're currently showing a fallback instead.
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
+  }
 
-function findFirstSuspended(row) {
-  var node = row;
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
 
-  while (node !== null) {
-    if (node.tag === SuspenseComponent) {
-      var state = node.memoizedState;
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
 
-      if (state !== null) {
-        var dehydrated = state.dehydrated;
+  InvalidNestedHooksDispatcherOnUpdateInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-        if (
-          dehydrated === null ||
-          isSuspenseInstancePending(dehydrated) ||
-          isSuspenseInstanceFallback(dehydrated)
-        ) {
-          return node;
-        }
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-    } else if (
-      node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
-      // keep track of whether it suspended or not.
-      node.memoizedProps.revealOrder !== undefined
-    ) {
-      var didSuspend = (node.flags & DidCapture) !== NoFlags$1;
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      if (didSuspend) {
-        return node;
+      try {
+        return updateReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-    } else if (node.child !== null) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
-
-    if (node === row) {
-      return null;
-    }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-    while (node.sibling === null) {
-      if (node.return === null || node.return === row) {
-        return null;
+      try {
+        return updateState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-
-      node = node.return;
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    node.sibling.return = node.return;
-    node = node.sibling;
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
   }
 
-  return null;
-}
-
-var NoFlags =
-  /*   */
-  0; // Represents whether effect should fire.
-
-var HasEffect =
-  /* */
-  1; // Represents the phase in which the effect (not the clean-up) fires.
-
-var Insertion =
-  /* */
-  2;
-var Layout =
-  /*    */
-  4;
-var Passive =
-  /*   */
-  8;
-
-// and should be reset before starting a new render.
-// This tracks which mutable sources need to be reset after a render.
-
-var workInProgressSources = [];
-var rendererSigil$1;
-
-{
-  // Used to detect multiple renderers using the same mutable source.
-  rendererSigil$1 = {};
-}
-
-function markSourceAsDirty(mutableSource) {
-  workInProgressSources.push(mutableSource);
-}
-function resetWorkInProgressVersions() {
-  for (var i = 0; i < workInProgressSources.length; i++) {
-    var mutableSource = workInProgressSources[i];
-
-    {
-      mutableSource._workInProgressVersionPrimary = null;
-    }
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
   }
 
-  workInProgressSources.length = 0;
-}
-function getWorkInProgressVersion(mutableSource) {
   {
-    return mutableSource._workInProgressVersionPrimary;
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
   }
-}
-function setWorkInProgressVersion(mutableSource, version) {
+
   {
-    mutableSource._workInProgressVersionPrimary = version;
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
   }
 
-  workInProgressSources.push(mutableSource);
-}
-function warnAboutMultipleRenderersDEV(mutableSource) {
-  {
-    {
-      if (mutableSource._currentPrimaryRenderer == null) {
-        mutableSource._currentPrimaryRenderer = rendererSigil$1;
-      } else if (mutableSource._currentPrimaryRenderer !== rendererSigil$1) {
-        error(
-          "Detected multiple renderers concurrently rendering the " +
-            "same mutable source. This is currently unsupported."
-        );
+  InvalidNestedHooksDispatcherOnRerenderInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+      try {
+        return rerenderReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+      try {
+        return rerenderState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return rerenderDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return rerenderTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateId();
     }
-  }
-} // Eager reads the version of a mutable source and stores it on the root.
-// This ensures that the version used for server rendering matches the one
-// that is eventually read during hydration.
-// If they don't match there's a potential tear and a full deopt render is required.
+  };
 
-function registerMutableSourceForHydration(root, mutableSource) {
-  var getVersion = mutableSource._getVersion;
-  var version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
-  // Retaining it forever may interfere with GC.
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
+  }
 
-  if (root.mutableSourceEagerHydrationData == null) {
-    root.mutableSourceEagerHydrationData = [mutableSource, version];
-  } else {
-    root.mutableSourceEagerHydrationData.push(mutableSource, version);
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
   }
-}
 
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
-var didWarnAboutMismatchedHooksForComponent;
-var didWarnUncachedGetSnapshot;
-var didWarnAboutUseWrappedInTryCatch;
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
 
-{
-  didWarnAboutMismatchedHooksForComponent = new Set();
-  didWarnAboutUseWrappedInTryCatch = new Set();
-} // These are set right before calling the component.
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
+  }
+}
 
-var renderLanes$1 = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
-// the work-in-progress hook.
+var now = Scheduler.unstable_now;
+var commitTime = 0;
+var layoutEffectStartTime = -1;
+var profilerStartTime = -1;
+var passiveEffectStartTime = -1;
+/**
+ * Tracks whether the current update was a nested/cascading update (scheduled from a layout effect).
+ *
+ * The overall sequence is:
+ *   1. render
+ *   2. commit (and call `onRender`, `onCommit`)
+ *   3. check for nested updates
+ *   4. flush passive effects (and call `onPostCommit`)
+ *
+ * Nested updates are identified in step 3 above,
+ * but step 4 still applies to the work that was just committed.
+ * We use two flags to track nested updates then:
+ * one tracks whether the upcoming update is a nested update,
+ * and the other tracks whether the current update was a nested update.
+ * The first value gets synced to the second at the start of the render phase.
+ */
 
-var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
-// current hook list is the list that belongs to the current fiber. The
-// work-in-progress hook list is a new list that will be added to the
-// work-in-progress fiber.
+var currentUpdateIsNested = false;
+var nestedUpdateScheduled = false;
 
-var currentHook = null;
-var workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
-// does not get reset if we do another render pass; only when we're completely
-// finished evaluating this component. This is an optimization so we know
-// whether we need to clear render phase updates after a throw.
+function isCurrentUpdateNested() {
+  return currentUpdateIsNested;
+}
 
-var didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
-// gets reset after each attempt.
-// TODO: Maybe there's some way to consolidate this with
-// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+function markNestedUpdateScheduled() {
+  {
+    nestedUpdateScheduled = true;
+  }
+}
 
-var didScheduleRenderPhaseUpdateDuringThisPass = false;
-var shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+function resetNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = false;
+    nestedUpdateScheduled = false;
+  }
+}
 
-var localIdCounter = 0; // Counts number of `use`-d thenables
+function syncNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = nestedUpdateScheduled;
+    nestedUpdateScheduled = false;
+  }
+}
 
-var thenableIndexCounter = 0;
-var thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
-// hydration). This counter is global, so client ids are not stable across
-// render attempts.
+function getCommitTime() {
+  return commitTime;
+}
 
-var globalClientIdCounter = 0;
-var RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+function recordCommitTime() {
+  commitTime = now();
+}
 
-var currentHookNameInDev = null; // In DEV, this list ensures that hooks are called in the same order between renders.
-// The list stores the order of hooks used during the initial render (mount).
-// Subsequent renders (updates) reference this list.
+function startProfilerTimer(fiber) {
+  profilerStartTime = now();
 
-var hookTypesDev = null;
-var hookTypesUpdateIndexDev = -1; // In DEV, this tracks whether currently rendering component needs to ignore
-// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
-// When true, such Hooks will always be "remounted". Only used during hot reload.
+  if (fiber.actualStartTime < 0) {
+    fiber.actualStartTime = now();
+  }
+}
 
-var ignorePreviousDependencies = false;
+function stopProfilerTimerIfRunning(fiber) {
+  profilerStartTime = -1;
+}
 
-function mountHookTypesDev() {
-  {
-    var hookName = currentHookNameInDev;
+function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+  if (profilerStartTime >= 0) {
+    var elapsedTime = now() - profilerStartTime;
+    fiber.actualDuration += elapsedTime;
 
-    if (hookTypesDev === null) {
-      hookTypesDev = [hookName];
-    } else {
-      hookTypesDev.push(hookName);
+    if (overrideBaseTime) {
+      fiber.selfBaseDuration = elapsedTime;
     }
+
+    profilerStartTime = -1;
   }
 }
 
-function updateHookTypesDev() {
-  {
-    var hookName = currentHookNameInDev;
+function recordLayoutEffectDuration(fiber) {
+  if (layoutEffectStartTime >= 0) {
+    var elapsedTime = now() - layoutEffectStartTime;
+    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
 
-    if (hookTypesDev !== null) {
-      hookTypesUpdateIndexDev++;
+    var parentFiber = fiber.return;
 
-      if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
-        warnOnHookMismatchInDev(hookName);
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
+          root.effectDuration += elapsedTime;
+          return;
+
+        case Profiler:
+          var parentStateNode = parentFiber.stateNode;
+          parentStateNode.effectDuration += elapsedTime;
+          return;
       }
-    }
-  }
-}
 
-function checkDepsAreArrayDev(deps) {
-  {
-    if (deps !== undefined && deps !== null && !isArray(deps)) {
-      // Verify deps, but only on mount to avoid extra checks.
-      // It's unlikely their type would change as usually you define them inline.
-      error(
-        "%s received a final argument that is not an array (instead, received `%s`). When " +
-          "specified, the final argument must be an array.",
-        currentHookNameInDev,
-        typeof deps
-      );
+      parentFiber = parentFiber.return;
     }
   }
 }
 
-function warnOnHookMismatchInDev(currentHookName) {
-  {
-    var componentName = getComponentNameFromFiber(currentlyRenderingFiber$1);
-
-    if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
-      didWarnAboutMismatchedHooksForComponent.add(componentName);
+function recordPassiveEffectDuration(fiber) {
+  if (passiveEffectStartTime >= 0) {
+    var elapsedTime = now() - passiveEffectStartTime;
+    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
 
-      if (hookTypesDev !== null) {
-        var table = "";
-        var secondColumnStart = 30;
+    var parentFiber = fiber.return;
 
-        for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
-          var oldHookName = hookTypesDev[i];
-          var newHookName =
-            i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
-          var row = i + 1 + ". " + oldHookName; // Extra space so second column lines up
-          // lol @ IE not supporting String#repeat
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
 
-          while (row.length < secondColumnStart) {
-            row += " ";
+          if (root !== null) {
+            root.passiveEffectDuration += elapsedTime;
           }
 
-          row += newHookName + "\n";
-          table += row;
-        }
+          return;
 
-        error(
-          "React has detected a change in the order of Hooks called by %s. " +
-            "This will lead to bugs and errors if not fixed. " +
-            "For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n" +
-            "   Previous render            Next render\n" +
-            "   ------------------------------------------------------\n" +
-            "%s" +
-            "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-          componentName,
-          table
-        );
+        case Profiler:
+          var parentStateNode = parentFiber.stateNode;
+
+          if (parentStateNode !== null) {
+            // Detached fibers have their state node cleared out.
+            // In this case, the return pointer is also cleared out,
+            // so we won't be able to report the time spent in this Profiler's subtree.
+            parentStateNode.passiveEffectDuration += elapsedTime;
+          }
+
+          return;
       }
+
+      parentFiber = parentFiber.return;
     }
   }
 }
 
-function throwInvalidHookError() {
-  throw new Error(
-    "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for" +
-      " one of the following reasons:\n" +
-      "1. You might have mismatching versions of React and the renderer (such as React DOM)\n" +
-      "2. You might be breaking the Rules of Hooks\n" +
-      "3. You might have more than one copy of React in the same app\n" +
-      "See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."
-  );
+function startLayoutEffectTimer() {
+  layoutEffectStartTime = now();
 }
 
-function areHookInputsEqual(nextDeps, prevDeps) {
-  {
-    if (ignorePreviousDependencies) {
-      // Only true when this component is being hot reloaded.
-      return false;
-    }
-  }
+function startPassiveEffectTimer() {
+  passiveEffectStartTime = now();
+}
 
-  if (prevDeps === null) {
-    {
-      error(
-        "%s received a final argument during this render, but not during " +
-          "the previous render. Even though the final argument is optional, " +
-          "its type cannot change between renders.",
-        currentHookNameInDev
-      );
-    }
+function transferActualDuration(fiber) {
+  // Transfer time spent rendering these children so we don't lose it
+  // after we rerender. This is used as a helper in special cases
+  // where we should count the work of multiple passes.
+  var child = fiber.child;
 
-    return false;
+  while (child) {
+    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    fiber.actualDuration += child.actualDuration;
+    child = child.sibling;
   }
+}
 
-  {
-    // Don't bother comparing lengths in prod because these arrays should be
-    // passed inline.
-    if (nextDeps.length !== prevDeps.length) {
-      error(
-        "The final argument passed to %s changed size between renders. The " +
-          "order and size of this array must remain constant.\n\n" +
-          "Previous: %s\n" +
-          "Incoming: %s",
-        currentHookNameInDev,
-        "[" + prevDeps.join(", ") + "]",
-        "[" + nextDeps.join(", ") + "]"
-      );
-    }
-  } // $FlowFixMe[incompatible-use] found when upgrading Flow
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    var props = assign({}, baseProps);
+    var defaultProps = Component.defaultProps;
 
-  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
-    // $FlowFixMe[incompatible-use] found when upgrading Flow
-    if (objectIs(nextDeps[i], prevDeps[i])) {
-      continue;
+    for (var propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
     }
 
-    return false;
+    return props;
   }
 
-  return true;
+  return baseProps;
 }
 
-function renderWithHooks(
-  current,
-  workInProgress,
-  Component,
-  props,
-  secondArg,
-  nextRenderLanes
-) {
-  renderLanes$1 = nextRenderLanes;
-  currentlyRenderingFiber$1 = workInProgress;
+var fakeInternalInstance = {};
+var didWarnAboutStateAssignmentForComponent;
+var didWarnAboutUninitializedState;
+var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
+var didWarnAboutLegacyLifecyclesAndDerivedState;
+var didWarnAboutUndefinedDerivedState;
+var didWarnAboutDirectlyAssigningPropsToState;
+var didWarnAboutContextTypeAndContextTypes;
+var didWarnAboutInvalidateContextType;
+var didWarnOnInvalidCallback;
+
+{
+  didWarnAboutStateAssignmentForComponent = new Set();
+  didWarnAboutUninitializedState = new Set();
+  didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+  didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+  didWarnAboutDirectlyAssigningPropsToState = new Set();
+  didWarnAboutUndefinedDerivedState = new Set();
+  didWarnAboutContextTypeAndContextTypes = new Set();
+  didWarnAboutInvalidateContextType = new Set();
+  didWarnOnInvalidCallback = new Set(); // This is so gross but it's at least non-critical and can be removed if
+  // it causes problems. This is meant to give a nicer error message for
+  // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
+  // ...)) which otherwise throws a "_processChildContext is not a function"
+  // exception.
+
+  Object.defineProperty(fakeInternalInstance, "_processChildContext", {
+    enumerable: false,
+    value: function () {
+      throw new Error(
+        "_processChildContext is not available in React 16+. This likely " +
+          "means you have multiple copies of React and are attempting to nest " +
+          "a React 15 tree inside a React 16 tree using " +
+          "unstable_renderSubtreeIntoContainer, which isn't supported. Try " +
+          "to make sure you have only one copy of React (and ideally, switch " +
+          "to ReactDOM.createPortal)."
+      );
+    }
+  });
+  Object.freeze(fakeInternalInstance);
+}
 
+function warnOnInvalidCallback$1(callback, callerName) {
   {
-    hookTypesDev = current !== null ? current._debugHookTypes : null;
-    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
+    if (callback === null || typeof callback === "function") {
+      return;
+    }
 
-    ignorePreviousDependencies =
-      current !== null && current.type !== workInProgress.type;
-  }
+    var key = callerName + "_" + callback;
 
-  workInProgress.memoizedState = null;
-  workInProgress.updateQueue = null;
-  workInProgress.lanes = NoLanes; // The following should have already been reset
-  // currentHook = null;
-  // workInProgressHook = null;
-  // didScheduleRenderPhaseUpdate = false;
-  // localIdCounter = 0;
-  // thenableIndexCounter = 0;
-  // thenableState = null;
-  // TODO Warn if no hooks are used at all during mount, then some are used during update.
-  // Currently we will identify the update render as a mount because memoizedState === null.
-  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
-  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
-  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
-  // so memoizedState would be null during updates and mounts.
+    if (!didWarnOnInvalidCallback.has(key)) {
+      didWarnOnInvalidCallback.add(key);
 
-  {
-    if (current !== null && current.memoizedState !== null) {
-      ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
-    } else if (hookTypesDev !== null) {
-      // This dispatcher handles an edge case where a component is updating,
-      // but no stateful hooks have been used.
-      // We want to match the production code behavior (which will use HooksDispatcherOnMount),
-      // but with the extra DEV validation to ensure hooks ordering hasn't changed.
-      // This dispatcher does that.
-      ReactCurrentDispatcher$1.current =
-        HooksDispatcherOnMountWithHookTypesInDEV;
-    } else {
-      ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
+      error(
+        "%s(...): Expected the last optional `callback` argument to be a " +
+          "function. Instead received: %s.",
+        callerName,
+        callback
+      );
     }
-  } // In Strict Mode, during development, user functions are double invoked to
-  // help detect side effects. The logic for how this is implemented for in
-  // hook components is a bit complex so let's break it down.
-  //
-  // We will invoke the entire component function twice. However, during the
-  // second invocation of the component, the hook state from the first
-  // invocation will be reused. That means things like `useMemo` functions won't
-  // run again, because the deps will match and the memoized result will
-  // be reused.
-  //
-  // We want memoized functions to run twice, too, so account for this, user
-  // functions are double invoked during the *first* invocation of the component
-  // function, and are *not* double invoked during the second incovation:
-  //
-  // - First execution of component function: user functions are double invoked
-  // - Second execution of component function (in Strict Mode, during
-  //   development): user functions are not double invoked.
-  //
-  // This is intentional for a few reasons; most importantly, it's because of
-  // how `use` works when something suspends: it reuses the promise that was
-  // passed during the first attempt. This is itself a form of memoization.
-  // We need to be able to memoize the reactive inputs to the `use` call using
-  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
-  // come from the same component invocation as the output.
-  //
-  // There are plenty of tests to ensure this behavior is correct.
-
-  var shouldDoubleRenderDEV =
-    (workInProgress.mode & StrictLegacyMode) !== NoMode;
-  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
-  var children = Component(props, secondArg);
-  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
-
-  if (didScheduleRenderPhaseUpdateDuringThisPass) {
-    // Keep rendering until the component stabilizes (there are no more render
-    // phase updates).
-    children = renderWithHooksAgain(
-      workInProgress,
-      Component,
-      props,
-      secondArg
-    );
   }
+}
 
-  if (shouldDoubleRenderDEV) {
-    // In development, components are invoked twice to help detect side effects.
-    setIsStrictModeForDevtools(true);
+function warnOnUndefinedDerivedState(type, partialState) {
+  {
+    if (partialState === undefined) {
+      var componentName = getComponentNameFromType(type) || "Component";
 
-    try {
-      children = renderWithHooksAgain(
-        workInProgress,
-        Component,
-        props,
-        secondArg
-      );
-    } finally {
-      setIsStrictModeForDevtools(false);
+      if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
+        didWarnAboutUndefinedDerivedState.add(componentName);
+
+        error(
+          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
+            "You have returned undefined.",
+          componentName
+        );
+      }
     }
   }
-
-  finishRenderingHooks(current, workInProgress);
-  return children;
 }
 
-function finishRenderingHooks(current, workInProgress) {
-  // We can assume the previous dispatcher is always this one, since we set it
-  // at the beginning of the render phase and there's no re-entrance.
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-
-  {
-    workInProgress._debugHookTypes = hookTypesDev;
-  } // This check uses currentHook so that it works the same in DEV and prod bundles.
-  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
-
-  var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
-  renderLanes$1 = NoLanes;
-  currentlyRenderingFiber$1 = null;
-  currentHook = null;
-  workInProgressHook = null;
+function applyDerivedStateFromProps(
+  workInProgress,
+  ctor,
+  getDerivedStateFromProps,
+  nextProps
+) {
+  var prevState = workInProgress.memoizedState;
+  var partialState = getDerivedStateFromProps(nextProps, prevState);
 
   {
-    currentHookNameInDev = null;
-    hookTypesDev = null;
-    hookTypesUpdateIndexDev = -1; // Confirm that a static flag was not added or removed since the last
-    // render. If this fires, it suggests that we incorrectly reset the static
-    // flags in some other part of the codebase. This has happened before, for
-    // example, in the SuspenseList implementation.
+    if (workInProgress.mode & StrictLegacyMode) {
+      setIsStrictModeForDevtools(true);
 
-    if (
-      current !== null &&
-      (current.flags & StaticMask) !== (workInProgress.flags & StaticMask) && // Disable this warning in legacy mode, because legacy Suspense is weird
-      // and creates false positives. To make this work in legacy mode, we'd
-      // need to mark fibers that commit in an incomplete state, somehow. For
-      // now I'll disable the warning that most of the bugs that would trigger
-      // it are either exclusive to concurrent mode or exist in both.
-      (current.mode & ConcurrentMode) !== NoMode
-    ) {
-      error(
-        "Internal React error: Expected static flag was missing. Please " +
-          "notify the React team."
-      );
+      try {
+        // Invoke the function an extra time to help detect side-effects.
+        partialState = getDerivedStateFromProps(nextProps, prevState);
+      } finally {
+        setIsStrictModeForDevtools(false);
+      }
     }
-  }
 
-  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
-  // localIdCounter = 0;
+    warnOnUndefinedDerivedState(ctor, partialState);
+  } // Merge the partial state and the previous state.
 
-  thenableIndexCounter = 0;
-  thenableState = null;
+  var memoizedState =
+    partialState === null || partialState === undefined
+      ? prevState
+      : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
 
-  if (didRenderTooFewHooks) {
-    throw new Error(
-      "Rendered fewer hooks than expected. This may be caused by an accidental " +
-        "early return statement."
-    );
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    var updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
   }
+}
 
-  if (enableLazyContextPropagation) {
-    if (current !== null) {
-      if (!checkIfWorkInProgressReceivedUpdate()) {
-        // If there were no changes to props or state, we need to check if there
-        // was a context change. We didn't already do this because there's no
-        // 1:1 correspondence between dependencies and hooks. Although, because
-        // there almost always is in the common case (`readContext` is an
-        // internal API), we could compare in there. OTOH, we only hit this case
-        // if everything else bails out, so on the whole it might be better to
-        // keep the comparison out of the common path.
-        var currentDependencies = current.dependencies;
+var classComponentUpdater = {
+  isMounted: isMounted,
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState: function (inst, payload, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.payload = payload;
 
-        if (
-          currentDependencies !== null &&
-          checkIfContextChanged(currentDependencies)
-        ) {
-          markWorkInProgressReceivedUpdate();
-        }
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback$1(callback, "setState");
       }
+
+      update.callback = callback;
     }
-  }
 
-  {
-    if (checkIfUseWrappedInTryCatch()) {
-      var componentName =
-        getComponentNameFromFiber(workInProgress) || "Unknown";
+    var root = enqueueUpdate(fiber, update, lane);
 
-      if (!didWarnAboutUseWrappedInTryCatch.has(componentName)) {
-        didWarnAboutUseWrappedInTryCatch.add(componentName);
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
+    }
 
-        error(
-          "`use` was called from inside a try/catch block. This is not allowed " +
-            "and can lead to unexpected behavior. To handle errors triggered " +
-            "by `use`, wrap your component in a error boundary."
-        );
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
       }
     }
-  }
-}
 
-function replaySuspendedComponentWithHooks(
-  current,
-  workInProgress,
-  Component,
-  props,
-  secondArg
-) {
-  // This function is used to replay a component that previously suspended,
-  // after its data resolves.
-  //
-  // It's a simplified version of renderWithHooks, but it doesn't need to do
-  // most of the set up work because they weren't reset when we suspended; they
-  // only get reset when the component either completes (finishRenderingHooks)
-  // or unwinds (resetHooksOnUnwind).
-  {
-    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+  enqueueReplaceState: function (inst, payload, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
 
-    ignorePreviousDependencies =
-      current !== null && current.type !== workInProgress.type;
-  }
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback$1(callback, "replaceState");
+      }
 
-  var children = renderWithHooksAgain(
-    workInProgress,
-    Component,
-    props,
-    secondArg
-  );
-  finishRenderingHooks(current, workInProgress);
-  return children;
-}
+      update.callback = callback;
+    }
 
-function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
-  // This is used to perform another render pass. It's used when setState is
-  // called during render, and for double invoking components in Strict Mode
-  // during development.
-  //
-  // The state from the previous pass is reused whenever possible. So, state
-  // updates that were already processed are not processed again, and memoized
-  // functions (`useMemo`) are not invoked again.
-  //
-  // Keep rendering in a loop for as long as render phase updates continue to
-  // be scheduled. Use a counter to prevent infinite loops.
-  var numberOfReRenders = 0;
-  var children;
+    var root = enqueueUpdate(fiber, update, lane);
 
-  do {
-    if (didScheduleRenderPhaseUpdateDuringThisPass) {
-      // It's possible that a use() value depended on a state that was updated in
-      // this rerender, so we need to watch for different thenables this time.
-      thenableState = null;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
     }
 
-    thenableIndexCounter = 0;
-    didScheduleRenderPhaseUpdateDuringThisPass = false;
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
 
-    if (numberOfReRenders >= RE_RENDER_LIMIT) {
-      throw new Error(
-        "Too many re-renders. React limits the number of renders to prevent " +
-          "an infinite loop."
-      );
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
     }
+  },
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate: function (inst, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.tag = ForceUpdate;
 
-    numberOfReRenders += 1;
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback$1(callback, "forceUpdate");
+      }
 
-    {
-      // Even when hot reloading, allow dependencies to stabilize
-      // after first render to prevent infinite render phase updates.
-      ignorePreviousDependencies = false;
-    } // Start over from the beginning of the list
+      update.callback = callback;
+    }
 
-    currentHook = null;
-    workInProgressHook = null;
-    workInProgress.updateQueue = null;
+    var root = enqueueUpdate(fiber, update, lane);
 
-    {
-      // Also validate hook order for cascading updates.
-      hookTypesUpdateIndexDev = -1;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
     }
 
-    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV;
-    children = Component(props, secondArg);
-  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logForceUpdateScheduled(name, lane);
+        }
+      }
+    }
 
-  return children;
-}
+    if (enableSchedulingProfiler) {
+      markForceUpdateScheduled(fiber, lane);
+    }
+  }
+};
 
-function checkDidRenderIdHook() {
-  // This should be called immediately after every renderWithHooks call.
-  // Conceptually, it's part of the return value of renderWithHooks; it's only a
-  // separate function to avoid using an array tuple.
-  var didRenderIdHook = localIdCounter !== 0;
-  localIdCounter = 0;
-  return didRenderIdHook;
-}
-function bailoutHooks(current, workInProgress, lanes) {
-  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
-  // complete phase (bubbleProperties).
+function checkShouldComponentUpdate(
+  workInProgress,
+  ctor,
+  oldProps,
+  newProps,
+  oldState,
+  newState,
+  nextContext
+) {
+  var instance = workInProgress.stateNode;
 
-  if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-    workInProgress.flags &= ~(
-      MountPassiveDev |
-      MountLayoutDev |
-      Passive$1 |
-      Update
+  if (typeof instance.shouldComponentUpdate === "function") {
+    var shouldUpdate = instance.shouldComponentUpdate(
+      newProps,
+      newState,
+      nextContext
     );
-  } else {
-    workInProgress.flags &= ~(Passive$1 | Update);
-  }
-
-  current.lanes = removeLanes(current.lanes, lanes);
-}
-function resetHooksAfterThrow() {
-  // This is called immediaetly after a throw. It shouldn't reset the entire
-  // module state, because the work loop might decide to replay the component
-  // again without rewinding.
-  //
-  // It should only reset things like the current dispatcher, to prevent hooks
-  // from being called outside of a component.
-  // We can assume the previous dispatcher is always this one, since we set it
-  // at the beginning of the render phase and there's no re-entrance.
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-}
-function resetHooksOnUnwind() {
-  if (didScheduleRenderPhaseUpdate) {
-    // There were render phase updates. These are only valid for this render
-    // phase, which we are now aborting. Remove the updates from the queues so
-    // they do not persist to the next render. Do not remove updates from hooks
-    // that weren't processed.
-    //
-    // Only reset the updates from the queue if it has a clone. If it does
-    // not have a clone, that means it wasn't processed, and the updates were
-    // scheduled before we entered the render phase.
-    var hook = currentlyRenderingFiber$1.memoizedState;
 
-    while (hook !== null) {
-      var queue = hook.queue;
+    {
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
 
-      if (queue !== null) {
-        queue.pending = null;
+        try {
+          // Invoke the function an extra time to help detect side-effects.
+          shouldUpdate = instance.shouldComponentUpdate(
+            newProps,
+            newState,
+            nextContext
+          );
+        } finally {
+          setIsStrictModeForDevtools(false);
+        }
       }
 
-      hook = hook.next;
+      if (shouldUpdate === undefined) {
+        error(
+          "%s.shouldComponentUpdate(): Returned undefined instead of a " +
+            "boolean value. Make sure to return true or false.",
+          getComponentNameFromType(ctor) || "Component"
+        );
+      }
     }
 
-    didScheduleRenderPhaseUpdate = false;
+    return shouldUpdate;
   }
 
-  renderLanes$1 = NoLanes;
-  currentlyRenderingFiber$1 = null;
-  currentHook = null;
-  workInProgressHook = null;
-
-  {
-    hookTypesDev = null;
-    hookTypesUpdateIndexDev = -1;
-    currentHookNameInDev = null;
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return (
+      !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
+    );
   }
 
-  didScheduleRenderPhaseUpdateDuringThisPass = false;
-  localIdCounter = 0;
-  thenableIndexCounter = 0;
-  thenableState = null;
+  return true;
 }
 
-function mountWorkInProgressHook() {
-  var hook = {
-    memoizedState: null,
-    baseState: null,
-    baseQueue: null,
-    queue: null,
-    next: null
-  };
+function checkClassInstance(workInProgress, ctor, newProps) {
+  var instance = workInProgress.stateNode;
 
-  if (workInProgressHook === null) {
-    // This is the first hook in the list
-    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
-  } else {
-    // Append to the end of the list
-    workInProgressHook = workInProgressHook.next = hook;
-  }
+  {
+    var name = getComponentNameFromType(ctor) || "Component";
+    var renderPresent = instance.render;
 
-  return workInProgressHook;
-}
+    if (!renderPresent) {
+      if (ctor.prototype && typeof ctor.prototype.render === "function") {
+        error(
+          "%s(...): No `render` method found on the returned component " +
+            "instance: did you accidentally return an object from the constructor?",
+          name
+        );
+      } else {
+        error(
+          "%s(...): No `render` method found on the returned component " +
+            "instance: you may have forgotten to define `render`.",
+          name
+        );
+      }
+    }
 
-function updateWorkInProgressHook() {
-  // This function is used both for updates and for re-renders triggered by a
-  // render phase update. It assumes there is either a current hook we can
-  // clone, or a work-in-progress hook from a previous render pass that we can
-  // use as a base.
-  var nextCurrentHook;
-
-  if (currentHook === null) {
-    var current = currentlyRenderingFiber$1.alternate;
-
-    if (current !== null) {
-      nextCurrentHook = current.memoizedState;
-    } else {
-      nextCurrentHook = null;
+    if (
+      instance.getInitialState &&
+      !instance.getInitialState.isReactClassApproved &&
+      !instance.state
+    ) {
+      error(
+        "getInitialState was defined on %s, a plain JavaScript class. " +
+          "This is only supported for classes created using React.createClass. " +
+          "Did you mean to define a state property instead?",
+        name
+      );
     }
-  } else {
-    nextCurrentHook = currentHook.next;
-  }
-
-  var nextWorkInProgressHook;
-
-  if (workInProgressHook === null) {
-    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
-  } else {
-    nextWorkInProgressHook = workInProgressHook.next;
-  }
-
-  if (nextWorkInProgressHook !== null) {
-    // There's already a work-in-progress. Reuse it.
-    workInProgressHook = nextWorkInProgressHook;
-    nextWorkInProgressHook = workInProgressHook.next;
-    currentHook = nextCurrentHook;
-  } else {
-    // Clone from the current hook.
-    if (nextCurrentHook === null) {
-      var currentFiber = currentlyRenderingFiber$1.alternate;
 
-      if (currentFiber === null) {
-        // This is the initial render. This branch is reached when the component
-        // suspends, resumes, then renders an additional hook.
-        // Should never be reached because we should switch to the mount dispatcher first.
-        throw new Error(
-          "Update hook called on initial render. This is likely a bug in React. Please file an issue."
-        );
-      } else {
-        // This is an update. We should always have a current hook.
-        throw new Error("Rendered more hooks than during the previous render.");
-      }
+    if (
+      instance.getDefaultProps &&
+      !instance.getDefaultProps.isReactClassApproved
+    ) {
+      error(
+        "getDefaultProps was defined on %s, a plain JavaScript class. " +
+          "This is only supported for classes created using React.createClass. " +
+          "Use a static property to define defaultProps instead.",
+        name
+      );
     }
 
-    currentHook = nextCurrentHook;
-    var newHook = {
-      memoizedState: currentHook.memoizedState,
-      baseState: currentHook.baseState,
-      baseQueue: currentHook.baseQueue,
-      queue: currentHook.queue,
-      next: null
-    };
-
-    if (workInProgressHook === null) {
-      // This is the first hook in the list.
-      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
-    } else {
-      // Append to the end of the list.
-      workInProgressHook = workInProgressHook.next = newHook;
+    if (instance.propTypes) {
+      error(
+        "propTypes was defined as an instance property on %s. Use a static " +
+          "property to define propTypes instead.",
+        name
+      );
     }
-  }
-
-  return workInProgressHook;
-} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
-// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
-
-var createFunctionComponentUpdateQueue;
-
-{
-  createFunctionComponentUpdateQueue = function () {
-    return {
-      lastEffect: null,
-      events: null,
-      stores: null,
-      memoCache: null
-    };
-  };
-}
 
-function use(usable) {
-  if (usable !== null && typeof usable === "object") {
-    // $FlowFixMe[method-unbinding]
-    if (typeof usable.then === "function") {
-      // This is a thenable.
-      var thenable = usable; // Track the position of the thenable within this fiber.
-
-      var index = thenableIndexCounter;
-      thenableIndexCounter += 1;
+    if (instance.contextType) {
+      error(
+        "contextType was defined as an instance property on %s. Use a static " +
+          "property to define contextType instead.",
+        name
+      );
+    }
 
-      if (thenableState === null) {
-        thenableState = createThenableState();
+    {
+      if (instance.contextTypes) {
+        error(
+          "contextTypes was defined as an instance property on %s. Use a static " +
+            "property to define contextTypes instead.",
+          name
+        );
       }
 
-      var result = trackUsedThenable(thenableState, thenable, index);
-
       if (
-        currentlyRenderingFiber$1.alternate === null &&
-        (workInProgressHook === null
-          ? currentlyRenderingFiber$1.memoizedState === null
-          : workInProgressHook.next === null)
+        ctor.contextType &&
+        ctor.contextTypes &&
+        !didWarnAboutContextTypeAndContextTypes.has(ctor)
       ) {
-        // Initial render, and either this is the first time the component is
-        // called, or there were no Hooks called after this use() the previous
-        // time (perhaps because it threw). Subsequent Hook calls should use the
-        // mount dispatcher.
-        {
-          ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
-        }
+        didWarnAboutContextTypeAndContextTypes.add(ctor);
+
+        error(
+          "%s declares both contextTypes and contextType static properties. " +
+            "The legacy contextTypes property will be ignored.",
+          name
+        );
       }
+    }
 
-      return result;
-    } else if (
-      usable.$$typeof === REACT_CONTEXT_TYPE ||
-      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    if (typeof instance.componentShouldUpdate === "function") {
+      error(
+        "%s has a method called " +
+          "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
+          "The name is phrased as a question because the function is " +
+          "expected to return a value.",
+        name
+      );
+    }
+
+    if (
+      ctor.prototype &&
+      ctor.prototype.isPureReactComponent &&
+      typeof instance.shouldComponentUpdate !== "undefined"
     ) {
-      var context = usable;
-      return readContext(context);
+      error(
+        "%s has a method called shouldComponentUpdate(). " +
+          "shouldComponentUpdate should not be used when extending React.PureComponent. " +
+          "Please extend React.Component if shouldComponentUpdate is used.",
+        getComponentNameFromType(ctor) || "A pure component"
+      );
     }
-  } // eslint-disable-next-line react-internal/safe-string-coercion
 
-  throw new Error("An unsupported type was passed to use(): " + String(usable));
-}
+    if (typeof instance.componentDidUnmount === "function") {
+      error(
+        "%s has a method called " +
+          "componentDidUnmount(). But there is no such lifecycle method. " +
+          "Did you mean componentWillUnmount()?",
+        name
+      );
+    }
 
-function useMemoCache(size) {
-  var memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
+    if (typeof instance.componentDidReceiveProps === "function") {
+      error(
+        "%s has a method called " +
+          "componentDidReceiveProps(). But there is no such lifecycle method. " +
+          "If you meant to update the state in response to changing props, " +
+          "use componentWillReceiveProps(). If you meant to fetch data or " +
+          "run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
+        name
+      );
+    }
 
-  var updateQueue = currentlyRenderingFiber$1.updateQueue;
+    if (typeof instance.componentWillRecieveProps === "function") {
+      error(
+        "%s has a method called " +
+          "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
+        name
+      );
+    }
 
-  if (updateQueue !== null) {
-    memoCache = updateQueue.memoCache;
-  } // Otherwise clone from the current fiber
+    if (typeof instance.UNSAFE_componentWillRecieveProps === "function") {
+      error(
+        "%s has a method called " +
+          "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
+        name
+      );
+    }
 
-  if (memoCache == null) {
-    var current = currentlyRenderingFiber$1.alternate;
+    var hasMutatedProps = instance.props !== newProps;
 
-    if (current !== null) {
-      var currentUpdateQueue = current.updateQueue;
+    if (instance.props !== undefined && hasMutatedProps) {
+      error(
+        "%s(...): When calling super() in `%s`, make sure to pass " +
+          "up the same props that your component's constructor was passed.",
+        name,
+        name
+      );
+    }
 
-      if (currentUpdateQueue !== null) {
-        var currentMemoCache = currentUpdateQueue.memoCache;
+    if (instance.defaultProps) {
+      error(
+        "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
+          " Instead, define defaultProps as a static property on %s.",
+        name,
+        name
+      );
+    }
 
-        if (currentMemoCache != null) {
-          memoCache = {
-            data: currentMemoCache.data.map(function (array) {
-              return array.slice();
-            }),
-            index: 0
-          };
-        }
-      }
+    if (
+      typeof instance.getSnapshotBeforeUpdate === "function" &&
+      typeof instance.componentDidUpdate !== "function" &&
+      !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)
+    ) {
+      didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+
+      error(
+        "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
+          "This component defines getSnapshotBeforeUpdate() only.",
+        getComponentNameFromType(ctor)
+      );
     }
-  } // Finally fall back to allocating a fresh instance of the cache
 
-  if (memoCache == null) {
-    memoCache = {
-      data: [],
-      index: 0
-    };
-  }
+    if (typeof instance.getDerivedStateFromProps === "function") {
+      error(
+        "%s: getDerivedStateFromProps() is defined as an instance method " +
+          "and will be ignored. Instead, declare it as a static method.",
+        name
+      );
+    }
 
-  if (updateQueue === null) {
-    updateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = updateQueue;
-  }
+    if (typeof instance.getDerivedStateFromError === "function") {
+      error(
+        "%s: getDerivedStateFromError() is defined as an instance method " +
+          "and will be ignored. Instead, declare it as a static method.",
+        name
+      );
+    }
 
-  updateQueue.memoCache = memoCache;
-  var data = memoCache.data[memoCache.index];
+    if (typeof ctor.getSnapshotBeforeUpdate === "function") {
+      error(
+        "%s: getSnapshotBeforeUpdate() is defined as a static method " +
+          "and will be ignored. Instead, declare it as an instance method.",
+        name
+      );
+    }
 
-  if (data === undefined) {
-    data = memoCache.data[memoCache.index] = new Array(size);
+    var state = instance.state;
 
-    for (var i = 0; i < size; i++) {
-      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    if (state && (typeof state !== "object" || isArray(state))) {
+      error("%s.state: must be set to an object or null", name);
     }
-  } else if (data.length !== size) {
-    // TODO: consider warning or throwing here
-    {
+
+    if (
+      typeof instance.getChildContext === "function" &&
+      typeof ctor.childContextTypes !== "object"
+    ) {
       error(
-        "Expected a constant size argument for each invocation of useMemoCache. " +
-          "The previous cache was allocated with size %s but size %s was requested.",
-        data.length,
-        size
+        "%s.getChildContext(): childContextTypes must be defined in order to " +
+          "use getChildContext().",
+        name
       );
     }
   }
-
-  memoCache.index++;
-  return data;
 }
 
-function basicStateReducer(state, action) {
-  // $FlowFixMe: Flow doesn't like mixed types
-  return typeof action === "function" ? action(state) : action;
-}
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
 
-function mountReducer(reducer, initialArg, init) {
-  var hook = mountWorkInProgressHook();
-  var initialState;
+  set(instance, workInProgress);
 
-  if (init !== undefined) {
-    initialState = init(initialArg);
-  } else {
-    initialState = initialArg;
+  {
+    instance._reactInternalInstance = fakeInternalInstance;
   }
-
-  hook.memoizedState = hook.baseState = initialState;
-  var queue = {
-    pending: null,
-    lanes: NoLanes,
-    dispatch: null,
-    lastRenderedReducer: reducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = queue;
-  var dispatch = (queue.dispatch = dispatchReducerAction.bind(
-    null,
-    currentlyRenderingFiber$1,
-    queue
-  ));
-  return [hook.memoizedState, dispatch];
 }
 
-function updateReducer(reducer, initialArg, init) {
-  var hook = updateWorkInProgressHook();
-  var queue = hook.queue;
-
-  if (queue === null) {
-    throw new Error(
-      "Should have a queue. This is likely a bug in React. Please file an issue."
-    );
-  }
-
-  queue.lastRenderedReducer = reducer;
-  var current = currentHook; // The last rebase update that is NOT part of the base state.
+function constructClassInstance(workInProgress, ctor, props) {
+  var isLegacyContextConsumer = false;
+  var unmaskedContext = emptyContextObject;
+  var context = emptyContextObject;
+  var contextType = ctor.contextType;
 
-  var baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.
+  {
+    if ("contextType" in ctor) {
+      var isValid = // Allow null for conditional declaration
+        contextType === null ||
+        (contextType !== undefined &&
+          contextType.$$typeof === REACT_CONTEXT_TYPE &&
+          contextType._context === undefined); // Not a <Context.Consumer>
 
-  var pendingQueue = queue.pending;
+      if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
+        didWarnAboutInvalidateContextType.add(ctor);
+        var addendum = "";
 
-  if (pendingQueue !== null) {
-    // We have new updates that haven't been processed yet.
-    // We'll add them to the base queue.
-    if (baseQueue !== null) {
-      // Merge the pending queue and the base queue.
-      var baseFirst = baseQueue.next;
-      var pendingFirst = pendingQueue.next;
-      baseQueue.next = pendingFirst;
-      pendingQueue.next = baseFirst;
-    }
+        if (contextType === undefined) {
+          addendum =
+            " However, it is set to undefined. " +
+            "This can be caused by a typo or by mixing up named and default imports. " +
+            "This can also happen due to a circular dependency, so " +
+            "try moving the createContext() call to a separate file.";
+        } else if (typeof contextType !== "object") {
+          addendum = " However, it is set to a " + typeof contextType + ".";
+        } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
+          addendum = " Did you accidentally pass the Context.Provider instead?";
+        } else if (contextType._context !== undefined) {
+          // <Context.Consumer>
+          addendum = " Did you accidentally pass the Context.Consumer instead?";
+        } else {
+          addendum =
+            " However, it is set to an object with keys {" +
+            Object.keys(contextType).join(", ") +
+            "}.";
+        }
 
-    {
-      if (current.baseQueue !== baseQueue) {
-        // Internal invariant that should never happen, but feasibly could in
-        // the future if we implement resuming, or some form of that.
         error(
-          "Internal error: Expected work-in-progress queue to be a clone. " +
-            "This is a bug in React."
+          "%s defines an invalid contextType. " +
+            "contextType should point to the Context object returned by React.createContext().%s",
+          getComponentNameFromType(ctor) || "Component",
+          addendum
         );
       }
     }
+  }
 
-    current.baseQueue = baseQueue = pendingQueue;
-    queue.pending = null;
+  if (typeof contextType === "object" && contextType !== null) {
+    context = readContext(contextType);
+  } else {
+    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    var contextTypes = ctor.contextTypes;
+    isLegacyContextConsumer =
+      contextTypes !== null && contextTypes !== undefined;
+    context = isLegacyContextConsumer
+      ? getMaskedContext(workInProgress, unmaskedContext)
+      : emptyContextObject;
   }
 
-  if (baseQueue !== null) {
-    // We have a queue to process.
-    var first = baseQueue.next;
-    var newState = current.baseState;
-    var newBaseState = null;
-    var newBaseQueueFirst = null;
-    var newBaseQueueLast = null;
-    var update = first;
+  var instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
 
-    do {
-      // An extra OffscreenLane bit is added to updates that were made to
-      // a hidden tree, so that we can distinguish them from updates that were
-      // already there when the tree was hidden.
-      var updateLane = removeLanes(update.lane, OffscreenLane);
-      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
-      // it's not a "base" update and we should disregard the extra base lanes
-      // that were added to renderLanes when we entered the Offscreen tree.
+  {
+    if (workInProgress.mode & StrictLegacyMode) {
+      setIsStrictModeForDevtools(true);
 
-      var shouldSkipUpdate = isHiddenUpdate
-        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
-        : !isSubsetOfLanes(renderLanes$1, updateLane);
+      try {
+        instance = new ctor(props, context); // eslint-disable-line no-new
+      } finally {
+        setIsStrictModeForDevtools(false);
+      }
+    }
+  }
 
-      if (shouldSkipUpdate) {
-        // Priority is insufficient. Skip this update. If this is the first
-        // skipped update, the previous update/state is the new base
-        // update/state.
-        var clone = {
-          lane: updateLane,
-          action: update.action,
-          hasEagerState: update.hasEagerState,
-          eagerState: update.eagerState,
-          next: null
-        };
+  var state = (workInProgress.memoizedState =
+    instance.state !== null && instance.state !== undefined
+      ? instance.state
+      : null);
+  adoptClassInstance(workInProgress, instance);
 
-        if (newBaseQueueLast === null) {
-          newBaseQueueFirst = newBaseQueueLast = clone;
-          newBaseState = newState;
-        } else {
-          newBaseQueueLast = newBaseQueueLast.next = clone;
-        } // Update the remaining priority in the queue.
-        // TODO: Don't need to accumulate this. Instead, we can remove
-        // renderLanes from the original lanes.
+  {
+    if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+      var componentName = getComponentNameFromType(ctor) || "Component";
 
-        currentlyRenderingFiber$1.lanes = mergeLanes(
-          currentlyRenderingFiber$1.lanes,
-          updateLane
+      if (!didWarnAboutUninitializedState.has(componentName)) {
+        didWarnAboutUninitializedState.add(componentName);
+
+        error(
+          "`%s` uses `getDerivedStateFromProps` but its initial state is " +
+            "%s. This is not recommended. Instead, define the initial state by " +
+            "assigning an object to `this.state` in the constructor of `%s`. " +
+            "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
+          componentName,
+          instance.state === null ? "null" : "undefined",
+          componentName
         );
-        markSkippedUpdateLanes(updateLane);
-      } else {
-        // This update does have sufficient priority.
-        if (newBaseQueueLast !== null) {
-          var _clone = {
-            // This update is going to be committed so we never want uncommit
-            // it. Using NoLane works because 0 is a subset of all bitmasks, so
-            // this will never be skipped by the check above.
-            lane: NoLane,
-            action: update.action,
-            hasEagerState: update.hasEagerState,
-            eagerState: update.eagerState,
-            next: null
-          };
-          newBaseQueueLast = newBaseQueueLast.next = _clone;
-        } // Process this update.
+      }
+    } // If new component APIs are defined, "unsafe" lifecycles won't be called.
+    // Warn about these lifecycles if they are present.
+    // Don't warn about react-lifecycles-compat polyfilled methods though.
 
-        var action = update.action;
+    if (
+      typeof ctor.getDerivedStateFromProps === "function" ||
+      typeof instance.getSnapshotBeforeUpdate === "function"
+    ) {
+      var foundWillMountName = null;
+      var foundWillReceivePropsName = null;
+      var foundWillUpdateName = null;
 
-        if (shouldDoubleInvokeUserFnsInHooksDEV) {
-          reducer(newState, action);
-        }
+      if (
+        typeof instance.componentWillMount === "function" &&
+        instance.componentWillMount.__suppressDeprecationWarning !== true
+      ) {
+        foundWillMountName = "componentWillMount";
+      } else if (typeof instance.UNSAFE_componentWillMount === "function") {
+        foundWillMountName = "UNSAFE_componentWillMount";
+      }
 
-        if (update.hasEagerState) {
-          // If this update is a state update (not a reducer) and was processed eagerly,
-          // we can use the eagerly computed state
-          newState = update.eagerState;
-        } else {
-          newState = reducer(newState, action);
-        }
+      if (
+        typeof instance.componentWillReceiveProps === "function" &&
+        instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
+      ) {
+        foundWillReceivePropsName = "componentWillReceiveProps";
+      } else if (
+        typeof instance.UNSAFE_componentWillReceiveProps === "function"
+      ) {
+        foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
       }
 
-      update = update.next;
-    } while (update !== null && update !== first);
+      if (
+        typeof instance.componentWillUpdate === "function" &&
+        instance.componentWillUpdate.__suppressDeprecationWarning !== true
+      ) {
+        foundWillUpdateName = "componentWillUpdate";
+      } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+        foundWillUpdateName = "UNSAFE_componentWillUpdate";
+      }
 
-    if (newBaseQueueLast === null) {
-      newBaseState = newState;
-    } else {
-      newBaseQueueLast.next = newBaseQueueFirst;
-    } // Mark that the fiber performed work, but only if the new state is
-    // different from the current state.
+      if (
+        foundWillMountName !== null ||
+        foundWillReceivePropsName !== null ||
+        foundWillUpdateName !== null
+      ) {
+        var _componentName = getComponentNameFromType(ctor) || "Component";
 
-    if (!objectIs(newState, hook.memoizedState)) {
-      markWorkInProgressReceivedUpdate();
-    }
+        var newApiName =
+          typeof ctor.getDerivedStateFromProps === "function"
+            ? "getDerivedStateFromProps()"
+            : "getSnapshotBeforeUpdate()";
 
-    hook.memoizedState = newState;
-    hook.baseState = newBaseState;
-    hook.baseQueue = newBaseQueueLast;
-    queue.lastRenderedState = newState;
-  }
+        if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
+          didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
 
-  if (baseQueue === null) {
-    // `queue.lanes` is used for entangling transitions. We can set it back to
-    // zero once the queue is empty.
-    queue.lanes = NoLanes;
+          error(
+            "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" +
+              "The above lifecycles should be removed. Learn more about this warning here:\n" +
+              "https://reactjs.org/link/unsafe-component-lifecycles",
+            _componentName,
+            newApiName,
+            foundWillMountName !== null ? "\n  " + foundWillMountName : "",
+            foundWillReceivePropsName !== null
+              ? "\n  " + foundWillReceivePropsName
+              : "",
+            foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : ""
+          );
+        }
+      }
+    }
+  } // Cache unmasked context so we can avoid recreating masked context unless necessary.
+  // ReactFiberContext usually updates this cache but can't for newly-created instances.
+
+  if (isLegacyContextConsumer) {
+    cacheContext(workInProgress, unmaskedContext, context);
   }
 
-  var dispatch = queue.dispatch;
-  return [hook.memoizedState, dispatch];
+  return instance;
 }
 
-function rerenderReducer(reducer, initialArg, init) {
-  var hook = updateWorkInProgressHook();
-  var queue = hook.queue;
+function callComponentWillMount(workInProgress, instance) {
+  var oldState = instance.state;
 
-  if (queue === null) {
-    throw new Error(
-      "Should have a queue. This is likely a bug in React. Please file an issue."
-    );
+  if (typeof instance.componentWillMount === "function") {
+    instance.componentWillMount();
   }
 
-  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
-  // work-in-progress hook.
+  if (typeof instance.UNSAFE_componentWillMount === "function") {
+    instance.UNSAFE_componentWillMount();
+  }
 
-  var dispatch = queue.dispatch;
-  var lastRenderPhaseUpdate = queue.pending;
-  var newState = hook.memoizedState;
+  if (oldState !== instance.state) {
+    {
+      error(
+        "%s.componentWillMount(): Assigning directly to this.state is " +
+          "deprecated (except inside a component's " +
+          "constructor). Use setState instead.",
+        getComponentNameFromFiber(workInProgress) || "Component"
+      );
+    }
 
-  if (lastRenderPhaseUpdate !== null) {
-    // The queue doesn't persist past this render pass.
-    queue.pending = null;
-    var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
-    var update = firstRenderPhaseUpdate;
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+}
 
-    do {
-      // Process this render phase update. We don't have to check the
-      // priority because it will always be the same as the current
-      // render's.
-      var action = update.action;
-      newState = reducer(newState, action);
-      update = update.next;
-    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
-    // different from the current state.
+function callComponentWillReceiveProps(
+  workInProgress,
+  instance,
+  newProps,
+  nextContext
+) {
+  var oldState = instance.state;
 
-    if (!objectIs(newState, hook.memoizedState)) {
-      markWorkInProgressReceivedUpdate();
-    }
+  if (typeof instance.componentWillReceiveProps === "function") {
+    instance.componentWillReceiveProps(newProps, nextContext);
+  }
 
-    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
-    // the base state unless the queue is empty.
-    // TODO: Not sure if this is the desired semantics, but it's what we
-    // do for gDSFP. I can't remember why.
+  if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
 
-    if (hook.baseQueue === null) {
-      hook.baseState = newState;
+  if (instance.state !== oldState) {
+    {
+      var componentName =
+        getComponentNameFromFiber(workInProgress) || "Component";
+
+      if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
+        didWarnAboutStateAssignmentForComponent.add(componentName);
+
+        error(
+          "%s.componentWillReceiveProps(): Assigning directly to " +
+            "this.state is deprecated (except inside a component's " +
+            "constructor). Use setState instead.",
+          componentName
+        );
+      }
     }
 
-    queue.lastRenderedState = newState;
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
   }
+} // Invokes the mount life-cycles on a previously never rendered instance.
 
-  return [newState, dispatch];
-}
-
-function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
   {
-    warnAboutMultipleRenderersDEV(source);
+    checkClassInstance(workInProgress, ctor, newProps);
   }
 
-  var getVersion = source._getVersion;
-  var version = getVersion(source._source); // Is it safe for this component to read from this source during the current render?
-
-  var isSafeToReadFromSource = false; // Check the version first.
-  // If this render has already been started with a specific version,
-  // we can use it alone to determine if we can safely read from the source.
-
-  var currentRenderVersion = getWorkInProgressVersion(source);
+  var instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  var contextType = ctor.contextType;
 
-  if (currentRenderVersion !== null) {
-    // It's safe to read if the store hasn't been mutated since the last time
-    // we read something.
-    isSafeToReadFromSource = currentRenderVersion === version;
+  if (typeof contextType === "object" && contextType !== null) {
+    instance.context = readContext(contextType);
   } else {
-    // If there's no version, then this is the first time we've read from the
-    // source during the current render pass, so we need to do a bit more work.
-    // What we need to determine is if there are any hooks that already
-    // subscribed to the source, and if so, whether there are any pending
-    // mutations that haven't been synchronized yet.
-    //
-    // If there are no pending mutations, then `root.mutableReadLanes` will be
-    // empty, and we know we can safely read.
-    //
-    // If there *are* pending mutations, we may still be able to safely read
-    // if the currently rendering lanes are inclusive of the pending mutation
-    // lanes, since that guarantees that the value we're about to read from
-    // the source is consistent with the values that we read during the most
-    // recent mutation.
-    isSafeToReadFromSource = isSubsetOfLanes(
-      renderLanes$1,
-      root.mutableReadLanes
-    );
-
-    if (isSafeToReadFromSource) {
-      // If it's safe to read from this source during the current render,
-      // store the version in case other components read from it.
-      // A changed version number will let those components know to throw and restart the render.
-      setWorkInProgressVersion(source, version);
-    }
+    var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    instance.context = getMaskedContext(workInProgress, unmaskedContext);
   }
 
-  if (isSafeToReadFromSource) {
-    var snapshot = getSnapshot(source._source);
+  {
+    if (instance.state === newProps) {
+      var componentName = getComponentNameFromType(ctor) || "Component";
+
+      if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
+        didWarnAboutDirectlyAssigningPropsToState.add(componentName);
 
-    {
-      if (typeof snapshot === "function") {
         error(
-          "Mutable source should not return a function as the snapshot value. " +
-            "Functions may close over mutable values and cause tearing."
+          "%s: It is not recommended to assign props directly to state " +
+            "because updates to props won't be reflected in state. " +
+            "In most cases, it is better to use props directly.",
+          componentName
         );
       }
     }
 
-    return snapshot;
-  } else {
-    // This handles the special case of a mutable source being shared between renderers.
-    // In that case, if the source is mutated between the first and second renderer,
-    // The second renderer don't know that it needs to reset the WIP version during unwind,
-    // (because the hook only marks sources as dirty if it's written to their WIP version).
-    // That would cause this tear check to throw again and eventually be visible to the user.
-    // We can avoid this infinite loop by explicitly marking the source as dirty.
-    //
-    // This can lead to tearing in the first renderer when it resumes,
-    // but there's nothing we can do about that (short of throwing here and refusing to continue the render).
-    markSourceAsDirty(source); // Intentioally throw an error to force React to retry synchronously. During
-    // the synchronous retry, it will block interleaved mutations, so we should
-    // get a consistent read. Therefore, the following error should never be
-    // visible to the user.
-    // We expect this error not to be thrown during the synchronous retry,
-    // because we blocked interleaved mutations.
+    if (workInProgress.mode & StrictLegacyMode) {
+      ReactStrictModeWarnings.recordLegacyContextWarning(
+        workInProgress,
+        instance
+      );
+    }
 
-    throw new Error(
-      "Cannot read from mutable source during the current render without tearing. This may be a bug in React. Please file an issue."
+    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
+      workInProgress,
+      instance
     );
   }
-}
 
-function useMutableSource(hook, source, getSnapshot, subscribe) {
-  var root = getWorkInProgressRoot();
+  instance.state = workInProgress.memoizedState;
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
 
-  if (root === null) {
-    throw new Error(
-      "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
     );
-  }
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
 
-  var getVersion = source._getVersion;
-  var version = getVersion(source._source);
-  var dispatcher = ReactCurrentDispatcher$1.current; // eslint-disable-next-line prefer-const
+  if (
+    typeof ctor.getDerivedStateFromProps !== "function" &&
+    typeof instance.getSnapshotBeforeUpdate !== "function" &&
+    (typeof instance.UNSAFE_componentWillMount === "function" ||
+      typeof instance.componentWillMount === "function")
+  ) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
 
-  var _dispatcher$useState = dispatcher.useState(function () {
-      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    }),
-    currentSnapshot = _dispatcher$useState[0],
-    setSnapshot = _dispatcher$useState[1];
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
+  }
 
-  var snapshot = currentSnapshot; // Grab a handle to the state hook as well.
-  // We use it to clear the pending update queue if we have a new source.
+  if (typeof instance.componentDidMount === "function") {
+    var fiberFlags = Update | LayoutStatic;
 
-  var stateHook = workInProgressHook;
-  var memoizedState = hook.memoizedState;
-  var refs = memoizedState.refs;
-  var prevGetSnapshot = refs.getSnapshot;
-  var prevSource = memoizedState.source;
-  var prevSubscribe = memoizedState.subscribe;
-  var fiber = currentlyRenderingFiber$1;
-  hook.memoizedState = {
-    refs: refs,
-    source: source,
-    subscribe: subscribe
-  }; // Sync the values needed by our subscription handler after each commit.
+    if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+      fiberFlags |= MountLayoutDev;
+    }
 
-  dispatcher.useEffect(
-    function () {
-      refs.getSnapshot = getSnapshot; // Normally the dispatch function for a state hook never changes,
-      // but this hook recreates the queue in certain cases  to avoid updates from stale sources.
-      // handleChange() below needs to reference the dispatch function without re-subscribing,
-      // so we use a ref to ensure that it always has the latest version.
+    workInProgress.flags |= fiberFlags;
+  }
+}
 
-      refs.setSnapshot = setSnapshot; // Check for a possible change between when we last rendered now.
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  var instance = workInProgress.stateNode;
+  var oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  var oldContext = instance.context;
+  var contextType = ctor.contextType;
+  var nextContext = emptyContextObject;
 
-      var maybeNewVersion = getVersion(source._source);
+  if (typeof contextType === "object" && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    var nextLegacyUnmaskedContext = getUnmaskedContext(
+      workInProgress,
+      ctor,
+      true
+    );
+    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+  }
 
-      if (!objectIs(version, maybeNewVersion)) {
-        var maybeNewSnapshot = getSnapshot(source._source);
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  var hasNewLifecycles =
+    typeof getDerivedStateFromProps === "function" ||
+    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
 
-        {
-          if (typeof maybeNewSnapshot === "function") {
-            error(
-              "Mutable source should not return a function as the snapshot value. " +
-                "Functions may close over mutable values and cause tearing."
-            );
-          }
-        }
+  if (
+    !hasNewLifecycles &&
+    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
+      typeof instance.componentWillReceiveProps === "function")
+  ) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(
+        workInProgress,
+        instance,
+        newProps,
+        nextContext
+      );
+    }
+  }
 
-        if (!objectIs(snapshot, maybeNewSnapshot)) {
-          setSnapshot(maybeNewSnapshot);
-          var lane = requestUpdateLane(fiber);
-          markRootMutableRead(root, lane);
-        } // If the source mutated between render and now,
-        // there may be state updates already scheduled from the old source.
-        // Entangle the updates so that they render in the same batch.
+  resetHasForceUpdateBeforeProcessing();
+  var oldState = workInProgress.memoizedState;
+  var newState = (instance.state = oldState);
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
 
-        markRootEntangled(root, root.mutableReadLanes);
+  if (
+    oldProps === newProps &&
+    oldState === newState &&
+    !hasContextChanged() &&
+    !checkHasForceUpdateAfterProcessing()
+  ) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === "function") {
+      var fiberFlags = Update | LayoutStatic;
+
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        fiberFlags |= MountLayoutDev;
       }
-    },
-    [getSnapshot, source, subscribe]
-  ); // If we got a new source or subscribe function, re-subscribe in a passive effect.
 
-  dispatcher.useEffect(
-    function () {
-      var handleChange = function () {
-        var latestGetSnapshot = refs.getSnapshot;
-        var latestSetSnapshot = refs.setSnapshot;
+      workInProgress.flags |= fiberFlags;
+    }
 
-        try {
-          latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
+    return false;
+  }
 
-          var lane = requestUpdateLane(fiber);
-          markRootMutableRead(root, lane);
-        } catch (error) {
-          // A selector might throw after a source mutation.
-          // e.g. it might try to read from a part of the store that no longer exists.
-          // In this case we should still schedule an update with React.
-          // Worst case the selector will throw again and then an error boundary will handle it.
-          latestSetSnapshot(function () {
-            throw error;
-          });
-        }
-      };
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    newState = workInProgress.memoizedState;
+  }
 
-      var unsubscribe = subscribe(source._source, handleChange);
+  var shouldUpdate =
+    checkHasForceUpdateAfterProcessing() ||
+    checkShouldComponentUpdate(
+      workInProgress,
+      ctor,
+      oldProps,
+      newProps,
+      oldState,
+      newState,
+      nextContext
+    );
 
-      {
-        if (typeof unsubscribe !== "function") {
-          error(
-            "Mutable source subscribe function must return an unsubscribe function."
-          );
-        }
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (
+      !hasNewLifecycles &&
+      (typeof instance.UNSAFE_componentWillMount === "function" ||
+        typeof instance.componentWillMount === "function")
+    ) {
+      if (typeof instance.componentWillMount === "function") {
+        instance.componentWillMount();
       }
 
-      return unsubscribe;
-    },
-    [source, subscribe]
-  ); // If any of the inputs to useMutableSource change, reading is potentially unsafe.
-  //
-  // If either the source or the subscription have changed we can't can't trust the update queue.
-  // Maybe the source changed in a way that the old subscription ignored but the new one depends on.
-  //
-  // If the getSnapshot function changed, we also shouldn't rely on the update queue.
-  // It's possible that the underlying source was mutated between the when the last "change" event fired,
-  // and when the current render (with the new getSnapshot function) is processed.
-  //
-  // In both cases, we need to throw away pending updates (since they are no longer relevant)
-  // and treat reading from the source as we do in the mount case.
+      if (typeof instance.UNSAFE_componentWillMount === "function") {
+        instance.UNSAFE_componentWillMount();
+      }
+    }
 
-  if (
-    !objectIs(prevGetSnapshot, getSnapshot) ||
-    !objectIs(prevSource, source) ||
-    !objectIs(prevSubscribe, subscribe)
-  ) {
-    // Create a new queue and setState method,
-    // So if there are interleaved updates, they get pushed to the older queue.
-    // When this becomes current, the previous queue and dispatch method will be discarded,
-    // including any interleaving updates that occur.
-    var newQueue = {
-      pending: null,
-      lanes: NoLanes,
-      dispatch: null,
-      lastRenderedReducer: basicStateReducer,
-      lastRenderedState: snapshot
-    };
-    newQueue.dispatch = setSnapshot = dispatchSetState.bind(
-      null,
-      currentlyRenderingFiber$1,
-      newQueue
-    );
-    stateHook.queue = newQueue;
-    stateHook.baseQueue = null;
-    snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    stateHook.memoizedState = stateHook.baseState = snapshot;
-  }
+    if (typeof instance.componentDidMount === "function") {
+      var _fiberFlags = Update | LayoutStatic;
 
-  return snapshot;
-}
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        _fiberFlags |= MountLayoutDev;
+      }
 
-function mountMutableSource(source, getSnapshot, subscribe) {
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = {
-    refs: {
-      getSnapshot: getSnapshot,
-      setSnapshot: null
-    },
-    source: source,
-    subscribe: subscribe
-  };
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
+      workInProgress.flags |= _fiberFlags;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === "function") {
+      var _fiberFlags2 = Update | LayoutStatic;
 
-function updateMutableSource(source, getSnapshot, subscribe) {
-  var hook = updateWorkInProgressHook();
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        _fiberFlags2 |= MountLayoutDev;
+      }
 
-function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-  var fiber = currentlyRenderingFiber$1;
-  var hook = mountWorkInProgressHook();
-  var nextSnapshot;
-  var isHydrating = getIsHydrating();
+      workInProgress.flags |= _fiberFlags2;
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized state to indicate that this work can be reused.
 
-  if (isHydrating) {
-    if (getServerSnapshot === undefined) {
-      throw new Error(
-        "Missing getServerSnapshot, which is required for " +
-          "server-rendered content. Will revert to client rendering."
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+
+function updateClassInstance(
+  current,
+  workInProgress,
+  ctor,
+  newProps,
+  renderLanes
+) {
+  var instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  var unresolvedOldProps = workInProgress.memoizedProps;
+  var oldProps =
+    workInProgress.type === workInProgress.elementType
+      ? unresolvedOldProps
+      : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  var unresolvedNewProps = workInProgress.pendingProps;
+  var oldContext = instance.context;
+  var contextType = ctor.contextType;
+  var nextContext = emptyContextObject;
+
+  if (typeof contextType === "object" && contextType !== null) {
+    nextContext = readContext(contextType);
+  } else {
+    var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+  }
+
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  var hasNewLifecycles =
+    typeof getDerivedStateFromProps === "function" ||
+    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (
+    !hasNewLifecycles &&
+    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
+      typeof instance.componentWillReceiveProps === "function")
+  ) {
+    if (
+      unresolvedOldProps !== unresolvedNewProps ||
+      oldContext !== nextContext
+    ) {
+      callComponentWillReceiveProps(
+        workInProgress,
+        instance,
+        newProps,
+        nextContext
       );
     }
+  }
 
-    nextSnapshot = getServerSnapshot();
+  resetHasForceUpdateBeforeProcessing();
+  var oldState = workInProgress.memoizedState;
+  var newState = (instance.state = oldState);
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
 
-    {
-      if (!didWarnUncachedGetSnapshot) {
-        if (nextSnapshot !== getServerSnapshot()) {
-          error(
-            "The result of getServerSnapshot should be cached to avoid an infinite loop"
-          );
+  if (
+    unresolvedOldProps === unresolvedNewProps &&
+    oldState === newState &&
+    !hasContextChanged() &&
+    !checkHasForceUpdateAfterProcessing() &&
+    !(
+      enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies)
+    )
+  ) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Update;
+      }
+    }
 
-          didWarnUncachedGetSnapshot = true;
-        }
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Snapshot;
       }
     }
-  } else {
-    nextSnapshot = getSnapshot();
 
-    {
-      if (!didWarnUncachedGetSnapshot) {
-        var cachedSnapshot = getSnapshot();
+    return false;
+  }
 
-        if (!objectIs(nextSnapshot, cachedSnapshot)) {
-          error(
-            "The result of getSnapshot should be cached to avoid an infinite loop"
-          );
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    newState = workInProgress.memoizedState;
+  }
 
-          didWarnUncachedGetSnapshot = true;
-        }
+  var shouldUpdate =
+    checkHasForceUpdateAfterProcessing() ||
+    checkShouldComponentUpdate(
+      workInProgress,
+      ctor,
+      oldProps,
+      newProps,
+      oldState,
+      newState,
+      nextContext
+    ) || // TODO: In some cases, we'll end up checking if context has changed twice,
+    // both before and after `shouldComponentUpdate` has been called. Not ideal,
+    // but I'm loath to refactor this function. This only happens for memoized
+    // components so it's not that common.
+    (enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies));
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (
+      !hasNewLifecycles &&
+      (typeof instance.UNSAFE_componentWillUpdate === "function" ||
+        typeof instance.componentWillUpdate === "function")
+    ) {
+      if (typeof instance.componentWillUpdate === "function") {
+        instance.componentWillUpdate(newProps, newState, nextContext);
       }
-    } // Unless we're rendering a blocking lane, schedule a consistency check.
-    // Right before committing, we will walk the tree and check if any of the
-    // stores were mutated.
-    //
-    // We won't do this if we're hydrating server-rendered content, because if
-    // the content is stale, it's already visible anyway. Instead we'll patch
-    // it up in a passive effect.
 
-    var root = getWorkInProgressRoot();
+      if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
+    }
 
-    if (root === null) {
-      throw new Error(
-        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
-      );
+    if (typeof instance.componentDidUpdate === "function") {
+      workInProgress.flags |= Update;
     }
 
-    if (!includesBlockingLane(root, renderLanes$1)) {
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Update;
+      }
     }
-  } // Read the current snapshot from the store on every render. This breaks the
-  // normal rules of React, and only works because store updates are
-  // always synchronous.
 
-  hook.memoizedState = nextSnapshot;
-  var inst = {
-    value: nextSnapshot,
-    getSnapshot: getSnapshot
-  };
-  hook.queue = inst; // Schedule an effect to subscribe to the store.
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
 
-  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
-  // this whenever subscribe, getSnapshot, or value changes. Because there's no
-  // clean-up function, and we track the deps correctly, we can call pushEffect
-  // directly, without storing any additional state. For the same reason, we
-  // don't need to set a static flag, either.
-  // TODO: We can move this to the passive phase once we add a pre-commit
-  // consistency check. See the next comment.
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
 
-  fiber.flags |= Passive$1;
-  pushEffect(
-    HasEffect | Passive,
-    updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
-    undefined,
-    null
-  );
-  return nextSnapshot;
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
 }
 
-function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-  var fiber = currentlyRenderingFiber$1;
-  var hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
-  // normal rules of React, and only works because store updates are
-  // always synchronous.
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value: value,
+    source: source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value: value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
+}
 
-  var nextSnapshot = getSnapshot();
+var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
 
-  {
-    if (!didWarnUncachedGetSnapshot) {
-      var cachedSnapshot = getSnapshot();
+if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== "function") {
+  throw new Error(
+    "Expected ReactFiberErrorDialog.showErrorDialog to be a function."
+  );
+}
 
-      if (!objectIs(nextSnapshot, cachedSnapshot)) {
-        error(
-          "The result of getSnapshot should be cached to avoid an infinite loop"
-        );
+function showErrorDialog(boundary, errorInfo) {
+  var capturedError = {
+    componentStack: errorInfo.stack !== null ? errorInfo.stack : "",
+    error: errorInfo.value,
+    errorBoundary:
+      boundary !== null && boundary.tag === ClassComponent
+        ? boundary.stateNode
+        : null
+  };
+  return ReactFiberErrorDialogWWW.showErrorDialog(capturedError);
+}
 
-        didWarnUncachedGetSnapshot = true;
-      }
+function logCapturedError(boundary, errorInfo) {
+  try {
+    var logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
+
+    if (logError === false) {
+      return;
     }
-  }
 
-  var prevSnapshot = (currentHook || hook).memoizedState;
-  var snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
+    var error = errorInfo.value;
 
-  if (snapshotChanged) {
-    hook.memoizedState = nextSnapshot;
-    markWorkInProgressReceivedUpdate();
-  }
+    if (true) {
+      var source = errorInfo.source;
+      var stack = errorInfo.stack;
+      var componentStack = stack !== null ? stack : ""; // Browsers support silencing uncaught errors by calling
+      // `preventDefault()` in window `error` handler.
+      // We record this information as an expando on the error.
 
-  var inst = hook.queue;
-  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [
-    subscribe
-  ]); // Whenever getSnapshot or subscribe changes, we need to check in the
-  // commit phase if there was an interleaved mutation. In concurrent mode
-  // this can happen all the time, but even in synchronous mode, an earlier
-  // effect may have mutated the store.
+      if (error != null && error._suppressLogging) {
+        if (boundary.tag === ClassComponent) {
+          // The error is recoverable and was silenced.
+          // Ignore it and don't print the stack addendum.
+          // This is handy for testing error boundaries without noise.
+          return;
+        } // The error is fatal. Since the silencing might have
+        // been accidental, we'll surface it anyway.
+        // However, the browser would have silenced the original error
+        // so we'll print it first, and then print the stack addendum.
 
-  if (
-    inst.getSnapshot !== getSnapshot ||
-    snapshotChanged || // Check if the susbcribe function changed. We can save some memory by
-    // checking whether we scheduled a subscription effect above.
-    (workInProgressHook !== null &&
-      workInProgressHook.memoizedState.tag & HasEffect)
-  ) {
-    fiber.flags |= Passive$1;
-    pushEffect(
-      HasEffect | Passive,
-      updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
-      undefined,
-      null
-    ); // Unless we're rendering a blocking lane, schedule a consistency check.
-    // Right before committing, we will walk the tree and check if any of the
-    // stores were mutated.
+        console["error"](error); // Don't transform to our wrapper
+        // For a more detailed description of this block, see:
+        // https://github.com/facebook/react/pull/13384
+      }
 
-    var root = getWorkInProgressRoot();
+      var componentName = source ? getComponentNameFromFiber(source) : null;
+      var componentNameMessage = componentName
+        ? "The above error occurred in the <" + componentName + "> component:"
+        : "The above error occurred in one of your React components:";
+      var errorBoundaryMessage;
 
-    if (root === null) {
-      throw new Error(
-        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
-      );
-    }
+      if (boundary.tag === HostRoot) {
+        errorBoundaryMessage =
+          "Consider adding an error boundary to your tree to customize error handling behavior.\n" +
+          "Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.";
+      } else {
+        var errorBoundaryName =
+          getComponentNameFromFiber(boundary) || "Anonymous";
+        errorBoundaryMessage =
+          "React will try to recreate this component tree from scratch " +
+          ("using the error boundary you provided, " + errorBoundaryName + ".");
+      }
 
-    if (!includesBlockingLane(root, renderLanes$1)) {
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+      var combinedMessage =
+        componentNameMessage +
+        "\n" +
+        componentStack +
+        "\n\n" +
+        ("" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.
+      // We don't include the original error message and JS stack because the browser
+      // has already printed it. Even if the application swallows the error, it is still
+      // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
+
+      console["error"](combinedMessage); // Don't transform to our wrapper
     }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(function () {
+      throw e;
+    });
   }
-
-  return nextSnapshot;
 }
 
-function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
-  fiber.flags |= StoreConsistency;
-  var check = {
-    getSnapshot: getSnapshot,
-    value: renderedSnapshot
-  };
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  var update = createUpdate(lane); // Unmount the root by rendering null.
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.stores = [check];
-  } else {
-    var stores = componentUpdateQueue.stores;
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-    if (stores === null) {
-      componentUpdateQueue.stores = [check];
-    } else {
-      stores.push(check);
-    }
-  }
-}
+  update.payload = {
+    element: null
+  };
+  var error = errorInfo.value;
 
-function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
-  // These are updated in the passive phase
-  inst.value = nextSnapshot;
-  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
-  // have been in an event that fired before the passive effects, or it could
-  // have been in a layout effect. In that case, we would have used the old
-  // snapsho and getSnapshot values to bail out. We need to check one more time.
+  update.callback = function () {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
+  };
 
-  if (checkIfSnapshotChanged(inst)) {
-    // Force a re-render.
-    forceStoreRerender(fiber);
-  }
+  return update;
 }
 
-function subscribeToStore(fiber, inst, subscribe) {
-  var handleStoreChange = function () {
-    // The store changed. Check if the snapshot changed since the last time we
-    // read from the store.
-    if (checkIfSnapshotChanged(inst)) {
-      // Force a re-render.
-      forceStoreRerender(fiber);
-    }
-  }; // Subscribe to the store and return a clean-up function.
-
-  return subscribe(handleStoreChange);
-}
-
-function checkIfSnapshotChanged(inst) {
-  var latestGetSnapshot = inst.getSnapshot;
-  var prevValue = inst.value;
-
-  try {
-    var nextValue = latestGetSnapshot();
-    return !objectIs(prevValue, nextValue);
-  } catch (error) {
-    return true;
-  }
-}
-
-function forceStoreRerender(fiber) {
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
-  if (root !== null) {
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-  }
-}
-
-function mountState(initialState) {
-  var hook = mountWorkInProgressHook();
-
-  if (typeof initialState === "function") {
-    // $FlowFixMe: Flow doesn't like mixed types
-    initialState = initialState();
-  }
-
-  hook.memoizedState = hook.baseState = initialState;
-  var queue = {
-    pending: null,
-    lanes: NoLanes,
-    dispatch: null,
-    lastRenderedReducer: basicStateReducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = queue;
-  var dispatch = (queue.dispatch = dispatchSetState.bind(
-    null,
-    currentlyRenderingFiber$1,
-    queue
-  ));
-  return [hook.memoizedState, dispatch];
-}
-
-function updateState(initialState) {
-  return updateReducer(basicStateReducer);
-}
-
-function rerenderState(initialState) {
-  return rerenderReducer(basicStateReducer);
-}
-
-function pushEffect(tag, create, destroy, deps) {
-  var effect = {
-    tag: tag,
-    create: create,
-    destroy: destroy,
-    deps: deps,
-    // Circular
-    next: null
-  };
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
-
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.lastEffect = effect.next = effect;
-  } else {
-    var lastEffect = componentUpdateQueue.lastEffect;
-
-    if (lastEffect === null) {
-      componentUpdateQueue.lastEffect = effect.next = effect;
-    } else {
-      var firstEffect = lastEffect.next;
-      lastEffect.next = effect;
-      effect.next = firstEffect;
-      componentUpdateQueue.lastEffect = effect;
-    }
-  }
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  var update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
 
-  return effect;
-}
+  if (typeof getDerivedStateFromError === "function") {
+    var error$1 = errorInfo.value;
 
-var stackContainsErrorMessage = null;
+    update.payload = function () {
+      return getDerivedStateFromError(error$1);
+    };
 
-function getCallerStackFrame() {
-  // eslint-disable-next-line react-internal/prod-error-codes
-  var stackFrames = new Error("Error message").stack.split("\n"); // Some browsers (e.g. Chrome) include the error message in the stack
-  // but others (e.g. Firefox) do not.
+    update.callback = function () {
+      {
+        markFailedErrorBoundaryForHotReloading(fiber);
+      }
 
-  if (stackContainsErrorMessage === null) {
-    stackContainsErrorMessage = stackFrames[0].includes("Error message");
+      logCapturedError(fiber, errorInfo);
+    };
   }
 
-  return stackContainsErrorMessage
-    ? stackFrames.slice(3, 4).join("\n")
-    : stackFrames.slice(2, 3).join("\n");
-}
-
-function mountRef(initialValue) {
-  var hook = mountWorkInProgressHook();
-
-  if (enableUseRefAccessWarning) {
-    {
-      // Support lazy initialization pattern shown in docs.
-      // We need to store the caller stack frame so that we don't warn on subsequent renders.
-      var hasBeenInitialized = initialValue != null;
-      var lazyInitGetterStack = null;
-      var didCheckForLazyInit = false; // Only warn once per component+hook.
+  var inst = fiber.stateNode;
 
-      var didWarnAboutRead = false;
-      var didWarnAboutWrite = false;
-      var current = initialValue;
-      var ref = {
-        get current() {
-          if (!hasBeenInitialized) {
-            didCheckForLazyInit = true;
-            lazyInitGetterStack = getCallerStackFrame();
-          } else if (currentlyRenderingFiber$1 !== null && !didWarnAboutRead) {
-            if (
-              lazyInitGetterStack === null ||
-              lazyInitGetterStack !== getCallerStackFrame()
-            ) {
-              didWarnAboutRead = true;
+  if (inst !== null && typeof inst.componentDidCatch === "function") {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+      {
+        markFailedErrorBoundaryForHotReloading(fiber);
+      }
 
-              warn(
-                "%s: Unsafe read of a mutable value during render.\n\n" +
-                  "Reading from a ref during render is only safe if:\n" +
-                  "1. The ref value has not been updated, or\n" +
-                  "2. The ref holds a lazily-initialized value that is only set once.\n",
-                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
-                  "Unknown"
-              );
-            }
-          }
+      logCapturedError(fiber, errorInfo);
 
-          return current;
-        },
+      if (typeof getDerivedStateFromError !== "function") {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
 
-        set current(value) {
-          if (currentlyRenderingFiber$1 !== null && !didWarnAboutWrite) {
-            if (hasBeenInitialized || !didCheckForLazyInit) {
-              didWarnAboutWrite = true;
+      var error$1 = errorInfo.value;
+      var stack = errorInfo.stack;
+      this.componentDidCatch(error$1, {
+        componentStack: stack !== null ? stack : ""
+      });
 
-              warn(
-                "%s: Unsafe write of a mutable value during render.\n\n" +
-                  "Writing to a ref during render is only safe if the ref holds " +
-                  "a lazily-initialized value that is only set once.\n",
-                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
-                  "Unknown"
-              );
-            }
+      {
+        if (typeof getDerivedStateFromError !== "function") {
+          // If componentDidCatch is the only error boundary method defined,
+          // then it needs to call setState to recover from errors.
+          // If no state update is scheduled then the boundary will swallow the error.
+          if (!includesSomeLane(fiber.lanes, SyncLane)) {
+            error(
+              "%s: Error boundaries should implement getDerivedStateFromError(). " +
+                "In that method, return a state update to display an error message or fallback UI.",
+              getComponentNameFromFiber(fiber) || "Unknown"
+            );
           }
-
-          hasBeenInitialized = true;
-          current = value;
         }
-      };
-      Object.seal(ref);
-      hook.memoizedState = ref;
-      return ref;
-    }
-  } else {
-    var _ref2 = {
-      current: initialValue
+      }
     };
-    hook.memoizedState = _ref2;
-    return _ref2;
   }
-}
-
-function updateRef(initialValue) {
-  var hook = updateWorkInProgressHook();
-  return hook.memoizedState;
-}
 
-function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    HasEffect | hookFlags,
-    create,
-    undefined,
-    nextDeps
-  );
+  return update;
 }
 
-function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var destroy = undefined; // currentHook is null when rerendering after a render phase state update.
-
-  if (currentHook !== null) {
-    var prevEffect = currentHook.memoizedState;
-    destroy = prevEffect.destroy;
-
-    if (nextDeps !== null) {
-      var prevDeps = prevEffect.deps;
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  if (enableLazyContextPropagation) {
+    var currentSourceFiber = sourceFiber.alternate;
 
-      if (areHookInputsEqual(nextDeps, prevDeps)) {
-        hook.memoizedState = pushEffect(hookFlags, create, destroy, nextDeps);
-        return;
-      }
+    if (currentSourceFiber !== null) {
+      // Since we never visited the children of the suspended component, we
+      // need to propagate the context change now, to ensure that we visit
+      // them during the retry.
+      //
+      // We don't have to do this for errors because we retry errors without
+      // committing in between. So this is specific to Suspense.
+      propagateParentContextChangesToDeferredTree(
+        currentSourceFiber,
+        sourceFiber,
+        rootRenderLanes
+      );
     }
-  }
-
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    HasEffect | hookFlags,
-    create,
-    destroy,
-    nextDeps
-  );
-}
-
-function mountEffect(create, deps) {
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    mountEffectImpl(
-      MountPassiveDev | Passive$1 | PassiveStatic,
-      Passive,
-      create,
-      deps
-    );
-  } else {
-    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
-  }
-}
-
-function updateEffect(create, deps) {
-  updateEffectImpl(Passive$1, Passive, create, deps);
-}
+  } // Reset the memoizedState to what it was before we attempted to render it.
+  // A legacy mode Suspense quirk, only relevant to hook components.
 
-function useEffectEventImpl(payload) {
-  currentlyRenderingFiber$1.flags |= Update;
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+  var tag = sourceFiber.tag;
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.events = [payload];
-  } else {
-    var events = componentUpdateQueue.events;
+  if (
+    (sourceFiber.mode & ConcurrentMode) === NoMode &&
+    (tag === FunctionComponent ||
+      tag === ForwardRef ||
+      tag === SimpleMemoComponent)
+  ) {
+    var currentSource = sourceFiber.alternate;
 
-    if (events === null) {
-      componentUpdateQueue.events = [payload];
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
     } else {
-      events.push(payload);
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
     }
   }
 }
 
-function mountEvent(callback) {
-  var hook = mountWorkInProgressHook();
-  var ref = {
-    impl: callback
-  };
-  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
+function markSuspenseBoundaryShouldCapture(
+  suspenseBoundary,
+  returnFiber,
+  sourceFiber,
+  root,
+  rootRenderLanes
+) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // 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.
 
-  return function eventFn() {
-    if (isInvalidExecutionContextForEventFunction()) {
-      throw new Error(
-        "A function wrapped in useEffectEvent can't be called during rendering."
-      );
-    }
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
 
-    return ref.impl.apply(undefined, arguments);
-  };
-}
+      if (sourceFiber.tag === ClassComponent) {
+        var currentSourceFiber = sourceFiber.alternate;
 
-function updateEvent(callback) {
-  var hook = updateWorkInProgressHook();
-  var ref = hook.memoizedState;
-  useEffectEventImpl({
-    ref: ref,
-    nextImpl: callback
-  }); // $FlowIgnore[incompatible-return]
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
+        } else {
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          var update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
+        }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
 
-  return function eventFn() {
-    if (isInvalidExecutionContextForEventFunction()) {
-      throw new Error(
-        "A function wrapped in useEffectEvent can't be called during rendering."
-      );
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
     }
 
-    return ref.impl.apply(undefined, arguments);
-  };
-}
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
 
-function mountInsertionEffect(create, deps) {
-  mountEffectImpl(Update, Insertion, create, deps);
-}
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
 
-function updateInsertionEffect(create, deps) {
-  return updateEffectImpl(Update, Insertion, create, deps);
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
 }
 
-function mountLayoutEffect(create, deps) {
-  var fiberFlags = Update | LayoutStatic;
+function throwException(
+  root,
+  returnFiber,
+  sourceFiber,
+  value,
+  rootRenderLanes
+) {
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
 
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    fiberFlags |= MountLayoutDev;
+  {
+    if (isDevToolsPresent) {
+      // If we have pending work still, restore the original updaters
+      restorePendingUpdaters(root, rootRenderLanes);
+    }
   }
 
-  return mountEffectImpl(fiberFlags, Layout, create, deps);
-}
-
-function updateLayoutEffect(create, deps) {
-  return updateEffectImpl(Update, Layout, create, deps);
-}
-
-function imperativeHandleEffect(create, ref) {
-  if (typeof ref === "function") {
-    var refCallback = ref;
-    var inst = create();
-    refCallback(inst);
-    return function () {
-      refCallback(null);
-    };
-  } else if (ref !== null && ref !== undefined) {
-    var refObject = ref;
+  if (
+    value !== null &&
+    typeof value === "object" &&
+    typeof value.then === "function"
+  ) {
+    // This is a wakeable. The component suspended.
+    var wakeable = value;
+    resetSuspendedComponent(sourceFiber, rootRenderLanes);
 
     {
-      if (!refObject.hasOwnProperty("current")) {
-        error(
-          "Expected useImperativeHandle() first argument to either be a " +
-            "ref callback or React.createRef() object. Instead received: %s.",
-          "an object with keys {" + Object.keys(refObject).join(", ") + "}"
-        );
+      if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+        markDidThrowWhileHydratingDEV();
       }
     }
 
-    var _inst = create();
+    {
+      if (enableDebugTracing) {
+        if (sourceFiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(sourceFiber) || "Unknown";
+          logComponentSuspended(name, wakeable);
+        }
+      }
+    } // Mark the nearest Suspense boundary to switch to rendering a fallback.
 
-    refObject.current = _inst;
-    return function () {
-      refObject.current = null;
-    };
-  }
-}
-
-function mountImperativeHandle(ref, create, deps) {
-  {
-    if (typeof create !== "function") {
-      error(
-        "Expected useImperativeHandle() second argument to be a function " +
-          "that creates a handle. Instead received: %s.",
-        create !== null ? typeof create : "null"
-      );
-    }
-  } // TODO: If deps are provided, should we skip comparing the ref itself?
-
-  var effectDeps =
-    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-  var fiberFlags = Update | LayoutStatic;
+    var suspenseBoundary = getSuspenseHandler();
 
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    fiberFlags |= MountLayoutDev;
-  }
+    if (suspenseBoundary !== null) {
+      switch (suspenseBoundary.tag) {
+        case SuspenseComponent: {
+          // If this suspense boundary is not already showing a fallback, mark
+          // the in-progress render as suspended. We try to perform this logic
+          // as soon as soon as possible during the render phase, so the work
+          // loop can know things like whether it's OK to switch to other tasks,
+          // or whether it can wait for data to resolve before continuing.
+          // TODO: Most of these checks are already performed when entering a
+          // Suspense boundary. We should track the information on the stack so
+          // we don't have to recompute it on demand. This would also allow us
+          // to unify with `use` which needs to perform this logic even sooner,
+          // before `throwException` is called.
+          if (sourceFiber.mode & ConcurrentMode) {
+            if (getShellBoundary() === null) {
+              // Suspended in the "shell" of the app. This is an undesirable
+              // loading state. We should avoid committing this tree.
+              renderDidSuspendDelayIfPossible();
+            } else {
+              // If we suspended deeper than the shell, we don't need to delay
+              // the commmit. However, we still call renderDidSuspend if this is
+              // a new boundary, to tell the work loop that a new fallback has
+              // appeared during this render.
+              // TODO: Theoretically we should be able to delete this branch.
+              // It's currently used for two things: 1) to throttle the
+              // appearance of successive loading states, and 2) in
+              // SuspenseList, to determine whether the children include any
+              // pending fallbacks. For 1, we should apply throttling to all
+              // retries, not just ones that render an additional fallback. For
+              // 2, we should check subtreeFlags instead. Then we can delete
+              // this branch.
+              var current = suspenseBoundary.alternate;
 
-  mountEffectImpl(
-    fiberFlags,
-    Layout,
-    imperativeHandleEffect.bind(null, create, ref),
-    effectDeps
-  );
-}
+              if (current === null) {
+                renderDidSuspend();
+              }
+            }
+          }
 
-function updateImperativeHandle(ref, create, deps) {
-  {
-    if (typeof create !== "function") {
-      error(
-        "Expected useImperativeHandle() second argument to be a function " +
-          "that creates a handle. Instead received: %s.",
-        create !== null ? typeof create : "null"
-      );
-    }
-  } // TODO: If deps are provided, should we skip comparing the ref itself?
+          suspenseBoundary.flags &= ~ForceClientRender;
+          markSuspenseBoundaryShouldCapture(
+            suspenseBoundary,
+            returnFiber,
+            sourceFiber,
+            root,
+            rootRenderLanes
+          ); // Retry listener
+          //
+          // If the fallback does commit, we need to attach a different type of
+          // listener. This one schedules an update on the Suspense boundary to
+          // turn the fallback state off.
+          //
+          // Stash the wakeable on the boundary fiber so we can access it in the
+          // commit phase.
+          //
+          // When the wakeable resolves, we'll attempt to render the boundary
+          // again ("retry").
 
-  var effectDeps =
-    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-  updateEffectImpl(
-    Update,
-    Layout,
-    imperativeHandleEffect.bind(null, create, ref),
-    effectDeps
-  );
-}
+          var wakeables = suspenseBoundary.updateQueue;
 
-function mountDebugValue(value, formatterFn) {
-  // This hook is normally a no-op.
-  // The react-debug-hooks package injects its own implementation
-  // so that e.g. DevTools can display custom hook values.
-}
+          if (wakeables === null) {
+            suspenseBoundary.updateQueue = new Set([wakeable]);
+          } else {
+            wakeables.add(wakeable);
+          }
 
-var updateDebugValue = mountDebugValue;
+          break;
+        }
 
-function mountCallback(callback, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  hook.memoizedState = [callback, nextDeps];
-  return callback;
-}
+        case OffscreenComponent: {
+          if (suspenseBoundary.mode & ConcurrentMode) {
+            suspenseBoundary.flags |= ShouldCapture;
+            var offscreenQueue = suspenseBoundary.updateQueue;
 
-function updateCallback(callback, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var prevState = hook.memoizedState;
+            if (offscreenQueue === null) {
+              var newOffscreenQueue = {
+                transitions: null,
+                markerInstances: null,
+                wakeables: new Set([wakeable])
+              };
+              suspenseBoundary.updateQueue = newOffscreenQueue;
+            } else {
+              var _wakeables = offscreenQueue.wakeables;
 
-  if (nextDeps !== null) {
-    var prevDeps = prevState[1];
+              if (_wakeables === null) {
+                offscreenQueue.wakeables = new Set([wakeable]);
+              } else {
+                _wakeables.add(wakeable);
+              }
+            }
 
-    if (areHookInputsEqual(nextDeps, prevDeps)) {
-      return prevState[0];
-    }
-  }
+            break;
+          }
+        }
+        // eslint-disable-next-line no-fallthrough
 
-  hook.memoizedState = [callback, nextDeps];
-  return callback;
-}
+        default: {
+          throw new Error(
+            "Unexpected Suspense handler tag (" +
+              suspenseBoundary.tag +
+              "). This " +
+              "is a bug in React."
+          );
+        }
+      } // We only attach ping listeners in concurrent mode. Legacy Suspense always
+      // commits fallbacks synchronously, so there are no pings.
 
-function mountMemo(nextCreate, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
+      if (suspenseBoundary.mode & ConcurrentMode) {
+        attachPingListener(root, wakeable, rootRenderLanes);
+      }
 
-  if (shouldDoubleInvokeUserFnsInHooksDEV) {
-    nextCreate();
-  }
+      return;
+    } else {
+      // No boundary was found. Unless this is a sync update, this is OK.
+      // We can suspend and wait for more data to arrive.
+      if (root.tag === ConcurrentRoot) {
+        // In a concurrent root, suspending without a Suspense boundary is
+        // allowed. It will suspend indefinitely without committing.
+        //
+        // TODO: Should we have different behavior for discrete updates? What
+        // about flushSync? Maybe it should put the tree into an inert state,
+        // and potentially log a warning. Revisit this for a future release.
+        attachPingListener(root, wakeable, rootRenderLanes);
+        renderDidSuspendDelayIfPossible();
+        return;
+      } else {
+        // In a legacy root, suspending without a boundary is always an error.
+        var uncaughtSuspenseError = new Error(
+          "A component suspended while responding to synchronous input. This " +
+            "will cause the UI to be replaced with a loading indicator. To " +
+            "fix, updates that suspend should be wrapped " +
+            "with startTransition."
+        );
+        value = uncaughtSuspenseError;
+      }
+    }
+  } else {
+    // This is a regular error, not a Suspense wakeable.
+    if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+      markDidThrowWhileHydratingDEV();
 
-  var nextValue = nextCreate();
-  hook.memoizedState = [nextValue, nextDeps];
-  return nextValue;
-}
+      var _suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+      // discarding the dehydrated content and switching to a client render.
+      // Instead of surfacing the error, find the nearest Suspense boundary
+      // and render it again without hydration.
 
-function updateMemo(nextCreate, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
+      if (_suspenseBoundary !== null) {
+        if ((_suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+          // Set a flag to indicate that we should try rendering the normal
+          // children again, not the fallback.
+          _suspenseBoundary.flags |= ForceClientRender;
+        }
 
-  if (nextDeps !== null) {
-    var prevDeps = prevState[1];
+        markSuspenseBoundaryShouldCapture(
+          _suspenseBoundary,
+          returnFiber,
+          sourceFiber,
+          root,
+          rootRenderLanes
+        ); // Even though the user may not be affected by this error, we should
+        // still log it so it can be fixed.
 
-    if (areHookInputsEqual(nextDeps, prevDeps)) {
-      return prevState[0];
+        queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+        return;
+      }
     }
   }
 
-  if (shouldDoubleInvokeUserFnsInHooksDEV) {
-    nextCreate();
-  }
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // 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.
 
-  var nextValue = nextCreate();
-  hook.memoizedState = [nextValue, nextDeps];
-  return nextValue;
-}
+  var workInProgress = returnFiber;
 
-function mountDeferredValue(value) {
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = value;
-  return value;
-}
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot: {
+        var _errorInfo = value;
+        workInProgress.flags |= ShouldCapture;
+        var lane = pickArbitraryLane(rootRenderLanes);
+        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+        var update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
+        enqueueCapturedUpdate(workInProgress, update);
+        return;
+      }
 
-function updateDeferredValue(value) {
-  var hook = updateWorkInProgressHook();
-  var resolvedCurrentHook = currentHook;
-  var prevValue = resolvedCurrentHook.memoizedState;
-  return updateDeferredValueImpl(hook, prevValue, value);
-}
+      case ClassComponent:
+        // Capture and retry
+        var errorInfo = value;
+        var ctor = workInProgress.type;
+        var instance = workInProgress.stateNode;
 
-function rerenderDeferredValue(value) {
-  var hook = updateWorkInProgressHook();
+        if (
+          (workInProgress.flags & DidCapture) === NoFlags$1 &&
+          (typeof ctor.getDerivedStateFromError === "function" ||
+            (instance !== null &&
+              typeof instance.componentDidCatch === "function" &&
+              !isAlreadyFailedLegacyErrorBoundary(instance)))
+        ) {
+          workInProgress.flags |= ShouldCapture;
 
-  if (currentHook === null) {
-    // This is a rerender during a mount.
-    hook.memoizedState = value;
-    return value;
-  } else {
-    // This is a rerender during an update.
-    var prevValue = currentHook.memoizedState;
-    return updateDeferredValueImpl(hook, prevValue, value);
-  }
-}
+          var _lane = pickArbitraryLane(rootRenderLanes);
 
-function updateDeferredValueImpl(hook, prevValue, value) {
-  var shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes$1);
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, _lane); // Schedule the error boundary to re-render using updated state
 
-  if (shouldDeferValue) {
-    // This is an urgent update. If the value has changed, keep using the
-    // previous value and spawn a deferred render to update it later.
-    if (!objectIs(value, prevValue)) {
-      // Schedule a deferred render
-      var deferredLane = claimNextTransitionLane();
-      currentlyRenderingFiber$1.lanes = mergeLanes(
-        currentlyRenderingFiber$1.lanes,
-        deferredLane
-      );
-      markSkippedUpdateLanes(deferredLane); // Set this to true to indicate that the rendered value is inconsistent
-      // from the latest value. The name "baseState" doesn't really match how we
-      // use it because we're reusing a state hook field instead of creating a
-      // new one.
+          var _update = createClassErrorUpdate(
+            workInProgress,
+            errorInfo,
+            _lane
+          );
 
-      hook.baseState = true;
-    } // Reuse the previous value
+          enqueueCapturedUpdate(workInProgress, _update);
+          return;
+        }
 
-    return prevValue;
-  } else {
-    // This is not an urgent update, so we can use the latest value regardless
-    // of what it is. No need to defer it.
-    // However, if we're currently inside a spawned render, then we need to mark
-    // this as an update to prevent the fiber from bailing out.
-    //
-    // `baseState` is true when the current value is different from the rendered
-    // value. The name doesn't really match how we use it because we're reusing
-    // a state hook field instead of creating a new one.
-    if (hook.baseState) {
-      // Flip this back to false.
-      hook.baseState = false;
-      markWorkInProgressReceivedUpdate();
-    }
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-    hook.memoizedState = value;
-    return value;
-  }
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
 }
 
-function startTransition(setPending, callback, options) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  setCurrentUpdatePriority(
-    higherEventPriority(previousPriority, ContinuousEventPriority)
-  );
-  setPending(true);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
-  var currentTransition = ReactCurrentBatchConfig$2.transition;
-
+var TransitionRoot = 0;
+var TransitionTracingMarker = 1;
+function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
   if (enableTransitionTracing) {
-    if (options !== undefined && options.name !== undefined) {
-      ReactCurrentBatchConfig$2.transition.name = options.name;
-      ReactCurrentBatchConfig$2.transition.startTime = now$1();
-    }
-  }
+    if (pendingTransitions !== null) {
+      var transitionStart = pendingTransitions.transitionStart;
+      var onTransitionStart = callbacks.onTransitionStart;
 
-  {
-    ReactCurrentBatchConfig$2.transition._updatedFibers = new Set();
-  }
+      if (transitionStart !== null && onTransitionStart != null) {
+        transitionStart.forEach(function (transition) {
+          return onTransitionStart(transition.name, transition.startTime);
+        });
+      }
 
-  try {
-    setPending(false);
-    callback();
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$2.transition = prevTransition;
+      var markerProgress = pendingTransitions.markerProgress;
+      var onMarkerProgress = callbacks.onMarkerProgress;
 
-    {
-      if (prevTransition === null && currentTransition._updatedFibers) {
-        var updatedFibersCount = currentTransition._updatedFibers.size;
+      if (onMarkerProgress != null && markerProgress !== null) {
+        markerProgress.forEach(function (markerInstance, markerName) {
+          if (markerInstance.transitions !== null) {
+            // TODO: Clone the suspense object so users can't modify it
+            var pending =
+              markerInstance.pendingBoundaries !== null
+                ? Array.from(markerInstance.pendingBoundaries.values())
+                : [];
+            markerInstance.transitions.forEach(function (transition) {
+              onMarkerProgress(
+                transition.name,
+                markerName,
+                transition.startTime,
+                endTime,
+                pending
+              );
+            });
+          }
+        });
+      }
 
-        currentTransition._updatedFibers.clear();
+      var markerComplete = pendingTransitions.markerComplete;
+      var onMarkerComplete = callbacks.onMarkerComplete;
 
-        if (updatedFibersCount > 10) {
-          warn(
-            "Detected a large number of updates inside startTransition. " +
-              "If this is due to a subscription please re-write it to use React provided hooks. " +
-              "Otherwise concurrent mode guarantees are off the table."
-          );
-        }
+      if (markerComplete !== null && onMarkerComplete != null) {
+        markerComplete.forEach(function (transitions, markerName) {
+          transitions.forEach(function (transition) {
+            onMarkerComplete(
+              transition.name,
+              markerName,
+              transition.startTime,
+              endTime
+            );
+          });
+        });
       }
-    }
-  }
-}
-
-function mountTransition() {
-  var _mountState = mountState(false),
-    isPending = _mountState[0],
-    setPending = _mountState[1]; // The `start` method never changes.
 
-  var start = startTransition.bind(null, setPending);
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = start;
-  return [isPending, start];
-}
+      var markerIncomplete = pendingTransitions.markerIncomplete;
+      var onMarkerIncomplete = callbacks.onMarkerIncomplete;
 
-function updateTransition() {
-  var _updateState = updateState(),
-    isPending = _updateState[0];
+      if (onMarkerIncomplete != null && markerIncomplete !== null) {
+        markerIncomplete.forEach(function (_ref, markerName) {
+          var transitions = _ref.transitions,
+            aborts = _ref.aborts;
+          transitions.forEach(function (transition) {
+            var filteredAborts = [];
+            aborts.forEach(function (abort) {
+              switch (abort.reason) {
+                case "marker": {
+                  filteredAborts.push({
+                    type: "marker",
+                    name: abort.name,
+                    endTime: endTime
+                  });
+                  break;
+                }
 
-  var hook = updateWorkInProgressHook();
-  var start = hook.memoizedState;
-  return [isPending, start];
-}
+                case "suspense": {
+                  filteredAborts.push({
+                    type: "suspense",
+                    name: abort.name,
+                    endTime: endTime
+                  });
+                  break;
+                }
+              }
+            });
 
-function rerenderTransition() {
-  var _rerenderState = rerenderState(),
-    isPending = _rerenderState[0];
+            if (filteredAborts.length > 0) {
+              onMarkerIncomplete(
+                transition.name,
+                markerName,
+                transition.startTime,
+                filteredAborts
+              );
+            }
+          });
+        });
+      }
 
-  var hook = updateWorkInProgressHook();
-  var start = hook.memoizedState;
-  return [isPending, start];
-}
+      var transitionProgress = pendingTransitions.transitionProgress;
+      var onTransitionProgress = callbacks.onTransitionProgress;
 
-function mountId() {
-  var hook = mountWorkInProgressHook();
-  var root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
-  // should do this in Fiber, too? Deferring this decision for now because
-  // there's no other place to store the prefix except for an internal field on
-  // the public createRoot object, which the fiber tree does not currently have
-  // a reference to.
+      if (onTransitionProgress != null && transitionProgress !== null) {
+        transitionProgress.forEach(function (pending, transition) {
+          onTransitionProgress(
+            transition.name,
+            transition.startTime,
+            endTime,
+            Array.from(pending.values())
+          );
+        });
+      }
 
-  var identifierPrefix = root.identifierPrefix;
-  var id;
+      var transitionComplete = pendingTransitions.transitionComplete;
+      var onTransitionComplete = callbacks.onTransitionComplete;
 
-  if (getIsHydrating()) {
-    var treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
-
-    id = ":" + identifierPrefix + "R" + treeId; // Unless this is the first id at this level, append a number at the end
-    // that represents the position of this useId hook among all the useId
-    // hooks for this fiber.
+      if (transitionComplete !== null && onTransitionComplete != null) {
+        transitionComplete.forEach(function (transition) {
+          return onTransitionComplete(
+            transition.name,
+            transition.startTime,
+            endTime
+          );
+        });
+      }
+    }
+  }
+} // For every tracing marker, store a pointer to it. We will later access it
+// to get the set of suspense boundaries that need to resolve before the
+// tracing marker can be logged as complete
+// This code lives separate from the ReactFiberTransition code because
+// we push and pop on the tracing marker, not the suspense boundary
 
-    var localId = localIdCounter++;
+var markerInstanceStack = createCursor(null);
+function pushRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    // On the root, every transition gets mapped to it's own map of
+    // suspense boundaries. The transition is marked as complete when
+    // the suspense boundaries map is empty. We do this because every
+    // transition completes at different times and depends on different
+    // suspense boundaries to complete. We store all the transitions
+    // along with its map of suspense boundaries in the root incomplete
+    // transitions map. Each entry in this map functions like a tracing
+    // marker does, so we can push it onto the marker instance stack
+    var transitions = getWorkInProgressTransitions();
+    var root = workInProgress.stateNode;
 
-    if (localId > 0) {
-      id += "H" + localId.toString(32);
+    if (transitions !== null) {
+      transitions.forEach(function (transition) {
+        if (!root.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: TransitionRoot,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root.incompleteTransitions.set(transition, markerInstance);
+        }
+      });
     }
 
-    id += ":";
-  } else {
-    // Use a lowercase r prefix for client-generated ids.
-    var globalClientId = globalClientIdCounter++;
-    id = ":" + identifierPrefix + "r" + globalClientId.toString(32) + ":";
-  }
+    var markerInstances = []; // For ever transition on the suspense boundary, we push the transition
+    // along with its map of pending suspense boundaries onto the marker
+    // instance stack.
 
-  hook.memoizedState = id;
-  return id;
+    root.incompleteTransitions.forEach(function (markerInstance) {
+      markerInstances.push(markerInstance);
+    });
+    push(markerInstanceStack, markerInstances, workInProgress);
+  }
 }
-
-function updateId() {
-  var hook = updateWorkInProgressHook();
-  var id = hook.memoizedState;
-  return id;
+function popRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
+  }
 }
-
-function mountRefresh() {
-  var hook = mountWorkInProgressHook();
-  var refresh = (hook.memoizedState = refreshCache.bind(
-    null,
-    currentlyRenderingFiber$1
-  ));
-  return refresh;
+function pushMarkerInstance(workInProgress, markerInstance) {
+  if (enableTransitionTracing) {
+    if (markerInstanceStack.current === null) {
+      push(markerInstanceStack, [markerInstance], workInProgress);
+    } else {
+      push(
+        markerInstanceStack,
+        markerInstanceStack.current.concat(markerInstance),
+        workInProgress
+      );
+    }
+  }
 }
-
-function updateRefresh() {
-  var hook = updateWorkInProgressHook();
-  return hook.memoizedState;
+function popMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
+  }
 }
+function getMarkerInstances() {
+  if (enableTransitionTracing) {
+    return markerInstanceStack.current;
+  }
 
-function refreshCache(fiber, seedKey, seedValue) {
-  // TODO: Consider warning if the refresh is at discrete priority, or if we
-  // otherwise suspect that it wasn't batched properly.
-
-  var provider = fiber.return;
+  return null;
+}
 
-  while (provider !== null) {
-    switch (provider.tag) {
-      case CacheComponent:
-      case HostRoot: {
-        // Schedule an update on the cache boundary to trigger a refresh.
-        var lane = requestUpdateLane(provider);
-        var refreshUpdate = createUpdate(lane);
-        var root = enqueueUpdate(provider, refreshUpdate, lane);
+var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
 
-        if (root !== null) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, provider, lane, eventTime);
-          entangleTransitions(root, provider, lane);
-        } // TODO: If a refresh never commits, the new cache created here must be
-        // released. A simple case is start refreshing a cache boundary, but then
-        // unmount that boundary before the refresh completes.
+var SelectiveHydrationException = new Error(
+  "This is not a real error. It's an implementation detail of React's " +
+    "selective hydration feature. If this leaks into userspace, it's a bug in " +
+    "React. Please file an issue."
+);
+var didReceiveUpdate = false;
+var didWarnAboutBadClass;
+var didWarnAboutModulePatternComponent;
+var didWarnAboutContextTypeOnFunctionComponent;
+var didWarnAboutGetDerivedStateOnFunctionComponent;
+var didWarnAboutFunctionRefs;
+var didWarnAboutReassigningProps;
+var didWarnAboutRevealOrder;
+var didWarnAboutTailOptions;
+var didWarnAboutDefaultPropsOnFunctionComponent;
 
-        var seededCache = createCache();
+{
+  didWarnAboutBadClass = {};
+  didWarnAboutModulePatternComponent = {};
+  didWarnAboutContextTypeOnFunctionComponent = {};
+  didWarnAboutGetDerivedStateOnFunctionComponent = {};
+  didWarnAboutFunctionRefs = {};
+  didWarnAboutReassigningProps = false;
+  didWarnAboutRevealOrder = {};
+  didWarnAboutTailOptions = {};
+  didWarnAboutDefaultPropsOnFunctionComponent = {};
+}
 
-        if (seedKey !== null && seedKey !== undefined && root !== null) {
-          {
-            // Seed the cache with the value passed by the caller. This could be
-            // from a server mutation, or it could be a streaming response.
-            seededCache.data.set(seedKey, seedValue);
-          }
-        }
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === 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
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      current.child,
+      nextChildren,
+      renderLanes
+    );
+  }
+}
 
-        var payload = {
-          cache: seededCache
-        };
-        refreshUpdate.payload = payload;
-        return;
-      }
-    }
+function forceUnmountCurrentAndReconcile(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes
+) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(
+    workInProgress,
+    current.child,
+    null,
+    renderLanes
+  ); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
 
-    provider = provider.return;
-  } // TODO: Warn if unmounted?
+  workInProgress.child = reconcileChildFibers(
+    workInProgress,
+    null,
+    nextChildren,
+    renderLanes
+  );
 }
 
-function dispatchReducerAction(fiber, queue, action) {
+function updateForwardRef(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  // TODO: current can be non-null here even if the component
+  // hasn't yet mounted. This happens after the first render suspends.
+  // We'll need to figure out if this is fine or can cause issues.
   {
-    if (typeof arguments[3] === "function") {
-      error(
-        "State updates from the useState() and useReducer() Hooks don't support the " +
-          "second callback argument. To execute a side effect after " +
-          "rendering, declare it in the component body with useEffect()."
-      );
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
+
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
+        );
+      }
     }
   }
 
-  var lane = requestUpdateLane(fiber);
-  var update = {
-    lane: lane,
-    action: action,
-    hasEagerState: false,
-    eagerState: null,
-    next: null
-  };
+  var render = Component.render;
+  var ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
 
-  if (isRenderPhaseUpdate(fiber)) {
-    enqueueRenderPhaseUpdate(queue, update);
-  } else {
-    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+  var nextChildren;
+  var hasId;
+  prepareToReadContext(workInProgress, renderLanes);
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitionUpdate(root, queue, lane);
-    }
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
   }
 
-  markUpdateInDevTools(fiber, lane, action);
-}
-
-function dispatchSetState(fiber, queue, action) {
   {
-    if (typeof arguments[3] === "function") {
-      error(
-        "State updates from the useState() and useReducer() Hooks don't support the " +
-          "second callback argument. To execute a side effect after " +
-          "rendering, declare it in the component body with useEffect()."
-      );
-    }
+    ReactCurrentOwner$2.current = workInProgress;
+    setIsRendering(true);
+    nextChildren = renderWithHooks(
+      current,
+      workInProgress,
+      render,
+      nextProps,
+      ref,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
   }
 
-  var lane = requestUpdateLane(fiber);
-  var update = {
-    lane: lane,
-    action: action,
-    hasEagerState: false,
-    eagerState: null,
-    next: null
-  };
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
 
-  if (isRenderPhaseUpdate(fiber)) {
-    enqueueRenderPhaseUpdate(queue, update);
-  } else {
-    var alternate = fiber.alternate;
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (current === null) {
+    var type = Component.type;
 
     if (
-      fiber.lanes === NoLanes &&
-      (alternate === null || alternate.lanes === NoLanes)
+      isSimpleFunctionComponent(type) &&
+      Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+      Component.defaultProps === undefined
     ) {
-      // The queue is currently empty, which means we can eagerly compute the
-      // next state before entering the render phase. If the new state is the
-      // same as the current state, we may be able to bail out entirely.
-      var lastRenderedReducer = queue.lastRenderedReducer;
+      var resolvedType = type;
 
-      if (lastRenderedReducer !== null) {
-        var prevDispatcher;
+      {
+        resolvedType = resolveFunctionForHotReloading(type);
+      } // If this is a plain function component without default props,
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
 
-        {
-          prevDispatcher = ReactCurrentDispatcher$1.current;
-          ReactCurrentDispatcher$1.current =
-            InvalidNestedHooksDispatcherOnUpdateInDEV;
-        }
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
 
-        try {
-          var currentState = queue.lastRenderedState;
-          var eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
-          // it, on the update object. If the reducer hasn't changed by the
-          // time we enter the render phase, then the eager state can be used
-          // without calling the reducer again.
+      {
+        validateFunctionComponentInDev(workInProgress, type);
+      }
 
-          update.hasEagerState = true;
-          update.eagerState = eagerState;
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        resolvedType,
+        nextProps,
+        renderLanes
+      );
+    }
 
-          if (objectIs(eagerState, currentState)) {
-            // Fast path. We can bail out without scheduling React to re-render.
-            // It's still possible that we'll need to rebase this update later,
-            // if the component re-renders for a different reason and by that
-            // time the reducer has changed.
-            // TODO: Do we still need to entangle transitions in this case?
-            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
-            return;
-          }
-        } catch (error) {
-          // Suppress the error. It will throw again in the render phase.
-        } finally {
-          {
-            ReactCurrentDispatcher$1.current = prevDispatcher;
-          }
+    {
+      var innerPropTypes = type.propTypes;
+
+      if (innerPropTypes) {
+        // Inner memo component props aren't currently validated in createElement.
+        // We could move it there, but we'd still need this for lazy code path.
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(type)
+        );
+      }
+
+      if (Component.defaultProps !== undefined) {
+        var componentName = getComponentNameFromType(type) || "Unknown";
+
+        if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
+          error(
+            "%s: Support for defaultProps will be removed from memo components " +
+              "in a future major release. Use JavaScript default parameters instead.",
+            componentName
+          );
+
+          didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
         }
       }
     }
 
-    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+    var child = createFiberFromTypeAndProps(
+      Component.type,
+      null,
+      nextProps,
+      workInProgress,
+      workInProgress.mode,
+      renderLanes
+    );
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitionUpdate(root, queue, lane);
+  {
+    var _type = Component.type;
+    var _innerPropTypes = _type.propTypes;
+
+    if (_innerPropTypes) {
+      // Inner memo component props aren't currently validated in createElement.
+      // We could move it there, but we'd still need this for lazy code path.
+      checkPropTypes(
+        _innerPropTypes,
+        nextProps, // Resolved props
+        "prop",
+        getComponentNameFromType(_type)
+      );
     }
   }
 
-  markUpdateInDevTools(fiber, lane, action);
-}
+  var currentChild = current.child; // This is always exactly one child
 
-function isRenderPhaseUpdate(fiber) {
-  var alternate = fiber.alternate;
-  return (
-    fiber === currentlyRenderingFiber$1 ||
-    (alternate !== null && alternate === currentlyRenderingFiber$1)
+  var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
+    current,
+    renderLanes
   );
-}
 
-function enqueueRenderPhaseUpdate(queue, update) {
-  // This is a render phase update. Stash it in a lazily-created map of
-  // queue -> linked list of updates. After this render pass, we'll restart
-  // and apply the stashed updates on top of the work-in-progress hook.
-  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
-    true;
-  var pending = queue.pending;
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    var prevProps = currentChild.memoizedProps; // Default to shallow comparison
 
-  if (pending === null) {
-    // This is the first update. Create a circular list.
-    update.next = update;
-  } else {
-    update.next = pending.next;
-    pending.next = update;
-  }
+    var compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
 
-  queue.pending = update;
-} // TODO: Move to ReactFiberConcurrentUpdates?
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+  } // React DevTools reads this flag.
 
-function entangleTransitionUpdate(root, queue, lane) {
-  if (isTransitionLane(lane)) {
-    var queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
-    // must have finished. We can remove them from the shared queue, which
-    // represents a superset of the actually pending lanes. In some cases we
-    // may entangle more than we need to, but that's OK. In fact it's worse if
-    // we *don't* entangle when we should.
+  workInProgress.flags |= PerformedWork;
+  var newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
 
-    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+function updateSimpleMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  // TODO: current can be non-null here even if the component
+  // hasn't yet mounted. This happens when the inner render suspends.
+  // We'll need to figure out if this is fine or can cause issues.
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var outerMemoType = workInProgress.elementType;
 
-    var newQueueLanes = mergeLanes(queueLanes, lane);
-    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
-    // the lane finished since the last time we entangled it. So we need to
-    // entangle it again, just to be sure.
+      if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
+        // We warn when you define propTypes on lazy()
+        // so let's just skip over it to find memo() outer wrapper.
+        // Inner props for memo are validated later.
+        var lazyComponent = outerMemoType;
+        var payload = lazyComponent._payload;
+        var init = lazyComponent._init;
 
-    markRootEntangled(root, newQueueLanes);
-  }
-}
+        try {
+          outerMemoType = init(payload);
+        } catch (x) {
+          outerMemoType = null;
+        } // Inner propTypes will be validated in the function component path.
 
-function markUpdateInDevTools(fiber, lane, action) {
-  {
-    if (enableDebugTracing) {
-      if (fiber.mode & DebugTracingMode) {
-        var name = getComponentNameFromFiber(fiber) || "Unknown";
-        logStateUpdateScheduled(name, lane, action);
+        var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+
+        if (outerPropTypes) {
+          checkPropTypes(
+            outerPropTypes,
+            nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
+            "prop",
+            getComponentNameFromType(outerMemoType)
+          );
+        }
       }
     }
   }
 
-  if (enableSchedulingProfiler) {
-    markStateUpdateScheduled(fiber, lane);
+  if (current !== null) {
+    var prevProps = current.memoizedProps;
+
+    if (
+      shallowEqual(prevProps, nextProps) &&
+      current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
+      workInProgress.type === current.type
+    ) {
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
+
+      workInProgress.pendingProps = nextProps = prevProps;
+
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      }
+    }
   }
+
+  return updateFunctionComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    renderLanes
+  );
 }
 
-var ContextOnlyDispatcher = {
-  readContext: readContext,
-  useCallback: throwInvalidHookError,
-  useContext: throwInvalidHookError,
-  useEffect: throwInvalidHookError,
-  useImperativeHandle: throwInvalidHookError,
-  useInsertionEffect: throwInvalidHookError,
-  useLayoutEffect: throwInvalidHookError,
-  useMemo: throwInvalidHookError,
-  useReducer: throwInvalidHookError,
-  useRef: throwInvalidHookError,
-  useState: throwInvalidHookError,
-  useDebugValue: throwInvalidHookError,
-  useDeferredValue: throwInvalidHookError,
-  useTransition: throwInvalidHookError,
-  useMutableSource: throwInvalidHookError,
-  useSyncExternalStore: throwInvalidHookError,
-  useId: throwInvalidHookError
-};
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  var nextIsDetached =
+    (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  var prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
 
-{
-  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
-}
+  if (
+    nextProps.mode === "hidden" ||
+    nextProps.mode === "unstable-defer-without-hiding" ||
+    nextIsDetached
+  ) {
+    // Rendering a hidden tree.
+    var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-{
-  ContextOnlyDispatcher.use = throwInvalidHookError;
-}
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      var nextBaseLanes =
+        prevState !== null
+          ? mergeLanes(prevState.baseLanes, renderLanes)
+          : renderLanes;
 
-{
-  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
-}
+      if (current !== null) {
+        // Reset to the current children
+        var currentChild = (workInProgress.child = current.child); // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
 
-{
-  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
-}
+        var currentChildLanes = NoLanes;
 
-var HooksDispatcherOnMountInDEV = null;
-var HooksDispatcherOnMountWithHookTypesInDEV = null;
-var HooksDispatcherOnUpdateInDEV = null;
-var HooksDispatcherOnRerenderInDEV = null;
-var InvalidNestedHooksDispatcherOnMountInDEV = null;
-var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
-var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(
+            mergeLanes(currentChildLanes, currentChild.lanes),
+            currentChild.childLanes
+          );
+          currentChild = currentChild.sibling;
+        }
 
-{
-  var warnInvalidContextAccess = function () {
-    error(
-      "Context can only be read while React is rendering. " +
-        "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-        "In function components, you can read it directly in the function body, but not " +
-        "inside Hooks like useReducer() or useMemo()."
-    );
-  };
+        var lanesWeJustAttempted = nextBaseLanes;
+        var remainingChildLanes = removeLanes(
+          currentChildLanes,
+          lanesWeJustAttempted
+        );
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
+      }
 
-  var warnInvalidHookAccess = function () {
-    error(
-      "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " +
-        "You can only call Hooks at the top level of your React function. " +
-        "For more information, see " +
-        "https://reactjs.org/link/rules-of-hooks"
-    );
-  };
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        nextBaseLanes,
+        renderLanes
+      );
+    }
 
-  HooksDispatcherOnMountInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      mountHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      var nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null, null);
+        }
       }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      reuseHiddenContextOnStack(workInProgress);
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes =
+        laneToLanes(OffscreenLane); // Include the base lanes from the last render
+
+      var _nextBaseLanes =
+        prevState !== null
+          ? mergeLanes(prevState.baseLanes, renderLanes)
+          : renderLanes;
+
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        _nextBaseLanes,
+        renderLanes
+      );
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      var _nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = _nextState;
+
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        var prevCachePool = prevState !== null ? prevState.cachePool : null; // TODO: Consider if and how Offscreen pre-rendering should
+        // be attributed to the transition that spawned it
+
+        pushTransition(workInProgress, prevCachePool, null);
+      } // Push the lanes that were skipped when we bailed out.
+
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack(workInProgress);
       }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      mountHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      pushOffscreenSuspenseHandler(workInProgress);
+    }
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      var _prevCachePool = null;
+
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        _prevCachePool = prevState.cachePool;
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      mountHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      mountHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      mountHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      mountHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      mountHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      mountHookTypesDev();
-      return mountId();
+
+      var transitions = null;
+
+      if (enableTransitionTracing) {
+        // We have now gone from hidden to visible, so any transitions should
+        // be added to the stack to get added to any Offscreen/suspense children
+        var instance = workInProgress.stateNode;
+
+        if (instance !== null && instance._transitions != null) {
+          transitions = Array.from(instance._transitions);
+        }
+      }
+
+      pushTransition(workInProgress, _prevCachePool, transitions); // Push the lanes that were skipped when we bailed out.
+
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
+
+      reuseHiddenContextOnStack(workInProgress);
+      reuseSuspenseHandlerOnStack(workInProgress);
     }
+  }
+
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
+  var nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache()
   };
+  workInProgress.memoizedState = nextState;
 
   {
-    HooksDispatcherOnMountInDEV.useCacheRefresh = function useCacheRefresh() {
-      currentHookNameInDev = "useCacheRefresh";
-      mountHookTypesDev();
-      return mountRefresh();
-    };
-  }
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
 
-  {
-    HooksDispatcherOnMountInDEV.use = use;
-  }
+  reuseHiddenContextOnStack(workInProgress);
+  pushOffscreenSuspenseHandler(workInProgress);
 
-  {
-    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
+  if (enableLazyContextPropagation && current !== null) {
+    // Since this tree will resume rendering in a separate render, we need
+    // to propagate parent contexts now so we don't lose track of which
+    // ones changed.
+    propagateParentContextChangesToDeferredTree(
+      current,
+      workInProgress,
+      renderLanes
+    );
   }
 
-  {
-    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      mountHookTypesDev();
-      return mountEvent(callback);
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+// ourselves to this constraint, though. If the behavior diverges, we should
+// fork the function.
+
+var updateLegacyHiddenComponent = updateOffscreenComponent;
+
+function updateCacheComponent(current, workInProgress, renderLanes) {
+  prepareToReadContext(workInProgress, renderLanes);
+  var parentCache = readContext(CacheContext);
+
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    var freshCache = requestCacheFromPool(renderLanes);
+    var initialState = {
+      parent: parentCache,
+      cache: freshCache
     };
-  }
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
+    }
 
-  HooksDispatcherOnMountWithHookTypesInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+    var prevState = current.memoizedState;
+    var nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      var derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      workInProgress.memoizedState = derivedState;
+
+      if (workInProgress.lanes === NoLanes) {
+        var updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
       }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      var nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
+
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return mountId();
     }
-  };
-
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return mountRefresh();
-      };
   }
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.use = use;
-  }
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
-  }
+function updateTracingMarkerComponent(current, workInProgress, renderLanes) {
+  if (!enableTransitionTracing) {
+    return null;
+  } // TODO: (luna) Only update the tracing marker if it's newly rendered or it's name changed.
+  // A tracing marker is only associated with the transitions that rendered
+  // or updated it, so we can create a new set of transitions each time
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        updateHookTypesDev();
-        return mountEvent(callback);
+  if (current === null) {
+    var currentTransitions = getPendingTransitions();
+
+    if (currentTransitions !== null) {
+      var markerInstance = {
+        tag: TransitionTracingMarker,
+        transitions: new Set(currentTransitions),
+        pendingBoundaries: null,
+        name: workInProgress.pendingProps.name,
+        aborts: null
       };
+      workInProgress.stateNode = markerInstance; // We call the marker complete callback when all child suspense boundaries resolve.
+      // We do this in the commit phase on Offscreen. If the marker has no child suspense
+      // boundaries, we need to schedule a passive effect to make sure we call the marker
+      // complete callback.
+
+      workInProgress.flags |= Passive$1;
+    }
+  } else {
+    {
+      if (current.memoizedProps.name !== workInProgress.pendingProps.name) {
+        error(
+          "Changing the name of a tracing marker after mount is not supported. " +
+            "To remount the tracing marker, pass it a new key."
+        );
+      }
+    }
   }
 
-  HooksDispatcherOnUpdateInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  var instance = workInProgress.stateNode;
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  if (instance !== null) {
+    pushMarkerInstance(workInProgress, instance);
+  }
 
-      try {
-        return updateReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-      try {
-        return updateState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return updateDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return updateTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return updateId();
-    }
-  };
+function updateFragment(current, workInProgress, renderLanes) {
+  var nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  {
-    HooksDispatcherOnUpdateInDEV.useCacheRefresh = function useCacheRefresh() {
-      currentHookNameInDev = "useCacheRefresh";
-      updateHookTypesDev();
-      return updateRefresh();
-    };
-  }
+function updateMode(current, workInProgress, renderLanes) {
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
+function updateProfiler(current, workInProgress, renderLanes) {
   {
-    HooksDispatcherOnUpdateInDEV.use = use;
-  }
+    workInProgress.flags |= Update;
 
-  {
-    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
+    {
+      // Reset effect durations for the next eventual effect phase.
+      // These are reset during render to allow the DevTools commit hook a chance to read them,
+      var stateNode = workInProgress.stateNode;
+      stateNode.effectDuration = 0;
+      stateNode.passiveEffectDuration = 0;
+    }
   }
 
-  {
-    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      updateHookTypesDev();
-      return updateEvent(callback);
-    };
-  }
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  HooksDispatcherOnRerenderInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+function markRef$1(current, workInProgress) {
+  var ref = workInProgress.ref;
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+  if (
+    (current === null && ref !== null) ||
+    (current !== null && current.ref !== ref)
+  ) {
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
 
-      try {
-        return rerenderReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+function updateFunctionComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
 
-      try {
-        return rerenderState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
+        );
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return rerenderDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return rerenderTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return updateId();
     }
-  };
+  }
+
+  var context;
 
   {
-    HooksDispatcherOnRerenderInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
+    var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+    context = getMaskedContext(workInProgress, unmaskedContext);
   }
 
-  {
-    HooksDispatcherOnRerenderInDEV.use = use;
+  var nextChildren;
+  var hasId;
+  prepareToReadContext(workInProgress, renderLanes);
+
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
   }
 
   {
-    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
+    ReactCurrentOwner$2.current = workInProgress;
+    setIsRendering(true);
+    nextChildren = renderWithHooks(
+      current,
+      workInProgress,
+      Component,
+      nextProps,
+      context,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
   }
 
-  {
-    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      updateHookTypesDev();
-      return updateEvent(callback);
-    };
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
   }
 
-  InvalidNestedHooksDispatcherOnMountInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountId();
-    }
-  };
+function replayFunctionComponent(
+  current,
+  workInProgress,
+  nextProps,
+  Component,
+  renderLanes
+) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  var context;
 
   {
-    InvalidNestedHooksDispatcherOnMountInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        mountHookTypesDev();
-        return mountRefresh();
-      };
+    var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+    context = getMaskedContext(workInProgress, unmaskedContext);
   }
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
+  prepareToReadContext(workInProgress, renderLanes);
+
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
   }
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
+  var nextChildren = replaySuspendedComponentWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    context
+  );
+  var hasId = checkDidRenderIdHook();
+
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
   }
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        mountHookTypesDev();
-        return mountEvent(callback);
-      };
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
 
-  InvalidNestedHooksDispatcherOnUpdateInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateClassComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  {
+    // This is used by DevTools to force a boundary to error.
+    switch (shouldError(workInProgress)) {
+      case false: {
+        var _instance = workInProgress.stateNode;
+        var ctor = workInProgress.type; // TODO This way of resetting the error boundary state is a hack.
+        // Is there a better way to do this?
+
+        var tempInstance = new ctor(
+          workInProgress.memoizedProps,
+          _instance.context
+        );
+        var state = tempInstance.state;
+
+        _instance.updater.enqueueSetState(_instance, state, null);
+
+        break;
       }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      try {
-        return updateReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      case true: {
+        workInProgress.flags |= DidCapture;
+        workInProgress.flags |= ShouldCapture; // eslint-disable-next-line react-internal/prod-error-codes
+
+        var error$1 = new Error("Simulated error coming from DevTools");
+        var lane = pickArbitraryLane(renderLanes);
+        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+
+        var update = createClassErrorUpdate(
+          workInProgress,
+          createCapturedValueAtFiber(error$1, workInProgress),
+          lane
+        );
+        enqueueCapturedUpdate(workInProgress, update);
+        break;
       }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+    }
 
-      try {
-        return updateState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
+
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
+        );
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateId();
     }
-  };
+  } // 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.
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
-  }
+  var hasContext;
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
   }
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
+  prepareToReadContext(workInProgress, renderLanes);
+  var instance = workInProgress.stateNode;
+  var shouldUpdate;
+
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(
+      workInProgress,
+      Component,
+      nextProps,
+      renderLanes
+    );
+  } else {
+    shouldUpdate = updateClassInstance(
+      current,
+      workInProgress,
+      Component,
+      nextProps,
+      renderLanes
+    );
   }
 
+  var nextUnitOfWork = finishClassComponent(
+    current,
+    workInProgress,
+    Component,
+    shouldUpdate,
+    hasContext,
+    renderLanes
+  );
+
   {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        updateHookTypesDev();
-        return updateEvent(callback);
-      };
+    var inst = workInProgress.stateNode;
+
+    if (shouldUpdate && inst.props !== nextProps) {
+      if (!didWarnAboutReassigningProps) {
+        error(
+          "It looks like %s is reassigning its own `this.props` while rendering. " +
+            "This is not supported and can lead to confusing bugs.",
+          getComponentNameFromFiber(workInProgress) || "a component"
+        );
+      }
+
+      didWarnAboutReassigningProps = true;
+    }
   }
 
-  InvalidNestedHooksDispatcherOnRerenderInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  return nextUnitOfWork;
+}
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+function finishClassComponent(
+  current,
+  workInProgress,
+  Component,
+  shouldUpdate,
+  hasContext,
+  renderLanes
+) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  var didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-      try {
-        return rerenderReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+  if (!shouldUpdate && !didCaptureError) {
+    // Context providers should defer to sCU for rendering
+    if (hasContext) {
+      invalidateContextProvider(workInProgress, Component, false);
+    }
+
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+
+  var instance = workInProgress.stateNode; // Rerender
+
+  ReactCurrentOwner$2.current = workInProgress;
+  var nextChildren;
+
+  if (
+    didCaptureError &&
+    typeof Component.getDerivedStateFromError !== "function"
+  ) {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
+
+    {
+      stopProfilerTimerIfRunning();
+    }
+  } else {
+    if (enableSchedulingProfiler) {
+      markComponentRenderStarted(workInProgress);
+    }
+
+    {
+      setIsRendering(true);
+      nextChildren = instance.render();
+
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
+
+        try {
+          instance.render();
+        } finally {
+          setIsStrictModeForDevtools(false);
+        }
       }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      try {
-        return rerenderState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      setIsRendering(false);
+    }
+
+    if (enableSchedulingProfiler) {
+      markComponentRenderStopped();
+    }
+  } // React DevTools reads this flag.
+
+  workInProgress.flags |= PerformedWork;
+
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(
+      current,
+      workInProgress,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
+
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+
+  if (hasContext) {
+    invalidateContextProvider(workInProgress, Component, true);
+  }
+
+  return workInProgress.child;
+}
+
+function pushHostRootContext(workInProgress) {
+  var root = workInProgress.stateNode;
+
+  if (root.pendingContext) {
+    pushTopLevelContextObject(
+      workInProgress,
+      root.pendingContext,
+      root.pendingContext !== root.context
+    );
+  } else if (root.context) {
+    // Should always be set
+    pushTopLevelContextObject(workInProgress, root.context, false);
+  }
+
+  pushHostContainer(workInProgress, root.containerInfo);
+}
+
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
+
+  if (current === null) {
+    throw new Error("Should have a current fiber. This is a bug in React.");
+  }
+
+  var nextProps = workInProgress.pendingProps;
+  var prevState = workInProgress.memoizedState;
+  var prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  var nextState = workInProgress.memoizedState;
+  var root = workInProgress.stateNode;
+  pushRootTransition(workInProgress);
+
+  if (enableTransitionTracing) {
+    pushRootMarkerInstance(workInProgress);
+  }
+
+  {
+    var nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
+
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
+    }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
+
+  var nextChildren = nextState.element;
+
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    var overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    var updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
+
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
+
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      var recoverableError = createCapturedValueAtFiber(
+        new Error(
+          "There was an error while hydrating. Because the error happened outside " +
+            "of a Suspense boundary, the entire root will switch to " +
+            "client rendering."
+        ),
+        workInProgress
+      );
+      return mountHostRootWithoutHydrating(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes,
+        recoverableError
+      );
+    } else if (nextChildren !== prevChildren) {
+      var _recoverableError = createCapturedValueAtFiber(
+        new Error(
+          "This root received an early update, before anything was able " +
+            "hydrate. Switched the entire root to client rendering."
+        ),
+        workInProgress
+      );
+
+      return mountHostRootWithoutHydrating(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes,
+        _recoverableError
+      );
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
+
+      {
+        var mutableSourceEagerHydrationData =
+          root.mutableSourceEagerHydrationData;
+
+        if (mutableSourceEagerHydrationData != null) {
+          for (var i = 0; i < mutableSourceEagerHydrationData.length; i += 2) {
+            var mutableSource = mutableSourceEagerHydrationData[i];
+            var version = mutableSourceEagerHydrationData[i + 1];
+            setWorkInProgressVersion(mutableSource, version);
+          }
+        }
+      }
+
+      var child = mountChildFibers(
+        workInProgress,
+        null,
+        nextChildren,
+        renderLanes
+      );
+      workInProgress.child = child;
+      var node = child;
+
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = (node.flags & ~Placement) | Hydrating;
+        node = node.sibling;
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return rerenderDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return rerenderTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateId();
     }
-  };
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
+
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  return workInProgress.child;
+}
+
+function mountHostRootWithoutHydrating(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes,
+  recoverableError
+) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
+
+  var type = workInProgress.type;
+  var nextProps = workInProgress.pendingProps;
+  var prevProps = current !== null ? current.memoizedProps : null;
+  var nextChildren = nextProps.children;
+  var isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } 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.flags |= ContentReset;
+  }
+
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  var currentProps = current === null ? null : current.memoizedProps;
+  var resource = (workInProgress.memoizedState = getResource(
+    workInProgress.type,
+    currentProps,
+    workInProgress.pendingProps
+  ));
+
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(
+        workInProgress.type,
+        workInProgress.pendingProps,
+        getRootHostContainer(),
+        workInProgress
+      );
+    }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
+
+  return null;
+}
+
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
+  }
+
+  var nextChildren = workInProgress.pendingProps.children;
+
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
+
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
+
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
+
+  return null;
+}
+
+function mountLazyComponent(
+  _current,
+  workInProgress,
+  elementType,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  var props = workInProgress.pendingProps;
+  var lazyComponent = elementType;
+  var payload = lazyComponent._payload;
+  var init = lazyComponent._init;
+  var Component = init(payload); // Store the unwrapped component in the type.
+
+  workInProgress.type = Component;
+  var resolvedTag = (workInProgress.tag = resolveLazyComponentTag(Component));
+  var resolvedProps = resolveDefaultProps(Component, props);
+  var child;
+
+  switch (resolvedTag) {
+    case FunctionComponent: {
+      {
+        validateFunctionComponentInDev(workInProgress, Component);
+        workInProgress.type = Component =
+          resolveFunctionForHotReloading(Component);
+      }
+
+      child = updateFunctionComponent(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
+    }
+
+    case ClassComponent: {
+      {
+        workInProgress.type = Component =
+          resolveClassForHotReloading(Component);
+      }
+
+      child = updateClassComponent(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
+    }
+
+    case ForwardRef: {
+      {
+        workInProgress.type = Component =
+          resolveForwardRefForHotReloading(Component);
+      }
+
+      child = updateForwardRef(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
+    }
+
+    case MemoComponent: {
+      {
+        if (workInProgress.type !== workInProgress.elementType) {
+          var outerPropTypes = Component.propTypes;
+
+          if (outerPropTypes) {
+            checkPropTypes(
+              outerPropTypes,
+              resolvedProps, // Resolved for outer only
+              "prop",
+              getComponentNameFromType(Component)
+            );
+          }
+        }
+      }
+
+      child = updateMemoComponent(
+        null,
+        workInProgress,
+        Component,
+        resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes
+      );
+      return child;
+    }
+  }
+
+  var hint = "";
+
+  {
+    if (
+      Component !== null &&
+      typeof Component === "object" &&
+      Component.$$typeof === REACT_LAZY_TYPE
+    ) {
+      hint = " Did you wrap a component in React.lazy() more than once?";
+    }
+  } // This message intentionally doesn't mention ForwardRef or MemoComponent
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
+
+  throw new Error(
+    "Element type is invalid. Received a promise that resolves to: " +
+      Component +
+      ". " +
+      ("Lazy element type must resolve to a class or function." + hint)
+  );
+}
+
+function mountIncompleteClassComponent(
+  _current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // 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;
+
+  if (isContextProvider(Component)) {
+    hasContext = true;
+    pushContextProvider(workInProgress);
+  } else {
+    hasContext = false;
+  }
+
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(
+    null,
+    workInProgress,
+    Component,
+    true,
+    hasContext,
+    renderLanes
+  );
+}
+
+function mountIndeterminateComponent(
+  _current,
+  workInProgress,
+  Component,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  var props = workInProgress.pendingProps;
+  var context;
 
   {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
+    var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+    context = getMaskedContext(workInProgress, unmaskedContext);
   }
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
-  }
+  prepareToReadContext(workInProgress, renderLanes);
+  var value;
+  var hasId;
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
   }
 
   {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        updateHookTypesDev();
-        return updateEvent(callback);
-      };
-  }
-}
+    if (
+      Component.prototype &&
+      typeof Component.prototype.render === "function"
+    ) {
+      var componentName = getComponentNameFromType(Component) || "Unknown";
 
-var now = Scheduler.unstable_now;
-var commitTime = 0;
-var layoutEffectStartTime = -1;
-var profilerStartTime = -1;
-var passiveEffectStartTime = -1;
-/**
- * Tracks whether the current update was a nested/cascading update (scheduled from a layout effect).
- *
- * The overall sequence is:
- *   1. render
- *   2. commit (and call `onRender`, `onCommit`)
- *   3. check for nested updates
- *   4. flush passive effects (and call `onPostCommit`)
- *
- * Nested updates are identified in step 3 above,
- * but step 4 still applies to the work that was just committed.
- * We use two flags to track nested updates then:
- * one tracks whether the upcoming update is a nested update,
- * and the other tracks whether the current update was a nested update.
- * The first value gets synced to the second at the start of the render phase.
- */
+      if (!didWarnAboutBadClass[componentName]) {
+        error(
+          "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
+            "This is likely to cause errors. Change %s to extend React.Component instead.",
+          componentName,
+          componentName
+        );
 
-var currentUpdateIsNested = false;
-var nestedUpdateScheduled = false;
+        didWarnAboutBadClass[componentName] = true;
+      }
+    }
 
-function isCurrentUpdateNested() {
-  return currentUpdateIsNested;
-}
+    if (workInProgress.mode & StrictLegacyMode) {
+      ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+    }
 
-function markNestedUpdateScheduled() {
-  {
-    nestedUpdateScheduled = true;
+    setIsRendering(true);
+    ReactCurrentOwner$2.current = workInProgress;
+    value = renderWithHooks(
+      null,
+      workInProgress,
+      Component,
+      props,
+      context,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
   }
-}
 
-function resetNestedUpdateFlag() {
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
+  workInProgress.flags |= PerformedWork;
+
   {
-    currentUpdateIsNested = false;
-    nestedUpdateScheduled = false;
+    // Support for module components is deprecated and is removed behind a flag.
+    // Whether or not it would crash later, we want to show a good message in DEV first.
+    if (
+      typeof value === "object" &&
+      value !== null &&
+      typeof value.render === "function" &&
+      value.$$typeof === undefined
+    ) {
+      var _componentName = getComponentNameFromType(Component) || "Unknown";
+
+      if (!didWarnAboutModulePatternComponent[_componentName]) {
+        error(
+          "The <%s /> component appears to be a function component that returns a class instance. " +
+            "Change %s to a class that extends React.Component instead. " +
+            "If you can't use a class try assigning the prototype on the function as a workaround. " +
+            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
+            "cannot be called with `new` by React.",
+          _componentName,
+          _componentName,
+          _componentName
+        );
+
+        didWarnAboutModulePatternComponent[_componentName] = true;
+      }
+    }
   }
-}
 
-function syncNestedUpdateFlag() {
   {
-    currentUpdateIsNested = nestedUpdateScheduled;
-    nestedUpdateScheduled = false;
-  }
-}
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
 
-function getCommitTime() {
-  return commitTime;
-}
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
+    }
 
-function recordCommitTime() {
-  commitTime = now();
-}
+    reconcileChildren(null, workInProgress, value, renderLanes);
 
-function startProfilerTimer(fiber) {
-  profilerStartTime = now();
+    {
+      validateFunctionComponentInDev(workInProgress, Component);
+    }
 
-  if (fiber.actualStartTime < 0) {
-    fiber.actualStartTime = now();
+    return workInProgress.child;
   }
 }
 
-function stopProfilerTimerIfRunning(fiber) {
-  profilerStartTime = -1;
-}
+function validateFunctionComponentInDev(workInProgress, Component) {
+  {
+    if (Component) {
+      if (Component.childContextTypes) {
+        error(
+          "%s(...): childContextTypes cannot be defined on a function component.",
+          Component.displayName || Component.name || "Component"
+        );
+      }
+    }
 
-function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
-  if (profilerStartTime >= 0) {
-    var elapsedTime = now() - profilerStartTime;
-    fiber.actualDuration += elapsedTime;
+    if (workInProgress.ref !== null) {
+      var info = "";
+      var ownerName = getCurrentFiberOwnerNameInDevOrNull();
 
-    if (overrideBaseTime) {
-      fiber.selfBaseDuration = elapsedTime;
+      if (ownerName) {
+        info += "\n\nCheck the render method of `" + ownerName + "`.";
+      }
+
+      var warningKey = ownerName || "";
+      var debugSource = workInProgress._debugSource;
+
+      if (debugSource) {
+        warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
+      }
+
+      if (!didWarnAboutFunctionRefs[warningKey]) {
+        didWarnAboutFunctionRefs[warningKey] = true;
+
+        error(
+          "Function components cannot be given refs. " +
+            "Attempts to access this ref will fail. " +
+            "Did you mean to use React.forwardRef()?%s",
+          info
+        );
+      }
     }
 
-    profilerStartTime = -1;
-  }
-}
+    if (Component.defaultProps !== undefined) {
+      var componentName = getComponentNameFromType(Component) || "Unknown";
 
-function recordLayoutEffectDuration(fiber) {
-  if (layoutEffectStartTime >= 0) {
-    var elapsedTime = now() - layoutEffectStartTime;
-    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
-    // Or the root (for the DevTools Profiler to read)
+      if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
+        error(
+          "%s: Support for defaultProps will be removed from function components " +
+            "in a future major release. Use JavaScript default parameters instead.",
+          componentName
+        );
 
-    var parentFiber = fiber.return;
+        didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+      }
+    }
 
-    while (parentFiber !== null) {
-      switch (parentFiber.tag) {
-        case HostRoot:
-          var root = parentFiber.stateNode;
-          root.effectDuration += elapsedTime;
-          return;
+    if (typeof Component.getDerivedStateFromProps === "function") {
+      var _componentName3 = getComponentNameFromType(Component) || "Unknown";
 
-        case Profiler:
-          var parentStateNode = parentFiber.stateNode;
-          parentStateNode.effectDuration += elapsedTime;
-          return;
+      if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
+        error(
+          "%s: Function components do not support getDerivedStateFromProps.",
+          _componentName3
+        );
+
+        didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
       }
+    }
 
-      parentFiber = parentFiber.return;
+    if (
+      typeof Component.contextType === "object" &&
+      Component.contextType !== null
+    ) {
+      var _componentName4 = getComponentNameFromType(Component) || "Unknown";
+
+      if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
+        error(
+          "%s: Function components do not support contextType.",
+          _componentName4
+        );
+
+        didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
+      }
     }
   }
 }
 
-function recordPassiveEffectDuration(fiber) {
-  if (passiveEffectStartTime >= 0) {
-    var elapsedTime = now() - passiveEffectStartTime;
-    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
-    // Or the root (for the DevTools Profiler to read)
+var SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
 
-    var parentFiber = fiber.return;
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
 
-    while (parentFiber !== null) {
-      switch (parentFiber.tag) {
-        case HostRoot:
-          var root = parentFiber.stateNode;
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  var cachePool = null;
 
-          if (root !== null) {
-            root.passiveEffectDuration += elapsedTime;
-          }
+  {
+    var prevCachePool = prevOffscreenState.cachePool;
 
-          return;
+    if (prevCachePool !== null) {
+      var parentCache = CacheContext._currentValue;
 
-        case Profiler:
-          var parentStateNode = parentFiber.stateNode;
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
+      }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
+    }
+  }
 
-          if (parentStateNode !== null) {
-            // Detached fibers have their state node cleared out.
-            // In this case, the return pointer is also cleared out,
-            // so we won't be able to report the time spent in this Profiler's subtree.
-            parentStateNode.passiveEffectDuration += elapsedTime;
-          }
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool: cachePool
+  };
+} // TODO: Probably should inline this back
 
-          return;
-      }
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  if (current !== null) {
+    var suspenseState = current.memoizedState;
 
-      parentFiber = parentFiber.return;
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
     }
-  }
-}
+  } // Not currently showing content. Consult the Suspense context.
 
-function startLayoutEffectTimer() {
-  layoutEffectStartTime = now();
+  var suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
 }
 
-function startPassiveEffectTimer() {
-  passiveEffectStartTime = now();
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
 }
 
-function transferActualDuration(fiber) {
-  // Transfer time spent rendering these children so we don't lose it
-  // after we rerender. This is used as a helper in special cases
-  // where we should count the work of multiple passes.
-  var child = fiber.child;
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
 
-  while (child) {
-    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
-    fiber.actualDuration += child.actualDuration;
-    child = child.sibling;
+  {
+    if (shouldSuspend(workInProgress)) {
+      workInProgress.flags |= DidCapture;
+    }
   }
-}
 
-function resolveDefaultProps(Component, baseProps) {
-  if (Component && Component.defaultProps) {
-    // Resolve default props. Taken from ReactElement
-    var props = assign({}, baseProps);
-    var defaultProps = Component.defaultProps;
+  var showFallback = false;
+  var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-    for (var propName in defaultProps) {
-      if (props[propName] === undefined) {
-        props[propName] = defaultProps[propName];
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
+
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
       }
+
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+
+      var suspenseState = workInProgress.memoizedState;
+
+      if (suspenseState !== null) {
+        var dehydrated = suspenseState.dehydrated;
+
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
+
+      popSuspenseHandler(workInProgress);
     }
 
-    return props;
-  }
+    var nextPrimaryChildren = nextProps.children;
+    var nextFallbackChildren = nextProps.fallback;
 
-  return baseProps;
-}
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var fallbackFragment = mountSuspenseFallbackChildren(
+        workInProgress,
+        nextPrimaryChildren,
+        nextFallbackChildren,
+        renderLanes
+      );
+      var primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
 
-var fakeInternalInstance = {};
-var didWarnAboutStateAssignmentForComponent;
-var didWarnAboutUninitializedState;
-var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
-var didWarnAboutLegacyLifecyclesAndDerivedState;
-var didWarnAboutUndefinedDerivedState;
-var didWarnAboutDirectlyAssigningPropsToState;
-var didWarnAboutContextTypeAndContextTypes;
-var didWarnAboutInvalidateContextType;
-var didWarnOnInvalidCallback;
+      if (enableTransitionTracing) {
+        var currentTransitions = getPendingTransitions();
 
-{
-  didWarnAboutStateAssignmentForComponent = new Set();
-  didWarnAboutUninitializedState = new Set();
-  didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
-  didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
-  didWarnAboutDirectlyAssigningPropsToState = new Set();
-  didWarnAboutUndefinedDerivedState = new Set();
-  didWarnAboutContextTypeAndContextTypes = new Set();
-  didWarnAboutInvalidateContextType = new Set();
-  didWarnOnInvalidCallback = new Set(); // This is so gross but it's at least non-critical and can be removed if
-  // it causes problems. This is meant to give a nicer error message for
-  // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
-  // ...)) which otherwise throws a "_processChildContext is not a function"
-  // exception.
+        if (currentTransitions !== null) {
+          var parentMarkerInstances = getMarkerInstances();
+          var offscreenQueue = primaryChildFragment.updateQueue;
 
-  Object.defineProperty(fakeInternalInstance, "_processChildContext", {
-    enumerable: false,
-    value: function () {
-      throw new Error(
-        "_processChildContext is not available in React 16+. This likely " +
-          "means you have multiple copies of React and are attempting to nest " +
-          "a React 15 tree inside a React 16 tree using " +
-          "unstable_renderSubtreeIntoContainer, which isn't supported. Try " +
-          "to make sure you have only one copy of React (and ideally, switch " +
-          "to ReactDOM.createPortal)."
+          if (offscreenQueue === null) {
+            var newOffscreenQueue = {
+              transitions: currentTransitions,
+              markerInstances: parentMarkerInstances,
+              wakeables: null
+            };
+            primaryChildFragment.updateQueue = newOffscreenQueue;
+          } else {
+            offscreenQueue.transitions = currentTransitions;
+            offscreenQueue.markerInstances = parentMarkerInstances;
+          }
+        }
+      }
+
+      return fallbackFragment;
+    } else if (typeof nextProps.unstable_expectedLoadTime === "number") {
+      // This is a CPU-bound tree. Skip this tree and show a placeholder to
+      // unblock the surrounding content. Then immediately retry after the
+      // initial commit.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+
+      var _fallbackFragment = mountSuspenseFallbackChildren(
+        workInProgress,
+        nextPrimaryChildren,
+        nextFallbackChildren,
+        renderLanes
       );
-    }
-  });
-  Object.freeze(fakeInternalInstance);
-}
 
-function warnOnInvalidCallback$1(callback, callerName) {
-  {
-    if (callback === null || typeof callback === "function") {
-      return;
+      var _primaryChildFragment = workInProgress.child;
+      _primaryChildFragment.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
+      // Since nothing actually suspended, there will nothing to ping this to
+      // get it started back up to attempt the next item. While in terms of
+      // priority this work has the same priority as this current render, it's
+      // not part of the same transition once the transition has committed. If
+      // it's sync, we still want to yield so that it can be painted.
+      // Conceptually, this is really the same as pinging. We can use any
+      // RetryLane even if it's the one currently rendering since we're leaving
+      // it behind on this node.
+
+      workInProgress.lanes = SomeRetryLane;
+      return _fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
     }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    var prevState = current.memoizedState;
 
-    var key = callerName + "_" + callback;
+    if (prevState !== null) {
+      var _dehydrated = prevState.dehydrated;
 
-    if (!didWarnOnInvalidCallback.has(key)) {
-      didWarnOnInvalidCallback.add(key);
+      if (_dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(
+          current,
+          workInProgress,
+          didSuspend,
+          nextProps,
+          _dehydrated,
+          prevState,
+          renderLanes
+        );
+      }
+    }
 
-      error(
-        "%s(...): Expected the last optional `callback` argument to be a " +
-          "function. Instead received: %s.",
-        callerName,
-        callback
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var _nextFallbackChildren = nextProps.fallback;
+      var _nextPrimaryChildren = nextProps.children;
+      var fallbackChildFragment = updateSuspenseFallbackChildren(
+        current,
+        workInProgress,
+        _nextPrimaryChildren,
+        _nextFallbackChildren,
+        renderLanes
       );
-    }
-  }
-}
+      var _primaryChildFragment2 = workInProgress.child;
+      var prevOffscreenState = current.child.memoizedState;
+      _primaryChildFragment2.memoizedState =
+        prevOffscreenState === null
+          ? mountSuspenseOffscreenState(renderLanes)
+          : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
 
-function warnOnUndefinedDerivedState(type, partialState) {
-  {
-    if (partialState === undefined) {
-      var componentName = getComponentNameFromType(type) || "Component";
+      if (enableTransitionTracing) {
+        var _currentTransitions = getPendingTransitions();
 
-      if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
-        didWarnAboutUndefinedDerivedState.add(componentName);
+        if (_currentTransitions !== null) {
+          var _parentMarkerInstances = getMarkerInstances();
 
-        error(
-          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
-            "You have returned undefined.",
-          componentName
-        );
+          var _offscreenQueue = _primaryChildFragment2.updateQueue;
+          var currentOffscreenQueue = current.updateQueue;
+
+          if (_offscreenQueue === null) {
+            var _newOffscreenQueue = {
+              transitions: _currentTransitions,
+              markerInstances: _parentMarkerInstances,
+              wakeables: null
+            };
+            _primaryChildFragment2.updateQueue = _newOffscreenQueue;
+          } else if (_offscreenQueue === currentOffscreenQueue) {
+            // If the work-in-progress queue is the same object as current, we
+            // can't modify it without cloning it first.
+            var _newOffscreenQueue2 = {
+              transitions: _currentTransitions,
+              markerInstances: _parentMarkerInstances,
+              wakeables:
+                currentOffscreenQueue !== null
+                  ? currentOffscreenQueue.wakeables
+                  : null
+            };
+            _primaryChildFragment2.updateQueue = _newOffscreenQueue2;
+          } else {
+            _offscreenQueue.transitions = _currentTransitions;
+            _offscreenQueue.markerInstances = _parentMarkerInstances;
+          }
+        }
       }
+
+      _primaryChildFragment2.childLanes = getRemainingWorkInPrimaryTree(
+        current,
+        renderLanes
+      );
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      var _nextPrimaryChildren2 = nextProps.children;
+
+      var _primaryChildFragment3 = updateSuspensePrimaryChildren(
+        current,
+        workInProgress,
+        _nextPrimaryChildren2,
+        renderLanes
+      );
+
+      workInProgress.memoizedState = null;
+      return _primaryChildFragment3;
     }
   }
 }
 
-function applyDerivedStateFromProps(
+function mountSuspensePrimaryChildren(
   workInProgress,
-  ctor,
-  getDerivedStateFromProps,
-  nextProps
+  primaryChildren,
+  renderLanes
 ) {
-  var prevState = workInProgress.memoizedState;
-  var partialState = getDerivedStateFromProps(nextProps, prevState);
-
-  {
-    if (workInProgress.mode & StrictLegacyMode) {
-      setIsStrictModeForDevtools(true);
+  var mode = workInProgress.mode;
+  var primaryChildProps = {
+    mode: "visible",
+    children: primaryChildren
+  };
+  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
+    primaryChildProps,
+    mode
+  );
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
 
-      try {
-        // Invoke the function an extra time to help detect side-effects.
-        partialState = getDerivedStateFromProps(nextProps, prevState);
-      } finally {
-        setIsStrictModeForDevtools(false);
-      }
-    }
+function mountSuspenseFallbackChildren(
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var progressedPrimaryFragment = workInProgress.child;
+  var primaryChildProps = {
+    mode: "hidden",
+    children: primaryChildren
+  };
+  var primaryChildFragment;
+  var fallbackChildFragment;
 
-    warnOnUndefinedDerivedState(ctor, partialState);
-  } // Merge the partial state and the previous state.
+  if (
+    (mode & ConcurrentMode) === NoMode &&
+    progressedPrimaryFragment !== null
+  ) {
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
 
-  var memoizedState =
-    partialState === null || partialState === undefined
-      ? prevState
-      : assign({}, prevState, partialState);
-  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
-  // base state.
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration = 0;
+      primaryChildFragment.treeBaseDuration = 0;
+    }
 
-  if (workInProgress.lanes === NoLanes) {
-    // Queue is always non-null for classes
-    var updateQueue = workInProgress.updateQueue;
-    updateQueue.baseState = memoizedState;
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    );
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(
+      primaryChildProps,
+      mode
+    );
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    );
   }
-}
-
-var classComponentUpdater = {
-  isMounted: isMounted,
-  // $FlowFixMe[missing-local-annot]
-  enqueueSetState: function (inst, payload, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.payload = payload;
-
-    if (callback !== undefined && callback !== null) {
-      {
-        warnOnInvalidCallback$1(callback, "setState");
-      }
 
-      update.callback = callback;
-    }
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
 
-    var root = enqueueUpdate(fiber, update, lane);
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
+}
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
+}
 
+function updateSuspensePrimaryChildren(
+  current,
+  workInProgress,
+  primaryChildren,
+  renderLanes
+) {
+  var currentPrimaryChildFragment = current.child;
+  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  var primaryChildFragment = updateWorkInProgressOffscreenFiber(
+    currentPrimaryChildFragment,
     {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logStateUpdateScheduled(name, lane, payload);
-        }
-      }
-    }
-
-    if (enableSchedulingProfiler) {
-      markStateUpdateScheduled(fiber, lane);
+      mode: "visible",
+      children: primaryChildren
     }
-  },
-  enqueueReplaceState: function (inst, payload, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.tag = ReplaceState;
-    update.payload = payload;
+  );
 
-    if (callback !== undefined && callback !== null) {
-      {
-        warnOnInvalidCallback$1(callback, "replaceState");
-      }
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
 
-      update.callback = callback;
-    }
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
 
-    var root = enqueueUpdate(fiber, update, lane);
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    var deletions = workInProgress.deletions;
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
     }
+  }
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logStateUpdateScheduled(name, lane, payload);
-        }
-      }
-    }
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
 
-    if (enableSchedulingProfiler) {
-      markStateUpdateScheduled(fiber, lane);
-    }
-  },
-  // $FlowFixMe[missing-local-annot]
-  enqueueForceUpdate: function (inst, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.tag = ForceUpdate;
+function updateSuspenseFallbackChildren(
+  current,
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var currentPrimaryChildFragment = current.child;
+  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  var primaryChildProps = {
+    mode: "hidden",
+    children: primaryChildren
+  };
+  var primaryChildFragment;
 
-    if (callback !== undefined && callback !== null) {
-      {
-        warnOnInvalidCallback$1(callback, "forceUpdate");
-      }
+  if (
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+    // already cloned. In legacy mode, the only case where this isn't true is
+    // when DevTools forces us to display a fallback; we skip the first render
+    // pass entirely and go straight to rendering the fallback. (In Concurrent
+    // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+    // only codepath.)
+    workInProgress.child !== currentPrimaryChildFragment
+  ) {
+    var progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
 
-      update.callback = callback;
-    }
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration =
+        currentPrimaryChildFragment.selfBaseDuration;
+      primaryChildFragment.treeBaseDuration =
+        currentPrimaryChildFragment.treeBaseDuration;
+    } // The fallback fiber was added as a deletion during the first pass.
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
 
-    var root = enqueueUpdate(fiber, update, lane);
+    workInProgress.deletions = null;
+  } else {
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(
+      currentPrimaryChildFragment,
+      primaryChildProps
+    ); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+    primaryChildFragment.subtreeFlags =
+      currentPrimaryChildFragment.subtreeFlags & StaticMask;
+  }
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logForceUpdateScheduled(name, lane);
-        }
-      }
-    }
+  var fallbackChildFragment;
 
-    if (enableSchedulingProfiler) {
-      markForceUpdateScheduled(fiber, lane);
-    }
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(
+      currentFallbackChildFragment,
+      fallbackChildren
+    );
+  } else {
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    ); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
+
+    fallbackChildFragment.flags |= Placement;
   }
-};
 
-function checkShouldComponentUpdate(
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
+
+function retrySuspenseComponentWithoutHydrating(
+  current,
   workInProgress,
-  ctor,
-  oldProps,
-  newProps,
-  oldState,
-  newState,
-  nextContext
+  renderLanes,
+  recoverableError
 ) {
-  var instance = workInProgress.stateNode;
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
 
-  if (typeof instance.shouldComponentUpdate === "function") {
-    var shouldUpdate = instance.shouldComponentUpdate(
-      newProps,
-      newState,
-      nextContext
-    );
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
 
-    {
-      if (workInProgress.mode & StrictLegacyMode) {
-        setIsStrictModeForDevtools(true);
+  var nextProps = workInProgress.pendingProps;
+  var primaryChildren = nextProps.children;
+  var primaryChildFragment = mountSuspensePrimaryChildren(
+    workInProgress,
+    primaryChildren
+  ); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
 
-        try {
-          // Invoke the function an extra time to help detect side-effects.
-          shouldUpdate = instance.shouldComponentUpdate(
-            newProps,
-            newState,
-            nextContext
-          );
-        } finally {
-          setIsStrictModeForDevtools(false);
-        }
-      }
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
+}
 
-      if (shouldUpdate === undefined) {
-        error(
-          "%s.shouldComponentUpdate(): Returned undefined instead of a " +
-            "boolean value. Make sure to return true or false.",
-          getComponentNameFromType(ctor) || "Component"
-        );
-      }
-    }
+function mountSuspenseFallbackAfterRetryWithoutHydrating(
+  current,
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var fiberMode = workInProgress.mode;
+  var primaryChildProps = {
+    mode: "visible",
+    children: primaryChildren
+  };
+  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
+    primaryChildProps,
+    fiberMode
+  );
+  var fallbackChildFragment = createFiberFromFragment(
+    fallbackChildren,
+    fiberMode,
+    renderLanes,
+    null
+  ); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
 
-    return shouldUpdate;
-  }
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
 
-  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
-    return (
-      !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
-    );
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
   }
 
-  return true;
+  return fallbackChildFragment;
 }
 
-function checkClassInstance(workInProgress, ctor, newProps) {
-  var instance = workInProgress.stateNode;
-
-  {
-    var name = getComponentNameFromType(ctor) || "Component";
-    var renderPresent = instance.render;
-
-    if (!renderPresent) {
-      if (ctor.prototype && typeof ctor.prototype.render === "function") {
-        error(
-          "%s(...): No `render` method found on the returned component " +
-            "instance: did you accidentally return an object from the constructor?",
-          name
-        );
-      } else {
-        error(
-          "%s(...): No `render` method found on the returned component " +
-            "instance: you may have forgotten to define `render`.",
-          name
-        );
-      }
-    }
-
-    if (
-      instance.getInitialState &&
-      !instance.getInitialState.isReactClassApproved &&
-      !instance.state
-    ) {
+function mountDehydratedSuspenseComponent(
+  workInProgress,
+  suspenseInstance,
+  renderLanes
+) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    {
       error(
-        "getInitialState was defined on %s, a plain JavaScript class. " +
-          "This is only supported for classes created using React.createClass. " +
-          "Did you mean to define a state property instead?",
-        name
+        "Cannot hydrate Suspense in legacy mode. Switch from " +
+          "ReactDOM.hydrate(element, container) to " +
+          "ReactDOMClient.hydrateRoot(container, <App />)" +
+          ".render(element) or remove the Suspense components from " +
+          "the server rendered components."
       );
     }
 
-    if (
-      instance.getDefaultProps &&
-      !instance.getDefaultProps.isReactClassApproved
-    ) {
-      error(
-        "getDefaultProps was defined on %s, a plain JavaScript class. " +
-          "This is only supported for classes created using React.createClass. " +
-          "Use a static property to define defaultProps instead.",
-        name
-      );
-    }
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
+  }
 
-    if (instance.propTypes) {
-      error(
-        "propTypes was defined as an instance property on %s. Use a static " +
-          "property to define propTypes instead.",
-        name
-      );
-    }
+  return null;
+}
 
-    if (instance.contextType) {
-      error(
-        "contextType was defined as an instance property on %s. Use a static " +
-          "property to define contextType instead.",
-        name
+function updateDehydratedSuspenseComponent(
+  current,
+  workInProgress,
+  didSuspend,
+  nextProps,
+  suspenseInstance,
+  suspenseState,
+  renderLanes
+) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+    // but after we've already committed once.
+
+    warnIfHydrating();
+
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        null
       );
     }
 
-    {
-      if (instance.contextTypes) {
-        error(
-          "contextTypes was defined as an instance property on %s. Use a static " +
-            "property to define contextTypes instead.",
-          name
-        );
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      var digest, message, stack;
+
+      {
+        var _getSuspenseInstanceF =
+          getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+
+        digest = _getSuspenseInstanceF.digest;
+        message = _getSuspenseInstanceF.message;
+        stack = _getSuspenseInstanceF.stack;
       }
 
-      if (
-        ctor.contextType &&
-        ctor.contextTypes &&
-        !didWarnAboutContextTypeAndContextTypes.has(ctor)
-      ) {
-        didWarnAboutContextTypeAndContextTypes.add(ctor);
+      var error;
 
-        error(
-          "%s declares both contextTypes and contextType static properties. " +
-            "The legacy contextTypes property will be ignored.",
-          name
+      if (message) {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        error = new Error(message);
+      } else {
+        error = new Error(
+          "The server could not finish this Suspense boundary, likely " +
+            "due to an error during server rendering. Switched to " +
+            "client rendering."
         );
       }
-    }
 
-    if (typeof instance.componentShouldUpdate === "function") {
-      error(
-        "%s has a method called " +
-          "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
-          "The name is phrased as a question because the function is " +
-          "expected to return a value.",
-        name
+      error.digest = digest;
+      var capturedValue = createCapturedValue(error, digest, stack);
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        capturedValue
       );
     }
 
     if (
-      ctor.prototype &&
-      ctor.prototype.isPureReactComponent &&
-      typeof instance.shouldComponentUpdate !== "undefined"
+      enableLazyContextPropagation && // TODO: Factoring is a little weird, since we check this right below, too.
+      // But don't want to re-arrange the if-else chain until/unless this
+      // feature lands.
+      !didReceiveUpdate
     ) {
-      error(
-        "%s has a method called shouldComponentUpdate(). " +
-          "shouldComponentUpdate should not be used when extending React.PureComponent. " +
-          "Please extend React.Component if shouldComponentUpdate is used.",
-        getComponentNameFromType(ctor) || "A pure component"
-      );
-    }
+      // We need to check if any children have context before we decide to bail
+      // out, so propagate the changes now.
+      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
+    } // We use lanes to indicate that a child might depend on context, so if
+    // any context has changed, we need to treat is as if the input might have changed.
 
-    if (typeof instance.componentDidUnmount === "function") {
-      error(
-        "%s has a method called " +
-          "componentDidUnmount(). But there is no such lifecycle method. " +
-          "Did you mean componentWillUnmount()?",
-        name
-      );
-    }
+    var hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
 
-    if (typeof instance.componentDidReceiveProps === "function") {
-      error(
-        "%s has a method called " +
-          "componentDidReceiveProps(). But there is no such lifecycle method. " +
-          "If you meant to update the state in response to changing props, " +
-          "use componentWillReceiveProps(). If you meant to fetch data or " +
-          "run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
-        name
-      );
-    }
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      var root = getWorkInProgressRoot();
 
-    if (typeof instance.componentWillRecieveProps === "function") {
-      error(
-        "%s has a method called " +
-          "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
-        name
-      );
-    }
+      if (root !== null) {
+        var attemptHydrationAtLane = getBumpedLaneForHydration(
+          root,
+          renderLanes
+        );
 
-    if (typeof instance.UNSAFE_componentWillRecieveProps === "function") {
-      error(
-        "%s has a method called " +
-          "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
-        name
-      );
-    }
+        if (
+          attemptHydrationAtLane !== NoLane &&
+          attemptHydrationAtLane !== suspenseState.retryLane
+        ) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane; // TODO: Ideally this would inherit the event time of the current render
 
-    var hasMutatedProps = instance.props !== newProps;
+          var eventTime = NoTimestamp;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(
+            root,
+            current,
+            attemptHydrationAtLane,
+            eventTime
+          ); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
 
-    if (instance.props !== undefined && hasMutatedProps) {
-      error(
-        "%s(...): When calling super() in `%s`, make sure to pass " +
-          "up the same props that your component's constructor was passed.",
-        name,
-        name
-      );
-    }
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
 
-    if (instance.defaultProps) {
-      error(
-        "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
-          " Instead, define defaultProps as a static property on %s.",
-        name,
-        name
+      renderDidSuspendDelayIfPossible();
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        null
       );
-    }
-
-    if (
-      typeof instance.getSnapshotBeforeUpdate === "function" &&
-      typeof instance.componentDidUpdate !== "function" &&
-      !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)
-    ) {
-      didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
 
-      error(
-        "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
-          "This component defines getSnapshotBeforeUpdate() only.",
-        getComponentNameFromType(ctor)
-      );
-    }
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
 
-    if (typeof instance.getDerivedStateFromProps === "function") {
-      error(
-        "%s: getDerivedStateFromProps() is defined as an instance method " +
-          "and will be ignored. Instead, declare it as a static method.",
-        name
+      var retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
+    } else {
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(
+        workInProgress,
+        suspenseInstance,
+        suspenseState.treeContext
       );
-    }
+      var primaryChildren = nextProps.children;
+      var primaryChildFragment = mountSuspensePrimaryChildren(
+        workInProgress,
+        primaryChildren
+      ); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
 
-    if (typeof instance.getDerivedStateFromError === "function") {
-      error(
-        "%s: getDerivedStateFromError() is defined as an instance method " +
-          "and will be ignored. Instead, declare it as a static method.",
-        name
-      );
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
     }
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
 
-    if (typeof ctor.getSnapshotBeforeUpdate === "function") {
-      error(
-        "%s: getSnapshotBeforeUpdate() is defined as a static method " +
-          "and will be ignored. Instead, declare it as an instance method.",
-        name
+      var _capturedValue = createCapturedValue(
+        new Error(
+          "There was an error while hydrating this Suspense boundary. " +
+            "Switched to client rendering."
+        )
       );
-    }
-
-    var state = instance.state;
-
-    if (state && (typeof state !== "object" || isArray(state))) {
-      error("%s.state: must be set to an object or null", name);
-    }
 
-    if (
-      typeof instance.getChildContext === "function" &&
-      typeof ctor.childContextTypes !== "object"
-    ) {
-      error(
-        "%s.getChildContext(): childContextTypes must be defined in order to " +
-          "use getChildContext().",
-        name
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        _capturedValue
       );
-    }
-  }
-}
-
-function adoptClassInstance(workInProgress, instance) {
-  instance.updater = classComponentUpdater;
-  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
-
-  set(instance, workInProgress);
-
-  {
-    instance._reactInternalInstance = fakeInternalInstance;
-  }
-}
-
-function constructClassInstance(workInProgress, ctor, props) {
-  var isLegacyContextConsumer = false;
-  var unmaskedContext = emptyContextObject;
-  var context = emptyContextObject;
-  var contextType = ctor.contextType;
-
-  {
-    if ("contextType" in ctor) {
-      var isValid = // Allow null for conditional declaration
-        contextType === null ||
-        (contextType !== undefined &&
-          contextType.$$typeof === REACT_CONTEXT_TYPE &&
-          contextType._context === undefined); // Not a <Context.Consumer>
-
-      if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
-        didWarnAboutInvalidateContextType.add(ctor);
-        var addendum = "";
-
-        if (contextType === undefined) {
-          addendum =
-            " However, it is set to undefined. " +
-            "This can be caused by a typo or by mixing up named and default imports. " +
-            "This can also happen due to a circular dependency, so " +
-            "try moving the createContext() call to a separate file.";
-        } else if (typeof contextType !== "object") {
-          addendum = " However, it is set to a " + typeof contextType + ".";
-        } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
-          addendum = " Did you accidentally pass the Context.Provider instead?";
-        } else if (contextType._context !== undefined) {
-          // <Context.Consumer>
-          addendum = " Did you accidentally pass the Context.Consumer instead?";
-        } else {
-          addendum =
-            " However, it is set to an object with keys {" +
-            Object.keys(contextType).join(", ") +
-            "}.";
-        }
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
 
-        error(
-          "%s defines an invalid contextType. " +
-            "contextType should point to the Context object returned by React.createContext().%s",
-          getComponentNameFromType(ctor) || "Component",
-          addendum
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var nextPrimaryChildren = nextProps.children;
+      var nextFallbackChildren = nextProps.fallback;
+      var fallbackChildFragment =
+        mountSuspenseFallbackAfterRetryWithoutHydrating(
+          current,
+          workInProgress,
+          nextPrimaryChildren,
+          nextFallbackChildren,
+          renderLanes
         );
-      }
-    }
-  }
-
-  if (typeof contextType === "object" && contextType !== null) {
-    context = readContext(contextType);
-  } else {
-    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
-    var contextTypes = ctor.contextTypes;
-    isLegacyContextConsumer =
-      contextTypes !== null && contextTypes !== undefined;
-    context = isLegacyContextConsumer
-      ? getMaskedContext(workInProgress, unmaskedContext)
-      : emptyContextObject;
-  }
-
-  var instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
-
-  {
-    if (workInProgress.mode & StrictLegacyMode) {
-      setIsStrictModeForDevtools(true);
-
-      try {
-        instance = new ctor(props, context); // eslint-disable-line no-new
-      } finally {
-        setIsStrictModeForDevtools(false);
-      }
+      var _primaryChildFragment4 = workInProgress.child;
+      _primaryChildFragment4.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
     }
   }
+}
 
-  var state = (workInProgress.memoizedState =
-    instance.state !== null && instance.state !== undefined
-      ? instance.state
-      : null);
-  adoptClassInstance(workInProgress, instance);
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  var alternate = fiber.alternate;
 
-  {
-    if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
-      var componentName = getComponentNameFromType(ctor) || "Component";
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  }
 
-      if (!didWarnAboutUninitializedState.has(componentName)) {
-        didWarnAboutUninitializedState.add(componentName);
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
 
-        error(
-          "`%s` uses `getDerivedStateFromProps` but its initial state is " +
-            "%s. This is not recommended. Instead, define the initial state by " +
-            "assigning an object to `this.state` in the constructor of `%s`. " +
-            "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
-          componentName,
-          instance.state === null ? "null" : "undefined",
-          componentName
-        );
-      }
-    } // If new component APIs are defined, "unsafe" lifecycles won't be called.
-    // Warn about these lifecycles if they are present.
-    // Don't warn about react-lifecycles-compat polyfilled methods though.
+function propagateSuspenseContextChange(
+  workInProgress,
+  firstChild,
+  renderLanes
+) {
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  var node = firstChild;
 
-    if (
-      typeof ctor.getDerivedStateFromProps === "function" ||
-      typeof instance.getSnapshotBeforeUpdate === "function"
-    ) {
-      var foundWillMountName = null;
-      var foundWillReceivePropsName = null;
-      var foundWillUpdateName = null;
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      var state = node.memoizedState;
 
-      if (
-        typeof instance.componentWillMount === "function" &&
-        instance.componentWillMount.__suppressDeprecationWarning !== true
-      ) {
-        foundWillMountName = "componentWillMount";
-      } else if (typeof instance.UNSAFE_componentWillMount === "function") {
-        foundWillMountName = "UNSAFE_componentWillMount";
+      if (state !== null) {
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
       }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
 
-      if (
-        typeof instance.componentWillReceiveProps === "function" &&
-        instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
-      ) {
-        foundWillReceivePropsName = "componentWillReceiveProps";
-      } else if (
-        typeof instance.UNSAFE_componentWillReceiveProps === "function"
-      ) {
-        foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
-      }
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-      if (
-        typeof instance.componentWillUpdate === "function" &&
-        instance.componentWillUpdate.__suppressDeprecationWarning !== true
-      ) {
-        foundWillUpdateName = "componentWillUpdate";
-      } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        foundWillUpdateName = "UNSAFE_componentWillUpdate";
+    while (node.sibling === null) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
       }
 
-      if (
-        foundWillMountName !== null ||
-        foundWillReceivePropsName !== null ||
-        foundWillUpdateName !== null
-      ) {
-        var _componentName = getComponentNameFromType(ctor) || "Component";
-
-        var newApiName =
-          typeof ctor.getDerivedStateFromProps === "function"
-            ? "getDerivedStateFromProps()"
-            : "getSnapshotBeforeUpdate()";
-
-        if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
-          didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
-
-          error(
-            "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" +
-              "The above lifecycles should be removed. Learn more about this warning here:\n" +
-              "https://reactjs.org/link/unsafe-component-lifecycles",
-            _componentName,
-            newApiName,
-            foundWillMountName !== null ? "\n  " + foundWillMountName : "",
-            foundWillReceivePropsName !== null
-              ? "\n  " + foundWillReceivePropsName
-              : "",
-            foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : ""
-          );
-        }
-      }
-    }
-  } // Cache unmasked context so we can avoid recreating masked context unless necessary.
-  // ReactFiberContext usually updates this cache but can't for newly-created instances.
+      node = node.return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-  if (isLegacyContextConsumer) {
-    cacheContext(workInProgress, unmaskedContext, context);
+    node.sibling.return = node.return;
+    node = node.sibling;
   }
-
-  return instance;
 }
 
-function callComponentWillMount(workInProgress, instance) {
-  var oldState = instance.state;
-
-  if (typeof instance.componentWillMount === "function") {
-    instance.componentWillMount();
-  }
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  var row = firstChild;
+  var lastContentRow = null;
 
-  if (typeof instance.UNSAFE_componentWillMount === "function") {
-    instance.UNSAFE_componentWillMount();
-  }
+  while (row !== null) {
+    var currentRow = row.alternate; // New rows can't be content rows.
 
-  if (oldState !== instance.state) {
-    {
-      error(
-        "%s.componentWillMount(): Assigning directly to this.state is " +
-          "deprecated (except inside a component's " +
-          "constructor). Use setState instead.",
-        getComponentNameFromFiber(workInProgress) || "Component"
-      );
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
     }
 
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+    row = row.sibling;
   }
+
+  return lastContentRow;
 }
 
-function callComponentWillReceiveProps(
-  workInProgress,
-  instance,
-  newProps,
-  nextContext
-) {
-  var oldState = instance.state;
+function validateRevealOrder(revealOrder) {
+  {
+    if (
+      revealOrder !== undefined &&
+      revealOrder !== "forwards" &&
+      revealOrder !== "backwards" &&
+      revealOrder !== "together" &&
+      !didWarnAboutRevealOrder[revealOrder]
+    ) {
+      didWarnAboutRevealOrder[revealOrder] = true;
 
-  if (typeof instance.componentWillReceiveProps === "function") {
-    instance.componentWillReceiveProps(newProps, nextContext);
-  }
+      if (typeof revealOrder === "string") {
+        switch (revealOrder.toLowerCase()) {
+          case "together":
+          case "forwards":
+          case "backwards": {
+            error(
+              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
+                'Use lowercase "%s" instead.',
+              revealOrder,
+              revealOrder.toLowerCase()
+            );
 
-  if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
-    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
-  }
+            break;
+          }
 
-  if (instance.state !== oldState) {
-    {
-      var componentName =
-        getComponentNameFromFiber(workInProgress) || "Component";
+          case "forward":
+          case "backward": {
+            error(
+              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
+                'React uses the -s suffix in the spelling. Use "%ss" instead.',
+              revealOrder,
+              revealOrder.toLowerCase()
+            );
 
-      if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
-        didWarnAboutStateAssignmentForComponent.add(componentName);
+            break;
+          }
+
+          default:
+            error(
+              '"%s" is not a supported revealOrder on <SuspenseList />. ' +
+                'Did you mean "together", "forwards" or "backwards"?',
+              revealOrder
+            );
 
+            break;
+        }
+      } else {
         error(
-          "%s.componentWillReceiveProps(): Assigning directly to " +
-            "this.state is deprecated (except inside a component's " +
-            "constructor). Use setState instead.",
-          componentName
+          "%s is not a supported value for revealOrder on <SuspenseList />. " +
+            'Did you mean "together", "forwards" or "backwards"?',
+          revealOrder
         );
       }
     }
-
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
-  }
-} // Invokes the mount life-cycles on a previously never rendered instance.
-
-function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  {
-    checkClassInstance(workInProgress, ctor, newProps);
-  }
-
-  var instance = workInProgress.stateNode;
-  instance.props = newProps;
-  instance.state = workInProgress.memoizedState;
-  instance.refs = {};
-  initializeUpdateQueue(workInProgress);
-  var contextType = ctor.contextType;
-
-  if (typeof contextType === "object" && contextType !== null) {
-    instance.context = readContext(contextType);
-  } else {
-    var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
-    instance.context = getMaskedContext(workInProgress, unmaskedContext);
   }
+}
 
+function validateTailOptions(tailMode, revealOrder) {
   {
-    if (instance.state === newProps) {
-      var componentName = getComponentNameFromType(ctor) || "Component";
+    if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
+      if (tailMode !== "collapsed" && tailMode !== "hidden") {
+        didWarnAboutTailOptions[tailMode] = true;
 
-      if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
-        didWarnAboutDirectlyAssigningPropsToState.add(componentName);
+        error(
+          '"%s" is not a supported value for tail on <SuspenseList />. ' +
+            'Did you mean "collapsed" or "hidden"?',
+          tailMode
+        );
+      } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
+        didWarnAboutTailOptions[tailMode] = true;
 
         error(
-          "%s: It is not recommended to assign props directly to state " +
-            "because updates to props won't be reflected in state. " +
-            "In most cases, it is better to use props directly.",
-          componentName
+          '<SuspenseList tail="%s" /> is only valid if revealOrder is ' +
+            '"forwards" or "backwards". ' +
+            'Did you mean to specify revealOrder="forwards"?',
+          tailMode
         );
       }
     }
-
-    if (workInProgress.mode & StrictLegacyMode) {
-      ReactStrictModeWarnings.recordLegacyContextWarning(
-        workInProgress,
-        instance
-      );
-    }
-
-    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
-      workInProgress,
-      instance
-    );
-  }
-
-  instance.state = workInProgress.memoizedState;
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    instance.state = workInProgress.memoizedState;
-  } // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
-
-  if (
-    typeof ctor.getDerivedStateFromProps !== "function" &&
-    typeof instance.getSnapshotBeforeUpdate !== "function" &&
-    (typeof instance.UNSAFE_componentWillMount === "function" ||
-      typeof instance.componentWillMount === "function")
-  ) {
-    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
-    // process them now.
-
-    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-    instance.state = workInProgress.memoizedState;
-  }
-
-  if (typeof instance.componentDidMount === "function") {
-    var fiberFlags = Update | LayoutStatic;
-
-    if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-      fiberFlags |= MountLayoutDev;
-    }
-
-    workInProgress.flags |= fiberFlags;
   }
 }
 
-function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  var instance = workInProgress.stateNode;
-  var oldProps = workInProgress.memoizedProps;
-  instance.props = oldProps;
-  var oldContext = instance.context;
-  var contextType = ctor.contextType;
-  var nextContext = emptyContextObject;
-
-  if (typeof contextType === "object" && contextType !== null) {
-    nextContext = readContext(contextType);
-  } else {
-    var nextLegacyUnmaskedContext = getUnmaskedContext(
-      workInProgress,
-      ctor,
-      true
-    );
-    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
-  }
+function validateSuspenseListNestedChild(childSlot, index) {
+  {
+    var isAnArray = isArray(childSlot);
+    var isIterable =
+      !isAnArray && typeof getIteratorFn(childSlot) === "function";
 
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-  var hasNewLifecycles =
-    typeof getDerivedStateFromProps === "function" ||
-    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
-  // ever the previously attempted to render - not the "current". However,
-  // during componentDidUpdate we pass the "current" props.
-  // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (isAnArray || isIterable) {
+      var type = isAnArray ? "array" : "iterable";
 
-  if (
-    !hasNewLifecycles &&
-    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
-      typeof instance.componentWillReceiveProps === "function")
-  ) {
-    if (oldProps !== newProps || oldContext !== nextContext) {
-      callComponentWillReceiveProps(
-        workInProgress,
-        instance,
-        newProps,
-        nextContext
+      error(
+        "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " +
+          "an additional SuspenseList to configure its revealOrder: " +
+          "<SuspenseList revealOrder=...> ... " +
+          "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " +
+          "</SuspenseList>",
+        type,
+        index,
+        type
       );
-    }
-  }
-
-  resetHasForceUpdateBeforeProcessing();
-  var oldState = workInProgress.memoizedState;
-  var newState = (instance.state = oldState);
-  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-  newState = workInProgress.memoizedState;
-
-  if (
-    oldProps === newProps &&
-    oldState === newState &&
-    !hasContextChanged() &&
-    !checkHasForceUpdateAfterProcessing()
-  ) {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidMount === "function") {
-      var fiberFlags = Update | LayoutStatic;
-
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        fiberFlags |= MountLayoutDev;
-      }
 
-      workInProgress.flags |= fiberFlags;
+      return false;
     }
-
-    return false;
-  }
-
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    newState = workInProgress.memoizedState;
   }
 
-  var shouldUpdate =
-    checkHasForceUpdateAfterProcessing() ||
-    checkShouldComponentUpdate(
-      workInProgress,
-      ctor,
-      oldProps,
-      newProps,
-      oldState,
-      newState,
-      nextContext
-    );
+  return true;
+}
 
-  if (shouldUpdate) {
-    // In order to support react-lifecycles-compat polyfilled components,
-    // Unsafe lifecycles should not be invoked for components using the new APIs.
+function validateSuspenseListChildren(children, revealOrder) {
+  {
     if (
-      !hasNewLifecycles &&
-      (typeof instance.UNSAFE_componentWillMount === "function" ||
-        typeof instance.componentWillMount === "function")
+      (revealOrder === "forwards" || revealOrder === "backwards") &&
+      children !== undefined &&
+      children !== null &&
+      children !== false
     ) {
-      if (typeof instance.componentWillMount === "function") {
-        instance.componentWillMount();
-      }
-
-      if (typeof instance.UNSAFE_componentWillMount === "function") {
-        instance.UNSAFE_componentWillMount();
-      }
-    }
-
-    if (typeof instance.componentDidMount === "function") {
-      var _fiberFlags = Update | LayoutStatic;
-
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        _fiberFlags |= MountLayoutDev;
-      }
-
-      workInProgress.flags |= _fiberFlags;
-    }
-  } else {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidMount === "function") {
-      var _fiberFlags2 = Update | LayoutStatic;
-
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        _fiberFlags2 |= MountLayoutDev;
-      }
+      if (isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+          if (!validateSuspenseListNestedChild(children[i], i)) {
+            return;
+          }
+        }
+      } else {
+        var iteratorFn = getIteratorFn(children);
 
-      workInProgress.flags |= _fiberFlags2;
-    } // If shouldComponentUpdate returned false, we should still update the
-    // memoized state to indicate that this work can be reused.
+        if (typeof iteratorFn === "function") {
+          var childrenIterator = iteratorFn.call(children);
 
-    workInProgress.memoizedProps = newProps;
-    workInProgress.memoizedState = newState;
-  } // Update the existing instance's state, props, and context pointers even
-  // if shouldComponentUpdate returns false.
+          if (childrenIterator) {
+            var step = childrenIterator.next();
+            var _i = 0;
 
-  instance.props = newProps;
-  instance.state = newState;
-  instance.context = nextContext;
-  return shouldUpdate;
-} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+            for (; !step.done; step = childrenIterator.next()) {
+              if (!validateSuspenseListNestedChild(step.value, _i)) {
+                return;
+              }
 
-function updateClassInstance(
-  current,
+              _i++;
+            }
+          }
+        } else {
+          error(
+            'A single row was passed to a <SuspenseList revealOrder="%s" />. ' +
+              "This is not useful since it needs multiple rows. " +
+              "Did you mean to pass multiple children or an array?",
+            revealOrder
+          );
+        }
+      }
+    }
+  }
+}
+
+function initSuspenseListRenderState(
   workInProgress,
-  ctor,
-  newProps,
-  renderLanes
+  isBackwards,
+  tail,
+  lastContentRow,
+  tailMode
 ) {
-  var instance = workInProgress.stateNode;
-  cloneUpdateQueue(current, workInProgress);
-  var unresolvedOldProps = workInProgress.memoizedProps;
-  var oldProps =
-    workInProgress.type === workInProgress.elementType
-      ? unresolvedOldProps
-      : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
-  instance.props = oldProps;
-  var unresolvedNewProps = workInProgress.pendingProps;
-  var oldContext = instance.context;
-  var contextType = ctor.contextType;
-  var nextContext = emptyContextObject;
+  var renderState = workInProgress.memoizedState;
 
-  if (typeof contextType === "object" && contextType !== null) {
-    nextContext = readContext(contextType);
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
   } else {
-    var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
-    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
   }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
 
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-  var hasNewLifecycles =
-    typeof getDerivedStateFromProps === "function" ||
-    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
-  // ever the previously attempted to render - not the "current". However,
-  // during componentDidUpdate we pass the "current" props.
-  // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var revealOrder = nextProps.revealOrder;
+  var tailMode = nextProps.tail;
+  var newChildren = nextProps.children;
+  validateRevealOrder(revealOrder);
+  validateTailOptions(tailMode, revealOrder);
+  validateSuspenseListChildren(newChildren, revealOrder);
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  var suspenseContext = suspenseStackCursor.current;
+  var shouldForceFallback = hasSuspenseListContext(
+    suspenseContext,
+    ForceSuspenseFallback
+  );
 
-  if (
-    !hasNewLifecycles &&
-    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
-      typeof instance.componentWillReceiveProps === "function")
-  ) {
-    if (
-      unresolvedOldProps !== unresolvedNewProps ||
-      oldContext !== nextContext
-    ) {
-      callComponentWillReceiveProps(
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(
+      suspenseContext,
+      ForceSuspenseFallback
+    );
+    workInProgress.flags |= DidCapture;
+  } else {
+    var didSuspendBefore =
+      current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(
         workInProgress,
-        instance,
-        newProps,
-        nextContext
+        workInProgress.child,
+        renderLanes
       );
     }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
   }
 
-  resetHasForceUpdateBeforeProcessing();
-  var oldState = workInProgress.memoizedState;
-  var newState = (instance.state = oldState);
-  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-  newState = workInProgress.memoizedState;
+  pushSuspenseListContext(workInProgress, suspenseContext);
 
-  if (
-    unresolvedOldProps === unresolvedNewProps &&
-    oldState === newState &&
-    !hasContextChanged() &&
-    !checkHasForceUpdateAfterProcessing() &&
-    !(
-      enableLazyContextPropagation &&
-      current !== null &&
-      current.dependencies !== null &&
-      checkIfContextChanged(current.dependencies)
-    )
-  ) {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Update;
-      }
-    }
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case "forwards": {
+        var lastContentRow = findLastContentRow(workInProgress.child);
+        var tail;
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Snapshot;
+        if (lastContentRow === null) {
+          // The whole list is part of the tail.
+          // TODO: We could fast path by just rendering the tail now.
+          tail = workInProgress.child;
+          workInProgress.child = null;
+        } else {
+          // Disconnect the tail rows after the content row.
+          // We're going to render them separately later.
+          tail = lastContentRow.sibling;
+          lastContentRow.sibling = null;
+        }
+
+        initSuspenseListRenderState(
+          workInProgress,
+          false, // isBackwards
+          tail,
+          lastContentRow,
+          tailMode
+        );
+        break;
       }
-    }
 
-    return false;
-  }
+      case "backwards": {
+        // We're going to find the first row that has existing content.
+        // At the same time we're going to reverse the list of everything
+        // we pass in the meantime. That's going to be our tail in reverse
+        // order.
+        var _tail = null;
+        var row = workInProgress.child;
+        workInProgress.child = null;
 
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    newState = workInProgress.memoizedState;
-  }
+        while (row !== null) {
+          var currentRow = row.alternate; // New rows can't be content rows.
 
-  var shouldUpdate =
-    checkHasForceUpdateAfterProcessing() ||
-    checkShouldComponentUpdate(
-      workInProgress,
-      ctor,
-      oldProps,
-      newProps,
-      oldState,
-      newState,
-      nextContext
-    ) || // TODO: In some cases, we'll end up checking if context has changed twice,
-    // both before and after `shouldComponentUpdate` has been called. Not ideal,
-    // but I'm loath to refactor this function. This only happens for memoized
-    // components so it's not that common.
-    (enableLazyContextPropagation &&
-      current !== null &&
-      current.dependencies !== null &&
-      checkIfContextChanged(current.dependencies));
+          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+            // This is the beginning of the main content.
+            workInProgress.child = row;
+            break;
+          }
 
-  if (shouldUpdate) {
-    // In order to support react-lifecycles-compat polyfilled components,
-    // Unsafe lifecycles should not be invoked for components using the new APIs.
-    if (
-      !hasNewLifecycles &&
-      (typeof instance.UNSAFE_componentWillUpdate === "function" ||
-        typeof instance.componentWillUpdate === "function")
-    ) {
-      if (typeof instance.componentWillUpdate === "function") {
-        instance.componentWillUpdate(newProps, newState, nextContext);
-      }
+          var nextRow = row.sibling;
+          row.sibling = _tail;
+          _tail = row;
+          row = nextRow;
+        } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
 
-      if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+        initSuspenseListRenderState(
+          workInProgress,
+          true, // isBackwards
+          _tail,
+          null, // last
+          tailMode
+        );
+        break;
       }
-    }
-
-    if (typeof instance.componentDidUpdate === "function") {
-      workInProgress.flags |= Update;
-    }
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      workInProgress.flags |= Snapshot;
-    }
-  } else {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Update;
+      case "together": {
+        initSuspenseListRenderState(
+          workInProgress,
+          false, // isBackwards
+          null, // tail
+          null, // last
+          undefined
+        );
+        break;
       }
-    }
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Snapshot;
+      default: {
+        // The default reveal order is the same as not having
+        // a boundary.
+        workInProgress.memoizedState = null;
       }
-    } // If shouldComponentUpdate returned false, we should still update the
-    // memoized props/state to indicate that this work can be reused.
-
-    workInProgress.memoizedProps = newProps;
-    workInProgress.memoizedState = newState;
-  } // Update the existing instance's state, props, and context pointers even
-  // if shouldComponentUpdate returns false.
+    }
+  }
 
-  instance.props = newProps;
-  instance.state = newState;
-  instance.context = nextContext;
-  return shouldUpdate;
+  return workInProgress.child;
 }
 
-function createCapturedValueAtFiber(value, source) {
-  // If the value is an error, call this function immediately after it is thrown
-  // so the stack is accurate.
-  return {
-    value: value,
-    source: source,
-    stack: getStackByFiberInDevAndProd(source),
-    digest: null
-  };
-}
-function createCapturedValue(value, digest, stack) {
-  return {
-    value: value,
-    source: null,
-    stack: stack != null ? stack : null,
-    digest: digest != null ? digest : null
-  };
-}
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  var nextChildren = workInProgress.pendingProps;
 
-var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
+  if (current === 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
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
 
-if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== "function") {
-  throw new Error(
-    "Expected ReactFiberErrorDialog.showErrorDialog to be a function."
-  );
+  return workInProgress.child;
 }
 
-function showErrorDialog(boundary, errorInfo) {
-  var capturedError = {
-    componentStack: errorInfo.stack !== null ? errorInfo.stack : "",
-    error: errorInfo.value,
-    errorBoundary:
-      boundary !== null && boundary.tag === ClassComponent
-        ? boundary.stateNode
-        : null
-  };
-  return ReactFiberErrorDialogWWW.showErrorDialog(capturedError);
-}
+var hasWarnedAboutUsingNoValuePropOnContextProvider = false;
 
-function logCapturedError(boundary, errorInfo) {
-  try {
-    var logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
-    // This enables renderers like ReactNative to better manage redbox behavior.
+function updateContextProvider(current, workInProgress, renderLanes) {
+  var providerType = workInProgress.type;
+  var context = providerType._context;
+  var newProps = workInProgress.pendingProps;
+  var oldProps = workInProgress.memoizedProps;
+  var newValue = newProps.value;
 
-    if (logError === false) {
-      return;
-    }
+  {
+    if (!("value" in newProps)) {
+      if (!hasWarnedAboutUsingNoValuePropOnContextProvider) {
+        hasWarnedAboutUsingNoValuePropOnContextProvider = true;
 
-    var error = errorInfo.value;
+        error(
+          "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
+        );
+      }
+    }
 
-    if (true) {
-      var source = errorInfo.source;
-      var stack = errorInfo.stack;
-      var componentStack = stack !== null ? stack : ""; // Browsers support silencing uncaught errors by calling
-      // `preventDefault()` in window `error` handler.
-      // We record this information as an expando on the error.
+    var providerPropTypes = workInProgress.type.propTypes;
 
-      if (error != null && error._suppressLogging) {
-        if (boundary.tag === ClassComponent) {
-          // The error is recoverable and was silenced.
-          // Ignore it and don't print the stack addendum.
-          // This is handy for testing error boundaries without noise.
-          return;
-        } // The error is fatal. Since the silencing might have
-        // been accidental, we'll surface it anyway.
-        // However, the browser would have silenced the original error
-        // so we'll print it first, and then print the stack addendum.
+    if (providerPropTypes) {
+      checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider");
+    }
+  }
 
-        console["error"](error); // Don't transform to our wrapper
-        // For a more detailed description of this block, see:
-        // https://github.com/facebook/react/pull/13384
-      }
+  pushProvider(workInProgress, context, newValue);
 
-      var componentName = source ? getComponentNameFromFiber(source) : null;
-      var componentNameMessage = componentName
-        ? "The above error occurred in the <" + componentName + "> component:"
-        : "The above error occurred in one of your React components:";
-      var errorBoundaryMessage;
+  if (enableLazyContextPropagation);
+  else {
+    if (oldProps !== null) {
+      var oldValue = oldProps.value;
 
-      if (boundary.tag === HostRoot) {
-        errorBoundaryMessage =
-          "Consider adding an error boundary to your tree to customize error handling behavior.\n" +
-          "Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.";
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(
+            current,
+            workInProgress,
+            renderLanes
+          );
+        }
       } else {
-        var errorBoundaryName =
-          getComponentNameFromFiber(boundary) || "Anonymous";
-        errorBoundaryMessage =
-          "React will try to recreate this component tree from scratch " +
-          ("using the error boundary you provided, " + errorBoundaryName + ".");
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
       }
-
-      var combinedMessage =
-        componentNameMessage +
-        "\n" +
-        componentStack +
-        "\n\n" +
-        ("" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.
-      // We don't include the original error message and JS stack because the browser
-      // has already printed it. Even if the application swallows the error, it is still
-      // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
-
-      console["error"](combinedMessage); // Don't transform to our wrapper
     }
-  } catch (e) {
-    // This method must not throw, or React internal state will get messed up.
-    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
-    // we want to report this error outside of the normal stack as a last resort.
-    // https://github.com/facebook/react/issues/13188
-    setTimeout(function () {
-      throw e;
-    });
   }
-}
-
-function createRootErrorUpdate(fiber, errorInfo, lane) {
-  var update = createUpdate(lane); // Unmount the root by rendering null.
-
-  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
-  // being called "element".
-
-  update.payload = {
-    element: null
-  };
-  var error = errorInfo.value;
-
-  update.callback = function () {
-    onUncaughtError(error);
-    logCapturedError(fiber, errorInfo);
-  };
 
-  return update;
+  var newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function createClassErrorUpdate(fiber, errorInfo, lane) {
-  var update = createUpdate(lane);
-  update.tag = CaptureUpdate;
-  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+var hasWarnedAboutUsingContextAsConsumer = false;
 
-  if (typeof getDerivedStateFromError === "function") {
-    var error$1 = errorInfo.value;
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  var context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+  // DEV mode, we create a separate object for Context.Consumer that acts
+  // like a proxy to Context. This proxy object adds unnecessary code in PROD
+  // so we use the old behaviour (Context.Consumer references Context) to
+  // reduce size and overhead. The separate object references context via
+  // a property called "_context", which also gives us the ability to check
+  // in DEV mode if this property exists or not and warn if it does not.
 
-    update.payload = function () {
-      return getDerivedStateFromError(error$1);
-    };
+  {
+    if (context._context === undefined) {
+      // This may be because it's a Context (rather than a Consumer).
+      // Or it may be because it's older React where they're the same thing.
+      // We only want to warn if we're sure it's a new React.
+      if (context !== context.Consumer) {
+        if (!hasWarnedAboutUsingContextAsConsumer) {
+          hasWarnedAboutUsingContextAsConsumer = true;
 
-    update.callback = function () {
-      {
-        markFailedErrorBoundaryForHotReloading(fiber);
+          error(
+            "Rendering <Context> directly is not supported and will be removed in " +
+              "a future major release. Did you mean to render <Context.Consumer> instead?"
+          );
+        }
       }
-
-      logCapturedError(fiber, errorInfo);
-    };
+    } else {
+      context = context._context;
+    }
   }
 
-  var inst = fiber.stateNode;
+  var newProps = workInProgress.pendingProps;
+  var render = newProps.children;
 
-  if (inst !== null && typeof inst.componentDidCatch === "function") {
-    // $FlowFixMe[missing-this-annot]
-    update.callback = function callback() {
-      {
-        markFailedErrorBoundaryForHotReloading(fiber);
-      }
+  {
+    if (typeof render !== "function") {
+      error(
+        "A context consumer was rendered with multiple children, or a child " +
+          "that isn't a function. A context consumer expects a single child " +
+          "that is a function. If you did pass a function, make sure there " +
+          "is no trailing or leading whitespace around it."
+      );
+    }
+  }
 
-      logCapturedError(fiber, errorInfo);
+  prepareToReadContext(workInProgress, renderLanes);
+  var newValue = readContext(context);
 
-      if (typeof getDerivedStateFromError !== "function") {
-        // To preserve the preexisting retry behavior of error boundaries,
-        // we keep track of which ones already failed during this batch.
-        // This gets reset before we yield back to the browser.
-        // TODO: Warn in strict mode if getDerivedStateFromError is
-        // not defined.
-        markLegacyErrorBoundaryAsFailed(this);
-      }
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-      var error$1 = errorInfo.value;
-      var stack = errorInfo.stack;
-      this.componentDidCatch(error$1, {
-        componentStack: stack !== null ? stack : ""
-      });
+  var newChildren;
 
-      {
-        if (typeof getDerivedStateFromError !== "function") {
-          // If componentDidCatch is the only error boundary method defined,
-          // then it needs to call setState to recover from errors.
-          // If no state update is scheduled then the boundary will swallow the error.
-          if (!includesSomeLane(fiber.lanes, SyncLane)) {
-            error(
-              "%s: Error boundaries should implement getDerivedStateFromError(). " +
-                "In that method, return a state update to display an error message or fallback UI.",
-              getComponentNameFromFiber(fiber) || "Unknown"
-            );
-          }
-        }
-      }
-    };
+  {
+    ReactCurrentOwner$2.current = workInProgress;
+    setIsRendering(true);
+    newChildren = render(newValue);
+    setIsRendering(false);
   }
 
-  return update;
-}
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
 
-function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
-  if (enableLazyContextPropagation) {
-    var currentSourceFiber = sourceFiber.alternate;
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
 
-    if (currentSourceFiber !== null) {
-      // Since we never visited the children of the suspended component, we
-      // need to propagate the context change now, to ensure that we visit
-      // them during the retry.
-      //
-      // We don't have to do this for errors because we retry errors without
-      // committing in between. So this is specific to Suspense.
-      propagateParentContextChangesToDeferredTree(
-        currentSourceFiber,
-        sourceFiber,
-        rootRenderLanes
-      );
-    }
-  } // Reset the memoizedState to what it was before we attempted to render it.
-  // A legacy mode Suspense quirk, only relevant to hook components.
+function updateScopeComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  var tag = sourceFiber.tag;
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+function checkIfWorkInProgressReceivedUpdate() {
+  return didReceiveUpdate;
+}
 
-  if (
-    (sourceFiber.mode & ConcurrentMode) === NoMode &&
-    (tag === FunctionComponent ||
-      tag === ForwardRef ||
-      tag === SimpleMemoComponent)
-  ) {
-    var currentSource = sourceFiber.alternate;
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
 
-    if (currentSource) {
-      sourceFiber.updateQueue = currentSource.updateQueue;
-      sourceFiber.memoizedState = currentSource.memoizedState;
-      sourceFiber.lanes = currentSource.lanes;
-    } else {
-      sourceFiber.updateQueue = null;
-      sourceFiber.memoizedState = null;
+      workInProgress.flags |= Placement;
     }
   }
 }
 
-function markSuspenseBoundaryShouldCapture(
-  suspenseBoundary,
-  returnFiber,
-  sourceFiber,
-  root,
-  rootRenderLanes
-) {
-  // This marks a Suspense boundary so that when we're unwinding the stack,
-  // it captures the suspended "exception" and does a second (fallback) pass.
-  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
-    // Legacy Mode Suspense
-    //
-    // If the boundary is in legacy mode, we should *not*
-    // suspend the commit. Pretend as if the suspended component rendered
-    // null and keep rendering. When the Suspense boundary completes,
-    // we'll do a second pass to render the fallback.
-    if (suspenseBoundary === returnFiber) {
-      // Special case where we suspended while reconciling the children of
-      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
-      // when a React.lazy component is a direct child of a
-      // Suspense boundary.
-      //
-      // Suspense boundaries are implemented as multiple fibers, but they
-      // are a single conceptual unit. The legacy mode behavior where we
-      // pretend the suspended fiber committed as `null` won't work,
-      // because in this case the "suspended" fiber is the inner
-      // Offscreen wrapper.
-      //
-      // Because the contents of the boundary haven't started rendering
-      // yet (i.e. nothing in the tree has partially rendered) we can
-      // switch to the regular, concurrent mode behavior: mark the
-      // boundary with ShouldCapture and enter the unwind phase.
-      suspenseBoundary.flags |= ShouldCapture;
-    } else {
-      suspenseBoundary.flags |= DidCapture;
-      sourceFiber.flags |= ForceUpdateForLegacySuspense; // 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.
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    workInProgress.dependencies = current.dependencies;
+  }
 
-      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
+  {
+    // Don't update "base" render times for bailouts.
+    stopProfilerTimerIfRunning();
+  }
 
-      if (sourceFiber.tag === ClassComponent) {
-        var currentSourceFiber = sourceFiber.alternate;
+  markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.
 
-        if (currentSourceFiber === null) {
-          // This is a new mount. Change the tag so it's not mistaken for a
-          // completed class component. For example, we should not call
-          // componentWillUnmount if it is deleted.
-          sourceFiber.tag = IncompleteClassComponent;
-        } else {
-          // When we try rendering again, we should not reuse the current fiber,
-          // since it's known to be in an inconsistent state. Use a force update to
-          // prevent a bail out.
-          var update = createUpdate(SyncLane);
-          update.tag = ForceUpdate;
-          enqueueUpdate(sourceFiber, update, SyncLane);
-        }
-      } // The source fiber did not complete. Mark it with Sync priority to
-      // indicate that it still has pending work.
+  if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+    // 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.
+    if (enableLazyContextPropagation && current !== null) {
+      // Before bailing out, check if there are any context changes in
+      // the children.
+      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
 
-      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+        return null;
+      }
+    } else {
+      return null;
     }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
 
-    return suspenseBoundary;
-  } // Confirmed that the boundary is in a concurrent mode tree. Continue
-  // with the normal suspend path.
-  //
-  // After this we'll use a set of heuristics to determine whether this
-  // render pass will run to completion or restart or "suspend" the commit.
-  // The actual logic for this is spread out in different places.
-  //
-  // This first principle is that if we're going to suspend when we complete
-  // a root, then we should also restart if we get an update or ping that
-  // might unsuspend it, and vice versa. The only reason to suspend is
-  // because you think you might want to restart before committing. However,
-  // it doesn't make sense to restart only while in the period we're suspended.
-  //
-  // Restarting too aggressively is also not good because it starves out any
-  // intermediate loading state. So we use heuristics to determine when.
-  // Suspense Heuristics
-  //
-  // If nothing threw a Promise or all the same fallbacks are already showing,
-  // then don't suspend/restart.
-  //
-  // If this is an initial render of a new tree of Suspense boundaries and
-  // those trigger a fallback, then don't suspend/restart. We want to ensure
-  // that we can show the initial loading state as quickly as possible.
-  //
-  // If we hit a "Delayed" case, such as when we'd switch from content back into
-  // a fallback, then we should always suspend/restart. Transitions apply
-  // to this case. If none is defined, JND is used instead.
-  //
-  // If we're already showing a fallback and it gets "retried", allowing us to show
-  // another level, but there's still an inner boundary that would show a fallback,
-  // then we suspend/restart for 500ms since the last time we showed a fallback
-  // anywhere in the tree. This effectively throttles progressive loading into a
-  // consistent train of commits. This also gives us an opportunity to restart to
-  // get to the completed state slightly earlier.
-  //
-  // If there's ambiguity due to batching it's resolved in preference of:
-  // 1) "delayed", 2) "initial render", 3) "retry".
-  //
-  // We want to ensure that a "busy" state doesn't get force committed. We want to
-  // ensure that new initial loading states can commit as soon as possible.
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
 
-  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
-  // the begin phase to prevent an early bailout.
+function remountFiber(current, oldWorkInProgress, newWorkInProgress) {
+  {
+    var returnFiber = oldWorkInProgress.return;
 
-  suspenseBoundary.lanes = rootRenderLanes;
-  return suspenseBoundary;
-}
+    if (returnFiber === null) {
+      // eslint-disable-next-line react-internal/prod-error-codes
+      throw new Error("Cannot swap the root fiber.");
+    } // Disconnect from the old current.
+    // It will get deleted.
 
-function throwException(
-  root,
-  returnFiber,
-  sourceFiber,
-  value,
-  rootRenderLanes
-) {
-  // The source fiber did not complete.
-  sourceFiber.flags |= Incomplete;
+    current.alternate = null;
+    oldWorkInProgress.alternate = null; // Connect to the new tree.
 
-  {
-    if (isDevToolsPresent) {
-      // If we have pending work still, restore the original updaters
-      restorePendingUpdaters(root, rootRenderLanes);
-    }
-  }
+    newWorkInProgress.index = oldWorkInProgress.index;
+    newWorkInProgress.sibling = oldWorkInProgress.sibling;
+    newWorkInProgress.return = oldWorkInProgress.return;
+    newWorkInProgress.ref = oldWorkInProgress.ref; // Replace the child/sibling pointers above it.
 
-  if (
-    value !== null &&
-    typeof value === "object" &&
-    typeof value.then === "function"
-  ) {
-    // This is a wakeable. The component suspended.
-    var wakeable = value;
-    resetSuspendedComponent(sourceFiber, rootRenderLanes);
+    if (oldWorkInProgress === returnFiber.child) {
+      returnFiber.child = newWorkInProgress;
+    } else {
+      var prevSibling = returnFiber.child;
 
-    {
-      if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
-        markDidThrowWhileHydratingDEV();
-      }
-    }
+      if (prevSibling === null) {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error("Expected parent to have a child.");
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-    {
-      if (enableDebugTracing) {
-        if (sourceFiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(sourceFiber) || "Unknown";
-          logComponentSuspended(name, wakeable);
+      while (prevSibling.sibling !== oldWorkInProgress) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        prevSibling = prevSibling.sibling;
+
+        if (prevSibling === null) {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error("Expected to find the previous sibling.");
         }
-      }
-    } // Mark the nearest Suspense boundary to switch to rendering a fallback.
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-    var suspenseBoundary = getSuspenseHandler();
+      prevSibling.sibling = newWorkInProgress;
+    } // Delete the old fiber and place the new one.
+    // Since the old fiber is disconnected, we have to schedule it manually.
 
-    if (suspenseBoundary !== null) {
-      switch (suspenseBoundary.tag) {
-        case SuspenseComponent: {
-          // If this suspense boundary is not already showing a fallback, mark
-          // the in-progress render as suspended. We try to perform this logic
-          // as soon as soon as possible during the render phase, so the work
-          // loop can know things like whether it's OK to switch to other tasks,
-          // or whether it can wait for data to resolve before continuing.
-          // TODO: Most of these checks are already performed when entering a
-          // Suspense boundary. We should track the information on the stack so
-          // we don't have to recompute it on demand. This would also allow us
-          // to unify with `use` which needs to perform this logic even sooner,
-          // before `throwException` is called.
-          if (sourceFiber.mode & ConcurrentMode) {
-            if (getShellBoundary() === null) {
-              // Suspended in the "shell" of the app. This is an undesirable
-              // loading state. We should avoid committing this tree.
-              renderDidSuspendDelayIfPossible();
-            } else {
-              // If we suspended deeper than the shell, we don't need to delay
-              // the commmit. However, we still call renderDidSuspend if this is
-              // a new boundary, to tell the work loop that a new fallback has
-              // appeared during this render.
-              // TODO: Theoretically we should be able to delete this branch.
-              // It's currently used for two things: 1) to throttle the
-              // appearance of successive loading states, and 2) in
-              // SuspenseList, to determine whether the children include any
-              // pending fallbacks. For 1, we should apply throttling to all
-              // retries, not just ones that render an additional fallback. For
-              // 2, we should check subtreeFlags instead. Then we can delete
-              // this branch.
-              var current = suspenseBoundary.alternate;
+    var deletions = returnFiber.deletions;
 
-              if (current === null) {
-                renderDidSuspend();
-              }
-            }
-          }
+    if (deletions === null) {
+      returnFiber.deletions = [current];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(current);
+    }
 
-          suspenseBoundary.flags &= ~ForceClientRender;
-          markSuspenseBoundaryShouldCapture(
-            suspenseBoundary,
-            returnFiber,
-            sourceFiber,
-            root,
-            rootRenderLanes
-          ); // Retry listener
-          //
-          // If the fallback does commit, we need to attach a different type of
-          // listener. This one schedules an update on the Suspense boundary to
-          // turn the fallback state off.
-          //
-          // Stash the wakeable on the boundary fiber so we can access it in the
-          // commit phase.
-          //
-          // When the wakeable resolves, we'll attempt to render the boundary
-          // again ("retry").
+    newWorkInProgress.flags |= Placement; // Restart work from the new fiber.
 
-          var wakeables = suspenseBoundary.updateQueue;
+    return newWorkInProgress;
+  }
+}
 
-          if (wakeables === null) {
-            suspenseBoundary.updateQueue = new Set([wakeable]);
-          } else {
-            wakeables.add(wakeable);
-          }
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  var updateLanes = current.lanes;
 
-          break;
-        }
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+  // to check for a context change before we bail out.
 
-        case OffscreenComponent: {
-          if (suspenseBoundary.mode & ConcurrentMode) {
-            suspenseBoundary.flags |= ShouldCapture;
-            var offscreenQueue = suspenseBoundary.updateQueue;
+  if (enableLazyContextPropagation) {
+    var dependencies = current.dependencies;
 
-            if (offscreenQueue === null) {
-              var newOffscreenQueue = {
-                transitions: null,
-                markerInstances: null,
-                wakeables: new Set([wakeable])
-              };
-              suspenseBoundary.updateQueue = newOffscreenQueue;
-            } else {
-              var _wakeables = offscreenQueue.wakeables;
+    if (dependencies !== null && checkIfContextChanged(dependencies)) {
+      return true;
+    }
+  }
 
-              if (_wakeables === null) {
-                offscreenQueue.wakeables = new Set([wakeable]);
-              } else {
-                _wakeables.add(wakeable);
-              }
-            }
+  return false;
+}
 
-            break;
-          }
-        }
-        // eslint-disable-next-line no-fallthrough
+function attemptEarlyBailoutIfNoScheduledUpdate(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  // 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);
+      pushRootTransition(workInProgress);
 
-        default: {
-          throw new Error(
-            "Unexpected Suspense handler tag (" +
-              suspenseBoundary.tag +
-              "). This " +
-              "is a bug in React."
-          );
-        }
-      } // We only attach ping listeners in concurrent mode. Legacy Suspense always
-      // commits fallbacks synchronously, so there are no pings.
+      if (enableTransitionTracing) {
+        pushRootMarkerInstance(workInProgress);
+      }
 
-      if (suspenseBoundary.mode & ConcurrentMode) {
-        attachPingListener(root, wakeable, rootRenderLanes);
+      {
+        var cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
       }
 
-      return;
-    } else {
-      // No boundary was found. Unless this is a sync update, this is OK.
-      // We can suspend and wait for more data to arrive.
-      if (root.tag === ConcurrentRoot) {
-        // In a concurrent root, suspending without a Suspense boundary is
-        // allowed. It will suspend indefinitely without committing.
-        //
-        // TODO: Should we have different behavior for discrete updates? What
-        // about flushSync? Maybe it should put the tree into an inert state,
-        // and potentially log a warning. Revisit this for a future release.
-        attachPingListener(root, wakeable, rootRenderLanes);
-        renderDidSuspendDelayIfPossible();
-        return;
-      } else {
-        // In a legacy root, suspending without a boundary is always an error.
-        var uncaughtSuspenseError = new Error(
-          "A component suspended while responding to synchronous input. This " +
-            "will cause the UI to be replaced with a loading indicator. To " +
-            "fix, updates that suspend should be wrapped " +
-            "with startTransition."
-        );
-        value = uncaughtSuspenseError;
+      resetHydrationState();
+      break;
+
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
+
+    case ClassComponent: {
+      var Component = workInProgress.type;
+
+      if (isContextProvider(Component)) {
+        pushContextProvider(workInProgress);
       }
+
+      break;
+    }
+
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+
+    case ContextProvider: {
+      var newValue = workInProgress.memoizedProps.value;
+      var context = workInProgress.type._context;
+      pushProvider(workInProgress, context, newValue);
+      break;
     }
-  } else {
-    // This is a regular error, not a Suspense wakeable.
-    if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
-      markDidThrowWhileHydratingDEV();
 
-      var _suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
-      // discarding the dehydrated content and switching to a client render.
-      // Instead of surfacing the error, find the nearest Suspense boundary
-      // and render it again without hydration.
+    case Profiler:
+      {
+        // Profiler should only call onRender when one of its descendants actually rendered.
+        var hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
 
-      if (_suspenseBoundary !== null) {
-        if ((_suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
-          // Set a flag to indicate that we should try rendering the normal
-          // children again, not the fallback.
-          _suspenseBoundary.flags |= ForceClientRender;
+        if (hasChildWork) {
+          workInProgress.flags |= Update;
         }
 
-        markSuspenseBoundaryShouldCapture(
-          _suspenseBoundary,
-          returnFiber,
-          sourceFiber,
-          root,
-          rootRenderLanes
-        ); // Even though the user may not be affected by this error, we should
-        // still log it so it can be fixed.
-
-        queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
-        return;
+        {
+          // Reset effect durations for the next eventual effect phase.
+          // These are reset during render to allow the DevTools commit hook a chance to read them,
+          var stateNode = workInProgress.stateNode;
+          stateNode.effectDuration = 0;
+          stateNode.passiveEffectDuration = 0;
+        }
       }
-    }
-  }
 
-  value = createCapturedValueAtFiber(value, sourceFiber);
-  renderDidError(value); // 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.
+      break;
 
-  var workInProgress = returnFiber;
+    case SuspenseComponent: {
+      var state = workInProgress.memoizedState;
 
-  do {
-    switch (workInProgress.tag) {
-      case HostRoot: {
-        var _errorInfo = value;
-        workInProgress.flags |= ShouldCapture;
-        var lane = pickArbitraryLane(rootRenderLanes);
-        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
-        var update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
-        enqueueCapturedUpdate(workInProgress, update);
-        return;
-      }
+      if (state !== null) {
+        if (state.dehydrated !== null) {
+          // We're not going to render the children, so this is just to maintain
+          // push/pop symmetry
+          pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+          // been unsuspended it has committed as a resolved Suspense component.
+          // If it needs to be retried, it should have work scheduled on it.
 
-      case ClassComponent:
-        // Capture and retry
-        var errorInfo = value;
-        var ctor = workInProgress.type;
-        var instance = workInProgress.stateNode;
+          workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+          // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
 
-        if (
-          (workInProgress.flags & DidCapture) === NoFlags$1 &&
-          (typeof ctor.getDerivedStateFromError === "function" ||
-            (instance !== null &&
-              typeof instance.componentDidCatch === "function" &&
-              !isAlreadyFailedLegacyErrorBoundary(instance)))
-        ) {
-          workInProgress.flags |= ShouldCapture;
+          return null;
+        } // If this boundary is currently timed out, we need to decide
+        // whether to retry the primary children, or to skip over it and
+        // go straight to the fallback. Check the priority of the primary
+        // child fragment.
 
-          var _lane = pickArbitraryLane(rootRenderLanes);
+        var primaryChildFragment = workInProgress.child;
+        var primaryChildLanes = primaryChildFragment.childLanes;
 
-          workInProgress.lanes = mergeLanes(workInProgress.lanes, _lane); // Schedule the error boundary to re-render using updated state
+        if (includesSomeLane(renderLanes, primaryChildLanes)) {
+          // The primary children have pending work. Use the normal path
+          // to attempt to render the primary children again.
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        } else {
+          // The primary child fragment does not have pending work marked
+          // on it
+          pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+          // priority. Bailout.
 
-          var _update = createClassErrorUpdate(
+          var child = bailoutOnAlreadyFinishedWork(
+            current,
             workInProgress,
-            errorInfo,
-            _lane
+            renderLanes
           );
 
-          enqueueCapturedUpdate(workInProgress, _update);
-          return;
+          if (child !== null) {
+            // The fallback children have pending work. Skip over the
+            // primary children and work on the fallback.
+            return child.sibling;
+          } else {
+            // Note: We can return `null` here because we already checked
+            // whether there were nested context consumers, via the call to
+            // `bailoutOnAlreadyFinishedWork` above.
+            return null;
+          }
         }
+      } else {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      }
 
-        break;
-    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      break;
+    }
 
-    workInProgress = workInProgress.return;
-  } while (workInProgress !== null);
-}
+    case SuspenseListComponent: {
+      var didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
 
-var TransitionRoot = 0;
-var TransitionTracingMarker = 1;
-function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
-  if (enableTransitionTracing) {
-    if (pendingTransitions !== null) {
-      var transitionStart = pendingTransitions.transitionStart;
-      var onTransitionStart = callbacks.onTransitionStart;
+      var _hasChildWork = includesSomeLane(
+        renderLanes,
+        workInProgress.childLanes
+      );
 
-      if (transitionStart !== null && onTransitionStart != null) {
-        transitionStart.forEach(function (transition) {
-          return onTransitionStart(transition.name, transition.startTime);
-        });
+      if (enableLazyContextPropagation && !_hasChildWork) {
+        // Context changes may not have been propagated yet. We need to do
+        // that now, before we can decide whether to bail out.
+        // TODO: We use `childLanes` as a heuristic for whether there is
+        // remaining work in a few places, including
+        // `bailoutOnAlreadyFinishedWork` and
+        // `updateDehydratedSuspenseComponent`. We should maybe extract this
+        // into a dedicated function.
+        lazilyPropagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes
+        );
+        _hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
       }
 
-      var markerProgress = pendingTransitions.markerProgress;
-      var onMarkerProgress = callbacks.onMarkerProgress;
+      if (didSuspendBefore) {
+        if (_hasChildWork) {
+          // If something was in fallback state last time, and we have all the
+          // same children then we're still in progressive loading state.
+          // Something might get unblocked by state updates or retries in the
+          // tree which will affect the tail. So we need to use the normal
+          // path to compute the correct tail.
+          return updateSuspenseListComponent(
+            current,
+            workInProgress,
+            renderLanes
+          );
+        } // If none of the children had any work, that means that none of
+        // them got retried so they'll still be blocked in the same way
+        // as before. We can fast bail out.
 
-      if (onMarkerProgress != null && markerProgress !== null) {
-        markerProgress.forEach(function (markerInstance, markerName) {
-          if (markerInstance.transitions !== null) {
-            // TODO: Clone the suspense object so users can't modify it
-            var pending =
-              markerInstance.pendingBoundaries !== null
-                ? Array.from(markerInstance.pendingBoundaries.values())
-                : [];
-            markerInstance.transitions.forEach(function (transition) {
-              onMarkerProgress(
-                transition.name,
-                markerName,
-                transition.startTime,
-                endTime,
-                pending
-              );
-            });
-          }
-        });
-      }
+        workInProgress.flags |= DidCapture;
+      } // If nothing suspended before and we're rendering the same children,
+      // then the tail doesn't matter. Anything new that suspends will work
+      // in the "together" mode, so we can continue from the state we had.
 
-      var markerComplete = pendingTransitions.markerComplete;
-      var onMarkerComplete = callbacks.onMarkerComplete;
+      var renderState = workInProgress.memoizedState;
 
-      if (markerComplete !== null && onMarkerComplete != null) {
-        markerComplete.forEach(function (transitions, markerName) {
-          transitions.forEach(function (transition) {
-            onMarkerComplete(
-              transition.name,
-              markerName,
-              transition.startTime,
-              endTime
-            );
-          });
-        });
+      if (renderState !== null) {
+        // Reset to the "together" mode in case we've started a different
+        // update in the past but didn't complete it.
+        renderState.rendering = null;
+        renderState.tail = null;
+        renderState.lastEffect = null;
       }
 
-      var markerIncomplete = pendingTransitions.markerIncomplete;
-      var onMarkerIncomplete = callbacks.onMarkerIncomplete;
-
-      if (onMarkerIncomplete != null && markerIncomplete !== null) {
-        markerIncomplete.forEach(function (_ref, markerName) {
-          var transitions = _ref.transitions,
-            aborts = _ref.aborts;
-          transitions.forEach(function (transition) {
-            var filteredAborts = [];
-            aborts.forEach(function (abort) {
-              switch (abort.reason) {
-                case "marker": {
-                  filteredAborts.push({
-                    type: "marker",
-                    name: abort.name,
-                    endTime: endTime
-                  });
-                  break;
-                }
-
-                case "suspense": {
-                  filteredAborts.push({
-                    type: "suspense",
-                    name: abort.name,
-                    endTime: endTime
-                  });
-                  break;
-                }
-              }
-            });
+      pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
 
-            if (filteredAborts.length > 0) {
-              onMarkerIncomplete(
-                transition.name,
-                markerName,
-                transition.startTime,
-                filteredAborts
-              );
-            }
-          });
-        });
+      if (_hasChildWork) {
+        break;
+      } else {
+        // If none of the children had any work, that means that none of
+        // them got retried so they'll still be blocked in the same way
+        // as before. We can fast bail out.
+        return null;
       }
+    }
 
-      var transitionProgress = pendingTransitions.transitionProgress;
-      var onTransitionProgress = callbacks.onTransitionProgress;
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      // Need to check if the tree still needs to be deferred. This is
+      // almost identical to the logic used in the normal update path,
+      // so we'll just enter that. The only difference is we'll bail out
+      // at the next level instead of this one, because the child props
+      // have not changed. Which is fine.
+      // TODO: Probably should refactor `beginWork` to split the bailout
+      // path from the normal path. I'm tempted to do a labeled break here
+      // but I won't :)
+      workInProgress.lanes = NoLanes;
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    }
 
-      if (onTransitionProgress != null && transitionProgress !== null) {
-        transitionProgress.forEach(function (pending, transition) {
-          onTransitionProgress(
-            transition.name,
-            transition.startTime,
-            endTime,
-            Array.from(pending.values())
-          );
-        });
+    case CacheComponent: {
+      {
+        var _cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, _cache);
       }
 
-      var transitionComplete = pendingTransitions.transitionComplete;
-      var onTransitionComplete = callbacks.onTransitionComplete;
+      break;
+    }
 
-      if (transitionComplete !== null && onTransitionComplete != null) {
-        transitionComplete.forEach(function (transition) {
-          return onTransitionComplete(
-            transition.name,
-            transition.startTime,
-            endTime
-          );
-        });
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var instance = workInProgress.stateNode;
+
+        if (instance !== null) {
+          pushMarkerInstance(workInProgress, instance);
+        }
       }
     }
   }
-} // For every tracing marker, store a pointer to it. We will later access it
-// to get the set of suspense boundaries that need to resolve before the
-// tracing marker can be logged as complete
-// This code lives separate from the ReactFiberTransition code because
-// we push and pop on the tracing marker, not the suspense boundary
 
-var markerInstanceStack = createCursor(null);
-function pushRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    // On the root, every transition gets mapped to it's own map of
-    // suspense boundaries. The transition is marked as complete when
-    // the suspense boundaries map is empty. We do this because every
-    // transition completes at different times and depends on different
-    // suspense boundaries to complete. We store all the transitions
-    // along with its map of suspense boundaries in the root incomplete
-    // transitions map. Each entry in this map functions like a tracing
-    // marker does, so we can push it onto the marker instance stack
-    var transitions = getWorkInProgressTransitions();
-    var root = workInProgress.stateNode;
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+}
 
-    if (transitions !== null) {
-      transitions.forEach(function (transition) {
-        if (!root.incompleteTransitions.has(transition)) {
-          var markerInstance = {
-            tag: TransitionRoot,
-            transitions: new Set([transition]),
-            pendingBoundaries: null,
-            aborts: null,
-            name: null
-          };
-          root.incompleteTransitions.set(transition, markerInstance);
-        }
-      });
+function beginWork$1(current, workInProgress, renderLanes) {
+  {
+    if (workInProgress._debugNeedsRemount && current !== null) {
+      // This will restart the begin phase with a new fiber.
+      return remountFiber(
+        current,
+        workInProgress,
+        createFiberFromTypeAndProps(
+          workInProgress.type,
+          workInProgress.key,
+          workInProgress.pendingProps,
+          workInProgress._debugOwner || null,
+          workInProgress.mode,
+          workInProgress.lanes
+        )
+      );
     }
+  }
 
-    var markerInstances = []; // For ever transition on the suspense boundary, we push the transition
-    // along with its map of pending suspense boundaries onto the marker
-    // instance stack.
+  if (current !== null) {
+    var oldProps = current.memoizedProps;
+    var newProps = workInProgress.pendingProps;
 
-    root.incompleteTransitions.forEach(function (markerInstance) {
-      markerInstances.push(markerInstance);
-    });
-    push(markerInstanceStack, markerInstances, workInProgress);
-  }
-}
-function popRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    pop(markerInstanceStack, workInProgress);
-  }
-}
-function pushMarkerInstance(workInProgress, markerInstance) {
-  if (enableTransitionTracing) {
-    if (markerInstanceStack.current === null) {
-      push(markerInstanceStack, [markerInstance], workInProgress);
+    if (
+      oldProps !== newProps ||
+      hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
+      workInProgress.type !== current.type
+    ) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
     } else {
-      push(
-        markerInstanceStack,
-        markerInstanceStack.current.concat(markerInstance),
-        workInProgress
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
+        current,
+        renderLanes
+      );
+
+      if (
+        !hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+        // may not be work scheduled on `current`, so we check for this flag.
+        (workInProgress.flags & DidCapture) === NoFlags$1
+      ) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
+
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
+      }
+    }
+  } else {
+    didReceiveUpdate = false;
+
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      var slotIndex = workInProgress.index;
+      var numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
+
+  workInProgress.lanes = NoLanes;
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent: {
+      return mountIndeterminateComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        renderLanes
+      );
+    }
+
+    case LazyComponent: {
+      var elementType = workInProgress.elementType;
+      return mountLazyComponent(
+        current,
+        workInProgress,
+        elementType,
+        renderLanes
+      );
+    }
+
+    case FunctionComponent: {
+      var Component = workInProgress.type;
+      var unresolvedProps = workInProgress.pendingProps;
+      var resolvedProps =
+        workInProgress.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      return updateFunctionComponent(
+        current,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+    }
+
+    case ClassComponent: {
+      var _Component = workInProgress.type;
+      var _unresolvedProps = workInProgress.pendingProps;
+
+      var _resolvedProps =
+        workInProgress.elementType === _Component
+          ? _unresolvedProps
+          : resolveDefaultProps(_Component, _unresolvedProps);
+
+      return updateClassComponent(
+        current,
+        workInProgress,
+        _Component,
+        _resolvedProps,
+        renderLanes
       );
     }
-  }
-}
-function popMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    pop(markerInstanceStack, workInProgress);
-  }
-}
-function getMarkerInstances() {
-  if (enableTransitionTracing) {
-    return markerInstanceStack.current;
-  }
 
-  return null;
-}
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
 
-var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
-// into a dehydrated boundary.
+    case HostHoistable: {
+      return updateHostHoistable(current, workInProgress);
+    }
 
-var SelectiveHydrationException = new Error(
-  "This is not a real error. It's an implementation detail of React's " +
-    "selective hydration feature. If this leaks into userspace, it's a bug in " +
-    "React. Please file an issue."
-);
-var didReceiveUpdate = false;
-var didWarnAboutBadClass;
-var didWarnAboutModulePatternComponent;
-var didWarnAboutContextTypeOnFunctionComponent;
-var didWarnAboutGetDerivedStateOnFunctionComponent;
-var didWarnAboutFunctionRefs;
-var didWarnAboutReassigningProps;
-var didWarnAboutRevealOrder;
-var didWarnAboutTailOptions;
-var didWarnAboutDefaultPropsOnFunctionComponent;
+    // eslint-disable-next-line no-fallthrough
 
-{
-  didWarnAboutBadClass = {};
-  didWarnAboutModulePatternComponent = {};
-  didWarnAboutContextTypeOnFunctionComponent = {};
-  didWarnAboutGetDerivedStateOnFunctionComponent = {};
-  didWarnAboutFunctionRefs = {};
-  didWarnAboutReassigningProps = false;
-  didWarnAboutRevealOrder = {};
-  didWarnAboutTailOptions = {};
-  didWarnAboutDefaultPropsOnFunctionComponent = {};
-}
+    case HostSingleton: {
+      return updateHostSingleton(current, workInProgress, renderLanes);
+    }
 
-function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
-  if (current === 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
-    // we can optimize this reconciliation pass by not tracking side-effects.
-    workInProgress.child = mountChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    // If the current child is the same as the work in progress, it means that
-    // we haven't yet started any work on these children. Therefore, we use
-    // the clone algorithm to create a copy of all the current children.
-    // If we had any progressed work already, that is invalid at this point so
-    // let's throw it out.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      current.child,
-      nextChildren,
-      renderLanes
-    );
-  }
-}
+    // eslint-disable-next-line no-fallthrough
 
-function forceUnmountCurrentAndReconcile(
-  current,
-  workInProgress,
-  nextChildren,
-  renderLanes
-) {
-  // This function is fork of reconcileChildren. It's used in cases where we
-  // want to reconcile without matching against the existing set. This has the
-  // effect of all current children being unmounted; even if the type and key
-  // are the same, the old child is unmounted and a new child is created.
-  //
-  // To do this, we're going to go through the reconcile algorithm twice. In
-  // the first pass, we schedule a deletion for all the current children by
-  // passing null.
-  workInProgress.child = reconcileChildFibers(
-    workInProgress,
-    current.child,
-    null,
-    renderLanes
-  ); // In the second pass, we mount the new children. The trick here is that we
-  // pass null in place of where we usually pass the current child set. This has
-  // the effect of remounting all children regardless of whether their
-  // identities match.
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
 
-  workInProgress.child = reconcileChildFibers(
-    workInProgress,
-    null,
-    nextChildren,
-    renderLanes
-  );
-}
+    case HostText:
+      return updateHostText$1(current, workInProgress);
 
-function updateForwardRef(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  // TODO: current can be non-null here even if the component
-  // hasn't yet mounted. This happens after the first render suspends.
-  // We'll need to figure out if this is fine or can cause issues.
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
-      }
-    }
-  }
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
 
-  var render = Component.render;
-  var ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+    case ForwardRef: {
+      var type = workInProgress.type;
+      var _unresolvedProps2 = workInProgress.pendingProps;
 
-  var nextChildren;
-  var hasId;
-  prepareToReadContext(workInProgress, renderLanes);
+      var _resolvedProps2 =
+        workInProgress.elementType === type
+          ? _unresolvedProps2
+          : resolveDefaultProps(type, _unresolvedProps2);
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+      return updateForwardRef(
+        current,
+        workInProgress,
+        type,
+        _resolvedProps2,
+        renderLanes
+      );
+    }
 
-  {
-    ReactCurrentOwner$2.current = workInProgress;
-    setIsRendering(true);
-    nextChildren = renderWithHooks(
-      current,
-      workInProgress,
-      render,
-      nextProps,
-      ref,
-      renderLanes
-    );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  }
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
 
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
 
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
 
-function updateMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (current === null) {
-    var type = Component.type;
+    case MemoComponent: {
+      var _type2 = workInProgress.type;
+      var _unresolvedProps3 = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
 
-    if (
-      isSimpleFunctionComponent(type) &&
-      Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
-      Component.defaultProps === undefined
-    ) {
-      var resolvedType = type;
+      var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
 
       {
-        resolvedType = resolveFunctionForHotReloading(type);
-      } // If this is a plain function component without default props,
-      // and with only the default shallow comparison, we upgrade it
-      // to a SimpleMemoComponent to allow fast path updates.
-
-      workInProgress.tag = SimpleMemoComponent;
-      workInProgress.type = resolvedType;
+        if (workInProgress.type !== workInProgress.elementType) {
+          var outerPropTypes = _type2.propTypes;
 
-      {
-        validateFunctionComponentInDev(workInProgress, type);
+          if (outerPropTypes) {
+            checkPropTypes(
+              outerPropTypes,
+              _resolvedProps3, // Resolved for outer only
+              "prop",
+              getComponentNameFromType(_type2)
+            );
+          }
+        }
       }
 
+      _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
+      return updateMemoComponent(
+        current,
+        workInProgress,
+        _type2,
+        _resolvedProps3,
+        renderLanes
+      );
+    }
+
+    case SimpleMemoComponent: {
       return updateSimpleMemoComponent(
         current,
         workInProgress,
-        resolvedType,
-        nextProps,
+        workInProgress.type,
+        workInProgress.pendingProps,
         renderLanes
       );
     }
 
-    {
-      var innerPropTypes = type.propTypes;
+    case IncompleteClassComponent: {
+      var _Component2 = workInProgress.type;
+      var _unresolvedProps4 = workInProgress.pendingProps;
 
-      if (innerPropTypes) {
-        // Inner memo component props aren't currently validated in createElement.
-        // We could move it there, but we'd still need this for lazy code path.
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(type)
-        );
-      }
+      var _resolvedProps4 =
+        workInProgress.elementType === _Component2
+          ? _unresolvedProps4
+          : resolveDefaultProps(_Component2, _unresolvedProps4);
 
-      if (Component.defaultProps !== undefined) {
-        var componentName = getComponentNameFromType(type) || "Unknown";
+      return mountIncompleteClassComponent(
+        current,
+        workInProgress,
+        _Component2,
+        _resolvedProps4,
+        renderLanes
+      );
+    }
 
-        if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
-          error(
-            "%s: Support for defaultProps will be removed from memo components " +
-              "in a future major release. Use JavaScript default parameters instead.",
-            componentName
-          );
+    case SuspenseListComponent: {
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    }
 
-          didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
-        }
+    case ScopeComponent: {
+      {
+        return updateScopeComponent(current, workInProgress, renderLanes);
       }
     }
 
-    var child = createFiberFromTypeAndProps(
-      Component.type,
-      null,
-      nextProps,
-      workInProgress,
-      workInProgress.mode,
-      renderLanes
-    );
-    child.ref = workInProgress.ref;
-    child.return = workInProgress;
-    workInProgress.child = child;
-    return child;
-  }
-
-  {
-    var _type = Component.type;
-    var _innerPropTypes = _type.propTypes;
-
-    if (_innerPropTypes) {
-      // Inner memo component props aren't currently validated in createElement.
-      // We could move it there, but we'd still need this for lazy code path.
-      checkPropTypes(
-        _innerPropTypes,
-        nextProps, // Resolved props
-        "prop",
-        getComponentNameFromType(_type)
-      );
+    case OffscreenComponent: {
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
     }
-  }
-
-  var currentChild = current.child; // This is always exactly one child
 
-  var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
-    current,
-    renderLanes
-  );
+    case LegacyHiddenComponent: {
+      {
+        return updateLegacyHiddenComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
+    }
 
-  if (!hasScheduledUpdateOrContext) {
-    // This will be the props with resolved defaultProps,
-    // unlike current.memoizedProps which will be the unresolved ones.
-    var prevProps = currentChild.memoizedProps; // Default to shallow comparison
+    case CacheComponent: {
+      {
+        return updateCacheComponent(current, workInProgress, renderLanes);
+      }
+    }
 
-    var compare = Component.compare;
-    compare = compare !== null ? compare : shallowEqual;
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        return updateTracingMarkerComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
 
-    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      break;
     }
-  } // React DevTools reads this flag.
+  }
 
-  workInProgress.flags |= PerformedWork;
-  var newChild = createWorkInProgress(currentChild, nextProps);
-  newChild.ref = workInProgress.ref;
-  newChild.return = workInProgress;
-  workInProgress.child = newChild;
-  return newChild;
+  throw new Error(
+    "Unknown unit of work tag (" +
+      workInProgress.tag +
+      "). This error is likely caused by a bug in " +
+      "React. Please file an issue."
+  );
 }
 
-function updateSimpleMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  // TODO: current can be non-null here even if the component
-  // hasn't yet mounted. This happens when the inner render suspends.
-  // We'll need to figure out if this is fine or can cause issues.
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var outerMemoType = workInProgress.elementType;
-
-      if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
-        // We warn when you define propTypes on lazy()
-        // so let's just skip over it to find memo() outer wrapper.
-        // Inner props for memo are validated later.
-        var lazyComponent = outerMemoType;
-        var payload = lazyComponent._payload;
-        var init = lazyComponent._init;
-
-        try {
-          outerMemoType = init(payload);
-        } catch (x) {
-          outerMemoType = null;
-        } // Inner propTypes will be validated in the function component path.
+var valueCursor = createCursor(null);
+var rendererCursorDEV;
 
-        var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+{
+  rendererCursorDEV = createCursor(null);
+}
 
-        if (outerPropTypes) {
-          checkPropTypes(
-            outerPropTypes,
-            nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
-            "prop",
-            getComponentNameFromType(outerMemoType)
-          );
-        }
-      }
-    }
-  }
+var rendererSigil;
 
-  if (current !== null) {
-    var prevProps = current.memoizedProps;
+{
+  // Use this to detect multiple renderers using the same context
+  rendererSigil = {};
+}
 
-    if (
-      shallowEqual(prevProps, nextProps) &&
-      current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
-      workInProgress.type === current.type
-    ) {
-      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
-      // would during a normal fiber bailout.
-      //
-      // We don't have strong guarantees that the props object is referentially
-      // equal during updates where we can't bail out anyway — like if the props
-      // are shallowly equal, but there's a local state or context update in the
-      // same batch.
-      //
-      // However, as a principle, we should aim to make the behavior consistent
-      // across different ways of memoizing a component. For example, React.memo
-      // has a different internal Fiber layout if you pass a normal function
-      // component (SimpleMemoComponent) versus if you pass a different type
-      // like forwardRef (MemoComponent). But this is an implementation detail.
-      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
-      // affect whether the props object is reused during a bailout.
+var currentlyRenderingFiber = null;
+var lastContextDependency = null;
+var lastFullyObservedContext = null;
+var isDisallowedContextReadInDEV = false;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
 
-      workInProgress.pendingProps = nextProps = prevProps;
+  {
+    isDisallowedContextReadInDEV = false;
+  }
+}
+function enterDisallowedContextReadInDEV() {
+  {
+    isDisallowedContextReadInDEV = true;
+  }
+}
+function exitDisallowedContextReadInDEV() {
+  {
+    isDisallowedContextReadInDEV = false;
+  }
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue, providerFiber);
+    context._currentValue = nextValue;
 
-      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
-        // The pending lanes were cleared at the beginning of beginWork. We're
-        // about to bail out, but there might be other lanes that weren't
-        // included in the current render. Usually, the priority level of the
-        // remaining updates is accumulated during the evaluation of the
-        // component (i.e. when processing the update queue). But since since
-        // we're bailing out early *without* evaluating the component, we need
-        // to account for it here, too. Reset to the value of the current fiber.
-        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
-        // because a MemoComponent fiber does not have hooks or an update queue;
-        // rather, it wraps around an inner component, which may or may not
-        // contains hooks.
-        // TODO: Move the reset at in beginWork out of the common path so that
-        // this is no longer necessary.
-        workInProgress.lanes = current.lanes;
-        return bailoutOnAlreadyFinishedWork(
-          current,
-          workInProgress,
-          renderLanes
+    {
+      push(rendererCursorDEV, context._currentRenderer, providerFiber);
+
+      if (
+        context._currentRenderer !== undefined &&
+        context._currentRenderer !== null &&
+        context._currentRenderer !== rendererSigil
+      ) {
+        error(
+          "Detected multiple renderers concurrently rendering the " +
+            "same context provider. This is currently unsupported."
         );
-      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
-        // This is a special case that only exists for legacy mode.
-        // See https://github.com/facebook/react/pull/19216.
-        didReceiveUpdate = true;
       }
+
+      context._currentRenderer = rendererSigil;
     }
   }
-
-  return updateFunctionComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    renderLanes
-  );
 }
+function popProvider(context, providerFiber) {
+  var currentValue = valueCursor.current;
 
-function updateOffscreenComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  var nextIsDetached =
-    (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
-  var prevState = current !== null ? current.memoizedState : null;
-  markRef$1(current, workInProgress);
-
-  if (
-    nextProps.mode === "hidden" ||
-    nextProps.mode === "unstable-defer-without-hiding" ||
-    nextIsDetached
-  ) {
-    // Rendering a hidden tree.
-    var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+  {
+    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = context._defaultValue;
+    } else {
+      context._currentValue = currentValue;
+    }
 
-    if (didSuspend) {
-      // Something suspended inside a hidden tree
-      // Include the base lanes from the last render
-      var nextBaseLanes =
-        prevState !== null
-          ? mergeLanes(prevState.baseLanes, renderLanes)
-          : renderLanes;
+    {
+      var currentRenderer = rendererCursorDEV.current;
+      pop(rendererCursorDEV, providerFiber);
+      context._currentRenderer = currentRenderer;
+    }
+  }
 
-      if (current !== null) {
-        // Reset to the current children
-        var currentChild = (workInProgress.child = current.child); // The current render suspended, but there may be other lanes with
-        // pending work. We can't read `childLanes` from the current Offscreen
-        // fiber because we reset it when it was deferred; however, we can read
-        // the pending lanes from the child fibers.
+  pop(valueCursor, providerFiber);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  var node = parent;
 
-        var currentChildLanes = NoLanes;
+  while (node !== null) {
+    var alternate = node.alternate;
 
-        while (currentChild !== null) {
-          currentChildLanes = mergeLanes(
-            mergeLanes(currentChildLanes, currentChild.lanes),
-            currentChild.childLanes
-          );
-          currentChild = currentChild.sibling;
-        }
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
 
-        var lanesWeJustAttempted = nextBaseLanes;
-        var remainingChildLanes = removeLanes(
-          currentChildLanes,
-          lanesWeJustAttempted
-        );
-        workInProgress.childLanes = remainingChildLanes;
-      } else {
-        workInProgress.childLanes = NoLanes;
-        workInProgress.child = null;
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
       }
+    } else if (
+      alternate !== null &&
+      !isSubsetOfLanes(alternate.childLanes, renderLanes)
+    ) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else;
 
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        nextBaseLanes,
-        renderLanes
+    if (node === propagationRoot) {
+      break;
+    }
+
+    node = node.return;
+  }
+
+  {
+    if (node !== propagationRoot) {
+      error(
+        "Expected to find the propagation root when scheduling context work. " +
+          "This error is likely caused by a bug in React. Please file an issue."
       );
     }
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  if (enableLazyContextPropagation) {
+    // TODO: This path is only used by Cache components. Update
+    // lazilyPropagateParentContextChanges to look for Cache components so they
+    // can take advantage of lazy propagation.
+    var forcePropagateEntireTree = true;
+    propagateContextChanges(
+      workInProgress,
+      [context],
+      renderLanes,
+      forcePropagateEntireTree
+    );
+  } else {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
+  }
+}
 
-    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-      // In legacy sync mode, don't defer the subtree. Render it now.
-      // TODO: Consider how Offscreen should work with transitions in the future
-      var nextState = {
-        baseLanes: NoLanes,
-        cachePool: null
-      };
-      workInProgress.memoizedState = nextState;
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+  // Only used by eager implementation
+  if (enableLazyContextPropagation) {
+    return;
+  }
 
-      {
-        // push the cache pool even though we're going to bail out
-        // because otherwise there'd be a context mismatch
-        if (current !== null) {
-          pushTransition(workInProgress, null, null);
-        }
-      }
+  var fiber = workInProgress.child;
 
-      reuseHiddenContextOnStack(workInProgress);
-      pushOffscreenSuspenseHandler(workInProgress);
-    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
-      // We're hidden, and we're not rendering at Offscreen. We will bail out
-      // and resume this tree later.
-      // Schedule this fiber to re-render at Offscreen priority
-      workInProgress.lanes = workInProgress.childLanes =
-        laneToLanes(OffscreenLane); // Include the base lanes from the last render
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
+  }
 
-      var _nextBaseLanes =
-        prevState !== null
-          ? mergeLanes(prevState.baseLanes, renderLanes)
-          : renderLanes;
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
 
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        _nextBaseLanes,
-        renderLanes
-      );
-    } else {
-      // This is the second render. The surrounding visible content has already
-      // committed. Now we resume rendering the hidden tree.
-      // Rendering at offscreen, so we can clear the base lanes.
-      var _nextState = {
-        baseLanes: NoLanes,
-        cachePool: null
-      };
-      workInProgress.memoizedState = _nextState;
+    var list = fiber.dependencies;
 
-      if (current !== null) {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        var prevCachePool = prevState !== null ? prevState.cachePool : null; // TODO: Consider if and how Offscreen pre-rendering should
-        // be attributed to the transition that spawned it
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dependency = list.firstContext;
 
-        pushTransition(workInProgress, prevCachePool, null);
-      } // Push the lanes that were skipped when we bailed out.
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            var lane = pickArbitraryLane(renderLanes);
+            var update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
 
-      if (prevState !== null) {
-        pushHiddenContext(workInProgress, prevState);
-      } else {
-        reuseHiddenContextOnStack(workInProgress);
-      }
+            var updateQueue = fiber.updateQueue;
 
-      pushOffscreenSuspenseHandler(workInProgress);
-    }
-  } else {
-    // Rendering a visible tree.
-    if (prevState !== null) {
-      // We're going from hidden -> visible.
-      var _prevCachePool = null;
+            if (updateQueue === null);
+            else {
+              var sharedQueue = updateQueue.shared;
+              var pending = sharedQueue.pending;
 
-      {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        _prevCachePool = prevState.cachePool;
-      }
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
 
-      var transitions = null;
+              sharedQueue.pending = update;
+            }
+          }
 
-      if (enableTransitionTracing) {
-        // We have now gone from hidden to visible, so any transitions should
-        // be added to the stack to get added to any Offscreen/suspense children
-        var instance = workInProgress.stateNode;
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          var alternate = fiber.alternate;
 
-        if (instance !== null && instance._transitions != null) {
-          transitions = Array.from(instance._transitions);
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
+
+          scheduleContextWorkOnParentPath(
+            fiber.return,
+            renderLanes,
+            workInProgress
+          ); // Mark the updated lanes on the list, too.
+
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
+
+          break;
         }
+
+        dependency = dependency.next;
       }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      var parentSuspense = fiber.return;
 
-      pushTransition(workInProgress, _prevCachePool, transitions); // Push the lanes that were skipped when we bailed out.
+      if (parentSuspense === null) {
+        throw new Error(
+          "We just came from a parent so we must have had a parent. This is a bug in React."
+        );
+      }
 
-      pushHiddenContext(workInProgress, prevState);
-      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      var _alternate = parentSuspense.alternate;
 
-      workInProgress.memoizedState = null;
+      if (_alternate !== null) {
+        _alternate.lanes = mergeLanes(_alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
+
+      scheduleContextWorkOnParentPath(
+        parentSuspense,
+        renderLanes,
+        workInProgress
+      );
+      nextFiber = fiber.sibling;
     } else {
-      // We weren't previously hidden, and we still aren't, so there's nothing
-      // special to do. Need to push to the stack regardless, though, to avoid
-      // a push/pop misalignment.
-      {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        if (current !== null) {
-          pushTransition(workInProgress, null, null);
+      // 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;
         }
-      } // We're about to bail out, but we need to push this to the stack anyway
-      // to avoid a push/pop misalignment.
 
-      reuseHiddenContextOnStack(workInProgress);
-      reuseSuspenseHandlerOnStack(workInProgress);
+        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;
+      }
     }
-  }
 
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+    fiber = nextFiber;
+  }
 }
 
-function deferHiddenOffscreenComponent(
-  current,
+function propagateContextChanges(
   workInProgress,
-  nextBaseLanes,
-  renderLanes
+  contexts,
+  renderLanes,
+  forcePropagateEntireTree
 ) {
-  var nextState = {
-    baseLanes: nextBaseLanes,
-    // Save the cache pool so we can resume later.
-    cachePool: getOffscreenDeferredCache()
-  };
-  workInProgress.memoizedState = nextState;
-
-  {
-    // push the cache pool even though we're going to bail out
-    // because otherwise there'd be a context mismatch
-    if (current !== null) {
-      pushTransition(workInProgress, null, null);
-    }
-  } // We're about to bail out, but we need to push this to the stack anyway
-  // to avoid a push/pop misalignment.
-
-  reuseHiddenContextOnStack(workInProgress);
-  pushOffscreenSuspenseHandler(workInProgress);
-
-  if (enableLazyContextPropagation && current !== null) {
-    // Since this tree will resume rendering in a separate render, we need
-    // to propagate parent contexts now so we don't lose track of which
-    // ones changed.
-    propagateParentContextChangesToDeferredTree(
-      current,
-      workInProgress,
-      renderLanes
-    );
+  // Only used by lazy implementation
+  if (!enableLazyContextPropagation) {
+    return;
   }
 
-  return null;
-} // Note: These happen to have identical begin phases, for now. We shouldn't hold
-// ourselves to this constraint, though. If the behavior diverges, we should
-// fork the function.
-
-var updateLegacyHiddenComponent = updateOffscreenComponent;
+  var fiber = workInProgress.child;
 
-function updateCacheComponent(current, workInProgress, renderLanes) {
-  prepareToReadContext(workInProgress, renderLanes);
-  var parentCache = readContext(CacheContext);
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
+  }
 
-  if (current === null) {
-    // Initial mount. Request a fresh cache from the pool.
-    var freshCache = requestCacheFromPool(renderLanes);
-    var initialState = {
-      parent: parentCache,
-      cache: freshCache
-    };
-    workInProgress.memoizedState = initialState;
-    initializeUpdateQueue(workInProgress);
-    pushCacheProvider(workInProgress, freshCache);
-  } else {
-    // Check for updates
-    if (includesSomeLane(current.lanes, renderLanes)) {
-      cloneUpdateQueue(current, workInProgress);
-      processUpdateQueue(workInProgress, null, null, renderLanes);
-    }
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
 
-    var prevState = current.memoizedState;
-    var nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
-    // a refresh.
+    var list = fiber.dependencies;
 
-    if (prevState.parent !== parentCache) {
-      // Refresh in parent. Update the parent.
-      var derivedState = {
-        parent: parentCache,
-        cache: parentCache
-      }; // Copied from getDerivedStateFromProps implementation. Once the update
-      // queue is empty, persist the derived state onto the base state.
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dep = list.firstContext;
 
-      workInProgress.memoizedState = derivedState;
+      findChangedDep: while (dep !== null) {
+        // Assigning these to constants to help Flow
+        var dependency = dep;
+        var consumer = fiber;
 
-      if (workInProgress.lanes === NoLanes) {
-        var updateQueue = workInProgress.updateQueue;
-        workInProgress.memoizedState = updateQueue.baseState = derivedState;
-      }
+        for (var i = 0; i < contexts.length; i++) {
+          var context = contexts[i]; // Check if the context matches.
+          // TODO: Compare selected values to bail out early.
 
-      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
-      // already did.
-    } else {
-      // The parent didn't refresh. Now check if this cache did.
-      var nextCache = nextState.cache;
-      pushCacheProvider(workInProgress, nextCache);
+          if (dependency.context === context) {
+            // Match! Schedule an update on this fiber.
+            // In the lazy implementation, don't mark a dirty flag on the
+            // dependency itself. Not all changes are propagated, so we can't
+            // rely on the propagation function alone to determine whether
+            // something has changed; the consumer will check. In the future, we
+            // could add back a dirty flag as an optimization to avoid double
+            // checking, but until we have selectors it's not really worth
+            // the trouble.
+            consumer.lanes = mergeLanes(consumer.lanes, renderLanes);
+            var alternate = consumer.alternate;
 
-      if (nextCache !== prevState.cache) {
-        // This cache refreshed. Propagate a context change.
-        propagateContextChange(workInProgress, CacheContext, renderLanes);
-      }
-    }
-  }
+            if (alternate !== null) {
+              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+            }
 
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-} // This should only be called if the name changes
+            scheduleContextWorkOnParentPath(
+              consumer.return,
+              renderLanes,
+              workInProgress
+            );
 
-function updateTracingMarkerComponent(current, workInProgress, renderLanes) {
-  if (!enableTransitionTracing) {
-    return null;
-  } // TODO: (luna) Only update the tracing marker if it's newly rendered or it's name changed.
-  // A tracing marker is only associated with the transitions that rendered
-  // or updated it, so we can create a new set of transitions each time
+            if (!forcePropagateEntireTree) {
+              // During lazy propagation, when we find a match, we can defer
+              // propagating changes to the children, because we're going to
+              // visit them during render. We should continue propagating the
+              // siblings, though
+              nextFiber = null;
+            } // Since we already found a match, we can stop traversing the
+            // dependency list.
 
-  if (current === null) {
-    var currentTransitions = getPendingTransitions();
+            break findChangedDep;
+          }
+        }
 
-    if (currentTransitions !== null) {
-      var markerInstance = {
-        tag: TransitionTracingMarker,
-        transitions: new Set(currentTransitions),
-        pendingBoundaries: null,
-        name: workInProgress.pendingProps.name,
-        aborts: null
-      };
-      workInProgress.stateNode = markerInstance; // We call the marker complete callback when all child suspense boundaries resolve.
-      // We do this in the commit phase on Offscreen. If the marker has no child suspense
-      // boundaries, we need to schedule a passive effect to make sure we call the marker
-      // complete callback.
+        dep = dependency.next;
+      }
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      var parentSuspense = fiber.return;
 
-      workInProgress.flags |= Passive$1;
-    }
-  } else {
-    {
-      if (current.memoizedProps.name !== workInProgress.pendingProps.name) {
-        error(
-          "Changing the name of a tracing marker after mount is not supported. " +
-            "To remount the tracing marker, pass it a new key."
+      if (parentSuspense === null) {
+        throw new Error(
+          "We just came from a parent so we must have had a parent. This is a bug in React."
         );
       }
-    }
-  }
 
-  var instance = workInProgress.stateNode;
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      var _alternate2 = parentSuspense.alternate;
 
-  if (instance !== null) {
-    pushMarkerInstance(workInProgress, instance);
-  }
+      if (_alternate2 !== null) {
+        _alternate2.lanes = mergeLanes(_alternate2.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
 
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+      scheduleContextWorkOnParentPath(
+        parentSuspense,
+        renderLanes,
+        workInProgress
+      );
+      nextFiber = null;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
 
-function updateFragment(current, workInProgress, renderLanes) {
-  var nextChildren = workInProgress.pendingProps;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.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;
 
-function updateMode(current, workInProgress, renderLanes) {
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
 
-function updateProfiler(current, workInProgress, renderLanes) {
-  {
-    workInProgress.flags |= Update;
+        var sibling = nextFiber.sibling;
 
-    {
-      // Reset effect durations for the next eventual effect phase.
-      // These are reset during render to allow the DevTools commit hook a chance to read them,
-      var stateNode = workInProgress.stateNode;
-      stateNode.effectDuration = 0;
-      stateNode.passiveEffectDuration = 0;
+        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;
+      }
     }
-  }
 
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+    fiber = nextFiber;
+  }
 }
 
-function markRef$1(current, workInProgress) {
-  var ref = workInProgress.ref;
+function lazilyPropagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = false;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
+} // Used for propagating a deferred tree (Suspense, Offscreen). We must propagate
+// to the entire subtree, because we won't revisit it until after the current
+// render has completed, at which point we'll have lost track of which providers
+// have changed.
 
-  if (
-    (current === null && ref !== null) ||
-    (current !== null && current.ref !== ref)
-  ) {
-    // Schedule a Ref effect
-    workInProgress.flags |= Ref;
-    workInProgress.flags |= RefStatic;
-  }
+function propagateParentContextChangesToDeferredTree(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = true;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
 }
 
-function updateFunctionComponent(
+function propagateParentContextChanges(
   current,
   workInProgress,
-  Component,
-  nextProps,
-  renderLanes
+  renderLanes,
+  forcePropagateEntireTree
 ) {
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+  if (!enableLazyContextPropagation) {
+    return;
+  } // Collect all the parent providers that changed. Since this is usually small
+  // number, we use an Array instead of Set.
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
+  var contexts = null;
+  var parent = workInProgress;
+  var isInsidePropagationBailout = false;
+
+  while (parent !== null) {
+    if (!isInsidePropagationBailout) {
+      if ((parent.flags & NeedsPropagation) !== NoFlags$1) {
+        isInsidePropagationBailout = true;
+      } else if ((parent.flags & DidPropagateContext) !== NoFlags$1) {
+        break;
       }
     }
-  }
 
-  var context;
+    if (parent.tag === ContextProvider) {
+      var currentParent = parent.alternate;
 
-  {
-    var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
-    context = getMaskedContext(workInProgress, unmaskedContext);
-  }
+      if (currentParent === null) {
+        throw new Error("Should have a current fiber. This is a bug in React.");
+      }
 
-  var nextChildren;
-  var hasId;
-  prepareToReadContext(workInProgress, renderLanes);
+      var oldProps = currentParent.memoizedProps;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
+      if (oldProps !== null) {
+        var providerType = parent.type;
+        var context = providerType._context;
+        var newProps = parent.pendingProps;
+        var newValue = newProps.value;
+        var oldValue = oldProps.value;
+
+        if (!objectIs(newValue, oldValue)) {
+          if (contexts !== null) {
+            contexts.push(context);
+          } else {
+            contexts = [context];
+          }
+        }
+      }
+    }
+
+    parent = parent.return;
   }
 
-  {
-    ReactCurrentOwner$2.current = workInProgress;
-    setIsRendering(true);
-    nextChildren = renderWithHooks(
-      current,
+  if (contexts !== null) {
+    // If there were any changed providers, search through the children and
+    // propagate their changes.
+    propagateContextChanges(
       workInProgress,
-      Component,
-      nextProps,
-      context,
-      renderLanes
+      contexts,
+      renderLanes,
+      forcePropagateEntireTree
     );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
+  } // This is an optimization so that we only propagate once per subtree. If a
+  // deeply nested child bails out, and it calls this propagation function, it
+  // uses this flag to know that the remaining ancestor providers have already
+  // been propagated.
+  //
+  // NOTE: This optimization is only necessary because we sometimes enter the
+  // begin phase of nodes that don't have any work scheduled on them —
+  // specifically, the siblings of a node that _does_ have scheduled work. The
+  // siblings will bail out and call this function again, even though we already
+  // propagated content changes to it and its subtree. So we use this flag to
+  // mark that the parent providers already propagated.
+  //
+  // Unfortunately, though, we need to ignore this flag when we're inside a
+  // tree whose context propagation was deferred — that's what the
+  // `NeedsPropagation` flag is for.
+  //
+  // If we could instead bail out before entering the siblings' begin phase,
+  // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
+  // Consider this as part of the next refactor to the fiber tree structure.
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+  workInProgress.flags |= DidPropagateContext;
+}
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  }
+function checkIfContextChanged(currentDependencies) {
+  if (!enableLazyContextPropagation) {
+    return false;
+  } // Iterate over the current dependencies to see if something changed. This
+  // only gets called if props and state has already bailed out, so it's a
+  // relatively uncommon path, except at the root of a changed subtree.
+  // Alternatively, we could move these comparisons into `readContext`, but
+  // that's a much hotter path, so I think this is an appropriate trade off.
 
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
+  var dependency = currentDependencies.firstContext;
 
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+  while (dependency !== null) {
+    var context = dependency.context;
+    var newValue = context._currentValue;
+    var oldValue = dependency.memoizedValue;
 
-function replayFunctionComponent(
-  current,
-  workInProgress,
-  nextProps,
-  Component,
-  renderLanes
-) {
-  // This function is used to replay a component that previously suspended,
-  // after its data resolves. It's a simplified version of
-  // updateFunctionComponent that reuses the hooks from the previous attempt.
-  var context;
+    if (!objectIs(newValue, oldValue)) {
+      return true;
+    }
 
-  {
-    var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
-    context = getMaskedContext(workInProgress, unmaskedContext);
+    dependency = dependency.next;
   }
 
-  prepareToReadContext(workInProgress, renderLanes);
-
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+  return false;
+}
+function prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  var dependencies = workInProgress.dependencies;
 
-  var nextChildren = replaySuspendedComponentWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    context
-  );
-  var hasId = checkDidRenderIdHook();
+  if (dependencies !== null) {
+    if (enableLazyContextPropagation) {
+      // Reset the work-in-progress list
+      dependencies.firstContext = null;
+    } else {
+      var firstContext = dependencies.firstContext;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+        dependencies.firstContext = null;
+      }
+    }
   }
-
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
 }
-
-function updateClassComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
+function readContext(context) {
   {
-    // This is used by DevTools to force a boundary to error.
-    switch (shouldError(workInProgress)) {
-      case false: {
-        var _instance = workInProgress.stateNode;
-        var ctor = workInProgress.type; // TODO This way of resetting the error boundary state is a hack.
-        // Is there a better way to do this?
-
-        var tempInstance = new ctor(
-          workInProgress.memoizedProps,
-          _instance.context
-        );
-        var state = tempInstance.state;
+    // This warning would fire if you read context inside a Hook like useMemo.
+    // Unlike the class check below, it's not enforced in production for perf.
+    if (isDisallowedContextReadInDEV) {
+      error(
+        "Context can only be read while React is rendering. " +
+          "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+          "In function components, you can read it directly in the function body, but not " +
+          "inside Hooks like useReducer() or useMemo()."
+      );
+    }
+  }
 
-        _instance.updater.enqueueSetState(_instance, state, null);
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
+  }
 
-        break;
-      }
+  return readContextForConsumer(consumer, context);
+}
 
-      case true: {
-        workInProgress.flags |= DidCapture;
-        workInProgress.flags |= ShouldCapture; // eslint-disable-next-line react-internal/prod-error-codes
+function readContextForConsumer(consumer, context) {
+  var value = context._currentValue;
 
-        var error$1 = new Error("Simulated error coming from DevTools");
-        var lane = pickArbitraryLane(renderLanes);
-        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+  if (lastFullyObservedContext === context);
+  else {
+    var contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
 
-        var update = createClassErrorUpdate(
-          workInProgress,
-          createCapturedValueAtFiber(error$1, workInProgress),
-          lane
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw new Error(
+          "Context can only be read while React is rendering. " +
+            "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+            "In function components, you can read it directly in the function body, but not " +
+            "inside Hooks like useReducer() or useMemo()."
         );
-        enqueueCapturedUpdate(workInProgress, update);
-        break;
-      }
-    }
+      } // This is the first dependency for this component. Create a new list.
 
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
+      if (enableLazyContextPropagation) {
+        consumer.flags |= NeedsPropagation;
       }
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
     }
-  } // 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;
+  return value;
+}
 
-  if (isContextProvider(Component)) {
-    hasContext = true;
-    pushContextProvider(workInProgress);
-  } else {
-    hasContext = false;
-  }
+// replace it with a lightweight shim that only has the features we use.
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var instance = workInProgress.stateNode;
-  var shouldUpdate;
+var AbortControllerLocal =
+  typeof AbortController !== "undefined"
+    ? AbortController // $FlowFixMe[missing-this-annot]
+    : function AbortControllerShim() {
+        var listeners = [];
+        var signal = (this.signal = {
+          aborted: false,
+          addEventListener: function (type, listener) {
+            listeners.push(listener);
+          }
+        });
 
-  if (instance === null) {
-    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+        this.abort = function () {
+          signal.aborted = true;
+          listeners.forEach(function (listener) {
+            return listener();
+          });
+        };
+      }; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
 
-    constructClassInstance(workInProgress, Component, nextProps);
-    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
-    shouldUpdate = true;
-  } else if (current === null) {
-    // In a resume, we'll already have an instance we can reuse.
-    shouldUpdate = resumeMountClassInstance(
-      workInProgress,
-      Component,
-      nextProps,
-      renderLanes
-    );
-  } else {
-    shouldUpdate = updateClassInstance(
-      current,
-      workInProgress,
-      Component,
-      nextProps,
-      renderLanes
-    );
-  }
+var scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+  NormalPriority = Scheduler.unstable_NormalPriority;
+var CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
+};
 
-  var nextUnitOfWork = finishClassComponent(
-    current,
-    workInProgress,
-    Component,
-    shouldUpdate,
-    hasContext,
-    renderLanes
-  );
+{
+  CacheContext._currentRenderer = null;
+  CacheContext._currentRenderer2 = null;
+} // Creates a new empty Cache instance with a ref-count of 0. The caller is responsible
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
 
+function createCache() {
+  var cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+  return cache;
+}
+function retainCache(cache) {
   {
-    var inst = workInProgress.stateNode;
-
-    if (shouldUpdate && inst.props !== nextProps) {
-      if (!didWarnAboutReassigningProps) {
-        error(
-          "It looks like %s is reassigning its own `this.props` while rendering. " +
-            "This is not supported and can lead to confusing bugs.",
-          getComponentNameFromFiber(workInProgress) || "a component"
-        );
-      }
-
-      didWarnAboutReassigningProps = true;
+    if (cache.controller.signal.aborted) {
+      warn(
+        "A cache instance was retained after it was already freed. " +
+          "This likely indicates a bug in React."
+      );
     }
   }
 
-  return nextUnitOfWork;
-}
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
 
-function finishClassComponent(
-  current,
-  workInProgress,
-  Component,
-  shouldUpdate,
-  hasContext,
-  renderLanes
-) {
-  // Refs should update even if shouldComponentUpdate returns false
-  markRef$1(current, workInProgress);
-  var didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+function releaseCache(cache) {
+  cache.refCount--;
 
-  if (!shouldUpdate && !didCaptureError) {
-    // Context providers should defer to sCU for rendering
-    if (hasContext) {
-      invalidateContextProvider(workInProgress, Component, false);
+  {
+    if (cache.refCount < 0) {
+      warn(
+        "A cache instance was released after it was already freed. " +
+          "This likely indicates a bug in React."
+      );
     }
-
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
 
-  var instance = workInProgress.stateNode; // Rerender
-
-  ReactCurrentOwner$2.current = workInProgress;
-  var nextChildren;
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, function () {
+      cache.controller.abort();
+    });
+  }
+}
+function pushCacheProvider(workInProgress, cache) {
+  pushProvider(workInProgress, CacheContext, cache);
+}
+function popCacheProvider(workInProgress, cache) {
+  popProvider(CacheContext, workInProgress);
+}
 
-  if (
-    didCaptureError &&
-    typeof Component.getDerivedStateFromError !== "function"
-  ) {
-    // If we captured an error, but getDerivedStateFromError is not defined,
-    // unmount all the children. componentDidCatch will schedule an update to
-    // re-render a fallback. This is temporary until we migrate everyone to
-    // the new API.
-    // TODO: Warn in a future release.
-    nextChildren = null;
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+var NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
 
-    {
-      stopProfilerTimerIfRunning();
-    }
-  } else {
-    if (enableSchedulingProfiler) {
-      markComponentRenderStarted(workInProgress);
-    }
+var resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+// transitions. Therefore, we want to lazily combine transitions. Instead of
+// comparing the arrays of transitions when we combine them and storing them
+// and filtering out the duplicates, we will instead store the unprocessed transitions
+// in an array and actually filter them in the passive phase.
 
-    {
-      setIsRendering(true);
-      nextChildren = instance.render();
+var transitionStack = createCursor(null);
 
-      if (workInProgress.mode & StrictLegacyMode) {
-        setIsStrictModeForDevtools(true);
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
 
-        try {
-          instance.render();
-        } finally {
-          setIsStrictModeForDevtools(false);
-        }
-      }
+  var cacheResumedFromPreviousRender = resumedCache.current;
 
-      setIsRendering(false);
-    }
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
 
-    if (enableSchedulingProfiler) {
-      markComponentRenderStopped();
-    }
-  } // React DevTools reads this flag.
+  var root = getWorkInProgressRoot();
+  var cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
+}
 
-  workInProgress.flags |= PerformedWork;
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  var cacheFromPool = peekCacheFromPool();
 
-  if (current !== null && didCaptureError) {
-    // If we're recovering from an error, reconcile without reusing any of
-    // the existing children. Conceptually, the normal children and the children
-    // that are shown on error are two different sets, so we shouldn't reuse
-    // normal children even if their identities match.
-    forceUnmountCurrentAndReconcile(
-      current,
-      workInProgress,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  } // Memoize state using the values we just used to render.
-  // TODO: Restructure so we never read values from the instance.
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
 
-  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+  var root = getWorkInProgressRoot();
+  var freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
 
-  if (hasContext) {
-    invalidateContextProvider(workInProgress, Component, true);
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
   }
 
-  return workInProgress.child;
+  return freshCache;
 }
-
-function pushHostRootContext(workInProgress) {
-  var root = workInProgress.stateNode;
-
-  if (root.pendingContext) {
-    pushTopLevelContextObject(
-      workInProgress,
-      root.pendingContext,
-      root.pendingContext !== root.context
-    );
-  } else if (root.context) {
-    // Should always be set
-    pushTopLevelContextObject(workInProgress, root.context, false);
+function pushRootTransition(workInProgress, root, renderLanes) {
+  if (enableTransitionTracing) {
+    var rootTransitions = getWorkInProgressTransitions();
+    push(transitionStack, rootTransitions, workInProgress);
   }
-
-  pushHostContainer(workInProgress, root.containerInfo);
 }
-
-function updateHostRoot(current, workInProgress, renderLanes) {
-  pushHostRootContext(workInProgress);
-
-  if (current === null) {
-    throw new Error("Should have a current fiber. This is a bug in React.");
-  }
-
-  var nextProps = workInProgress.pendingProps;
-  var prevState = workInProgress.memoizedState;
-  var prevChildren = prevState.element;
-  cloneUpdateQueue(current, workInProgress);
-  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
-  var nextState = workInProgress.memoizedState;
-  var root = workInProgress.stateNode;
-  pushRootTransition(workInProgress);
-
+function popRootTransition(workInProgress, root, renderLanes) {
   if (enableTransitionTracing) {
-    pushRootMarkerInstance(workInProgress);
+    pop(transitionStack, workInProgress);
   }
-
+}
+function pushTransition(
+  offscreenWorkInProgress,
+  prevCachePool,
+  newTransitions
+) {
   {
-    var nextCache = nextState.cache;
-    pushCacheProvider(workInProgress, nextCache);
-
-    if (nextCache !== prevState.cache) {
-      // The root cache refreshed.
-      propagateContextChange(workInProgress, CacheContext, renderLanes);
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current, offscreenWorkInProgress);
+    } else {
+      push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
     }
-  } // Caution: React DevTools currently depends on this property
-  // being called "element".
-
-  var nextChildren = nextState.element;
-
-  if (prevState.isDehydrated) {
-    // This is a hydration root whose shell has not yet hydrated. We should
-    // attempt to hydrate.
-    // Flip isDehydrated to false to indicate that when this render
-    // finishes, the root will no longer be dehydrated.
-    var overrideState = {
-      element: nextChildren,
-      isDehydrated: false,
-      cache: nextState.cache
-    };
-    var updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
-    // have reducer functions so it doesn't need rebasing.
-
-    updateQueue.baseState = overrideState;
-    workInProgress.memoizedState = overrideState;
-
-    if (workInProgress.flags & ForceClientRender) {
-      // Something errored during a previous attempt to hydrate the shell, so we
-      // forced a client render.
-      var recoverableError = createCapturedValueAtFiber(
-        new Error(
-          "There was an error while hydrating. Because the error happened outside " +
-            "of a Suspense boundary, the entire root will switch to " +
-            "client rendering."
-        ),
-        workInProgress
-      );
-      return mountHostRootWithoutHydrating(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes,
-        recoverableError
-      );
-    } else if (nextChildren !== prevChildren) {
-      var _recoverableError = createCapturedValueAtFiber(
-        new Error(
-          "This root received an early update, before anything was able " +
-            "hydrate. Switched the entire root to client rendering."
-        ),
-        workInProgress
-      );
+  }
 
-      return mountHostRootWithoutHydrating(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes,
-        _recoverableError
-      );
+  if (enableTransitionTracing) {
+    if (transitionStack.current === null) {
+      push(transitionStack, newTransitions, offscreenWorkInProgress);
+    } else if (newTransitions === null) {
+      push(transitionStack, transitionStack.current, offscreenWorkInProgress);
     } else {
-      // The outermost shell has not hydrated yet. Start hydrating.
-      enterHydrationState(workInProgress);
-
-      {
-        var mutableSourceEagerHydrationData =
-          root.mutableSourceEagerHydrationData;
-
-        if (mutableSourceEagerHydrationData != null) {
-          for (var i = 0; i < mutableSourceEagerHydrationData.length; i += 2) {
-            var mutableSource = mutableSourceEagerHydrationData[i];
-            var version = mutableSourceEagerHydrationData[i + 1];
-            setWorkInProgressVersion(mutableSource, version);
-          }
-        }
-      }
-
-      var child = mountChildFibers(
-        workInProgress,
-        null,
-        nextChildren,
-        renderLanes
+      push(
+        transitionStack,
+        transitionStack.current.concat(newTransitions),
+        offscreenWorkInProgress
       );
-      workInProgress.child = child;
-      var node = child;
-
-      while (node) {
-        // Mark each child as hydrating. This is a fast path to know whether this
-        // tree is part of a hydrating tree. This is used to determine if a child
-        // node has fully mounted yet, and for scheduling event replaying.
-        // Conceptually this is similar to Placement in that a new subtree is
-        // inserted into the React tree here. It just happens to not need DOM
-        // mutations because it already exists.
-        node.flags = (node.flags & ~Placement) | Hydrating;
-        node = node.sibling;
-      }
     }
-  } else {
-    // Root is not dehydrated. Either this is a client-only root, or it
-    // already hydrated.
-    resetHydrationState();
-
-    if (nextChildren === prevChildren) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+}
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+    if (enableTransitionTracing) {
+      pop(transitionStack, workInProgress);
     }
 
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+    {
+      pop(resumedCache, workInProgress);
+    }
   }
-
-  return workInProgress.child;
 }
+function getPendingTransitions() {
+  if (!enableTransitionTracing) {
+    return null;
+  }
 
-function mountHostRootWithoutHydrating(
-  current,
-  workInProgress,
-  nextChildren,
-  renderLanes,
-  recoverableError
-) {
-  // Revert to client rendering.
-  resetHydrationState();
-  queueHydrationError(recoverableError);
-  workInProgress.flags |= ForceClientRender;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+  return transitionStack.current;
 }
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
 
-function updateHostComponent$1(current, workInProgress, renderLanes) {
-  pushHostContext(workInProgress);
+  var cacheFromPool = peekCacheFromPool();
 
-  if (current === null) {
-    tryToClaimNextHydratableInstance(workInProgress);
+  if (cacheFromPool === null) {
+    return null;
   }
 
-  var type = workInProgress.type;
-  var nextProps = workInProgress.pendingProps;
-  var prevProps = current !== null ? current.memoizedProps : null;
-  var nextChildren = nextProps.children;
-  var isDirectTextChild = shouldSetTextContent(type, nextProps);
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue,
+    pool: cacheFromPool
+  };
+}
+function getOffscreenDeferredCache() {
+  var cacheFromPool = peekCacheFromPool();
 
-  if (isDirectTextChild) {
-    // We special case a direct text child of a host node. This is a common
-    // case. We won't handle it as a reified child. We will instead handle
-    // this in the host environment that also has access to this prop. That
-    // avoids allocating another HostText fiber and traversing it.
-    nextChildren = null;
-  } 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.flags |= ContentReset;
+  if (cacheFromPool === null) {
+    return null;
   }
 
-  markRef$1(current, workInProgress);
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue,
+    pool: cacheFromPool
+  };
 }
 
-function updateHostHoistable(current, workInProgress, renderLanes) {
-  markRef$1(current, workInProgress);
-  var currentProps = current === null ? null : current.memoizedProps;
-  var resource = (workInProgress.memoizedState = getResource(
-    workInProgress.type,
-    currentProps,
-    workInProgress.pendingProps
-  ));
-
-  if (current === null) {
-    if (!getIsHydrating() && resource === null) {
-      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
-      workInProgress.stateNode = createHoistableInstance(
-        workInProgress.type,
-        workInProgress.pendingProps,
-        getRootHostContainer(),
-        workInProgress
-      );
-    }
-  } // Resources never have reconciler managed children. It is possible for
-  // the host implementation of getResource to consider children in the
-  // resource construction but they will otherwise be discarded. In practice
-  // this precludes all but the simplest children and Host specific warnings
-  // should be implemented to warn when children are passsed when otherwise not
-  // expected
-
-  return null;
+function getSuspenseFallbackChild(fiber) {
+  return fiber.child.sibling.child;
 }
 
-function updateHostSingleton(current, workInProgress, renderLanes) {
-  pushHostContext(workInProgress);
-
-  if (current === null) {
-    claimHydratableSingleton(workInProgress);
-  }
+var emptyObject = {};
 
-  var nextChildren = workInProgress.pendingProps.children;
+function collectScopedNodes(node, fn, scopedNodes) {
+  {
+    if (node.tag === HostComponent) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        stateNode = node.stateNode;
+      var instance = getPublicInstance(stateNode);
 
-  if (current === null && !getIsHydrating()) {
-    // Similar to Portals we append Singleton children in the commit phase. So we
-    // Track insertions even on mount.
-    // TODO: Consider unifying this with how the root works.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  }
+      if (
+        instance !== null &&
+        fn(type, memoizedProps || emptyObject, instance) === true
+      ) {
+        scopedNodes.push(instance);
+      }
+    }
 
-  markRef$1(current, workInProgress);
-  return workInProgress.child;
-}
+    var child = node.child;
 
-function updateHostText$1(current, workInProgress) {
-  if (current === null) {
-    tryToClaimNextHydratableTextInstance(workInProgress);
-  } // Nothing to do here. This is terminal. We'll do the completion step
-  // immediately after.
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
+    }
 
-  return null;
+    if (child !== null) {
+      collectScopedNodesFromChildren(child, fn, scopedNodes);
+    }
+  }
 }
 
-function mountLazyComponent(
-  _current,
-  workInProgress,
-  elementType,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
-  var props = workInProgress.pendingProps;
-  var lazyComponent = elementType;
-  var payload = lazyComponent._payload;
-  var init = lazyComponent._init;
-  var Component = init(payload); // Store the unwrapped component in the type.
-
-  workInProgress.type = Component;
-  var resolvedTag = (workInProgress.tag = resolveLazyComponentTag(Component));
-  var resolvedProps = resolveDefaultProps(Component, props);
-  var child;
+function collectFirstScopedNode(node, fn) {
+  {
+    if (node.tag === HostComponent) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        stateNode = node.stateNode;
+      var instance = getPublicInstance(stateNode);
 
-  switch (resolvedTag) {
-    case FunctionComponent: {
-      {
-        validateFunctionComponentInDev(workInProgress, Component);
-        workInProgress.type = Component =
-          resolveFunctionForHotReloading(Component);
+      if (instance !== null && fn(type, memoizedProps, instance) === true) {
+        return instance;
       }
-
-      child = updateFunctionComponent(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
     }
 
-    case ClassComponent: {
-      {
-        workInProgress.type = Component =
-          resolveClassForHotReloading(Component);
-      }
+    var child = node.child;
 
-      child = updateClassComponent(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
     }
 
-    case ForwardRef: {
-      {
-        workInProgress.type = Component =
-          resolveForwardRefForHotReloading(Component);
-      }
-
-      child = updateForwardRef(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
+    if (child !== null) {
+      return collectFirstScopedNodeFromChildren(child, fn);
     }
+  }
 
-    case MemoComponent: {
-      {
-        if (workInProgress.type !== workInProgress.elementType) {
-          var outerPropTypes = Component.propTypes;
+  return null;
+}
 
-          if (outerPropTypes) {
-            checkPropTypes(
-              outerPropTypes,
-              resolvedProps, // Resolved for outer only
-              "prop",
-              getComponentNameFromType(Component)
-            );
-          }
-        }
-      }
+function collectScopedNodesFromChildren(startingChild, fn, scopedNodes) {
+  var child = startingChild;
 
-      child = updateMemoComponent(
-        null,
-        workInProgress,
-        Component,
-        resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
-        renderLanes
-      );
-      return child;
+  while (child !== null) {
+    collectScopedNodes(child, fn, scopedNodes);
+    child = child.sibling;
+  }
+}
+
+function collectFirstScopedNodeFromChildren(startingChild, fn) {
+  var child = startingChild;
+
+  while (child !== null) {
+    var scopedNode = collectFirstScopedNode(child, fn);
+
+    if (scopedNode !== null) {
+      return scopedNode;
     }
+
+    child = child.sibling;
   }
 
-  var hint = "";
+  return null;
+}
 
-  {
-    if (
-      Component !== null &&
-      typeof Component === "object" &&
-      Component.$$typeof === REACT_LAZY_TYPE
-    ) {
-      hint = " Did you wrap a component in React.lazy() more than once?";
+function collectNearestContextValues(node, context, childContextValues) {
+  if (node.tag === ContextProvider && node.type._context === context) {
+    var contextValue = node.memoizedProps.value;
+    childContextValues.push(contextValue);
+  } else {
+    var child = node.child;
+
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
     }
-  } // This message intentionally doesn't mention ForwardRef or MemoComponent
-  // because the fact that it's a separate type of work is an
-  // implementation detail.
 
-  throw new Error(
-    "Element type is invalid. Received a promise that resolves to: " +
-      Component +
-      ". " +
-      ("Lazy element type must resolve to a class or function." + hint)
-  );
+    if (child !== null) {
+      collectNearestChildContextValues(child, context, childContextValues);
+    }
+  }
 }
 
-function mountIncompleteClassComponent(
-  _current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
+function collectNearestChildContextValues(
+  startingChild,
+  context,
+  childContextValues
 ) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+  var child = startingChild;
 
-  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
-  // 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.
+  while (child !== null) {
+    collectNearestContextValues(child, context, childContextValues);
+    child = child.sibling;
+  }
+}
 
-  var hasContext;
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
 
-  if (isContextProvider(Component)) {
-    hasContext = true;
-    pushContextProvider(workInProgress);
-  } else {
-    hasContext = false;
+  if (currentFiber === null) {
+    return null;
   }
 
-  prepareToReadContext(workInProgress, renderLanes);
-  constructClassInstance(workInProgress, Component, nextProps);
-  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
-  return finishClassComponent(
-    null,
-    workInProgress,
-    Component,
-    true,
-    hasContext,
-    renderLanes
-  );
+  var child = currentFiber.child;
+  var scopedNodes = [];
+
+  if (child !== null) {
+    collectScopedNodesFromChildren(child, fn, scopedNodes);
+  }
+
+  return scopedNodes.length === 0 ? null : scopedNodes;
 }
 
-function mountIndeterminateComponent(
-  _current,
-  workInProgress,
-  Component,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
-  var props = workInProgress.pendingProps;
-  var context;
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
 
-  {
-    var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
-    context = getMaskedContext(workInProgress, unmaskedContext);
+  if (currentFiber === null) {
+    return null;
   }
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var value;
-  var hasId;
+  var child = currentFiber.child;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
+  if (child !== null) {
+    return collectFirstScopedNodeFromChildren(child, fn);
   }
 
-  {
-    if (
-      Component.prototype &&
-      typeof Component.prototype.render === "function"
-    ) {
-      var componentName = getComponentNameFromType(Component) || "Unknown";
+  return null;
+}
 
-      if (!didWarnAboutBadClass[componentName]) {
-        error(
-          "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
-            "This is likely to cause errors. Change %s to extend React.Component instead.",
-          componentName,
-          componentName
-        );
+function containsNode(node) {
+  var fiber = getInstanceFromNode$1(node);
 
-        didWarnAboutBadClass[componentName] = true;
-      }
+  while (fiber !== null) {
+    if (fiber.tag === ScopeComponent && fiber.stateNode === this) {
+      return true;
     }
 
-    if (workInProgress.mode & StrictLegacyMode) {
-      ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
-    }
+    fiber = fiber.return;
+  }
 
-    setIsRendering(true);
-    ReactCurrentOwner$2.current = workInProgress;
-    value = renderWithHooks(
-      null,
-      workInProgress,
-      Component,
-      props,
-      context,
-      renderLanes
-    );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
+  return false;
+}
+
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
+
+  if (currentFiber === null) {
+    return [];
   }
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  } // React DevTools reads this flag.
+  var child = currentFiber.child;
+  var childContextValues = [];
 
-  workInProgress.flags |= PerformedWork;
+  if (child !== null) {
+    collectNearestChildContextValues(child, context, childContextValues);
+  }
 
-  {
-    // Support for module components is deprecated and is removed behind a flag.
-    // Whether or not it would crash later, we want to show a good message in DEV first.
-    if (
-      typeof value === "object" &&
-      value !== null &&
-      typeof value.render === "function" &&
-      value.$$typeof === undefined
-    ) {
-      var _componentName = getComponentNameFromType(Component) || "Unknown";
+  return childContextValues;
+}
 
-      if (!didWarnAboutModulePatternComponent[_componentName]) {
-        error(
-          "The <%s /> component appears to be a function component that returns a class instance. " +
-            "Change %s to a class that extends React.Component instead. " +
-            "If you can't use a class try assigning the prototype on the function as a workaround. " +
-            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
-            "cannot be called with `new` by React.",
-          _componentName,
-          _componentName,
-          _componentName
-        );
+function createScopeInstance() {
+  return {
+    DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+    DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+    containsNode: containsNode,
+    getChildContextValues: getChildContextValues
+  };
+}
 
-        didWarnAboutModulePatternComponent[_componentName] = true;
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
+
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
+
+function appendAllChildren(
+  parent,
+  workInProgress,
+  needsVisibilityToggle,
+  isHidden
+) {
+  {
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    var node = workInProgress.child;
+
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || node.tag === HostSingleton);
+      else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
       }
+
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
+        }
+
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      node.sibling.return = node.return;
+      node = node.sibling;
     }
   }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
 
+function updateHostComponent(current, workInProgress, type, newProps) {
   {
-    // Proceed under the assumption that this is a function component
-    workInProgress.tag = FunctionComponent;
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    var oldProps = current.memoizedProps;
 
-    if (getIsHydrating() && hasId) {
-      pushMaterializedTreeId(workInProgress);
-    }
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    } // If we get updated because one of our children updated, we don't
+    // have newProps so we'll have to reuse them.
+    // TODO: Split the update API as separate for the props vs. children.
+    // Even better would be if children weren't special cased at all tho.
 
-    reconcileChildren(null, workInProgress, value, renderLanes);
+    var instance = workInProgress.stateNode;
+    var currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host
+    // component is hitting the resume path. Figure out why. Possibly
+    // related to `hidden`.
 
-    {
-      validateFunctionComponentInDev(workInProgress, Component);
-    }
+    var updatePayload = prepareUpdate(
+      instance,
+      type,
+      oldProps,
+      newProps,
+      currentHostContext
+    ); // TODO: Type this specific to this type of component.
 
-    return workInProgress.child;
+    workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
+    // is a new ref we mark this as an update. All the work is done in commitWork.
+
+    if (updatePayload) {
+      markUpdate(workInProgress);
+    }
   }
 }
 
-function validateFunctionComponentInDev(workInProgress, Component) {
+function updateHostText(current, workInProgress, oldText, newText) {
   {
-    if (Component) {
-      if (Component.childContextTypes) {
-        error(
-          "%s(...): childContextTypes cannot be defined on a function component.",
-          Component.displayName || Component.name || "Component"
-        );
-      }
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
     }
+  }
+}
 
-    if (workInProgress.ref !== null) {
-      var info = "";
-      var ownerName = getCurrentFiberOwnerNameInDevOrNull();
-
-      if (ownerName) {
-        info += "\n\nCheck the render method of `" + ownerName + "`.";
-      }
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
 
-      var warningKey = ownerName || "";
-      var debugSource = workInProgress._debugSource;
+  switch (renderState.tailMode) {
+    case "hidden": {
+      // Any insertions at the end of the tail list after this point
+      // should be invisible. If there are already mounted boundaries
+      // anything before them are not considered for collapsing.
+      // Therefore we need to go through the whole tail to find if
+      // there are any.
+      var tailNode = renderState.tail;
+      var lastTailNode = null;
 
-      if (debugSource) {
-        warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
-      }
+      while (tailNode !== null) {
+        if (tailNode.alternate !== null) {
+          lastTailNode = tailNode;
+        }
 
-      if (!didWarnAboutFunctionRefs[warningKey]) {
-        didWarnAboutFunctionRefs[warningKey] = true;
+        tailNode = tailNode.sibling;
+      } // Next we're simply going to delete all insertions after the
+      // last rendered item.
 
-        error(
-          "Function components cannot be given refs. " +
-            "Attempts to access this ref will fail. " +
-            "Did you mean to use React.forwardRef()?%s",
-          info
-        );
+      if (lastTailNode === null) {
+        // All remaining items in the tail are insertions.
+        renderState.tail = null;
+      } else {
+        // Detach the insertion after the last node that was already
+        // inserted.
+        lastTailNode.sibling = null;
       }
+
+      break;
     }
 
-    if (Component.defaultProps !== undefined) {
-      var componentName = getComponentNameFromType(Component) || "Unknown";
+    case "collapsed": {
+      // Any insertions at the end of the tail list after this point
+      // should be invisible. If there are already mounted boundaries
+      // anything before them are not considered for collapsing.
+      // Therefore we need to go through the whole tail to find if
+      // there are any.
+      var _tailNode = renderState.tail;
+      var _lastTailNode = null;
 
-      if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
-        error(
-          "%s: Support for defaultProps will be removed from function components " +
-            "in a future major release. Use JavaScript default parameters instead.",
-          componentName
-        );
+      while (_tailNode !== null) {
+        if (_tailNode.alternate !== null) {
+          _lastTailNode = _tailNode;
+        }
 
-        didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+        _tailNode = _tailNode.sibling;
+      } // Next we're simply going to delete all insertions after the
+      // last rendered item.
+
+      if (_lastTailNode === null) {
+        // All remaining items in the tail are insertions.
+        if (!hasRenderedATailFallback && renderState.tail !== null) {
+          // We suspended during the head. We want to show at least one
+          // row at the tail. So we'll keep on and cut off the rest.
+          renderState.tail.sibling = null;
+        } else {
+          renderState.tail = null;
+        }
+      } else {
+        // Detach the insertion after the last node that was already
+        // inserted.
+        _lastTailNode.sibling = null;
       }
+
+      break;
     }
+  }
+}
 
-    if (typeof Component.getDerivedStateFromProps === "function") {
-      var _componentName3 = getComponentNameFromType(Component) || "Unknown";
+function bubbleProperties(completedWork) {
+  var didBailout =
+    completedWork.alternate !== null &&
+    completedWork.alternate.child === completedWork.child;
+  var newChildLanes = NoLanes;
+  var subtreeFlags = NoFlags$1;
 
-      if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
-        error(
-          "%s: Function components do not support getDerivedStateFromProps.",
-          _componentName3
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      var actualDuration = completedWork.actualDuration;
+      var treeBaseDuration = completedWork.selfBaseDuration;
+      var child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(child.lanes, child.childLanes)
         );
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // When a fiber is cloned, its actualDuration is reset to 0. This value will
+        // only be updated if work is done on the fiber (i.e. it doesn't bailout).
+        // When work is done, it should bubble to the parent's actualDuration. If
+        // the fiber has not been cloned though, (meaning no work was done), then
+        // this value will reflect the amount of time spent working on a previous
+        // render. In that case it should not bubble. We determine whether it was
+        // cloned by comparing the child pointer.
+        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
 
-        didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
+        actualDuration += child.actualDuration; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        treeBaseDuration += child.treeBaseDuration;
+        child = child.sibling;
       }
-    }
 
-    if (
-      typeof Component.contextType === "object" &&
-      Component.contextType !== null
-    ) {
-      var _componentName4 = getComponentNameFromType(Component) || "Unknown";
+      completedWork.actualDuration = actualDuration;
+      completedWork.treeBaseDuration = treeBaseDuration;
+    } else {
+      var _child = completedWork.child;
 
-      if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
-        error(
-          "%s: Function components do not support contextType.",
-          _componentName4
+      while (_child !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child.lanes, _child.childLanes)
         );
+        subtreeFlags |= _child.subtreeFlags;
+        subtreeFlags |= _child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
 
-        didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
+        _child.return = completedWork;
+        _child = _child.sibling;
       }
     }
-  }
-}
 
-var SUSPENDED_MARKER = {
-  dehydrated: null,
-  treeContext: null,
-  retryLane: NoLane
-};
-
-function mountSuspenseOffscreenState(renderLanes) {
-  return {
-    baseLanes: renderLanes,
-    cachePool: getSuspendedCache()
-  };
-}
-
-function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
-  var cachePool = null;
+    completedWork.subtreeFlags |= subtreeFlags;
+  } else {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      var _treeBaseDuration = completedWork.selfBaseDuration;
+      var _child2 = completedWork.child;
 
-  {
-    var prevCachePool = prevOffscreenState.cachePool;
+      while (_child2 !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child2.lanes, _child2.childLanes)
+        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
+        // so we should bubble those up even during a bailout. All the other
+        // flags have a lifetime only of a single render + commit, so we should
+        // ignore them.
 
-    if (prevCachePool !== null) {
-      var parentCache = CacheContext._currentValue;
+        subtreeFlags |= _child2.subtreeFlags & StaticMask;
+        subtreeFlags |= _child2.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
 
-      if (prevCachePool.parent !== parentCache) {
-        // Detected a refresh in the parent. This overrides any previously
-        // suspended cache.
-        cachePool = {
-          parent: parentCache,
-          pool: parentCache
-        };
-      } else {
-        // We can reuse the cache from last time. The only thing that would have
-        // overridden it is a parent refresh, which we checked for above.
-        cachePool = prevCachePool;
+        _treeBaseDuration += _child2.treeBaseDuration;
+        _child2 = _child2.sibling;
       }
+
+      completedWork.treeBaseDuration = _treeBaseDuration;
     } else {
-      // If there's no previous cache pool, grab the current one.
-      cachePool = getSuspendedCache();
-    }
-  }
+      var _child3 = completedWork.child;
 
-  return {
-    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
-    cachePool: cachePool
-  };
-} // TODO: Probably should inline this back
+      while (_child3 !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child3.lanes, _child3.childLanes)
+        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
+        // so we should bubble those up even during a bailout. All the other
+        // flags have a lifetime only of a single render + commit, so we should
+        // ignore them.
 
-function shouldRemainOnFallback(current, workInProgress, renderLanes) {
-  // If we're already showing a fallback, there are cases where we need to
-  // remain on that fallback regardless of whether the content has resolved.
-  // For example, SuspenseList coordinates when nested content appears.
-  if (current !== null) {
-    var suspenseState = current.memoizedState;
+        subtreeFlags |= _child3.subtreeFlags & StaticMask;
+        subtreeFlags |= _child3.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
 
-    if (suspenseState === null) {
-      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
-      // is true. More precise name might be "ForceRemainSuspenseFallback".
-      // Note: This is a factoring smell. Can't remain on a fallback if there's
-      // no fallback to remain on.
-      return false;
+        _child3.return = completedWork;
+        _child3 = _child3.sibling;
+      }
     }
-  } // Not currently showing content. Consult the Suspense context.
 
-  var suspenseContext = suspenseStackCursor.current;
-  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
-}
+    completedWork.subtreeFlags |= subtreeFlags;
+  }
 
-function getRemainingWorkInPrimaryTree(current, renderLanes) {
-  // TODO: Should not remove render lanes that were pinged during this render
-  return removeLanes(current.childLanes, renderLanes);
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
 }
 
-function updateSuspenseComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
-
-  {
-    if (shouldSuspend(workInProgress)) {
-      workInProgress.flags |= DidCapture;
-    }
+function completeDehydratedSuspenseBoundary(
+  current,
+  workInProgress,
+  nextState
+) {
+  if (
+    hasUnhydratedTailNodes() &&
+    (workInProgress.mode & ConcurrentMode) !== NoMode &&
+    (workInProgress.flags & DidCapture) === NoFlags$1
+  ) {
+    warnIfUnhydratedTailNodes(workInProgress);
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | Incomplete | ShouldCapture;
+    return false;
   }
 
-  var showFallback = false;
-  var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
-
-  if (didSuspend || shouldRemainOnFallback(current)) {
-    // Something in this boundary's subtree already suspended. Switch to
-    // rendering the fallback children.
-    showFallback = true;
-    workInProgress.flags &= ~DidCapture;
-  } // OK, the next part is confusing. We're about to reconcile the Suspense
-  // boundary's children. This involves some custom reconciliation logic. Two
-  // main reasons this is so complicated.
-  //
-  // First, Legacy Mode has different semantics for backwards compatibility. The
-  // primary tree will commit in an inconsistent state, so when we do the
-  // second pass to render the fallback, we do some exceedingly, uh, clever
-  // hacks to make that not totally break. Like transferring effects and
-  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
-  // because we bailout on the primary tree completely and leave it in its old
-  // state, no effects. Same as what we do for Offscreen (except that
-  // Offscreen doesn't have the first render pass).
-  //
-  // Second is hydration. During hydration, the Suspense fiber has a slightly
-  // different layout, where the child points to a dehydrated fragment, which
-  // contains the DOM rendered by the server.
-  //
-  // Third, even if you set all that aside, Suspense is like error boundaries in
-  // that we first we try to render one tree, and if that fails, we render again
-  // and switch to a different tree. Like a try/catch block. So we have to track
-  // which branch we're currently rendering. Ideally we would model this using
-  // a stack.
+  var wasHydrated = popHydrationState(workInProgress);
 
-  if (current === null) {
-    // Initial mount
-    // Special path for hydration
-    // If we're currently hydrating, try to hydrate this boundary.
-    if (getIsHydrating()) {
-      // We must push the suspense handler context *before* attempting to
-      // hydrate, to avoid a mismatch in case it errors.
-      if (showFallback) {
-        pushPrimaryTreeSuspenseHandler(workInProgress);
-      } else {
-        pushFallbackTreeSuspenseHandler(workInProgress);
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw new Error(
+          "A dehydrated suspense component was completed without a hydrated node. " +
+            "This is probably a bug in React."
+        );
       }
 
-      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
 
-      var suspenseState = workInProgress.memoizedState;
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          var isTimedOutSuspense = nextState !== null;
 
-      if (suspenseState !== null) {
-        var dehydrated = suspenseState.dehydrated;
+          if (isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var primaryChildFragment = workInProgress.child;
 
-        if (dehydrated !== null) {
-          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
         }
-      } // If hydration didn't succeed, fall through to the normal Suspense path.
-      // To avoid a stack mismatch we need to pop the Suspense handler that we
-      // pushed above. This will become less awkward when move the hydration
-      // logic to its own fiber.
+      }
 
-      popSuspenseHandler(workInProgress);
-    }
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
 
-    var nextPrimaryChildren = nextProps.children;
-    var nextFallbackChildren = nextProps.fallback;
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
 
-    if (showFallback) {
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var fallbackFragment = mountSuspenseFallbackChildren(
-        workInProgress,
-        nextPrimaryChildren,
-        nextFallbackChildren,
-        renderLanes
-      );
-      var primaryChildFragment = workInProgress.child;
-      primaryChildFragment.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER;
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
 
-      if (enableTransitionTracing) {
-        var currentTransitions = getPendingTransitions();
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          var _isTimedOutSuspense = nextState !== null;
 
-        if (currentTransitions !== null) {
-          var parentMarkerInstances = getMarkerInstances();
-          var offscreenQueue = primaryChildFragment.updateQueue;
+          if (_isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var _primaryChildFragment = workInProgress.child;
 
-          if (offscreenQueue === null) {
-            var newOffscreenQueue = {
-              transitions: currentTransitions,
-              markerInstances: parentMarkerInstances,
-              wakeables: null
-            };
-            primaryChildFragment.updateQueue = newOffscreenQueue;
-          } else {
-            offscreenQueue.transitions = currentTransitions;
-            offscreenQueue.markerInstances = parentMarkerInstances;
+            if (_primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                _primaryChildFragment.treeBaseDuration;
+            }
           }
         }
       }
 
-      return fallbackFragment;
-    } else if (typeof nextProps.unstable_expectedLoadTime === "number") {
-      // This is a CPU-bound tree. Skip this tree and show a placeholder to
-      // unblock the surrounding content. Then immediately retry after the
-      // initial commit.
-      pushFallbackTreeSuspenseHandler(workInProgress);
-
-      var _fallbackFragment = mountSuspenseFallbackChildren(
-        workInProgress,
-        nextPrimaryChildren,
-        nextFallbackChildren,
-        renderLanes
-      );
-
-      var _primaryChildFragment = workInProgress.child;
-      _primaryChildFragment.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
-      // Since nothing actually suspended, there will nothing to ping this to
-      // get it started back up to attempt the next item. While in terms of
-      // priority this work has the same priority as this current render, it's
-      // not part of the same transition once the transition has committed. If
-      // it's sync, we still want to yield so that it can be painted.
-      // Conceptually, this is really the same as pinging. We can use any
-      // RetryLane even if it's the one currently rendering since we're leaving
-      // it behind on this node.
-
-      workInProgress.lanes = SomeRetryLane;
-      return _fallbackFragment;
-    } else {
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+      return false;
     }
   } else {
-    // This is an update.
-    // Special path for hydration
-    var prevState = current.memoizedState;
-
-    if (prevState !== null) {
-      var _dehydrated = prevState.dehydrated;
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
 
-      if (_dehydrated !== null) {
-        return updateDehydratedSuspenseComponent(
-          current,
-          workInProgress,
-          didSuspend,
-          nextProps,
-          _dehydrated,
-          prevState,
-          renderLanes
-        );
-      }
-    }
+    return true;
+  }
+}
 
-    if (showFallback) {
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var _nextFallbackChildren = nextProps.fallback;
-      var _nextPrimaryChildren = nextProps.children;
-      var fallbackChildFragment = updateSuspenseFallbackChildren(
-        current,
-        workInProgress,
-        _nextPrimaryChildren,
-        _nextFallbackChildren,
-        renderLanes
-      );
-      var _primaryChildFragment2 = workInProgress.child;
-      var prevOffscreenState = current.child.memoizedState;
-      _primaryChildFragment2.memoizedState =
-        prevOffscreenState === null
-          ? mountSuspenseOffscreenState(renderLanes)
-          : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
 
-      if (enableTransitionTracing) {
-        var _currentTransitions = getPendingTransitions();
+  popTreeContext(workInProgress);
 
-        if (_currentTransitions !== null) {
-          var _parentMarkerInstances = getMarkerInstances();
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
 
-          var _offscreenQueue = _primaryChildFragment2.updateQueue;
-          var currentOffscreenQueue = current.updateQueue;
+    case ClassComponent: {
+      var Component = workInProgress.type;
 
-          if (_offscreenQueue === null) {
-            var _newOffscreenQueue = {
-              transitions: _currentTransitions,
-              markerInstances: _parentMarkerInstances,
-              wakeables: null
-            };
-            _primaryChildFragment2.updateQueue = _newOffscreenQueue;
-          } else if (_offscreenQueue === currentOffscreenQueue) {
-            // If the work-in-progress queue is the same object as current, we
-            // can't modify it without cloning it first.
-            var _newOffscreenQueue2 = {
-              transitions: _currentTransitions,
-              markerInstances: _parentMarkerInstances,
-              wakeables:
-                currentOffscreenQueue !== null
-                  ? currentOffscreenQueue.wakeables
-                  : null
-            };
-            _primaryChildFragment2.updateQueue = _newOffscreenQueue2;
-          } else {
-            _offscreenQueue.transitions = _currentTransitions;
-            _offscreenQueue.markerInstances = _parentMarkerInstances;
-          }
-        }
+      if (isContextProvider(Component)) {
+        popContext(workInProgress);
       }
 
-      _primaryChildFragment2.childLanes = getRemainingWorkInPrimaryTree(
-        current,
-        renderLanes
-      );
-      workInProgress.memoizedState = SUSPENDED_MARKER;
-      return fallbackChildFragment;
-    } else {
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      var _nextPrimaryChildren2 = nextProps.children;
-
-      var _primaryChildFragment3 = updateSuspensePrimaryChildren(
-        current,
-        workInProgress,
-        _nextPrimaryChildren2,
-        renderLanes
-      );
-
-      workInProgress.memoizedState = null;
-      return _primaryChildFragment3;
+      bubbleProperties(workInProgress);
+      return null;
     }
-  }
-}
-
-function mountSuspensePrimaryChildren(
-  workInProgress,
-  primaryChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode;
-  var primaryChildProps = {
-    mode: "visible",
-    children: primaryChildren
-  };
-  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
-    primaryChildProps,
-    mode
-  );
-  primaryChildFragment.return = workInProgress;
-  workInProgress.child = primaryChildFragment;
-  return primaryChildFragment;
-}
-
-function mountSuspenseFallbackChildren(
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode;
-  var progressedPrimaryFragment = workInProgress.child;
-  var primaryChildProps = {
-    mode: "hidden",
-    children: primaryChildren
-  };
-  var primaryChildFragment;
-  var fallbackChildFragment;
-
-  if (
-    (mode & ConcurrentMode) === NoMode &&
-    progressedPrimaryFragment !== null
-  ) {
-    // In legacy mode, we commit the primary tree as if it successfully
-    // completed, even though it's in an inconsistent state.
-    primaryChildFragment = progressedPrimaryFragment;
-    primaryChildFragment.childLanes = NoLanes;
-    primaryChildFragment.pendingProps = primaryChildProps;
 
-    if (workInProgress.mode & ProfileMode) {
-      // Reset the durations from the first pass so they aren't included in the
-      // final amounts. This seems counterintuitive, since we're intentionally
-      // not measuring part of the render phase, but this makes it match what we
-      // do in Concurrent Mode.
-      primaryChildFragment.actualDuration = 0;
-      primaryChildFragment.actualStartTime = -1;
-      primaryChildFragment.selfBaseDuration = 0;
-      primaryChildFragment.treeBaseDuration = 0;
-    }
+    case HostRoot: {
+      var fiberRoot = workInProgress.stateNode;
 
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    );
-  } else {
-    primaryChildFragment = mountWorkInProgressOffscreenFiber(
-      primaryChildProps,
-      mode
-    );
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    );
-  }
+      if (enableTransitionTracing) {
+        var transitions = getWorkInProgressTransitions(); // We set the Passive flag here because if there are new transitions,
+        // we will need to schedule callbacks and process the transitions,
+        // which we do in the passive phase
 
-  primaryChildFragment.return = workInProgress;
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
-  return fallbackChildFragment;
-}
+        if (transitions !== null) {
+          workInProgress.flags |= Passive$1;
+        }
+      }
 
-function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
-  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
-  // this wrapper function to constrain it.
-  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
-}
+      {
+        var previousCache = null;
 
-function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
-  // The props argument to `createWorkInProgress` is `any` typed, so we use this
-  // wrapper function to constrain it.
-  return createWorkInProgress(current, offscreenProps);
-}
+        if (current !== null) {
+          previousCache = current.memoizedState.cache;
+        }
 
-function updateSuspensePrimaryChildren(
-  current,
-  workInProgress,
-  primaryChildren,
-  renderLanes
-) {
-  var currentPrimaryChildFragment = current.child;
-  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
-  var primaryChildFragment = updateWorkInProgressOffscreenFiber(
-    currentPrimaryChildFragment,
-    {
-      mode: "visible",
-      children: primaryChildren
-    }
-  );
+        var cache = workInProgress.memoizedState.cache;
 
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    primaryChildFragment.lanes = renderLanes;
-  }
+        if (cache !== previousCache) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
+        }
 
-  primaryChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = null;
+        popCacheProvider(workInProgress);
+      }
 
-  if (currentFallbackChildFragment !== null) {
-    // Delete the fallback child fragment
-    var deletions = workInProgress.deletions;
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
 
-    if (deletions === null) {
-      workInProgress.deletions = [currentFallbackChildFragment];
-      workInProgress.flags |= ChildDeletion;
-    } else {
-      deletions.push(currentFallbackChildFragment);
-    }
-  }
+      popRootTransition(workInProgress);
+      popHostContainer(workInProgress);
+      popTopLevelContextObject(workInProgress);
+      resetWorkInProgressVersions();
 
-  workInProgress.child = primaryChildFragment;
-  return primaryChildFragment;
-}
+      if (fiberRoot.pendingContext) {
+        fiberRoot.context = fiberRoot.pendingContext;
+        fiberRoot.pendingContext = null;
+      }
 
-function updateSuspenseFallbackChildren(
-  current,
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode;
-  var currentPrimaryChildFragment = current.child;
-  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
-  var primaryChildProps = {
-    mode: "hidden",
-    children: primaryChildren
-  };
-  var primaryChildFragment;
+      if (current === null || current.child === null) {
+        // If we hydrated, pop so that we can delete any remaining children
+        // that weren't hydrated.
+        var wasHydrated = popHydrationState(workInProgress);
 
-  if (
-    // In legacy mode, we commit the primary tree as if it successfully
-    // completed, even though it's in an inconsistent state.
-    (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
-    // already cloned. In legacy mode, the only case where this isn't true is
-    // when DevTools forces us to display a fallback; we skip the first render
-    // pass entirely and go straight to rendering the fallback. (In Concurrent
-    // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
-    // only codepath.)
-    workInProgress.child !== currentPrimaryChildFragment
-  ) {
-    var progressedPrimaryFragment = workInProgress.child;
-    primaryChildFragment = progressedPrimaryFragment;
-    primaryChildFragment.childLanes = NoLanes;
-    primaryChildFragment.pendingProps = primaryChildProps;
+        if (wasHydrated) {
+          // If we hydrated, then we'll need to schedule an update for
+          // the commit side-effects on the root.
+          markUpdate(workInProgress);
+        } else {
+          if (current !== null) {
+            var prevState = current.memoizedState;
 
-    if (workInProgress.mode & ProfileMode) {
-      // Reset the durations from the first pass so they aren't included in the
-      // final amounts. This seems counterintuitive, since we're intentionally
-      // not measuring part of the render phase, but this makes it match what we
-      // do in Concurrent Mode.
-      primaryChildFragment.actualDuration = 0;
-      primaryChildFragment.actualStartTime = -1;
-      primaryChildFragment.selfBaseDuration =
-        currentPrimaryChildFragment.selfBaseDuration;
-      primaryChildFragment.treeBaseDuration =
-        currentPrimaryChildFragment.treeBaseDuration;
-    } // The fallback fiber was added as a deletion during the first pass.
-    // However, since we're going to remain on the fallback, we no longer want
-    // to delete it.
+            if (
+              // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1
+            ) {
+              // Schedule an effect to clear this container at the start of the
+              // next commit. This handles the case of React rendering into a
+              // container with previous children. It's also safe to do for
+              // updates too, because current.child would only be null if the
+              // previous render was null (so the container would already
+              // be empty).
+              workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+              // recoverable errors during first hydration attempt. If so, add
+              // them to a queue so we can log them in the commit phase.
 
-    workInProgress.deletions = null;
-  } else {
-    primaryChildFragment = updateWorkInProgressOffscreenFiber(
-      currentPrimaryChildFragment,
-      primaryChildProps
-    ); // Since we're reusing a current tree, we need to reuse the flags, too.
-    // (We don't do this in legacy mode, because in legacy mode we don't re-use
-    // the current tree; see previous branch.)
+              upgradeHydrationErrorsToRecoverable();
+            }
+          }
+        }
+      }
+      bubbleProperties(workInProgress);
 
-    primaryChildFragment.subtreeFlags =
-      currentPrimaryChildFragment.subtreeFlags & StaticMask;
-  }
+      if (enableTransitionTracing) {
+        if ((workInProgress.subtreeFlags & Visibility) !== NoFlags$1) {
+          // If any of our suspense children toggle visibility, this means that
+          // the pending boundaries array needs to be updated, which we only
+          // do in the passive phase.
+          workInProgress.flags |= Passive$1;
+        }
+      }
 
-  var fallbackChildFragment;
+      return null;
+    }
 
-  if (currentFallbackChildFragment !== null) {
-    fallbackChildFragment = createWorkInProgress(
-      currentFallbackChildFragment,
-      fallbackChildren
-    );
-  } else {
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    ); // Needs a placement effect because the parent (the Suspense boundary) already
-    // mounted but this is a new fiber.
+    case HostHoistable: {
+      {
+        var currentRef = current ? current.ref : null;
 
-    fallbackChildFragment.flags |= Placement;
-  }
+        if (currentRef !== workInProgress.ref) {
+          markRef(workInProgress);
+        }
 
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
-  return fallbackChildFragment;
-}
+        if (
+          // We are mounting and must Update this Hoistable in this commit
+          current === null || // We are transitioning to, from, or between Hoistable Resources
+          // and require an update
+          current.memoizedState !== workInProgress.memoizedState
+        ) {
+          markUpdate(workInProgress);
+        } else if (workInProgress.memoizedState === null) {
+          // We may have props to update on the Hoistable instance. We use the
+          // updateHostComponent path becuase it produces the update queue
+          // we need for Hoistables
+          updateHostComponent(
+            current,
+            workInProgress,
+            workInProgress.type,
+            workInProgress.pendingProps
+          );
+        }
 
-function retrySuspenseComponentWithoutHydrating(
-  current,
-  workInProgress,
-  renderLanes,
-  recoverableError
-) {
-  // Falling back to client rendering. Because this has performance
-  // implications, it's considered a recoverable error, even though the user
-  // likely won't observe anything wrong with the UI.
-  //
-  // The error is passed in as an argument to enforce that every caller provide
-  // a custom message, or explicitly opt out (currently the only path that opts
-  // out is legacy mode; every concurrent path provides an error).
-  if (recoverableError !== null) {
-    queueHydrationError(recoverableError);
-  } // This will add the old fiber to the deletion list
+        bubbleProperties(workInProgress);
+        return null;
+      }
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+    case HostSingleton: {
+      {
+        popHostContext(workInProgress);
+        var rootContainerInstance = getRootHostContainer();
+        var type = workInProgress.type;
 
-  var nextProps = workInProgress.pendingProps;
-  var primaryChildren = nextProps.children;
-  var primaryChildFragment = mountSuspensePrimaryChildren(
-    workInProgress,
-    primaryChildren
-  ); // Needs a placement effect because the parent (the Suspense boundary) already
-  // mounted but this is a new fiber.
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
 
-  primaryChildFragment.flags |= Placement;
-  workInProgress.memoizedState = null;
-  return primaryChildFragment;
-}
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw new Error(
+                "We must have new props for new mounts. This error is likely " +
+                  "caused by a bug in React. Please file an issue."
+              );
+            } // This can happen when we abort work.
 
-function mountSuspenseFallbackAfterRetryWithoutHydrating(
-  current,
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var fiberMode = workInProgress.mode;
-  var primaryChildProps = {
-    mode: "visible",
-    children: primaryChildren
-  };
-  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
-    primaryChildProps,
-    fiberMode
-  );
-  var fallbackChildFragment = createFiberFromFragment(
-    fallbackChildren,
-    fiberMode,
-    renderLanes,
-    null
-  ); // Needs a placement effect because the parent (the Suspense
-  // boundary) already mounted but this is a new fiber.
+            bubbleProperties(workInProgress);
+            return null;
+          }
 
-  fallbackChildFragment.flags |= Placement;
-  primaryChildFragment.return = workInProgress;
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
+          var currentHostContext = getHostContext();
 
-  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
-    // We will have dropped the effect list which contains the
-    // deletion. We need to reconcile to delete the current child.
-    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-  }
+          var _wasHydrated = popHydrationState(workInProgress);
 
-  return fallbackChildFragment;
-}
+          if (_wasHydrated) {
+            // We ignore the boolean indicating there is an updateQueue because
+            // it is used only to set text children and HostSingletons do not
+            // use them.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              rootContainerInstance,
+              currentHostContext,
+              true
+            );
+            markUpdate(workInProgress);
+          }
 
-function mountDehydratedSuspenseComponent(
-  workInProgress,
-  suspenseInstance,
-  renderLanes
-) {
-  // During the first pass, we'll bail out and not drill into the children.
-  // Instead, we'll leave the content in place and try to hydrate it later.
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    {
-      error(
-        "Cannot hydrate Suspense in legacy mode. Switch from " +
-          "ReactDOM.hydrate(element, container) to " +
-          "ReactDOMClient.hydrateRoot(container, <App />)" +
-          ".render(element) or remove the Suspense components from " +
-          "the server rendered components."
-      );
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
     }
+    // eslint-disable-next-line-no-fallthrough
 
-    workInProgress.lanes = laneToLanes(SyncLane);
-  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
-    // This is a client-only boundary. Since we won't get any content from the server
-    // for this, we need to schedule that at a higher priority based on when it would
-    // have timed out. In theory we could render it in this pass but it would have the
-    // wrong priority associated with it and will prevent hydration of parent path.
-    // Instead, we'll leave work left on it to render it in a separate commit.
-    // TODO This time should be the time at which the server rendered response that is
-    // a parent to this boundary was displayed. However, since we currently don't have
-    // a protocol to transfer that time, we'll just estimate it by using the current
-    // time. This will mean that Suspense timeouts are slightly shifted to later than
-    // they should be.
-    // Schedule a normal pri update to render this content.
-    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
-  } else {
-    // We'll continue hydrating the rest at offscreen priority since we'll already
-    // be showing the right content coming from the server, it is no rush.
-    workInProgress.lanes = laneToLanes(OffscreenLane);
-  }
+    case HostComponent: {
+      popHostContext(workInProgress);
+      var _type = workInProgress.type;
 
-  return null;
-}
+      if (current !== null && workInProgress.stateNode != null) {
+        updateHostComponent(current, workInProgress, _type, newProps);
 
-function updateDehydratedSuspenseComponent(
-  current,
-  workInProgress,
-  didSuspend,
-  nextProps,
-  suspenseInstance,
-  suspenseState,
-  renderLanes
-) {
-  if (!didSuspend) {
-    // This is the first render pass. Attempt to hydrate.
-    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
-    // but after we've already committed once.
+        if (current.ref !== workInProgress.ref) {
+          markRef(workInProgress);
+        }
+      } else {
+        if (!newProps) {
+          if (workInProgress.stateNode === null) {
+            throw new Error(
+              "We must have new props for new mounts. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          } // This can happen when we abort work.
 
-    warnIfHydrating();
+          bubbleProperties(workInProgress);
+          return null;
+        }
 
-    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        null
-      );
-    }
+        var _currentHostContext2 = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+        // "stack" as the parent. Then append children as we go in beginWork
+        // or completeWork depending on whether we want to add them top->down or
+        // bottom->up. Top->down is faster in IE11.
 
-    if (isSuspenseInstanceFallback(suspenseInstance)) {
-      // This boundary is in a permanent fallback state. In this case, we'll never
-      // get an update and we'll never be able to hydrate the final content. Let's just try the
-      // client side render instead.
-      var digest, message, stack;
+        var _wasHydrated2 = popHydrationState(workInProgress);
 
-      {
-        var _getSuspenseInstanceF =
-          getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+        if (_wasHydrated2) {
+          // TODO: Move this and createInstance step into the beginPhase
+          // to consolidate.
+          if (
+            prepareToHydrateHostInstance(workInProgress, _currentHostContext2)
+          ) {
+            // If changes to the hydrated node need to be applied at the
+            // commit-phase we mark this as such.
+            markUpdate(workInProgress);
+          }
+        } else {
+          var _rootContainerInstance = getRootHostContainer();
 
-        digest = _getSuspenseInstanceF.digest;
-        message = _getSuspenseInstanceF.message;
-        stack = _getSuspenseInstanceF.stack;
-      }
+          var instance = createInstance(
+            _type,
+            newProps,
+            _rootContainerInstance,
+            _currentHostContext2,
+            workInProgress
+          );
+          appendAllChildren(instance, workInProgress);
+          workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+          // (eg DOM renderer supports auto-focus for certain elements).
+          // Make sure such renderers get scheduled for later work.
 
-      var error;
+          if (finalizeInitialChildren(instance, _type, newProps)) {
+            markUpdate(workInProgress);
+          }
+        }
 
-      if (message) {
-        // eslint-disable-next-line react-internal/prod-error-codes
-        error = new Error(message);
-      } else {
-        error = new Error(
-          "The server could not finish this Suspense boundary, likely " +
-            "due to an error during server rendering. Switched to " +
-            "client rendering."
-        );
+        if (workInProgress.ref !== null) {
+          // If there is a ref on a host node we need to schedule a callback
+          markRef(workInProgress);
+        }
       }
 
-      error.digest = digest;
-      var capturedValue = createCapturedValue(error, digest, stack);
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        capturedValue
-      );
+      bubbleProperties(workInProgress);
+      return null;
     }
 
-    if (
-      enableLazyContextPropagation && // TODO: Factoring is a little weird, since we check this right below, too.
-      // But don't want to re-arrange the if-else chain until/unless this
-      // feature lands.
-      !didReceiveUpdate
-    ) {
-      // We need to check if any children have context before we decide to bail
-      // out, so propagate the changes now.
-      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
-    } // We use lanes to indicate that a child might depend on context, so if
-    // any context has changed, we need to treat is as if the input might have changed.
+    case HostText: {
+      var newText = newProps;
+
+      if (current && workInProgress.stateNode != null) {
+        var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+        // to schedule a side-effect to do the updates.
+
+        updateHostText(current, workInProgress, oldText, newText);
+      } else {
+        if (typeof newText !== "string") {
+          if (workInProgress.stateNode === null) {
+            throw new Error(
+              "We must have new props for new mounts. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          } // This can happen when we abort work.
+        }
 
-    var hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+        var _rootContainerInstance2 = getRootHostContainer();
 
-    if (didReceiveUpdate || hasContextChanged) {
-      // This boundary has changed since the first render. This means that we are now unable to
-      // hydrate it. We might still be able to hydrate it using a higher priority lane.
-      var root = getWorkInProgressRoot();
+        var _currentHostContext3 = getHostContext();
 
-      if (root !== null) {
-        var attemptHydrationAtLane = getBumpedLaneForHydration(
-          root,
-          renderLanes
-        );
+        var _wasHydrated3 = popHydrationState(workInProgress);
 
-        if (
-          attemptHydrationAtLane !== NoLane &&
-          attemptHydrationAtLane !== suspenseState.retryLane
-        ) {
-          // Intentionally mutating since this render will get interrupted. This
-          // is one of the very rare times where we mutate the current tree
-          // during the render phase.
-          suspenseState.retryLane = attemptHydrationAtLane; // TODO: Ideally this would inherit the event time of the current render
+        if (_wasHydrated3) {
+          if (prepareToHydrateHostTextInstance(workInProgress)) {
+            markUpdate(workInProgress);
+          }
+        } else {
+          workInProgress.stateNode = createTextInstance(
+            newText,
+            _rootContainerInstance2,
+            _currentHostContext3,
+            workInProgress
+          );
+        }
+      }
 
-          var eventTime = NoTimestamp;
-          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
-          scheduleUpdateOnFiber(
-            root,
-            current,
-            attemptHydrationAtLane,
-            eventTime
-          ); // Throw a special object that signals to the work loop that it should
-          // interrupt the current render.
-          //
-          // Because we're inside a React-only execution stack, we don't
-          // strictly need to throw here — we could instead modify some internal
-          // work loop state. But using an exception means we don't need to
-          // check for this case on every iteration of the work loop. So doing
-          // it this way moves the check out of the fast path.
+      bubbleProperties(workInProgress);
+      return null;
+    }
 
-          throw SelectiveHydrationException;
-        }
-      } // If we did not selectively hydrate, we'll continue rendering without
-      // hydrating. Mark this tree as suspended to prevent it from committing
-      // outside a transition.
-      //
-      // This path should only happen if the hydration lane already suspended.
-      // Currently, it also happens during sync updates because there is no
-      // hydration lane for sync updates.
-      // TODO: We should ideally have a sync hydration lane that we can apply to do
-      // a pass where we hydrate this subtree in place using the previous Context and then
-      // reapply the update afterwards.
+    case SuspenseComponent: {
+      popSuspenseHandler(workInProgress);
+      var nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+      // to its own fiber type so that we can add other kinds of hydration
+      // boundaries that aren't associated with a Suspense tree. In anticipation
+      // of such a refactor, all the hydration logic is contained in
+      // this branch.
 
-      renderDidSuspendDelayIfPossible();
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        null
-      );
-    } else if (isSuspenseInstancePending(suspenseInstance)) {
-      // This component is still pending more data from the server, so we can't hydrate its
-      // content. We treat it as if this component suspended itself. It might seem as if
-      // we could just try to render it client-side instead. However, this will perform a
-      // lot of unnecessary work and is unlikely to complete since it often will suspend
-      // on missing data anyway. Additionally, the server might be able to render more
-      // than we can on the client yet. In that case we'd end up with more fallback states
-      // on the client than if we just leave it alone. If the server times out or errors
-      // these should update this boundary to the permanent Fallback state instead.
-      // Mark it as having captured (i.e. suspended).
-      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+      if (
+        current === null ||
+        (current.memoizedState !== null &&
+          current.memoizedState.dehydrated !== null)
+      ) {
+        var fallthroughToNormalSuspensePath =
+          completeDehydratedSuspenseBoundary(
+            current,
+            workInProgress,
+            nextState
+          );
 
-      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+        if (!fallthroughToNormalSuspensePath) {
+          if (workInProgress.flags & ShouldCapture) {
+            // Special case. There were remaining unhydrated nodes. We treat
+            // this as a mismatch. Revert to client rendering.
+            return workInProgress;
+          } else {
+            // Did not finish hydrating, either because this is the initial
+            // render or because something suspended.
+            return null;
+          }
+        } // Continue with the normal Suspense path.
+      }
 
-      var retry = retryDehydratedSuspenseBoundary.bind(null, current);
-      registerSuspenseInstanceRetry(suspenseInstance, retry);
-      return null;
-    } else {
-      // This is the first attempt.
-      reenterHydrationStateFromDehydratedSuspenseInstance(
-        workInProgress,
-        suspenseInstance,
-        suspenseState.treeContext
-      );
-      var primaryChildren = nextProps.children;
-      var primaryChildFragment = mountSuspensePrimaryChildren(
-        workInProgress,
-        primaryChildren
-      ); // Mark the children as hydrating. This is a fast path to know whether this
-      // tree is part of a hydrating tree. This is used to determine if a child
-      // node has fully mounted yet, and for scheduling event replaying.
-      // Conceptually this is similar to Placement in that a new subtree is
-      // inserted into the React tree here. It just happens to not need DOM
-      // mutations because it already exists.
+      if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+        // Something suspended. Re-render with the fallback children.
+        workInProgress.lanes = renderLanes; // Do not reset the effect list.
 
-      primaryChildFragment.flags |= Hydrating;
-      return primaryChildFragment;
-    }
-  } else {
-    // This is the second render pass. We already attempted to hydrated, but
-    // something either suspended or errored.
-    if (workInProgress.flags & ForceClientRender) {
-      // Something errored during hydration. Try again without hydrating.
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      workInProgress.flags &= ~ForceClientRender;
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        } // Don't bubble properties in this case.
 
-      var _capturedValue = createCapturedValue(
-        new Error(
-          "There was an error while hydrating this Suspense boundary. " +
-            "Switched to client rendering."
-        )
-      );
+        return workInProgress;
+      }
 
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        _capturedValue
-      );
-    } else if (workInProgress.memoizedState !== null) {
-      // Something suspended and we should still be in dehydrated mode.
-      // Leave the existing child in place.
-      // Push to avoid a mismatch
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
-      // but the normal suspense pass doesn't.
+      var nextDidTimeout = nextState !== null;
+      var prevDidTimeout = current !== null && current.memoizedState !== null;
 
-      workInProgress.flags |= DidCapture;
-      return null;
-    } else {
-      // Suspended but we should no longer be in dehydrated mode.
-      // Therefore we now have to render the fallback.
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var nextPrimaryChildren = nextProps.children;
-      var nextFallbackChildren = nextProps.fallback;
-      var fallbackChildFragment =
-        mountSuspenseFallbackAfterRetryWithoutHydrating(
-          current,
-          workInProgress,
-          nextPrimaryChildren,
-          nextFallbackChildren,
-          renderLanes
-        );
-      var _primaryChildFragment4 = workInProgress.child;
-      _primaryChildFragment4.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER;
-      return fallbackChildFragment;
-    }
-  }
-}
+      if (nextDidTimeout) {
+        var offscreenFiber = workInProgress.child;
+        var _previousCache = null;
 
-function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
-  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
-  var alternate = fiber.alternate;
+        if (
+          offscreenFiber.alternate !== null &&
+          offscreenFiber.alternate.memoizedState !== null &&
+          offscreenFiber.alternate.memoizedState.cachePool !== null
+        ) {
+          _previousCache =
+            offscreenFiber.alternate.memoizedState.cachePool.pool;
+        }
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-  }
+        var _cache = null;
 
-  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
-}
+        if (
+          offscreenFiber.memoizedState !== null &&
+          offscreenFiber.memoizedState.cachePool !== null
+        ) {
+          _cache = offscreenFiber.memoizedState.cachePool.pool;
+        }
 
-function propagateSuspenseContextChange(
-  workInProgress,
-  firstChild,
-  renderLanes
-) {
-  // Mark any Suspense boundaries with fallbacks as having work to do.
-  // If they were previously forced into fallbacks, they may now be able
-  // to unblock.
-  var node = firstChild;
+        if (_cache !== _previousCache) {
+          // Run passive effects to retain/release the cache.
+          offscreenFiber.flags |= Passive$1;
+        }
+      } // If the suspended state of the boundary changes, we need to schedule
+      // a passive effect, which is when we process the transitions
 
-  while (node !== null) {
-    if (node.tag === SuspenseComponent) {
-      var state = node.memoizedState;
+      if (nextDidTimeout !== prevDidTimeout) {
+        if (enableTransitionTracing) {
+          var _offscreenFiber = workInProgress.child;
+          _offscreenFiber.flags |= Passive$1;
+        } // If the suspended state of the boundary changes, we need to schedule
+        // an effect to toggle the subtree's visibility. When we switch from
+        // fallback -> primary, the inner Offscreen fiber schedules this effect
+        // as part of its normal complete phase. But when we switch from
+        // primary -> fallback, the inner Offscreen fiber does not have a complete
+        // phase. So we need to schedule its effect here.
+        //
+        // We also use this flag to connect/disconnect the effects, but the same
+        // logic applies: when re-connecting, the Offscreen fiber's complete
+        // phase will handle scheduling the effect. It's only when the fallback
+        // is active that we have to do anything special.
 
-      if (state !== null) {
-        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+        if (nextDidTimeout) {
+          var _offscreenFiber2 = workInProgress.child;
+          _offscreenFiber2.flags |= Visibility;
+        }
       }
-    } else if (node.tag === SuspenseListComponent) {
-      // If the tail is hidden there might not be an Suspense boundaries
-      // to schedule work on. In this case we have to schedule it on the
-      // list itself.
-      // We don't have to traverse to the children of the list since
-      // the list will propagate the change when it rerenders.
-      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
-    } else if (node.child !== null) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
 
-    if (node === workInProgress) {
-      return;
-    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+      var wakeables = workInProgress.updateQueue;
 
-    while (node.sibling === null) {
-      // $FlowFixMe[incompatible-use] found when upgrading Flow
-      if (node.return === null || node.return === workInProgress) {
-        return;
+      if (wakeables !== null) {
+        // Schedule an effect to attach a retry listener to the promise.
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
       }
 
-      node = node.return;
-    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (
+        workInProgress.updateQueue !== null &&
+        workInProgress.memoizedProps.suspenseCallback != null
+      ) {
+        // Always notify the callback
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
+      }
 
-    node.sibling.return = node.return;
-    node = node.sibling;
-  }
-}
+      bubbleProperties(workInProgress);
 
-function findLastContentRow(firstChild) {
-  // This is going to find the last row among these children that is already
-  // showing content on the screen, as opposed to being in fallback state or
-  // new. If a row has multiple Suspense boundaries, any of them being in the
-  // fallback state, counts as the whole row being in a fallback state.
-  // Note that the "rows" will be workInProgress, but any nested children
-  // will still be current since we haven't rendered them yet. The mounted
-  // order may not be the same as the new order. We use the new order.
-  var row = firstChild;
-  var lastContentRow = null;
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          if (nextDidTimeout) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var primaryChildFragment = workInProgress.child;
 
-  while (row !== null) {
-    var currentRow = row.alternate; // New rows can't be content rows.
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
 
-    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
-      lastContentRow = row;
+      return null;
     }
 
-    row = row.sibling;
-  }
+    case HostPortal:
+      popHostContainer(workInProgress);
 
-  return lastContentRow;
-}
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
+      }
 
-function validateRevealOrder(revealOrder) {
-  {
-    if (
-      revealOrder !== undefined &&
-      revealOrder !== "forwards" &&
-      revealOrder !== "backwards" &&
-      revealOrder !== "together" &&
-      !didWarnAboutRevealOrder[revealOrder]
-    ) {
-      didWarnAboutRevealOrder[revealOrder] = true;
+      bubbleProperties(workInProgress);
+      return null;
 
-      if (typeof revealOrder === "string") {
-        switch (revealOrder.toLowerCase()) {
-          case "together":
-          case "forwards":
-          case "backwards": {
-            error(
-              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
-                'Use lowercase "%s" instead.',
-              revealOrder,
-              revealOrder.toLowerCase()
-            );
+    case ContextProvider:
+      // Pop provider fiber
+      var context = workInProgress.type._context;
+      popProvider(context, workInProgress);
+      bubbleProperties(workInProgress);
+      return null;
 
-            break;
-          }
+    case IncompleteClassComponent: {
+      // Same as class component case. I put it down here so that the tags are
+      // sequential to ensure this switch is compiled to a jump table.
+      var _Component = workInProgress.type;
 
-          case "forward":
-          case "backward": {
-            error(
-              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
-                'React uses the -s suffix in the spelling. Use "%ss" instead.',
-              revealOrder,
-              revealOrder.toLowerCase()
-            );
+      if (isContextProvider(_Component)) {
+        popContext(workInProgress);
+      }
 
-            break;
-          }
+      bubbleProperties(workInProgress);
+      return null;
+    }
 
-          default:
-            error(
-              '"%s" is not a supported revealOrder on <SuspenseList />. ' +
-                'Did you mean "together", "forwards" or "backwards"?',
-              revealOrder
-            );
+    case SuspenseListComponent: {
+      popSuspenseListContext(workInProgress);
+      var renderState = workInProgress.memoizedState;
 
-            break;
-        }
-      } else {
-        error(
-          "%s is not a supported value for revealOrder on <SuspenseList />. " +
-            'Did you mean "together", "forwards" or "backwards"?',
-          revealOrder
-        );
+      if (renderState === null) {
+        // We're running in the default, "independent" mode.
+        // We don't do anything in this mode.
+        bubbleProperties(workInProgress);
+        return null;
       }
-    }
-  }
-}
 
-function validateTailOptions(tailMode, revealOrder) {
-  {
-    if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
-      if (tailMode !== "collapsed" && tailMode !== "hidden") {
-        didWarnAboutTailOptions[tailMode] = true;
+      var didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+      var renderedTail = renderState.rendering;
 
-        error(
-          '"%s" is not a supported value for tail on <SuspenseList />. ' +
-            'Did you mean "collapsed" or "hidden"?',
-          tailMode
-        );
-      } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
-        didWarnAboutTailOptions[tailMode] = true;
+      if (renderedTail === null) {
+        // We just rendered the head.
+        if (!didSuspendAlready) {
+          // This is the first pass. We need to figure out if anything is still
+          // suspended in the rendered set.
+          // If new content unsuspended, but there's still some content that
+          // didn't. Then we need to do a second pass that forces everything
+          // to keep showing their fallbacks.
+          // We might be suspended if something in this render pass suspended, or
+          // something in the previous committed pass suspended. Otherwise,
+          // there's no chance so we can skip the expensive call to
+          // findFirstSuspended.
+          var cannotBeSuspended =
+            renderHasNotSuspendedYet() &&
+            (current === null || (current.flags & DidCapture) === NoFlags$1);
 
-        error(
-          '<SuspenseList tail="%s" /> is only valid if revealOrder is ' +
-            '"forwards" or "backwards". ' +
-            'Did you mean to specify revealOrder="forwards"?',
-          tailMode
-        );
-      }
-    }
-  }
-}
+          if (!cannotBeSuspended) {
+            var row = workInProgress.child;
 
-function validateSuspenseListNestedChild(childSlot, index) {
-  {
-    var isAnArray = isArray(childSlot);
-    var isIterable =
-      !isAnArray && typeof getIteratorFn(childSlot) === "function";
+            while (row !== null) {
+              var suspended = findFirstSuspended(row);
 
-    if (isAnArray || isIterable) {
-      var type = isAnArray ? "array" : "iterable";
+              if (suspended !== null) {
+                didSuspendAlready = true;
+                workInProgress.flags |= DidCapture;
+                cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                // part of the second pass. In that case nothing will subscribe to
+                // its thenables. Instead, we'll transfer its thenables to the
+                // SuspenseList so that it can retry if they resolve.
+                // There might be multiple of these in the list but since we're
+                // going to wait for all of them anyway, it doesn't really matter
+                // which ones gets to ping. In theory we could get clever and keep
+                // track of how many dependencies remain but it gets tricky because
+                // in the meantime, we can add/remove/change items and dependencies.
+                // We might bail out of the loop before finding any but that
+                // doesn't matter since that means that the other boundaries that
+                // we did find already has their listeners attached.
 
-      error(
-        "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " +
-          "an additional SuspenseList to configure its revealOrder: " +
-          "<SuspenseList revealOrder=...> ... " +
-          "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " +
-          "</SuspenseList>",
-        type,
-        index,
-        type
-      );
+                var newThenables = suspended.updateQueue;
+
+                if (newThenables !== null) {
+                  workInProgress.updateQueue = newThenables;
+                  workInProgress.flags |= Update;
+                } // Rerender the whole list, but this time, we'll force fallbacks
+                // to stay in place.
+                // Reset the effect flags before doing the second pass since that's now invalid.
+                // Reset the child fibers to their original state.
+
+                workInProgress.subtreeFlags = NoFlags$1;
+                resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                // immediately rerender the children.
+
+                pushSuspenseListContext(
+                  workInProgress,
+                  setShallowSuspenseListContext(
+                    suspenseStackCursor.current,
+                    ForceSuspenseFallback
+                  )
+                ); // Don't bubble properties in this case.
+
+                return workInProgress.child;
+              }
 
-      return false;
-    }
-  }
+              row = row.sibling;
+            }
+          }
 
-  return true;
-}
+          if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
+            // We have already passed our CPU deadline but we still have rows
+            // left in the tail. We'll just give up further attempts to render
+            // the main content and only render fallbacks.
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true;
+            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+            // to get it started back up to attempt the next item. While in terms
+            // of priority this work has the same priority as this current render,
+            // it's not part of the same transition once the transition has
+            // committed. If it's sync, we still want to yield so that it can be
+            // painted. Conceptually, this is really the same as pinging.
+            // We can use any RetryLane even if it's the one currently rendering
+            // since we're leaving it behind on this node.
 
-function validateSuspenseListChildren(children, revealOrder) {
-  {
-    if (
-      (revealOrder === "forwards" || revealOrder === "backwards") &&
-      children !== undefined &&
-      children !== null &&
-      children !== false
-    ) {
-      if (isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-          if (!validateSuspenseListNestedChild(children[i], i)) {
-            return;
+            workInProgress.lanes = SomeRetryLane;
           }
-        }
+        } else {
+          cutOffTailIfNeeded(renderState, false);
+        } // Next we're going to render the tail.
       } else {
-        var iteratorFn = getIteratorFn(children);
+        // Append the rendered row to the child list.
+        if (!didSuspendAlready) {
+          var _suspended = findFirstSuspended(renderedTail);
 
-        if (typeof iteratorFn === "function") {
-          var childrenIterator = iteratorFn.call(children);
+          if (_suspended !== null) {
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+            // get lost if this row ends up dropped during a second pass.
 
-          if (childrenIterator) {
-            var step = childrenIterator.next();
-            var _i = 0;
+            var _newThenables = _suspended.updateQueue;
 
-            for (; !step.done; step = childrenIterator.next()) {
-              if (!validateSuspenseListNestedChild(step.value, _i)) {
-                return;
-              }
+            if (_newThenables !== null) {
+              workInProgress.updateQueue = _newThenables;
+              workInProgress.flags |= Update;
+            }
 
-              _i++;
+            cutOffTailIfNeeded(renderState, true); // This might have been modified.
+
+            if (
+              renderState.tail === null &&
+              renderState.tailMode === "hidden" &&
+              !renderedTail.alternate &&
+              !getIsHydrating() // We don't cut it if we're hydrating.
+            ) {
+              // We're done.
+              bubbleProperties(workInProgress);
+              return null;
             }
+          } else if (
+            // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now$1() * 2 - renderState.renderingStartTime >
+              getRenderTargetTime() &&
+            renderLanes !== OffscreenLane
+          ) {
+            // We have now passed our CPU deadline and we'll just give up further
+            // attempts to render the main content and only render fallbacks.
+            // The assumption is that this is usually faster.
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true;
+            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+            // to get it started back up to attempt the next item. While in terms
+            // of priority this work has the same priority as this current render,
+            // it's not part of the same transition once the transition has
+            // committed. If it's sync, we still want to yield so that it can be
+            // painted. Conceptually, this is really the same as pinging.
+            // We can use any RetryLane even if it's the one currently rendering
+            // since we're leaving it behind on this node.
+
+            workInProgress.lanes = SomeRetryLane;
           }
+        }
+
+        if (renderState.isBackwards) {
+          // The effect list of the backwards tail will have been added
+          // to the end. This breaks the guarantee that life-cycles fire in
+          // sibling order but that isn't a strong guarantee promised by React.
+          // Especially since these might also just pop in during future commits.
+          // Append to the beginning of the list.
+          renderedTail.sibling = workInProgress.child;
+          workInProgress.child = renderedTail;
         } else {
-          error(
-            'A single row was passed to a <SuspenseList revealOrder="%s" />. ' +
-              "This is not useful since it needs multiple rows. " +
-              "Did you mean to pass multiple children or an array?",
-            revealOrder
-          );
+          var previousSibling = renderState.last;
+
+          if (previousSibling !== null) {
+            previousSibling.sibling = renderedTail;
+          } else {
+            workInProgress.child = renderedTail;
+          }
+
+          renderState.last = renderedTail;
         }
       }
-    }
-  }
-}
-
-function initSuspenseListRenderState(
-  workInProgress,
-  isBackwards,
-  tail,
-  lastContentRow,
-  tailMode
-) {
-  var renderState = workInProgress.memoizedState;
 
-  if (renderState === null) {
-    workInProgress.memoizedState = {
-      isBackwards: isBackwards,
-      rendering: null,
-      renderingStartTime: 0,
-      last: lastContentRow,
-      tail: tail,
-      tailMode: tailMode
-    };
-  } else {
-    // We can reuse the existing object from previous renders.
-    renderState.isBackwards = isBackwards;
-    renderState.rendering = null;
-    renderState.renderingStartTime = 0;
-    renderState.last = lastContentRow;
-    renderState.tail = tail;
-    renderState.tailMode = tailMode;
-  }
-} // This can end up rendering this component multiple passes.
-// The first pass splits the children fibers into two sets. A head and tail.
-// We first render the head. If anything is in fallback state, we do another
-// pass through beginWork to rerender all children (including the tail) with
-// the force suspend context. If the first render didn't have anything in
-// in fallback state. Then we render each row in the tail one-by-one.
-// That happens in the completeWork phase without going back to beginWork.
+      if (renderState.tail !== null) {
+        // We still have tail rows to render.
+        // Pop a row.
+        var next = renderState.tail;
+        renderState.rendering = next;
+        renderState.tail = next.sibling;
+        renderState.renderingStartTime = now$1();
+        next.sibling = null; // Restore the context.
+        // TODO: We can probably just avoid popping it instead and only
+        // setting it the first time we go from not suspended to suspended.
 
-function updateSuspenseListComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var revealOrder = nextProps.revealOrder;
-  var tailMode = nextProps.tail;
-  var newChildren = nextProps.children;
-  validateRevealOrder(revealOrder);
-  validateTailOptions(tailMode, revealOrder);
-  validateSuspenseListChildren(newChildren, revealOrder);
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  var suspenseContext = suspenseStackCursor.current;
-  var shouldForceFallback = hasSuspenseListContext(
-    suspenseContext,
-    ForceSuspenseFallback
-  );
+        var suspenseContext = suspenseStackCursor.current;
 
-  if (shouldForceFallback) {
-    suspenseContext = setShallowSuspenseListContext(
-      suspenseContext,
-      ForceSuspenseFallback
-    );
-    workInProgress.flags |= DidCapture;
-  } else {
-    var didSuspendBefore =
-      current !== null && (current.flags & DidCapture) !== NoFlags$1;
+        if (didSuspendAlready) {
+          suspenseContext = setShallowSuspenseListContext(
+            suspenseContext,
+            ForceSuspenseFallback
+          );
+        } else {
+          suspenseContext =
+            setDefaultShallowSuspenseListContext(suspenseContext);
+        }
 
-    if (didSuspendBefore) {
-      // If we previously forced a fallback, we need to schedule work
-      // on any nested boundaries to let them know to try to render
-      // again. This is the same as context updating.
-      propagateSuspenseContextChange(
-        workInProgress,
-        workInProgress.child,
-        renderLanes
-      );
-    }
+        pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+        // Don't bubble properties in this case.
 
-    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
-  }
+        return next;
+      }
 
-  pushSuspenseListContext(workInProgress, suspenseContext);
+      bubbleProperties(workInProgress);
+      return null;
+    }
 
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    // In legacy mode, SuspenseList doesn't work so we just
-    // use make it a noop by treating it as the default revealOrder.
-    workInProgress.memoizedState = null;
-  } else {
-    switch (revealOrder) {
-      case "forwards": {
-        var lastContentRow = findLastContentRow(workInProgress.child);
-        var tail;
+    case ScopeComponent: {
+      {
+        if (current === null) {
+          var scopeInstance = createScopeInstance();
+          workInProgress.stateNode = scopeInstance;
+          prepareScopeUpdate(scopeInstance, workInProgress);
 
-        if (lastContentRow === null) {
-          // The whole list is part of the tail.
-          // TODO: We could fast path by just rendering the tail now.
-          tail = workInProgress.child;
-          workInProgress.child = null;
+          if (workInProgress.ref !== null) {
+            markRef(workInProgress);
+            markUpdate(workInProgress);
+          }
         } else {
-          // Disconnect the tail rows after the content row.
-          // We're going to render them separately later.
-          tail = lastContentRow.sibling;
-          lastContentRow.sibling = null;
+          if (workInProgress.ref !== null) {
+            markUpdate(workInProgress);
+          }
+
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
         }
 
-        initSuspenseListRenderState(
-          workInProgress,
-          false, // isBackwards
-          tail,
-          lastContentRow,
-          tailMode
-        );
-        break;
+        bubbleProperties(workInProgress);
+        return null;
       }
+    }
 
-      case "backwards": {
-        // We're going to find the first row that has existing content.
-        // At the same time we're going to reverse the list of everything
-        // we pass in the meantime. That's going to be our tail in reverse
-        // order.
-        var _tail = null;
-        var row = workInProgress.child;
-        workInProgress.child = null;
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      popSuspenseHandler(workInProgress);
+      popHiddenContext(workInProgress);
+      var _nextState = workInProgress.memoizedState;
+      var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
 
-        while (row !== null) {
-          var currentRow = row.alternate; // New rows can't be content rows.
+      if (workInProgress.tag === LegacyHiddenComponent);
+      else {
+        if (current !== null) {
+          var _prevState = current.memoizedState;
+          var prevIsHidden = _prevState !== null;
 
-          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
-            // This is the beginning of the main content.
-            workInProgress.child = row;
-            break;
+          if (prevIsHidden !== nextIsHidden) {
+            workInProgress.flags |= Visibility;
+          }
+        } else {
+          // On initial mount, we only need a Visibility effect if the tree
+          // is hidden.
+          if (nextIsHidden) {
+            workInProgress.flags |= Visibility;
           }
+        }
+      }
 
-          var nextRow = row.sibling;
-          row.sibling = _tail;
-          _tail = row;
-          row = nextRow;
-        } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+      if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+        bubbleProperties(workInProgress);
+      } else {
+        // Don't bubble properties for hidden children unless we're rendering
+        // at offscreen priority.
+        if (
+          includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes
+        ) {
+          bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+          // If so, we need to hide those nodes in the commit phase, so
+          // schedule a visibility effect.
 
-        initSuspenseListRenderState(
-          workInProgress,
-          true, // isBackwards
-          _tail,
-          null, // last
-          tailMode
-        );
-        break;
+          if (
+            workInProgress.tag !== LegacyHiddenComponent &&
+            workInProgress.subtreeFlags & (Placement | Update)
+          ) {
+            workInProgress.flags |= Visibility;
+          }
+        }
       }
 
-      case "together": {
-        initSuspenseListRenderState(
-          workInProgress,
-          false, // isBackwards
-          null, // tail
-          null, // last
-          undefined
-        );
-        break;
+      if (workInProgress.updateQueue !== null) {
+        // Schedule an effect to attach Suspense retry listeners
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
       }
 
-      default: {
-        // The default reveal order is the same as not having
-        // a boundary.
-        workInProgress.memoizedState = null;
-      }
-    }
-  }
+      {
+        var _previousCache2 = null;
 
-  return workInProgress.child;
-}
+        if (
+          current !== null &&
+          current.memoizedState !== null &&
+          current.memoizedState.cachePool !== null
+        ) {
+          _previousCache2 = current.memoizedState.cachePool.pool;
+        }
 
-function updatePortalComponent(current, workInProgress, renderLanes) {
-  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-  var nextChildren = workInProgress.pendingProps;
+        var _cache2 = null;
 
-  if (current === 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
-    // the root always starts with a "current" with a null child.
-    // TODO: Consider unifying this with how the root works.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  }
+        if (
+          workInProgress.memoizedState !== null &&
+          workInProgress.memoizedState.cachePool !== null
+        ) {
+          _cache2 = workInProgress.memoizedState.cachePool.pool;
+        }
 
-  return workInProgress.child;
-}
+        if (_cache2 !== _previousCache2) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
+        }
+      }
 
-var hasWarnedAboutUsingNoValuePropOnContextProvider = false;
+      popTransition(workInProgress, current);
+      return null;
+    }
 
-function updateContextProvider(current, workInProgress, renderLanes) {
-  var providerType = workInProgress.type;
-  var context = providerType._context;
-  var newProps = workInProgress.pendingProps;
-  var oldProps = workInProgress.memoizedProps;
-  var newValue = newProps.value;
+    case CacheComponent: {
+      {
+        var _previousCache3 = null;
 
-  {
-    if (!("value" in newProps)) {
-      if (!hasWarnedAboutUsingNoValuePropOnContextProvider) {
-        hasWarnedAboutUsingNoValuePropOnContextProvider = true;
+        if (current !== null) {
+          _previousCache3 = current.memoizedState.cache;
+        }
 
-        error(
-          "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
-        );
-      }
-    }
+        var _cache3 = workInProgress.memoizedState.cache;
 
-    var providerPropTypes = workInProgress.type.propTypes;
+        if (_cache3 !== _previousCache3) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
+        }
 
-    if (providerPropTypes) {
-      checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider");
-    }
-  }
+        popCacheProvider(workInProgress);
+        bubbleProperties(workInProgress);
+      }
 
-  pushProvider(workInProgress, context, newValue);
+      return null;
+    }
 
-  if (enableLazyContextPropagation);
-  else {
-    if (oldProps !== null) {
-      var oldValue = oldProps.value;
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var _instance3 = workInProgress.stateNode;
 
-      if (objectIs(oldValue, newValue)) {
-        // No change. Bailout early if children are the same.
-        if (oldProps.children === newProps.children && !hasContextChanged()) {
-          return bailoutOnAlreadyFinishedWork(
-            current,
-            workInProgress,
-            renderLanes
-          );
+        if (_instance3 !== null) {
+          popMarkerInstance(workInProgress);
         }
-      } else {
-        // The context value changed. Search for matching consumers and schedule
-        // them to update.
-        propagateContextChange(workInProgress, context, renderLanes);
+
+        bubbleProperties(workInProgress);
       }
+
+      return null;
     }
   }
 
-  var newChildren = newProps.children;
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  return workInProgress.child;
+  throw new Error(
+    "Unknown unit of work tag (" +
+      workInProgress.tag +
+      "). This error is likely caused by a bug in " +
+      "React. Please file an issue."
+  );
 }
 
-var hasWarnedAboutUsingContextAsConsumer = false;
-
-function updateContextConsumer(current, workInProgress, renderLanes) {
-  var context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
-  // DEV mode, we create a separate object for Context.Consumer that acts
-  // like a proxy to Context. This proxy object adds unnecessary code in PROD
-  // so we use the old behaviour (Context.Consumer references Context) to
-  // reduce size and overhead. The separate object references context via
-  // a property called "_context", which also gives us the ability to check
-  // in DEV mode if this property exists or not and warn if it does not.
-
-  {
-    if (context._context === undefined) {
-      // This may be because it's a Context (rather than a Consumer).
-      // Or it may be because it's older React where they're the same thing.
-      // We only want to warn if we're sure it's a new React.
-      if (context !== context.Consumer) {
-        if (!hasWarnedAboutUsingContextAsConsumer) {
-          hasWarnedAboutUsingContextAsConsumer = true;
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
 
-          error(
-            "Rendering <Context> directly is not supported and will be removed in " +
-              "a future major release. Did you mean to render <Context.Consumer> instead?"
-          );
-        }
-      }
-    } else {
-      context = context._context;
-    }
-  }
+  switch (workInProgress.tag) {
+    case ClassComponent: {
+      var Component = workInProgress.type;
 
-  var newProps = workInProgress.pendingProps;
-  var render = newProps.children;
+      if (isContextProvider(Component)) {
+        popContext(workInProgress);
+      }
 
-  {
-    if (typeof render !== "function") {
-      error(
-        "A context consumer was rendered with multiple children, or a child " +
-          "that isn't a function. A context consumer expects a single child " +
-          "that is a function. If you did pass a function, make sure there " +
-          "is no trailing or leading whitespace around it."
-      );
-    }
-  }
+      var flags = workInProgress.flags;
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var newValue = readContext(context);
+      if (flags & ShouldCapture) {
+        workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
 
-  var newChildren;
+        return workInProgress;
+      }
 
-  {
-    ReactCurrentOwner$2.current = workInProgress;
-    setIsRendering(true);
-    newChildren = render(newValue);
-    setIsRendering(false);
-  }
+      return null;
+    }
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  } // React DevTools reads this flag.
+    case HostRoot: {
+      {
+        popCacheProvider(workInProgress);
+      }
 
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  return workInProgress.child;
-}
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
 
-function updateScopeComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+      popRootTransition(workInProgress);
+      popHostContainer(workInProgress);
+      popTopLevelContextObject(workInProgress);
+      resetWorkInProgressVersions();
+      var _flags = workInProgress.flags;
 
-function markWorkInProgressReceivedUpdate() {
-  didReceiveUpdate = true;
-}
-function checkIfWorkInProgressReceivedUpdate() {
-  return didReceiveUpdate;
-}
+      if (
+        (_flags & ShouldCapture) !== NoFlags$1 &&
+        (_flags & DidCapture) === NoFlags$1
+      ) {
+        // There was an error during render that wasn't captured by a suspense
+        // boundary. Do a second pass on the root to unmount the children.
+        workInProgress.flags = (_flags & ~ShouldCapture) | DidCapture;
+        return workInProgress;
+      } // We unwound to the root without completing it. Exit.
 
-function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    if (current !== null) {
-      // A lazy component only mounts if it suspended inside a non-
-      // concurrent tree, in an inconsistent state. We want to treat it like
-      // a new mount, even though an empty version of it already committed.
-      // Disconnect the alternate pointers.
-      current.alternate = null;
-      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+      return null;
+    }
 
-      workInProgress.flags |= Placement;
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      // TODO: popHydrationState
+      popHostContext(workInProgress);
+      return null;
     }
-  }
-}
 
-function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
-  if (current !== null) {
-    // Reuse previous dependencies
-    workInProgress.dependencies = current.dependencies;
-  }
+    case SuspenseComponent: {
+      popSuspenseHandler(workInProgress);
+      var suspenseState = workInProgress.memoizedState;
 
-  {
-    // Don't update "base" render times for bailouts.
-    stopProfilerTimerIfRunning();
-  }
+      if (suspenseState !== null && suspenseState.dehydrated !== null) {
+        if (workInProgress.alternate === null) {
+          throw new Error(
+            "Threw in newly mounted dehydrated component. This is likely a bug in " +
+              "React. Please file an issue."
+          );
+        }
 
-  markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.
+        resetHydrationState();
+      }
 
-  if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
-    // 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.
-    if (enableLazyContextPropagation && current !== null) {
-      // Before bailing out, check if there are any context changes in
-      // the children.
-      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
+      var _flags2 = workInProgress.flags;
 
-      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
-        return null;
+      if (_flags2 & ShouldCapture) {
+        workInProgress.flags = (_flags2 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
+
+        return workInProgress;
       }
-    } else {
+
       return null;
     }
-  } // This fiber doesn't have work, but its subtree does. Clone the child
-  // fibers and continue.
 
-  cloneChildFibers(current, workInProgress);
-  return workInProgress.child;
-}
+    case SuspenseListComponent: {
+      popSuspenseListContext(workInProgress); // SuspenseList doesn't actually catch anything. It should've been
+      // caught by a nested boundary. If not, it should bubble through.
 
-function remountFiber(current, oldWorkInProgress, newWorkInProgress) {
-  {
-    var returnFiber = oldWorkInProgress.return;
+      return null;
+    }
 
-    if (returnFiber === null) {
-      // eslint-disable-next-line react-internal/prod-error-codes
-      throw new Error("Cannot swap the root fiber.");
-    } // Disconnect from the old current.
-    // It will get deleted.
+    case HostPortal:
+      popHostContainer(workInProgress);
+      return null;
 
-    current.alternate = null;
-    oldWorkInProgress.alternate = null; // Connect to the new tree.
+    case ContextProvider:
+      var context = workInProgress.type._context;
+      popProvider(context, workInProgress);
+      return null;
 
-    newWorkInProgress.index = oldWorkInProgress.index;
-    newWorkInProgress.sibling = oldWorkInProgress.sibling;
-    newWorkInProgress.return = oldWorkInProgress.return;
-    newWorkInProgress.ref = oldWorkInProgress.ref; // Replace the child/sibling pointers above it.
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      popSuspenseHandler(workInProgress);
+      popHiddenContext(workInProgress);
+      popTransition(workInProgress, current);
+      var _flags3 = workInProgress.flags;
 
-    if (oldWorkInProgress === returnFiber.child) {
-      returnFiber.child = newWorkInProgress;
-    } else {
-      var prevSibling = returnFiber.child;
+      if (_flags3 & ShouldCapture) {
+        workInProgress.flags = (_flags3 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
 
-      if (prevSibling === null) {
-        // eslint-disable-next-line react-internal/prod-error-codes
-        throw new Error("Expected parent to have a child.");
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
 
-      while (prevSibling.sibling !== oldWorkInProgress) {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        prevSibling = prevSibling.sibling;
+        return workInProgress;
+      }
 
-        if (prevSibling === null) {
-          // eslint-disable-next-line react-internal/prod-error-codes
-          throw new Error("Expected to find the previous sibling.");
-        }
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+      return null;
+    }
 
-      prevSibling.sibling = newWorkInProgress;
-    } // Delete the old fiber and place the new one.
-    // Since the old fiber is disconnected, we have to schedule it manually.
+    case CacheComponent:
+      {
+        popCacheProvider(workInProgress);
+      }
 
-    var deletions = returnFiber.deletions;
+      return null;
 
-    if (deletions === null) {
-      returnFiber.deletions = [current];
-      returnFiber.flags |= ChildDeletion;
-    } else {
-      deletions.push(current);
-    }
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        if (workInProgress.stateNode !== null) {
+          popMarkerInstance(workInProgress);
+        }
+      }
 
-    newWorkInProgress.flags |= Placement; // Restart work from the new fiber.
+      return null;
 
-    return newWorkInProgress;
+    default:
+      return null;
   }
 }
 
-function checkScheduledUpdateOrContext(current, renderLanes) {
-  // Before performing an early bailout, we must check if there are pending
-  // updates or context.
-  var updateLanes = current.lanes;
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
 
-  if (includesSomeLane(updateLanes, renderLanes)) {
-    return true;
-  } // No pending update, but because context is propagated lazily, we need
-  // to check for a context change before we bail out.
+  switch (interruptedWork.tag) {
+    case ClassComponent: {
+      var childContextTypes = interruptedWork.type.childContextTypes;
 
-  if (enableLazyContextPropagation) {
-    var dependencies = current.dependencies;
+      if (childContextTypes !== null && childContextTypes !== undefined) {
+        popContext(interruptedWork);
+      }
 
-    if (dependencies !== null && checkIfContextChanged(dependencies)) {
-      return true;
+      break;
     }
-  }
-
-  return false;
-}
-
-function attemptEarlyBailoutIfNoScheduledUpdate(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  // 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);
-      pushRootTransition(workInProgress);
 
-      if (enableTransitionTracing) {
-        pushRootMarkerInstance(workInProgress);
+    case HostRoot: {
+      {
+        popCacheProvider(interruptedWork);
       }
 
-      {
-        var cache = current.memoizedState.cache;
-        pushCacheProvider(workInProgress, cache);
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(interruptedWork);
       }
 
-      resetHydrationState();
+      popRootTransition(interruptedWork);
+      popHostContainer(interruptedWork);
+      popTopLevelContextObject(interruptedWork);
+      resetWorkInProgressVersions();
       break;
+    }
 
+    case HostHoistable:
     case HostSingleton:
-    case HostComponent:
-      pushHostContext(workInProgress);
+    case HostComponent: {
+      popHostContext(interruptedWork);
       break;
+    }
 
-    case ClassComponent: {
-      var Component = workInProgress.type;
+    case HostPortal:
+      popHostContainer(interruptedWork);
+      break;
 
-      if (isContextProvider(Component)) {
-        pushContextProvider(workInProgress);
-      }
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
 
+    case SuspenseListComponent:
+      popSuspenseListContext(interruptedWork);
       break;
-    }
 
-    case HostPortal:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+    case ContextProvider:
+      var context = interruptedWork.type._context;
+      popProvider(context, interruptedWork);
       break;
 
-    case ContextProvider: {
-      var newValue = workInProgress.memoizedProps.value;
-      var context = workInProgress.type._context;
-      pushProvider(workInProgress, context, newValue);
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext(interruptedWork);
+      popTransition(interruptedWork, current);
       break;
-    }
 
-    case Profiler:
+    case CacheComponent:
       {
-        // Profiler should only call onRender when one of its descendants actually rendered.
-        var hasChildWork = includesSomeLane(
-          renderLanes,
-          workInProgress.childLanes
-        );
+        popCacheProvider(interruptedWork);
+      }
 
-        if (hasChildWork) {
-          workInProgress.flags |= Update;
-        }
+      break;
 
-        {
-          // Reset effect durations for the next eventual effect phase.
-          // These are reset during render to allow the DevTools commit hook a chance to read them,
-          var stateNode = workInProgress.stateNode;
-          stateNode.effectDuration = 0;
-          stateNode.passiveEffectDuration = 0;
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        var instance = interruptedWork.stateNode;
+
+        if (instance !== null) {
+          popMarkerInstance(interruptedWork);
         }
       }
 
       break;
+  }
+}
 
-    case SuspenseComponent: {
-      var state = workInProgress.memoizedState;
+// Provided by www
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
 
-      if (state !== null) {
-        if (state.dehydrated !== null) {
-          // We're not going to render the children, so this is just to maintain
-          // push/pop symmetry
-          pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
-          // been unsuspended it has committed as a resolved Suspense component.
-          // If it needs to be retried, it should have work scheduled on it.
+if (typeof ReactFbErrorUtils.invokeGuardedCallback !== "function") {
+  throw new Error(
+    "Expected ReactFbErrorUtils.invokeGuardedCallback to be a function."
+  );
+}
+
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  // This will call `this.onError(err)` if an error was caught.
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
+}
+
+var hasError = false;
+var caughtError = null; // Used by event system to capture/rethrow the first error.
+
+var hasRethrowError = false;
+var rethrowError = null;
+var reporter = {
+  onError: function (error) {
+    hasError = true;
+    caughtError = error;
+  }
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
+) {
+  invokeGuardedCallback.apply(this, arguments);
+
+  if (hasError) {
+    var error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
+  }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
+
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    var error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function hasCaughtError() {
+  return hasError;
+}
+function clearCaughtError() {
+  if (hasError) {
+    var error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw new Error(
+      "clearCaughtError was called but no error was captured. This error " +
+        "is likely caused by a bug in React. Please file an issue."
+    );
+  }
+}
+
+var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+
+{
+  didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+} // Used during the commit phase to track the state of the Offscreen component stack.
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+
+var offscreenSubtreeIsHidden = false;
+var offscreenSubtreeWasHidden = false;
+var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
+var nextEffect = null; // Used for Profiling builds to track updaters.
+
+var inProgressLanes = null;
+var inProgressRoot = null;
+
+function shouldProfile(current) {
+  return (
+    (current.mode & ProfileMode) !== NoMode &&
+    (getExecutionContext() & CommitContext) !== NoContext
+  );
+}
+
+function reportUncaughtErrorInDEV(error) {
+  // Wrapping each small part of the commit phase into a guarded
+  // callback is a bit too slow (https://github.com/facebook/react/pull/21666).
+  // But we rely on it to surface errors to DEV tools like overlays
+  // (https://github.com/facebook/react/issues/21712).
+  // As a compromise, rethrow only caught errors in a guard.
+  {
+    invokeGuardedCallback(null, function () {
+      throw error;
+    });
+    clearCaughtError();
+  }
+}
+
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+
+  if (shouldProfile(current)) {
+    try {
+      startLayoutEffectTimer();
+      instance.componentWillUnmount();
+    } finally {
+      recordLayoutEffectDuration(current);
+    }
+  } else {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
 
-          workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
-          // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+function safelyCallComponentWillUnmount(
+  current,
+  nearestMountedAncestor,
+  instance
+) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
 
-          return null;
-        } // If this boundary is currently timed out, we need to decide
-        // whether to retry the primary children, or to skip over it and
-        // go straight to the fallback. Check the priority of the primary
-        // child fragment.
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
 
-        var primaryChildFragment = workInProgress.child;
-        var primaryChildLanes = primaryChildFragment.childLanes;
+function safelyDetachRef(current, nearestMountedAncestor) {
+  var ref = current.ref;
+  var refCleanup = current.refCleanup;
 
-        if (includesSomeLane(renderLanes, primaryChildLanes)) {
-          // The primary children have pending work. Use the normal path
-          // to attempt to render the primary children again.
-          return updateSuspenseComponent(current, workInProgress, renderLanes);
+  if (ref !== null) {
+    if (typeof refCleanup === "function") {
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            refCleanup();
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
         } else {
-          // The primary child fragment does not have pending work marked
-          // on it
-          pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
-          // priority. Bailout.
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        var finishedWork = current.alternate;
 
-          var child = bailoutOnAlreadyFinishedWork(
-            current,
-            workInProgress,
-            renderLanes
-          );
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === "function") {
+      var retVal;
 
-          if (child !== null) {
-            // The fallback children have pending work. Skip over the
-            // primary children and work on the fallback.
-            return child.sibling;
-          } else {
-            // Note: We can return `null` here because we already checked
-            // whether there were nested context consumers, via the call to
-            // `bailoutOnAlreadyFinishedWork` above.
-            return null;
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            retVal = ref(null);
+          } finally {
+            recordLayoutEffectDuration(current);
           }
+        } else {
+          retVal = ref(null);
         }
-      } else {
-        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
       }
 
-      break;
-    }
-
-    case SuspenseListComponent: {
-      var didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
-
-      var _hasChildWork = includesSomeLane(
-        renderLanes,
-        workInProgress.childLanes
-      );
-
-      if (enableLazyContextPropagation && !_hasChildWork) {
-        // Context changes may not have been propagated yet. We need to do
-        // that now, before we can decide whether to bail out.
-        // TODO: We use `childLanes` as a heuristic for whether there is
-        // remaining work in a few places, including
-        // `bailoutOnAlreadyFinishedWork` and
-        // `updateDehydratedSuspenseComponent`. We should maybe extract this
-        // into a dedicated function.
-        lazilyPropagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes
-        );
-        _hasChildWork = includesSomeLane(
-          renderLanes,
-          workInProgress.childLanes
-        );
+      {
+        if (typeof retVal === "function") {
+          error(
+            "Unexpected return value from a callback ref in %s. " +
+              "A callback ref should not return a function.",
+            getComponentNameFromFiber(current)
+          );
+        }
       }
+    } else {
+      // $FlowFixMe unable to narrow type to RefObject
+      ref.current = null;
+    }
+  }
+}
 
-      if (didSuspendBefore) {
-        if (_hasChildWork) {
-          // If something was in fallback state last time, and we have all the
-          // same children then we're still in progressive loading state.
-          // Something might get unblocked by state updates or retries in the
-          // tree which will affect the tail. So we need to use the normal
-          // path to compute the correct tail.
-          return updateSuspenseListComponent(
-            current,
-            workInProgress,
-            renderLanes
-          );
-        } // If none of the children had any work, that means that none of
-        // them got retried so they'll still be blocked in the same way
-        // as before. We can fast bail out.
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
 
-        workInProgress.flags |= DidCapture;
-      } // If nothing suspended before and we're rendering the same children,
-      // then the tail doesn't matter. Anything new that suspends will work
-      // in the "together" mode, so we can continue from the state we had.
+var focusedInstanceHandle = null;
+var shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  focusedInstanceHandle = prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
 
-      var renderState = workInProgress.memoizedState;
+  var shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  focusedInstanceHandle = null;
+  return shouldFire;
+}
 
-      if (renderState !== null) {
-        // Reset to the "together" mode in case we've started a different
-        // update in the past but didn't complete it.
-        renderState.rendering = null;
-        renderState.tail = null;
-        renderState.lastEffect = null;
-      }
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    var fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+    // Let's skip the whole loop if it's off.
 
-      pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+    {
+      // TODO: Should wrap this in flags check, too, as optimization
+      var deletions = fiber.deletions;
 
-      if (_hasChildWork) {
-        break;
-      } else {
-        // If none of the children had any work, that means that none of
-        // them got retried so they'll still be blocked in the same way
-        // as before. We can fast bail out.
-        return null;
+      if (deletions !== null) {
+        for (var i = 0; i < deletions.length; i++) {
+          var deletion = deletions[i];
+          commitBeforeMutationEffectsDeletion(deletion);
+        }
       }
     }
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      // Need to check if the tree still needs to be deferred. This is
-      // almost identical to the logic used in the normal update path,
-      // so we'll just enter that. The only difference is we'll bail out
-      // at the next level instead of this one, because the child props
-      // have not changed. Which is fine.
-      // TODO: Probably should refactor `beginWork` to split the bailout
-      // path from the normal path. I'm tempted to do a labeled break here
-      // but I won't :)
-      workInProgress.lanes = NoLanes;
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    var child = fiber.child;
+
+    if (
+      (fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 &&
+      child !== null
+    ) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
     }
+  }
+}
 
-    case CacheComponent: {
-      {
-        var _cache = current.memoizedState.cache;
-        pushCacheProvider(workInProgress, _cache);
-      }
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    setCurrentFiber(fiber);
 
-      break;
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
     }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        var instance = workInProgress.stateNode;
+    resetCurrentFiber();
+    var sibling = fiber.sibling;
 
-        if (instance !== null) {
-          pushMarkerInstance(workInProgress, instance);
-        }
-      }
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
     }
-  }
 
-  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    nextEffect = fiber.return;
+  }
 }
 
-function beginWork$1(current, workInProgress, renderLanes) {
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  var current = finishedWork.alternate;
+  var flags = finishedWork.flags;
+
   {
-    if (workInProgress._debugNeedsRemount && current !== null) {
-      // This will restart the begin phase with a new fiber.
-      return remountFiber(
-        current,
-        workInProgress,
-        createFiberFromTypeAndProps(
-          workInProgress.type,
-          workInProgress.key,
-          workInProgress.pendingProps,
-          workInProgress._debugOwner || null,
-          workInProgress.mode,
-          workInProgress.lanes
-        )
-      );
+    if (!shouldFireAfterActiveInstanceBlur && focusedInstanceHandle !== null) {
+      // Check to see if the focused element was inside of a hidden (Suspense) subtree.
+      // TODO: Move this out of the hot path using a dedicated effect tag.
+      if (
+        finishedWork.tag === SuspenseComponent &&
+        isSuspenseBoundaryBeingHidden(current, finishedWork) && // $FlowFixMe[incompatible-call] found when upgrading Flow
+        doesFiberContain(finishedWork, focusedInstanceHandle)
+      ) {
+        shouldFireAfterActiveInstanceBlur = true;
+        beforeActiveInstanceBlur(finishedWork);
+      }
     }
   }
 
-  if (current !== null) {
-    var oldProps = current.memoizedProps;
-    var newProps = workInProgress.pendingProps;
-
-    if (
-      oldProps !== newProps ||
-      hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
-      workInProgress.type !== current.type
-    ) {
-      // If props or context changed, mark the fiber as having performed work.
-      // This may be unset if the props are determined to be equal later (memo).
-      didReceiveUpdate = true;
-    } else {
-      // Neither props nor legacy context changes. Check if there's a pending
-      // update or context change.
-      var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
-        current,
-        renderLanes
-      );
+  if ((flags & Snapshot) !== NoFlags$1) {
+    setCurrentFiber(finishedWork);
+  }
 
-      if (
-        !hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
-        // may not be work scheduled on `current`, so we check for this flag.
-        (workInProgress.flags & DidCapture) === NoFlags$1
-      ) {
-        // No pending updates or context. Bail out now.
-        didReceiveUpdate = false;
-        return attemptEarlyBailoutIfNoScheduledUpdate(
-          current,
-          workInProgress,
-          renderLanes
-        );
+  switch (finishedWork.tag) {
+    case FunctionComponent: {
+      {
+        if ((flags & Update) !== NoFlags$1) {
+          commitUseEffectEventMount(finishedWork);
+        }
       }
 
-      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
-        // This is a special case that only exists for legacy mode.
-        // See https://github.com/facebook/react/pull/19216.
-        didReceiveUpdate = true;
-      } else {
-        // An update was scheduled on this fiber, but there are no new props
-        // nor legacy context. Set this to false. If an update queue or context
-        // consumer produces a changed value, it will set this to true. Otherwise,
-        // the component will assume the children have not changed and bail out.
-        didReceiveUpdate = false;
-      }
+      break;
     }
-  } else {
-    didReceiveUpdate = false;
 
-    if (getIsHydrating() && isForkedChild(workInProgress)) {
-      // Check if this child belongs to a list of muliple children in
-      // its parent.
-      //
-      // In a true multi-threaded implementation, we would render children on
-      // parallel threads. This would represent the beginning of a new render
-      // thread for this subtree.
-      //
-      // We only use this for id generation during hydration, which is why the
-      // logic is located in this special branch.
-      var slotIndex = workInProgress.index;
-      var numberOfForks = getForksAtLevel();
-      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      break;
     }
-  } // Before entering the begin phase, clear pending update priority.
-  // TODO: This assumes that we're about to evaluate the component and process
-  // the update queue. However, there's an exception: SimpleMemoComponent
-  // sometimes bails out later in the begin phase. This indicates that we should
-  // move this assignment out of the common path and into each branch.
 
-  workInProgress.lanes = NoLanes;
+    case ClassComponent: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        if (current !== null) {
+          var prevProps = current.memoizedProps;
+          var prevState = current.memoizedState;
+          var instance = finishedWork.stateNode; // We could update instance props and state here,
+          // but instead we rely on them being set during last render.
+          // TODO: revisit this when we implement resuming.
 
-  switch (workInProgress.tag) {
-    case IndeterminateComponent: {
-      return mountIndeterminateComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        renderLanes
-      );
-    }
+          {
+            if (
+              finishedWork.type === finishedWork.elementType &&
+              !didWarnAboutReassigningProps
+            ) {
+              if (instance.props !== finishedWork.memoizedProps) {
+                error(
+                  "Expected %s props to match memoized props before " +
+                    "getSnapshotBeforeUpdate. " +
+                    "This might either be because of a bug in React, or because " +
+                    "a component reassigns its own `this.props`. " +
+                    "Please file an issue.",
+                  getComponentNameFromFiber(finishedWork) || "instance"
+                );
+              }
 
-    case LazyComponent: {
-      var elementType = workInProgress.elementType;
-      return mountLazyComponent(
-        current,
-        workInProgress,
-        elementType,
-        renderLanes
-      );
-    }
+              if (instance.state !== finishedWork.memoizedState) {
+                error(
+                  "Expected %s state to match memoized state before " +
+                    "getSnapshotBeforeUpdate. " +
+                    "This might either be because of a bug in React, or because " +
+                    "a component reassigns its own `this.state`. " +
+                    "Please file an issue.",
+                  getComponentNameFromFiber(finishedWork) || "instance"
+                );
+              }
+            }
+          }
 
-    case FunctionComponent: {
-      var Component = workInProgress.type;
-      var unresolvedProps = workInProgress.pendingProps;
-      var resolvedProps =
-        workInProgress.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      return updateFunctionComponent(
-        current,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-    }
+          var snapshot = instance.getSnapshotBeforeUpdate(
+            finishedWork.elementType === finishedWork.type
+              ? prevProps
+              : resolveDefaultProps(finishedWork.type, prevProps),
+            prevState
+          );
 
-    case ClassComponent: {
-      var _Component = workInProgress.type;
-      var _unresolvedProps = workInProgress.pendingProps;
+          {
+            var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
 
-      var _resolvedProps =
-        workInProgress.elementType === _Component
-          ? _unresolvedProps
-          : resolveDefaultProps(_Component, _unresolvedProps);
+            if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
+              didWarnSet.add(finishedWork.type);
 
-      return updateClassComponent(
-        current,
-        workInProgress,
-        _Component,
-        _resolvedProps,
-        renderLanes
-      );
-    }
+              error(
+                "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
+                  "must be returned. You have returned undefined.",
+                getComponentNameFromFiber(finishedWork)
+              );
+            }
+          }
 
-    case HostRoot:
-      return updateHostRoot(current, workInProgress, renderLanes);
+          instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+        }
+      }
 
-    case HostHoistable: {
-      return updateHostHoistable(current, workInProgress);
+      break;
     }
 
-    // eslint-disable-next-line no-fallthrough
+    case HostRoot: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        {
+          var root = finishedWork.stateNode;
+          clearContainer(root.containerInfo);
+        }
+      }
 
-    case HostSingleton: {
-      return updateHostSingleton(current, workInProgress, renderLanes);
+      break;
     }
 
-    // eslint-disable-next-line no-fallthrough
-
     case HostComponent:
-      return updateHostComponent$1(current, workInProgress, renderLanes);
-
+    case HostHoistable:
+    case HostSingleton:
     case HostText:
-      return updateHostText$1(current, workInProgress);
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
+
+    default: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        throw new Error(
+          "This unit of work tag should not have side-effects. This error is " +
+            "likely caused by a bug in React. Please file an issue."
+        );
+      }
+    }
+  }
+
+  if ((flags & Snapshot) !== NoFlags$1) {
+    resetCurrentFiber();
+  }
+}
+
+function commitBeforeMutationEffectsDeletion(deletion) {
+  {
+    // TODO (effects) It would be nice to avoid calling doesFiberContain()
+    // Maybe we can repurpose one of the subtreeFlags positions for this instead?
+    // Use it to store which part of the tree the focused instance is in?
+    // This assumes we can safely determine that instance during the "render" phase.
+    if (doesFiberContain(deletion, focusedInstanceHandle)) {
+      shouldFireAfterActiveInstanceBlur = true;
+      beforeActiveInstanceBlur(deletion);
+    }
+  }
+}
 
-    case SuspenseComponent:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
+function commitHookEffectListUnmount(
+  flags,
+  finishedWork,
+  nearestMountedAncestor
+) {
+  var updateQueue = finishedWork.updateQueue;
+  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
 
-    case HostPortal:
-      return updatePortalComponent(current, workInProgress, renderLanes);
+  if (lastEffect !== null) {
+    var firstEffect = lastEffect.next;
+    var effect = firstEffect;
 
-    case ForwardRef: {
-      var type = workInProgress.type;
-      var _unresolvedProps2 = workInProgress.pendingProps;
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        var destroy = effect.destroy;
+        effect.destroy = undefined;
 
-      var _resolvedProps2 =
-        workInProgress.elementType === type
-          ? _unresolvedProps2
-          : resolveDefaultProps(type, _unresolvedProps2);
+        if (destroy !== undefined) {
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStarted(finishedWork);
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStarted(finishedWork);
+            }
+          }
 
-      return updateForwardRef(
-        current,
-        workInProgress,
-        type,
-        _resolvedProps2,
-        renderLanes
-      );
-    }
+          {
+            if ((flags & Insertion) !== NoFlags) {
+              setIsRunningInsertionEffect(true);
+            }
+          }
 
-    case Fragment:
-      return updateFragment(current, workInProgress, renderLanes);
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
 
-    case Mode:
-      return updateMode(current, workInProgress, renderLanes);
+          {
+            if ((flags & Insertion) !== NoFlags) {
+              setIsRunningInsertionEffect(false);
+            }
+          }
 
-    case Profiler:
-      return updateProfiler(current, workInProgress, renderLanes);
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStopped();
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStopped();
+            }
+          }
+        }
+      }
 
-    case ContextProvider:
-      return updateContextProvider(current, workInProgress, renderLanes);
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
 
-    case ContextConsumer:
-      return updateContextConsumer(current, workInProgress, renderLanes);
+function commitHookEffectListMount(flags, finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
 
-    case MemoComponent: {
-      var _type2 = workInProgress.type;
-      var _unresolvedProps3 = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+  if (lastEffect !== null) {
+    var firstEffect = lastEffect.next;
+    var effect = firstEffect;
 
-      var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
+    do {
+      if ((effect.tag & flags) === flags) {
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStarted(finishedWork);
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStarted(finishedWork);
+          }
+        } // Mount
 
-      {
-        if (workInProgress.type !== workInProgress.elementType) {
-          var outerPropTypes = _type2.propTypes;
+        var create = effect.create;
 
-          if (outerPropTypes) {
-            checkPropTypes(
-              outerPropTypes,
-              _resolvedProps3, // Resolved for outer only
-              "prop",
-              getComponentNameFromType(_type2)
-            );
+        {
+          if ((flags & Insertion) !== NoFlags) {
+            setIsRunningInsertionEffect(true);
           }
         }
-      }
 
-      _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
-      return updateMemoComponent(
-        current,
-        workInProgress,
-        _type2,
-        _resolvedProps3,
-        renderLanes
-      );
-    }
+        effect.destroy = create();
 
-    case SimpleMemoComponent: {
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
-      );
-    }
+        {
+          if ((flags & Insertion) !== NoFlags) {
+            setIsRunningInsertionEffect(false);
+          }
+        }
 
-    case IncompleteClassComponent: {
-      var _Component2 = workInProgress.type;
-      var _unresolvedProps4 = workInProgress.pendingProps;
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStopped();
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStopped();
+          }
+        }
 
-      var _resolvedProps4 =
-        workInProgress.elementType === _Component2
-          ? _unresolvedProps4
-          : resolveDefaultProps(_Component2, _unresolvedProps4);
+        {
+          var destroy = effect.destroy;
 
-      return mountIncompleteClassComponent(
-        current,
-        workInProgress,
-        _Component2,
-        _resolvedProps4,
-        renderLanes
-      );
-    }
+          if (destroy !== undefined && typeof destroy !== "function") {
+            var hookName = void 0;
 
-    case SuspenseListComponent: {
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    }
+            if ((effect.tag & Layout) !== NoFlags$1) {
+              hookName = "useLayoutEffect";
+            } else if ((effect.tag & Insertion) !== NoFlags$1) {
+              hookName = "useInsertionEffect";
+            } else {
+              hookName = "useEffect";
+            }
 
-    case ScopeComponent: {
-      {
-        return updateScopeComponent(current, workInProgress, renderLanes);
-      }
-    }
+            var addendum = void 0;
 
-    case OffscreenComponent: {
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    }
+            if (destroy === null) {
+              addendum =
+                " You returned null. If your effect does not require clean " +
+                "up, return undefined (or nothing).";
+            } else if (typeof destroy.then === "function") {
+              addendum =
+                "\n\nIt looks like you wrote " +
+                hookName +
+                "(async () => ...) or returned a Promise. " +
+                "Instead, write the async function inside your effect " +
+                "and call it immediately:\n\n" +
+                hookName +
+                "(() => {\n" +
+                "  async function fetchData() {\n" +
+                "    // You can await here\n" +
+                "    const response = await MyAPI.getData(someId);\n" +
+                "    // ...\n" +
+                "  }\n" +
+                "  fetchData();\n" +
+                "}, [someId]); // Or [] if effect doesn't need props or state\n\n" +
+                "Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching";
+            } else {
+              addendum = " You returned: " + destroy;
+            }
 
-    case LegacyHiddenComponent: {
-      {
-        return updateLegacyHiddenComponent(
-          current,
-          workInProgress,
-          renderLanes
-        );
+            error(
+              "%s must not return anything besides a function, " +
+                "which is used for clean-up.%s",
+              hookName,
+              addendum
+            );
+          }
+        }
       }
-    }
 
-    case CacheComponent: {
-      {
-        return updateCacheComponent(current, workInProgress, renderLanes);
-      }
-    }
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        return updateTracingMarkerComponent(
-          current,
-          workInProgress,
-          renderLanes
-        );
-      }
+function commitUseEffectEventMount(finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  var eventPayloads = updateQueue !== null ? updateQueue.events : null;
 
-      break;
+  if (eventPayloads !== null) {
+    for (var ii = 0; ii < eventPayloads.length; ii++) {
+      var _eventPayloads$ii = eventPayloads[ii],
+        ref = _eventPayloads$ii.ref,
+        nextImpl = _eventPayloads$ii.nextImpl;
+      ref.impl = nextImpl;
     }
   }
-
-  throw new Error(
-    "Unknown unit of work tag (" +
-      workInProgress.tag +
-      "). This error is likely caused by a bug in " +
-      "React. Please file an issue."
-  );
 }
 
-var valueCursor = createCursor(null);
-var rendererCursorDEV;
+function commitPassiveEffectDurations(finishedRoot, finishedWork) {
+  if (getExecutionContext() & CommitContext) {
+    // Only Profilers with work in their subtree will have an Update effect scheduled.
+    if ((finishedWork.flags & Update) !== NoFlags$1) {
+      switch (finishedWork.tag) {
+        case Profiler: {
+          var passiveEffectDuration =
+            finishedWork.stateNode.passiveEffectDuration;
+          var _finishedWork$memoize = finishedWork.memoizedProps,
+            id = _finishedWork$memoize.id,
+            onPostCommit = _finishedWork$memoize.onPostCommit; // This value will still reflect the previous commit phase.
+          // It does not get reset until the start of the next commit phase.
 
-{
-  rendererCursorDEV = createCursor(null);
-}
+          var commitTime = getCommitTime();
+          var phase = finishedWork.alternate === null ? "mount" : "update";
 
-var rendererSigil;
+          {
+            if (isCurrentUpdateNested()) {
+              phase = "nested-update";
+            }
+          }
 
-{
-  // Use this to detect multiple renderers using the same context
-  rendererSigil = {};
-}
+          if (typeof onPostCommit === "function") {
+            onPostCommit(id, phase, passiveEffectDuration, commitTime);
+          } // Bubble times to the next nearest ancestor Profiler.
+          // After we process that Profiler, we'll bubble further up.
 
-var currentlyRenderingFiber = null;
-var lastContextDependency = null;
-var lastFullyObservedContext = null;
-var isDisallowedContextReadInDEV = false;
-function resetContextDependencies() {
-  // This is called right before React yields execution, to ensure `readContext`
-  // cannot be called outside the render phase.
-  currentlyRenderingFiber = null;
-  lastContextDependency = null;
-  lastFullyObservedContext = null;
+          var parentFiber = finishedWork.return;
 
-  {
-    isDisallowedContextReadInDEV = false;
-  }
-}
-function enterDisallowedContextReadInDEV() {
-  {
-    isDisallowedContextReadInDEV = true;
-  }
-}
-function exitDisallowedContextReadInDEV() {
-  {
-    isDisallowedContextReadInDEV = false;
-  }
-}
-function pushProvider(providerFiber, context, nextValue) {
-  {
-    push(valueCursor, context._currentValue, providerFiber);
-    context._currentValue = nextValue;
+          outer: while (parentFiber !== null) {
+            switch (parentFiber.tag) {
+              case HostRoot:
+                var root = parentFiber.stateNode;
+                root.passiveEffectDuration += passiveEffectDuration;
+                break outer;
 
-    {
-      push(rendererCursorDEV, context._currentRenderer, providerFiber);
+              case Profiler:
+                var parentStateNode = parentFiber.stateNode;
+                parentStateNode.passiveEffectDuration += passiveEffectDuration;
+                break outer;
+            }
 
-      if (
-        context._currentRenderer !== undefined &&
-        context._currentRenderer !== null &&
-        context._currentRenderer !== rendererSigil
-      ) {
-        error(
-          "Detected multiple renderers concurrently rendering the " +
-            "same context provider. This is currently unsupported."
-        );
-      }
+            parentFiber = parentFiber.return;
+          }
 
-      context._currentRenderer = rendererSigil;
+          break;
+        }
+      }
     }
   }
 }
-function popProvider(context, providerFiber) {
-  var currentValue = valueCursor.current;
 
-  {
-    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
-      context._currentValue = context._defaultValue;
-    } else {
-      context._currentValue = currentValue;
+function commitHookLayoutEffects(finishedWork, hookFlags) {
+  // At this point layout effects have already been destroyed (during mutation phase).
+  // This is done to prevent sibling component effects from interfering with each other,
+  // e.g. a destroy function in one component should never override a ref set
+  // by a create function in another component during the same commit.
+  if (shouldProfile(finishedWork)) {
+    try {
+      startLayoutEffectTimer();
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
 
-    {
-      var currentRenderer = rendererCursorDEV.current;
-      pop(rendererCursorDEV, providerFiber);
-      context._currentRenderer = currentRenderer;
+    recordLayoutEffectDuration(finishedWork);
+  } else {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
   }
-
-  pop(valueCursor, providerFiber);
 }
-function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
-  // Update the child lanes of all the ancestors, including the alternates.
-  var node = parent;
 
-  while (node !== null) {
-    var alternate = node.alternate;
+function commitClassLayoutLifecycles(finishedWork, current) {
+  var instance = finishedWork.stateNode;
 
-    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
-      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+  if (current === null) {
+    // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "componentDidMount. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-      if (alternate !== null) {
-        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "componentDidMount. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
       }
-    } else if (
-      alternate !== null &&
-      !isSubsetOfLanes(alternate.childLanes, renderLanes)
-    ) {
-      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
-    } else;
-
-    if (node === propagationRoot) {
-      break;
     }
 
-    node = node.return;
-  }
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
 
-  {
-    if (node !== propagationRoot) {
-      error(
-        "Expected to find the propagation root when scheduling context work. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
+      recordLayoutEffectDuration(finishedWork);
+    } else {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
     }
-  }
-}
-function propagateContextChange(workInProgress, context, renderLanes) {
-  if (enableLazyContextPropagation) {
-    // TODO: This path is only used by Cache components. Update
-    // lazilyPropagateParentContextChanges to look for Cache components so they
-    // can take advantage of lazy propagation.
-    var forcePropagateEntireTree = true;
-    propagateContextChanges(
-      workInProgress,
-      [context],
-      renderLanes,
-      forcePropagateEntireTree
-    );
   } else {
-    propagateContextChange_eager(workInProgress, context, renderLanes);
-  }
-}
-
-function propagateContextChange_eager(workInProgress, context, renderLanes) {
-  // Only used by eager implementation
-  if (enableLazyContextPropagation) {
-    return;
-  }
-
-  var fiber = workInProgress.child;
-
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
-  }
+    var prevProps =
+      finishedWork.elementType === finishedWork.type
+        ? current.memoizedProps
+        : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    var prevState = current.memoizedState; // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
 
-  while (fiber !== null) {
-    var nextFiber = void 0; // Visit this fiber.
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "componentDidUpdate. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-    var list = fiber.dependencies;
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "componentDidUpdate. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
+      }
+    }
 
-    if (list !== null) {
-      nextFiber = fiber.child;
-      var dependency = list.firstContext;
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
 
-      while (dependency !== null) {
-        // Check if the context matches.
-        if (dependency.context === context) {
-          // Match! Schedule an update on this fiber.
-          if (fiber.tag === ClassComponent) {
-            // Schedule a force update on the work-in-progress.
-            var lane = pickArbitraryLane(renderLanes);
-            var update = createUpdate(lane);
-            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
-            // update to the current fiber, too, which means it will persist even if
-            // this render is thrown away. Since it's a race condition, not sure it's
-            // worth fixing.
-            // Inlined `enqueueUpdate` to remove interleaved update check
+      recordLayoutEffectDuration(finishedWork);
+    } else {
+      try {
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+}
 
-            var updateQueue = fiber.updateQueue;
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  var updateQueue = finishedWork.updateQueue;
 
-            if (updateQueue === null);
-            else {
-              var sharedQueue = updateQueue.shared;
-              var pending = sharedQueue.pending;
+  if (updateQueue !== null) {
+    var instance = finishedWork.stateNode;
 
-              if (pending === null) {
-                // This is the first update. Create a circular list.
-                update.next = update;
-              } else {
-                update.next = pending.next;
-                pending.next = update;
-              }
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "processing the update queue. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-              sharedQueue.pending = update;
-            }
-          }
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "processing the update queue. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
+      }
+    } // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
 
-          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
-          var alternate = fiber.alternate;
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
 
-          if (alternate !== null) {
-            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-          }
+function commitHostComponentMount(finishedWork) {
+  var type = finishedWork.type;
+  var props = finishedWork.memoizedProps;
+  var instance = finishedWork.stateNode;
 
-          scheduleContextWorkOnParentPath(
-            fiber.return,
-            renderLanes,
-            workInProgress
-          ); // Mark the updated lanes on the list, too.
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
 
-          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
-          // dependency list.
+function commitProfilerUpdate(finishedWork, current) {
+  if (getExecutionContext() & CommitContext) {
+    try {
+      var _finishedWork$memoize2 = finishedWork.memoizedProps,
+        onCommit = _finishedWork$memoize2.onCommit,
+        onRender = _finishedWork$memoize2.onRender;
+      var effectDuration = finishedWork.stateNode.effectDuration;
+      var commitTime = getCommitTime();
+      var phase = current === null ? "mount" : "update";
 
-          break;
+      if (enableProfilerNestedUpdatePhase) {
+        if (isCurrentUpdateNested()) {
+          phase = "nested-update";
         }
-
-        dependency = dependency.next;
       }
-    } else if (fiber.tag === ContextProvider) {
-      // Don't scan deeper if this is a matching provider
-      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-    } else if (fiber.tag === DehydratedFragment) {
-      // If a dehydrated suspense boundary is in this subtree, we don't know
-      // if it will have any context consumers in it. The best we can do is
-      // mark it as having updates.
-      var parentSuspense = fiber.return;
 
-      if (parentSuspense === null) {
-        throw new Error(
-          "We just came from a parent so we must have had a parent. This is a bug in React."
+      if (typeof onRender === "function") {
+        onRender(
+          finishedWork.memoizedProps.id,
+          phase,
+          finishedWork.actualDuration,
+          finishedWork.treeBaseDuration,
+          finishedWork.actualStartTime,
+          commitTime
         );
       }
 
-      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
-      var _alternate = parentSuspense.alternate;
-
-      if (_alternate !== null) {
-        _alternate.lanes = mergeLanes(_alternate.lanes, renderLanes);
-      } // This is intentionally passing this fiber as the parent
-      // because we want to schedule this fiber as having work
-      // on its children. We'll use the childLanes on
-      // this fiber to indicate that a context has changed.
-
-      scheduleContextWorkOnParentPath(
-        parentSuspense,
-        renderLanes,
-        workInProgress
-      );
-      nextFiber = fiber.sibling;
-    } else {
-      // Traverse down.
-      nextFiber = fiber.child;
-    }
+      if (enableProfilerCommitHooks) {
+        if (typeof onCommit === "function") {
+          onCommit(
+            finishedWork.memoizedProps.id,
+            phase,
+            effectDuration,
+            commitTime
+          );
+        } // Schedule a passive effect for this Profiler to call onPostCommit hooks.
+        // This effect should be scheduled even if there is no onPostCommit callback for this Profiler,
+        // because the effect is also where times bubble to parent Profilers.
 
-    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;
+        enqueuePendingPassiveProfilerEffect(finishedWork); // Propagate layout effect durations to the next nearest Profiler ancestor.
+        // Do not reset these values until the next render so DevTools has a chance to read them first.
 
-      while (nextFiber !== null) {
-        if (nextFiber === workInProgress) {
-          // We're back to the root of this subtree. Exit.
-          nextFiber = null;
-          break;
-        }
+        var parentFiber = finishedWork.return;
 
-        var sibling = nextFiber.sibling;
+        outer: while (parentFiber !== null) {
+          switch (parentFiber.tag) {
+            case HostRoot:
+              var root = parentFiber.stateNode;
+              root.effectDuration += effectDuration;
+              break outer;
 
-        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.
+            case Profiler:
+              var parentStateNode = parentFiber.stateNode;
+              parentStateNode.effectDuration += effectDuration;
+              break outer;
+          }
 
-        nextFiber = nextFiber.return;
+          parentFiber = parentFiber.return;
+        }
       }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
-
-    fiber = nextFiber;
   }
 }
 
-function propagateContextChanges(
-  workInProgress,
-  contexts,
-  renderLanes,
-  forcePropagateEntireTree
+function commitLayoutEffectOnFiber(
+  finishedRoot,
+  current,
+  finishedWork,
+  committedLanes
 ) {
-  // Only used by lazy implementation
-  if (!enableLazyContextPropagation) {
-    return;
-  }
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  var flags = finishedWork.flags;
 
-  var fiber = workInProgress.child;
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
-  }
+      if (flags & Update) {
+        commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+      }
 
-  while (fiber !== null) {
-    var nextFiber = void 0; // Visit this fiber.
+      break;
+    }
 
-    var list = fiber.dependencies;
+    case ClassComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-    if (list !== null) {
-      nextFiber = fiber.child;
-      var dep = list.firstContext;
+      if (flags & Update) {
+        commitClassLayoutLifecycles(finishedWork, current);
+      }
 
-      findChangedDep: while (dep !== null) {
-        // Assigning these to constants to help Flow
-        var dependency = dep;
-        var consumer = fiber;
+      if (flags & Callback) {
+        commitClassCallbacks(finishedWork);
+      }
 
-        for (var i = 0; i < contexts.length; i++) {
-          var context = contexts[i]; // Check if the context matches.
-          // TODO: Compare selected values to bail out early.
+      if (flags & Ref) {
+        safelyAttachRef(finishedWork, finishedWork.return);
+      }
 
-          if (dependency.context === context) {
-            // Match! Schedule an update on this fiber.
-            // In the lazy implementation, don't mark a dirty flag on the
-            // dependency itself. Not all changes are propagated, so we can't
-            // rely on the propagation function alone to determine whether
-            // something has changed; the consumer will check. In the future, we
-            // could add back a dirty flag as an optimization to avoid double
-            // checking, but until we have selectors it's not really worth
-            // the trouble.
-            consumer.lanes = mergeLanes(consumer.lanes, renderLanes);
-            var alternate = consumer.alternate;
+      break;
+    }
 
-            if (alternate !== null) {
-              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-            }
+    case HostRoot: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-            scheduleContextWorkOnParentPath(
-              consumer.return,
-              renderLanes,
-              workInProgress
-            );
+      if (flags & Callback) {
+        // TODO: I think this is now always non-null by the time it reaches the
+        // commit phase. Consider removing the type check.
+        var updateQueue = finishedWork.updateQueue;
 
-            if (!forcePropagateEntireTree) {
-              // During lazy propagation, when we find a match, we can defer
-              // propagating changes to the children, because we're going to
-              // visit them during render. We should continue propagating the
-              // siblings, though
-              nextFiber = null;
-            } // Since we already found a match, we can stop traversing the
-            // dependency list.
+        if (updateQueue !== null) {
+          var instance = null;
 
-            break findChangedDep;
+          if (finishedWork.child !== null) {
+            switch (finishedWork.child.tag) {
+              case HostSingleton:
+              case HostComponent:
+                instance = getPublicInstance(finishedWork.child.stateNode);
+                break;
+
+              case ClassComponent:
+                instance = finishedWork.child.stateNode;
+                break;
+            }
           }
-        }
 
-        dep = dependency.next;
+          try {
+            commitCallbacks(updateQueue, instance);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
       }
-    } else if (fiber.tag === DehydratedFragment) {
-      // If a dehydrated suspense boundary is in this subtree, we don't know
-      // if it will have any context consumers in it. The best we can do is
-      // mark it as having updates.
-      var parentSuspense = fiber.return;
 
-      if (parentSuspense === null) {
-        throw new Error(
-          "We just came from a parent so we must have had a parent. This is a bug in React."
-        );
+      break;
+    }
+
+    case HostHoistable: {
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        break;
       }
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
-      var _alternate2 = parentSuspense.alternate;
+    case HostSingleton:
+    case HostComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+      // (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 (_alternate2 !== null) {
-        _alternate2.lanes = mergeLanes(_alternate2.lanes, renderLanes);
-      } // This is intentionally passing this fiber as the parent
-      // because we want to schedule this fiber as having work
-      // on its children. We'll use the childLanes on
-      // this fiber to indicate that a context has changed.
+      if (current === null && flags & Update) {
+        commitHostComponentMount(finishedWork);
+      }
 
-      scheduleContextWorkOnParentPath(
-        parentSuspense,
-        renderLanes,
-        workInProgress
-      );
-      nextFiber = null;
-    } else {
-      // Traverse down.
-      nextFiber = fiber.child;
+      if (flags & Ref) {
+        safelyAttachRef(finishedWork, finishedWork.return);
+      }
+
+      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;
+    case Profiler: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
+      // fire when the tree becomes visible again.
 
-      while (nextFiber !== null) {
-        if (nextFiber === workInProgress) {
-          // We're back to the root of this subtree. Exit.
-          nextFiber = null;
-          break;
-        }
+      if (flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
+      }
 
-        var sibling = nextFiber.sibling;
+      break;
+    }
 
-        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.
+    case SuspenseComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-        nextFiber = nextFiber.return;
+      if (flags & Update) {
+        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
       }
+
+      break;
     }
 
-    fiber = nextFiber;
-  }
-}
+    case OffscreenComponent: {
+      var isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
 
-function lazilyPropagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  var forcePropagateEntireTree = false;
-  propagateParentContextChanges(
-    current,
-    workInProgress,
-    renderLanes,
-    forcePropagateEntireTree
-  );
-} // Used for propagating a deferred tree (Suspense, Offscreen). We must propagate
-// to the entire subtree, because we won't revisit it until after the current
-// render has completed, at which point we'll have lost track of which providers
-// have changed.
+      if (isModernRoot) {
+        var isHidden = finishedWork.memoizedState !== null;
+        var newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
 
-function propagateParentContextChangesToDeferredTree(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  var forcePropagateEntireTree = true;
-  propagateParentContextChanges(
-    current,
-    workInProgress,
-    renderLanes,
-    forcePropagateEntireTree
-  );
-}
+        if (newOffscreenSubtreeIsHidden);
+        else {
+          // The Offscreen tree is visible.
+          var wasHidden = current !== null && current.memoizedState !== null;
+          var newOffscreenSubtreeWasHidden =
+            wasHidden || offscreenSubtreeWasHidden;
+          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
 
-function propagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (!enableLazyContextPropagation) {
-    return;
-  } // Collect all the parent providers that changed. Since this is usually small
-  // number, we use an Array instead of Set.
+          if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+            // This is the root of a reappearing boundary. As we continue
+            // traversing the layout effects, we must also re-mount layout
+            // effects that were unmounted when the Offscreen subtree was
+            // hidden. So this is a superset of the normal commitLayoutEffects.
+            var includeWorkInProgressEffects =
+              (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+            recursivelyTraverseReappearLayoutEffects(
+              finishedRoot,
+              finishedWork,
+              includeWorkInProgressEffects
+            );
+          } else {
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          }
 
-  var contexts = null;
-  var parent = workInProgress;
-  var isInsidePropagationBailout = false;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        }
+      } else {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      }
+
+      if (flags & Ref) {
+        var props = finishedWork.memoizedProps;
 
-  while (parent !== null) {
-    if (!isInsidePropagationBailout) {
-      if ((parent.flags & NeedsPropagation) !== NoFlags$1) {
-        isInsidePropagationBailout = true;
-      } else if ((parent.flags & DidPropagateContext) !== NoFlags$1) {
-        break;
+        if (props.mode === "manual") {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        } else {
+          safelyDetachRef(finishedWork, finishedWork.return);
+        }
       }
+
+      break;
     }
 
-    if (parent.tag === ContextProvider) {
-      var currentParent = parent.alternate;
+    default: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      break;
+    }
+  }
+}
 
-      if (currentParent === null) {
-        throw new Error("Should have a current fiber. This is a bug in React.");
-      }
+function abortRootTransitions(
+  root,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    var rootTransitions = root.incompleteTransitions;
+    deletedTransitions.forEach(function (transition) {
+      if (rootTransitions.has(transition)) {
+        var transitionInstance = rootTransitions.get(transition);
 
-      var oldProps = currentParent.memoizedProps;
+        if (transitionInstance.aborts === null) {
+          transitionInstance.aborts = [];
+        }
 
-      if (oldProps !== null) {
-        var providerType = parent.type;
-        var context = providerType._context;
-        var newProps = parent.pendingProps;
-        var newValue = newProps.value;
-        var oldValue = oldProps.value;
+        transitionInstance.aborts.push(abort);
 
-        if (!objectIs(newValue, oldValue)) {
-          if (contexts !== null) {
-            contexts.push(context);
-          } else {
-            contexts = [context];
+        if (deletedOffscreenInstance !== null) {
+          if (
+            transitionInstance.pendingBoundaries !== null &&
+            transitionInstance.pendingBoundaries.has(deletedOffscreenInstance)
+          ) {
+            // $FlowFixMe[incompatible-use] found when upgrading Flow
+            transitionInstance.pendingBoundaries.delete(
+              deletedOffscreenInstance
+            );
           }
         }
       }
-    }
-
-    parent = parent.return;
+    });
   }
-
-  if (contexts !== null) {
-    // If there were any changed providers, search through the children and
-    // propagate their changes.
-    propagateContextChanges(
-      workInProgress,
-      contexts,
-      renderLanes,
-      forcePropagateEntireTree
-    );
-  } // This is an optimization so that we only propagate once per subtree. If a
-  // deeply nested child bails out, and it calls this propagation function, it
-  // uses this flag to know that the remaining ancestor providers have already
-  // been propagated.
-  //
-  // NOTE: This optimization is only necessary because we sometimes enter the
-  // begin phase of nodes that don't have any work scheduled on them —
-  // specifically, the siblings of a node that _does_ have scheduled work. The
-  // siblings will bail out and call this function again, even though we already
-  // propagated content changes to it and its subtree. So we use this flag to
-  // mark that the parent providers already propagated.
-  //
-  // Unfortunately, though, we need to ignore this flag when we're inside a
-  // tree whose context propagation was deferred — that's what the
-  // `NeedsPropagation` flag is for.
-  //
-  // If we could instead bail out before entering the siblings' begin phase,
-  // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
-  // Consider this as part of the next refactor to the fiber tree structure.
-
-  workInProgress.flags |= DidPropagateContext;
 }
 
-function checkIfContextChanged(currentDependencies) {
-  if (!enableLazyContextPropagation) {
-    return false;
-  } // Iterate over the current dependencies to see if something changed. This
-  // only gets called if props and state has already bailed out, so it's a
-  // relatively uncommon path, except at the root of a changed subtree.
-  // Alternatively, we could move these comparisons into `readContext`, but
-  // that's a much hotter path, so I think this is an appropriate trade off.
-
-  var dependency = currentDependencies.firstContext;
+function abortTracingMarkerTransitions(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    var markerInstance = abortedFiber.stateNode;
+    var markerTransitions = markerInstance.transitions;
+    var pendingBoundaries = markerInstance.pendingBoundaries;
 
-  while (dependency !== null) {
-    var context = dependency.context;
-    var newValue = context._currentValue;
-    var oldValue = dependency.memoizedValue;
+    if (markerTransitions !== null) {
+      // TODO: Refactor this code. Is there a way to move this code to
+      // the deletions phase instead of calculating it here while making sure
+      // complete is called appropriately?
+      deletedTransitions.forEach(function (transition) {
+        // If one of the transitions on the tracing marker is a transition
+        // that was in an aborted subtree, we will abort that tracing marker
+        if (
+          abortedFiber !== null &&
+          markerTransitions.has(transition) &&
+          (markerInstance.aborts === null ||
+            !markerInstance.aborts.includes(abort))
+        ) {
+          if (markerInstance.transitions !== null) {
+            if (markerInstance.aborts === null) {
+              markerInstance.aborts = [abort];
+              addMarkerIncompleteCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                markerInstance.transitions,
+                markerInstance.aborts
+              );
+            } else {
+              markerInstance.aborts.push(abort);
+            } // We only want to call onTransitionProgress when the marker hasn't been
+            // deleted
 
-    if (!objectIs(newValue, oldValue)) {
-      return true;
+            if (
+              deletedOffscreenInstance !== null &&
+              !isInDeletedTree &&
+              pendingBoundaries !== null &&
+              pendingBoundaries.has(deletedOffscreenInstance)
+            ) {
+              pendingBoundaries.delete(deletedOffscreenInstance);
+              addMarkerProgressCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                deletedTransitions,
+                pendingBoundaries
+              );
+            }
+          }
+        }
+      });
     }
-
-    dependency = dependency.next;
   }
-
-  return false;
 }
-function prepareToReadContext(workInProgress, renderLanes) {
-  currentlyRenderingFiber = workInProgress;
-  lastContextDependency = null;
-  lastFullyObservedContext = null;
-  var dependencies = workInProgress.dependencies;
 
-  if (dependencies !== null) {
-    if (enableLazyContextPropagation) {
-      // Reset the work-in-progress list
-      dependencies.firstContext = null;
-    } else {
-      var firstContext = dependencies.firstContext;
+function abortParentMarkerTransitionsForDeletedFiber(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    // Find all pending markers that are waiting on child suspense boundaries in the
+    // aborted subtree and cancels them
+    var fiber = abortedFiber;
 
-      if (firstContext !== null) {
-        if (includesSomeLane(dependencies.lanes, renderLanes)) {
-          // Context list has a pending update. Mark that this fiber performed work.
-          markWorkInProgressReceivedUpdate();
-        } // Reset the work-in-progress list
+    while (fiber !== null) {
+      switch (fiber.tag) {
+        case TracingMarkerComponent:
+          abortTracingMarkerTransitions(
+            fiber,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance,
+            isInDeletedTree
+          );
+          break;
 
-        dependencies.firstContext = null;
+        case HostRoot:
+          var root = fiber.stateNode;
+          abortRootTransitions(
+            root,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance
+          );
+          break;
       }
-    }
-  }
-}
-function readContext(context) {
-  {
-    // This warning would fire if you read context inside a Hook like useMemo.
-    // Unlike the class check below, it's not enforced in production for perf.
-    if (isDisallowedContextReadInDEV) {
-      error(
-        "Context can only be read while React is rendering. " +
-          "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-          "In function components, you can read it directly in the function body, but not " +
-          "inside Hooks like useReducer() or useMemo()."
-      );
-    }
-  }
 
-  return readContextForConsumer(currentlyRenderingFiber, context);
-}
-function readContextDuringReconcilation(consumer, context, renderLanes) {
-  if (currentlyRenderingFiber === null) {
-    prepareToReadContext(consumer, renderLanes);
+      fiber = fiber.return;
+    }
   }
-
-  return readContextForConsumer(consumer, context);
 }
 
-function readContextForConsumer(consumer, context) {
-  var value = context._currentValue;
+function commitTransitionProgress(offscreenFiber) {
+  if (enableTransitionTracing) {
+    // This function adds suspense boundaries to the root
+    // or tracing marker's pendingBoundaries map.
+    // When a suspense boundary goes from a resolved to a fallback
+    // state we add the boundary to the map, and when it goes from
+    // a fallback to a resolved state, we remove the boundary from
+    // the map.
+    // We use stateNode on the Offscreen component as a stable object
+    // that doesnt change from render to render. This way we can
+    // distinguish between different Offscreen instances (vs. the same
+    // Offscreen instance with different fibers)
+    var offscreenInstance = offscreenFiber.stateNode;
+    var prevState = null;
+    var previousFiber = offscreenFiber.alternate;
 
-  if (lastFullyObservedContext === context);
-  else {
-    var contextItem = {
-      context: context,
-      memoizedValue: value,
-      next: null
-    };
+    if (previousFiber !== null && previousFiber.memoizedState !== null) {
+      prevState = previousFiber.memoizedState;
+    }
 
-    if (lastContextDependency === null) {
-      if (consumer === null) {
-        throw new Error(
-          "Context can only be read while React is rendering. " +
-            "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-            "In function components, you can read it directly in the function body, but not " +
-            "inside Hooks like useReducer() or useMemo()."
-        );
-      } // This is the first dependency for this component. Create a new list.
+    var nextState = offscreenFiber.memoizedState;
+    var wasHidden = prevState !== null;
+    var isHidden = nextState !== null;
+    var pendingMarkers = offscreenInstance._pendingMarkers; // If there is a name on the suspense boundary, store that in
+    // the pending boundaries.
 
-      lastContextDependency = contextItem;
-      consumer.dependencies = {
-        lanes: NoLanes,
-        firstContext: contextItem
-      };
+    var name = null;
+    var parent = offscreenFiber.return;
 
-      if (enableLazyContextPropagation) {
-        consumer.flags |= NeedsPropagation;
-      }
-    } else {
-      // Append a new context item.
-      lastContextDependency = lastContextDependency.next = contextItem;
+    if (
+      parent !== null &&
+      parent.tag === SuspenseComponent &&
+      parent.memoizedProps.unstable_name
+    ) {
+      name = parent.memoizedProps.unstable_name;
     }
-  }
 
-  return value;
-}
+    if (!wasHidden && isHidden) {
+      // The suspense boundaries was just hidden. Add the boundary
+      // to the pending boundary set if it's there
+      if (pendingMarkers !== null) {
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries;
+          var transitions = markerInstance.transitions;
+          var markerName = markerInstance.name;
 
-// replace it with a lightweight shim that only has the features we use.
+          if (
+            pendingBoundaries !== null &&
+            !pendingBoundaries.has(offscreenInstance)
+          ) {
+            pendingBoundaries.set(offscreenInstance, {
+              name: name
+            });
 
-var AbortControllerLocal =
-  typeof AbortController !== "undefined"
-    ? AbortController // $FlowFixMe[missing-this-annot]
-    : function AbortControllerShim() {
-        var listeners = [];
-        var signal = (this.signal = {
-          aborted: false,
-          addEventListener: function (type, listener) {
-            listeners.push(listener);
+            if (transitions !== null) {
+              if (
+                markerInstance.tag === TransitionTracingMarker &&
+                markerName !== null
+              ) {
+                addMarkerProgressCallbackToPendingTransition(
+                  markerName,
+                  transitions,
+                  pendingBoundaries
+                );
+              } else if (markerInstance.tag === TransitionRoot) {
+                transitions.forEach(function (transition) {
+                  addTransitionProgressCallbackToPendingTransition(
+                    transition,
+                    pendingBoundaries
+                  );
+                });
+              }
+            }
           }
         });
+      }
+    } else if (wasHidden && !isHidden) {
+      // The suspense boundary went from hidden to visible. Remove
+      // the boundary from the pending suspense boundaries set
+      // if it's there
+      if (pendingMarkers !== null) {
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries;
+          var transitions = markerInstance.transitions;
+          var markerName = markerInstance.name;
 
-        this.abort = function () {
-          signal.aborted = true;
-          listeners.forEach(function (listener) {
-            return listener();
-          });
-        };
-      }; // Intentionally not named imports because Rollup would
-// use dynamic dispatch for CommonJS interop named imports.
+          if (
+            pendingBoundaries !== null &&
+            pendingBoundaries.has(offscreenInstance)
+          ) {
+            pendingBoundaries.delete(offscreenInstance);
 
-var scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
-  NormalPriority = Scheduler.unstable_NormalPriority;
-var CacheContext = {
-  $$typeof: REACT_CONTEXT_TYPE,
-  // We don't use Consumer/Provider for Cache components. So we'll cheat.
-  Consumer: null,
-  Provider: null,
-  // We'll initialize these at the root.
-  _currentValue: null,
-  _currentValue2: null,
-  _threadCount: 0,
-  _defaultValue: null,
-  _globalName: null
-};
+            if (transitions !== null) {
+              if (
+                markerInstance.tag === TransitionTracingMarker &&
+                markerName !== null
+              ) {
+                addMarkerProgressCallbackToPendingTransition(
+                  markerName,
+                  transitions,
+                  pendingBoundaries
+                ); // If there are no more unresolved suspense boundaries, the interaction
+                // is considered finished
 
-{
-  CacheContext._currentRenderer = null;
-  CacheContext._currentRenderer2 = null;
-} // Creates a new empty Cache instance with a ref-count of 0. The caller is responsible
-// for retaining the cache once it is in use (retainCache), and releasing the cache
-// once it is no longer needed (releaseCache).
+                if (pendingBoundaries.size === 0) {
+                  if (markerInstance.aborts === null) {
+                    addMarkerCompleteCallbackToPendingTransition(
+                      markerName,
+                      transitions
+                    );
+                  }
 
-function createCache() {
-  var cache = {
-    controller: new AbortControllerLocal(),
-    data: new Map(),
-    refCount: 0
-  };
-  return cache;
-}
-function retainCache(cache) {
-  {
-    if (cache.controller.signal.aborted) {
-      warn(
-        "A cache instance was retained after it was already freed. " +
-          "This likely indicates a bug in React."
-      );
+                  markerInstance.transitions = null;
+                  markerInstance.pendingBoundaries = null;
+                  markerInstance.aborts = null;
+                }
+              } else if (markerInstance.tag === TransitionRoot) {
+                transitions.forEach(function (transition) {
+                  addTransitionProgressCallbackToPendingTransition(
+                    transition,
+                    pendingBoundaries
+                  );
+                });
+              }
+            }
+          }
+        });
+      }
     }
   }
+}
 
-  cache.refCount++;
-} // Cleanup a cache instance, potentially freeing it if there are no more references
-
-function releaseCache(cache) {
-  cache.refCount--;
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  var hostSubtreeRoot = null;
 
   {
-    if (cache.refCount < 0) {
-      warn(
-        "A cache instance was released after it was already freed. " +
-          "This likely indicates a bug in React."
-      );
-    }
-  }
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    var node = finishedWork;
 
-  if (cache.refCount === 0) {
-    scheduleCallback$1(NormalPriority, function () {
-      cache.controller.abort();
-    });
-  }
-}
-function pushCacheProvider(workInProgress, cache) {
-  pushProvider(workInProgress, CacheContext, cache);
-}
-function popCacheProvider(workInProgress, cache) {
-  popProvider(CacheContext, workInProgress);
-}
+    while (true) {
+      if (
+        node.tag === HostComponent ||
+        node.tag === HostHoistable ||
+        node.tag === HostSingleton
+      ) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
 
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig;
-var NoTransition = null;
-function requestCurrentTransition() {
-  return ReactCurrentBatchConfig$1.transition;
-} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
-// used during the previous render by placing it here, on the stack.
+          try {
+            var instance = node.stateNode;
+
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            var _instance = node.stateNode;
+
+            if (isHidden) {
+              hideTextInstance(_instance);
+            } else {
+              unhideTextInstance(_instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (
+        (node.tag === OffscreenComponent ||
+          node.tag === LegacyHiddenComponent) &&
+        node.memoizedState !== null &&
+        node !== finishedWork
+      );
+      else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
 
-var resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
-// transitions. Therefore, we want to lazily combine transitions. Instead of
-// comparing the arrays of transitions when we combine them and storing them
-// and filtering out the duplicates, we will instead store the unprocessed transitions
-// in an array and actually filter them in the passive phase.
+      if (node === finishedWork) {
+        return;
+      }
 
-var transitionStack = createCursor(null);
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
+        }
 
-function peekCacheFromPool() {
-  // If we're rendering inside a Suspense boundary that is currently hidden,
-  // we should use the same cache that we used during the previous render, if
-  // one exists.
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
 
-  var cacheResumedFromPreviousRender = resumedCache.current;
+        node = node.return;
+      }
 
-  if (cacheResumedFromPreviousRender !== null) {
-    return cacheResumedFromPreviousRender;
-  } // Otherwise, check the root's cache pool.
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
+      }
 
-  var root = getWorkInProgressRoot();
-  var cacheFromRootCachePool = root.pooledCache;
-  return cacheFromRootCachePool;
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
 }
 
-function requestCacheFromPool(renderLanes) {
-  // Similar to previous function, except if there's not already a cache in the
-  // pool, we allocate a new one.
-  var cacheFromPool = peekCacheFromPool();
+function commitAttachRef(finishedWork) {
+  var ref = finishedWork.ref;
 
-  if (cacheFromPool !== null) {
-    return cacheFromPool;
-  } // Create a fresh cache and add it to the root cache pool. A cache can have
-  // multiple owners:
-  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
-  //   are originally created (TODO: except during refreshes, until we implement
-  //   this correctly). The root takes ownership immediately when the cache is
-  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
-  //   and the return value of this function is a &Arc<Cache> (borrowed).
-  // - One of several fiber types: host root, cache boundary, suspense
-  //   component. These retain and release in the commit phase.
+  if (ref !== null) {
+    var instance = finishedWork.stateNode;
+    var instanceToUse;
 
-  var root = getWorkInProgressRoot();
-  var freshCache = createCache();
-  root.pooledCache = freshCache;
-  retainCache(freshCache);
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
 
-  if (freshCache !== null) {
-    root.pooledCacheLanes |= renderLanes;
-  }
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
 
-  return freshCache;
-}
-function pushRootTransition(workInProgress, root, renderLanes) {
-  if (enableTransitionTracing) {
-    var rootTransitions = getWorkInProgressTransitions();
-    push(transitionStack, rootTransitions, workInProgress);
-  }
-}
-function popRootTransition(workInProgress, root, renderLanes) {
-  if (enableTransitionTracing) {
-    pop(transitionStack, workInProgress);
-  }
-}
-function pushTransition(
-  offscreenWorkInProgress,
-  prevCachePool,
-  newTransitions
-) {
-  {
-    if (prevCachePool === null) {
-      push(resumedCache, resumedCache.current, offscreenWorkInProgress);
-    } else {
-      push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
+    if (finishedWork.tag === ScopeComponent) {
+      instanceToUse = instance;
     }
-  }
 
-  if (enableTransitionTracing) {
-    if (transitionStack.current === null) {
-      push(transitionStack, newTransitions, offscreenWorkInProgress);
-    } else if (newTransitions === null) {
-      push(transitionStack, transitionStack.current, offscreenWorkInProgress);
+    if (typeof ref === "function") {
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          finishedWork.refCleanup = ref(instanceToUse);
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
+        finishedWork.refCleanup = ref(instanceToUse);
+      }
     } else {
-      push(
-        transitionStack,
-        transitionStack.current.concat(newTransitions),
-        offscreenWorkInProgress
-      );
-    }
-  }
-}
-function popTransition(workInProgress, current) {
-  if (current !== null) {
-    if (enableTransitionTracing) {
-      pop(transitionStack, workInProgress);
-    }
+      {
+        if (!ref.hasOwnProperty("current")) {
+          error(
+            "Unexpected ref object provided for %s. " +
+              "Use either a ref-setter function or React.createRef().",
+            getComponentNameFromFiber(finishedWork)
+          );
+        }
+      } // $FlowFixMe unable to narrow type to the non-function case
 
-    {
-      pop(resumedCache, workInProgress);
+      ref.current = instanceToUse;
     }
   }
 }
-function getPendingTransitions() {
-  if (!enableTransitionTracing) {
-    return null;
+
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
+  //
+  // Ideally, we should also 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.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  var alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.return = null;
   }
 
-  return transitionStack.current;
+  fiber.return = null;
 }
-function getSuspendedCache() {
-  // cache that would have been used to render fresh data during this render,
-  // if there was any, so that we can resume rendering with the same cache when
-  // we receive more data.
 
-  var cacheFromPool = peekCacheFromPool();
+function detachFiberAfterEffects(fiber) {
+  var alternate = fiber.alternate;
 
-  if (cacheFromPool === null) {
-    return null;
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
+
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
+
+  if (fiber.tag === HostComponent) {
+    var hostInstance = fiber.stateNode;
+
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
+    }
   }
 
-  return {
-    // We must also save the parent, so that when we resume we can detect
-    // a refresh.
-    parent: CacheContext._currentValue,
-    pool: cacheFromPool
-  };
+  fiber.stateNode = null;
+
+  {
+    fiber._debugOwner = null;
+  } // Theoretically, nothing in here should be necessary, because we already
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
+
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+
+  fiber.updateQueue = null;
 }
-function getOffscreenDeferredCache() {
-  var cacheFromPool = peekCacheFromPool();
 
-  if (cacheFromPool === null) {
-    return null;
+function getHostParentFiber(fiber) {
+  var parent = fiber.return;
+
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
+    }
+
+    parent = parent.return;
   }
 
-  return {
-    // We must also store the parent, so that when we resume we can detect
-    // a refresh.
-    parent: CacheContext._currentValue,
-    pool: cacheFromPool
-  };
+  throw new Error(
+    "Expected to find a host parent. This error is likely caused by a bug " +
+      "in React. Please file an issue."
+  );
 }
 
-function getSuspenseFallbackChild(fiber) {
-  return fiber.child.sibling.child;
+function isHostParent(fiber) {
+  return (
+    fiber.tag === HostComponent ||
+    fiber.tag === HostRoot ||
+    fiber.tag === HostHoistable ||
+    fiber.tag === HostSingleton ||
+    fiber.tag === HostPortal
+  );
 }
 
-var emptyObject = {};
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  var node = fiber;
 
-function collectScopedNodes(node, fn, scopedNodes) {
-  {
-    if (node.tag === HostComponent) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        stateNode = node.stateNode;
-      var instance = getPublicInstance(stateNode);
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
 
-      if (
-        instance !== null &&
-        fn(type, memoizedProps || emptyObject, instance) === true
-      ) {
-        scopedNodes.push(instance);
-      }
+      node = node.return;
     }
 
-    var child = node.child;
+    node.sibling.return = node.return;
+    node = node.sibling;
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
-    }
+    while (
+      node.tag !== HostComponent &&
+      node.tag !== HostText &&
+      node.tag !== HostSingleton &&
+      node.tag !== DehydratedFragment
+    ) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
 
-    if (child !== null) {
-      collectScopedNodesFromChildren(child, fn, scopedNodes);
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
+      } else {
+        node.child.return = node;
+        node = node.child;
+      }
+    } // Check if this host node is stable or about to be placed.
+
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
     }
   }
 }
 
-function collectFirstScopedNode(node, fn) {
+function commitPlacement(finishedWork) {
   {
-    if (node.tag === HostComponent) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        stateNode = node.stateNode;
-      var instance = getPublicInstance(stateNode);
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
 
-      if (instance !== null && fn(type, memoizedProps, instance) === true) {
-        return instance;
+  var parentFiber = getHostParentFiber(finishedWork);
+
+  switch (parentFiber.tag) {
+    case HostSingleton: {
+      {
+        var parent = parentFiber.stateNode;
+        var before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
       }
     }
+    // eslint-disable-next-line no-fallthrough
 
-    var child = node.child;
+    case HostComponent: {
+      var _parent = parentFiber.stateNode;
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
+      if (parentFiber.flags & ContentReset) {
+        // Reset the text content of the parent before doing any insertions
+        resetTextContent(_parent); // Clear ContentReset from the effect tag
+
+        parentFiber.flags &= ~ContentReset;
+      }
+
+      var _before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+      // children to find all the terminal nodes.
+
+      insertOrAppendPlacementNode(finishedWork, _before, _parent);
+      break;
     }
 
-    if (child !== null) {
-      return collectFirstScopedNodeFromChildren(child, fn);
+    case HostRoot:
+    case HostPortal: {
+      var _parent2 = parentFiber.stateNode.containerInfo;
+
+      var _before2 = getHostSibling(finishedWork);
+
+      insertOrAppendPlacementNodeIntoContainer(
+        finishedWork,
+        _before2,
+        _parent2
+      );
+      break;
     }
-  }
+    // eslint-disable-next-line-no-fallthrough
 
-  return null;
+    default:
+      throw new Error(
+        "Invalid host parent fiber. This error is likely caused by a bug " +
+          "in React. Please file an issue."
+      );
+  }
 }
 
-function collectScopedNodesFromChildren(startingChild, fn, scopedNodes) {
-  var child = startingChild;
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  var tag = node.tag;
+  var isHost = tag === HostComponent || tag === HostText;
 
-  while (child !== null) {
-    collectScopedNodes(child, fn, scopedNodes);
-    child = child.sibling;
+  if (isHost) {
+    var stateNode = node.stateNode;
+
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
+    }
+  } else if (tag === HostPortal || tag === HostSingleton);
+  else {
+    var child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      var sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
   }
 }
 
-function collectFirstScopedNodeFromChildren(startingChild, fn) {
-  var child = startingChild;
+function insertOrAppendPlacementNode(node, before, parent) {
+  var tag = node.tag;
+  var isHost = tag === HostComponent || tag === HostText;
 
-  while (child !== null) {
-    var scopedNode = collectFirstScopedNode(child, fn);
+  if (isHost) {
+    var stateNode = node.stateNode;
 
-    if (scopedNode !== null) {
-      return scopedNode;
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
     }
+  } else if (tag === HostPortal || tag === HostSingleton);
+  else {
+    var child = node.child;
 
-    child = child.sibling;
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      var sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
   }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
 
-  return null;
-}
+var hostParent = null;
+var hostParentIsContainer = false;
 
-function collectNearestContextValues(node, context, childContextValues) {
-  if (node.tag === ContextProvider && node.type._context === context) {
-    var contextValue = node.memoizedProps.value;
-    childContextValues.push(contextValue);
-  } else {
-    var child = node.child;
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    var parent = returnFiber;
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent: {
+          hostParent = parent.stateNode;
+          hostParentIsContainer = false;
+          break findParent;
+        }
+
+        case HostRoot: {
+          hostParent = parent.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          break findParent;
+        }
+
+        case HostPortal: {
+          hostParent = parent.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          break findParent;
+        }
+      }
+
+      parent = parent.return;
     }
 
-    if (child !== null) {
-      collectNearestChildContextValues(child, context, childContextValues);
+    if (hostParent === null) {
+      throw new Error(
+        "Expected to find a host parent. This error is likely caused by " +
+          "a bug in React. Please file an issue."
+      );
     }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
   }
+
+  detachFiberMutation(deletedFiber);
 }
 
-function collectNearestChildContextValues(
-  startingChild,
-  context,
-  childContextValues
+function recursivelyTraverseDeletionEffects(
+  finishedRoot,
+  nearestMountedAncestor,
+  parent
 ) {
-  var child = startingChild;
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  var child = parent.child;
 
   while (child !== null) {
-    collectNearestContextValues(child, context, childContextValues);
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
     child = child.sibling;
   }
 }
 
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
+function commitDeletionEffectsOnFiber(
+  finishedRoot,
+  nearestMountedAncestor,
+  deletedFiber
+) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
 
-  if (currentFiber === null) {
-    return null;
-  }
+  switch (deletedFiber.tag) {
+    case HostHoistable: {
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        }
 
-  var child = currentFiber.child;
-  var scopedNodes = [];
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
 
-  if (child !== null) {
-    collectScopedNodesFromChildren(child, fn, scopedNodes);
-  }
+        if (deletedFiber.memoizedState) {
+          releaseResource(deletedFiber.memoizedState);
+        } else if (deletedFiber.stateNode) {
+          unmountHoistable(deletedFiber.stateNode);
+        }
 
-  return scopedNodes.length === 0 ? null : scopedNodes;
-}
+        return;
+      }
+    }
+    // eslint-disable-next-line no-fallthrough
 
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
+    case HostSingleton: {
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        }
 
-  if (currentFiber === null) {
-    return null;
-  }
+        var prevHostParent = hostParent;
+        var prevHostParentIsContainer = hostParentIsContainer;
+        hostParent = deletedFiber.stateNode;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        ); // Normally this is called in passive unmount effect phase however with
+        // HostSingleton we warn if you acquire one that is already associated to
+        // a different fiber. To increase our chances of avoiding this, specifically
+        // if you keyed a HostSingleton so there will be a delete followed by a Placement
+        // we treat detach eagerly here
 
-  var child = currentFiber.child;
+        releaseSingletonInstance(deletedFiber.stateNode);
+        hostParent = prevHostParent;
+        hostParentIsContainer = prevHostParentIsContainer;
+        return;
+      }
+    }
+    // eslint-disable-next-line no-fallthrough
 
-  if (child !== null) {
-    return collectFirstScopedNodeFromChildren(child, fn);
-  }
+    case HostComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      } // Intentional fallthrough to next branch
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-  return null;
-}
+    case HostText: {
+      // We only need to remove the nearest host child. Set the host parent
+      // to `null` on the stack to indicate that nested children don't
+      // need to be removed.
+      {
+        var _prevHostParent = hostParent;
+        var _prevHostParentIsContainer = hostParentIsContainer;
+        hostParent = null;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        hostParent = _prevHostParent;
+        hostParentIsContainer = _prevHostParentIsContainer;
 
-function containsNode(node) {
-  var fiber = getInstanceFromNode$1(node);
+        if (hostParent !== null) {
+          // Now that all the child effects have unmounted, we can remove the
+          // node from the tree.
+          if (hostParentIsContainer) {
+            removeChildFromContainer(hostParent, deletedFiber.stateNode);
+          } else {
+            removeChild(hostParent, deletedFiber.stateNode);
+          }
+        }
+      }
 
-  while (fiber !== null) {
-    if (fiber.tag === ScopeComponent && fiber.stateNode === this) {
-      return true;
+      return;
     }
 
-    fiber = fiber.return;
-  }
-
-  return false;
-}
-
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
+    case DehydratedFragment: {
+      {
+        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
 
-  if (currentFiber === null) {
-    return [];
-  }
+        if (hydrationCallbacks !== null) {
+          var onDeleted = hydrationCallbacks.onDeleted;
 
-  var child = currentFiber.child;
-  var childContextValues = [];
+          if (onDeleted) {
+            onDeleted(deletedFiber.stateNode);
+          }
+        }
+      } // Dehydrated fragments don't have any children
+      // Delete the dehydrated suspense boundary and all of its content.
 
-  if (child !== null) {
-    collectNearestChildContextValues(child, context, childContextValues);
-  }
+      {
+        if (hostParent !== null) {
+          if (hostParentIsContainer) {
+            clearSuspenseBoundaryFromContainer(
+              hostParent,
+              deletedFiber.stateNode
+            );
+          } else {
+            clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+          }
+        }
+      }
 
-  return childContextValues;
-}
+      return;
+    }
 
-function createScopeInstance() {
-  return {
-    DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-    DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-    containsNode: containsNode,
-    getChildContextValues: getChildContextValues
-  };
-}
+    case HostPortal: {
+      {
+        // When we go into a portal, it becomes the parent to remove from.
+        var _prevHostParent2 = hostParent;
+        var _prevHostParentIsContainer2 = hostParentIsContainer;
+        hostParent = deletedFiber.stateNode.containerInfo;
+        hostParentIsContainer = true;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        hostParent = _prevHostParent2;
+        hostParentIsContainer = _prevHostParentIsContainer2;
+      }
 
-function markUpdate(workInProgress) {
-  // Tag the fiber with an update effect. This turns a Placement into
-  // a PlacementAndUpdate.
-  workInProgress.flags |= Update;
-}
+      return;
+    }
 
-function markRef(workInProgress) {
-  workInProgress.flags |= Ref | RefStatic;
-}
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        var updateQueue = deletedFiber.updateQueue;
 
-function appendAllChildren(
-  parent,
-  workInProgress,
-  needsVisibilityToggle,
-  isHidden
-) {
-  {
-    // We only have the top Fiber that was created but we need recurse down its
-    // children to find all the terminal nodes.
-    var node = workInProgress.child;
+        if (updateQueue !== null) {
+          var lastEffect = updateQueue.lastEffect;
 
-    while (node !== null) {
-      if (node.tag === HostComponent || node.tag === HostText) {
-        appendInitialChild(parent, node.stateNode);
-      } else if (node.tag === HostPortal || node.tag === HostSingleton);
-      else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
+          if (lastEffect !== null) {
+            var firstEffect = lastEffect.next;
+            var effect = firstEffect;
 
-      if (node === workInProgress) {
-        return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+            do {
+              var _effect = effect,
+                destroy = _effect.destroy,
+                tag = _effect.tag;
 
-      while (node.sibling === null) {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        if (node.return === null || node.return === workInProgress) {
-          return;
-        }
+              if (destroy !== undefined) {
+                if ((tag & Insertion) !== NoFlags) {
+                  safelyCallDestroy(
+                    deletedFiber,
+                    nearestMountedAncestor,
+                    destroy
+                  );
+                } else if ((tag & Layout) !== NoFlags) {
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStarted(deletedFiber);
+                  }
 
-        node = node.return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+                  if (shouldProfile(deletedFiber)) {
+                    startLayoutEffectTimer();
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                    recordLayoutEffectDuration(deletedFiber);
+                  } else {
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                  }
 
-      node.sibling.return = node.return;
-      node = node.sibling;
-    }
-  }
-} // An unfortunate fork of appendAllChildren because we have two different parent types.
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStopped();
+                  }
+                }
+              }
 
-function updateHostComponent(current, workInProgress, type, newProps) {
-  {
-    // If we have an alternate, that means this is an update and we need to
-    // schedule a side-effect to do the updates.
-    var oldProps = current.memoizedProps;
+              effect = effect.next;
+            } while (effect !== firstEffect);
+          }
+        }
+      }
 
-    if (oldProps === newProps) {
-      // In mutation mode, this is sufficient for a bailout because
-      // we won't touch this node even if children changed.
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
       return;
-    } // If we get updated because one of our children updated, we don't
-    // have newProps so we'll have to reuse them.
-    // TODO: Split the update API as separate for the props vs. children.
-    // Even better would be if children weren't special cased at all tho.
-
-    var instance = workInProgress.stateNode;
-    var currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host
-    // component is hitting the resume path. Figure out why. Possibly
-    // related to `hidden`.
-
-    var updatePayload = prepareUpdate(
-      instance,
-      type,
-      oldProps,
-      newProps,
-      currentHostContext
-    ); // TODO: Type this specific to this type of component.
+    }
 
-    workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
-    // is a new ref we mark this as an update. All the work is done in commitWork.
+    case ClassComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        var instance = deletedFiber.stateNode;
 
-    if (updatePayload) {
-      markUpdate(workInProgress);
-    }
-  }
-}
+        if (typeof instance.componentWillUnmount === "function") {
+          safelyCallComponentWillUnmount(
+            deletedFiber,
+            nearestMountedAncestor,
+            instance
+          );
+        }
+      }
 
-function updateHostText(current, workInProgress, oldText, newText) {
-  {
-    // If the text differs, mark it as an update. All the work in done in commitWork.
-    if (oldText !== newText) {
-      markUpdate(workInProgress);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
     }
-  }
-}
-
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (getIsHydrating()) {
-    // If we're hydrating, we should consume as many items as we can
-    // so we don't leave any behind.
-    return;
-  }
 
-  switch (renderState.tailMode) {
-    case "hidden": {
-      // Any insertions at the end of the tail list after this point
-      // should be invisible. If there are already mounted boundaries
-      // anything before them are not considered for collapsing.
-      // Therefore we need to go through the whole tail to find if
-      // there are any.
-      var tailNode = renderState.tail;
-      var lastTailNode = null;
+    case ScopeComponent: {
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      }
 
-      while (tailNode !== null) {
-        if (tailNode.alternate !== null) {
-          lastTailNode = tailNode;
-        }
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
 
-        tailNode = tailNode.sibling;
-      } // Next we're simply going to delete all insertions after the
-      // last rendered item.
+    case OffscreenComponent: {
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
 
-      if (lastTailNode === null) {
-        // All remaining items in the tail are insertions.
-        renderState.tail = null;
+      if (deletedFiber.mode & ConcurrentMode) {
+        // If this offscreen component is hidden, we already unmounted it. Before
+        // deleting the children, track that it's already unmounted so that we
+        // don't attempt to unmount the effects again.
+        // TODO: If the tree is hidden, in most cases we should be able to skip
+        // over the nested children entirely. An exception is we haven't yet found
+        // the topmost host node to delete, which we already track on the stack.
+        // But the other case is portals, which need to be detached no matter how
+        // deeply they are nested. We should use a subtree flag to track whether a
+        // subtree includes a nested portal.
+        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+        offscreenSubtreeWasHidden =
+          prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
       } else {
-        // Detach the insertion after the last node that was already
-        // inserted.
-        lastTailNode.sibling = null;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
       }
 
       break;
     }
 
-    case "collapsed": {
-      // Any insertions at the end of the tail list after this point
-      // should be invisible. If there are already mounted boundaries
-      // anything before them are not considered for collapsing.
-      // Therefore we need to go through the whole tail to find if
-      // there are any.
-      var _tailNode = renderState.tail;
-      var _lastTailNode = null;
+    default: {
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
+  }
+}
 
-      while (_tailNode !== null) {
-        if (_tailNode.alternate !== null) {
-          _lastTailNode = _tailNode;
-        }
+function commitSuspenseCallback(finishedWork) {
+  // TODO: Move this to passive phase
+  var newState = finishedWork.memoizedState;
 
-        _tailNode = _tailNode.sibling;
-      } // Next we're simply going to delete all insertions after the
-      // last rendered item.
+  if (newState !== null) {
+    var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
 
-      if (_lastTailNode === null) {
-        // All remaining items in the tail are insertions.
-        if (!hasRenderedATailFallback && renderState.tail !== null) {
-          // We suspended during the head. We want to show at least one
-          // row at the tail. So we'll keep on and cut off the rest.
-          renderState.tail.sibling = null;
-        } else {
-          renderState.tail = null;
-        }
-      } else {
-        // Detach the insertion after the last node that was already
-        // inserted.
-        _lastTailNode.sibling = null;
-      }
+    if (typeof suspenseCallback === "function") {
+      var wakeables = finishedWork.updateQueue;
 
-      break;
+      if (wakeables !== null) {
+        suspenseCallback(new Set(wakeables));
+      }
+    } else {
+      if (suspenseCallback !== undefined) {
+        error("Unexpected type for suspenseCallback.");
+      }
     }
   }
 }
 
-function bubbleProperties(completedWork) {
-  var didBailout =
-    completedWork.alternate !== null &&
-    completedWork.alternate.child === completedWork.child;
-  var newChildLanes = NoLanes;
-  var subtreeFlags = NoFlags$1;
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+  var newState = finishedWork.memoizedState;
 
-  if (!didBailout) {
-    // Bubble up the earliest expiration time.
-    if ((completedWork.mode & ProfileMode) !== NoMode) {
-      // In profiling mode, resetChildExpirationTime is also used to reset
-      // profiler durations.
-      var actualDuration = completedWork.actualDuration;
-      var treeBaseDuration = completedWork.selfBaseDuration;
-      var child = completedWork.child;
+  if (newState === null) {
+    var current = finishedWork.alternate;
 
-      while (child !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(child.lanes, child.childLanes)
-        );
-        subtreeFlags |= child.subtreeFlags;
-        subtreeFlags |= child.flags; // When a fiber is cloned, its actualDuration is reset to 0. This value will
-        // only be updated if work is done on the fiber (i.e. it doesn't bailout).
-        // When work is done, it should bubble to the parent's actualDuration. If
-        // the fiber has not been cloned though, (meaning no work was done), then
-        // this value will reflect the amount of time spent working on a previous
-        // render. In that case it should not bubble. We determine whether it was
-        // cloned by comparing the child pointer.
-        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    if (current !== null) {
+      var prevState = current.memoizedState;
 
-        actualDuration += child.actualDuration; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+      if (prevState !== null) {
+        var suspenseInstance = prevState.dehydrated;
 
-        treeBaseDuration += child.treeBaseDuration;
-        child = child.sibling;
-      }
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
 
-      completedWork.actualDuration = actualDuration;
-      completedWork.treeBaseDuration = treeBaseDuration;
-    } else {
-      var _child = completedWork.child;
+            if (enableSuspenseCallback) {
+              var hydrationCallbacks = finishedRoot.hydrationCallbacks;
 
-      while (_child !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child.lanes, _child.childLanes)
-        );
-        subtreeFlags |= _child.subtreeFlags;
-        subtreeFlags |= _child.flags; // Update the return pointer so the tree is consistent. This is a code
-        // smell because it assumes the commit phase is never concurrent with
-        // the render phase. Will address during refactor to alternate model.
+              if (hydrationCallbacks !== null) {
+                var onHydrated = hydrationCallbacks.onHydrated;
 
-        _child.return = completedWork;
-        _child = _child.sibling;
+                if (onHydrated) {
+                  onHydrated(suspenseInstance);
+                }
+              }
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
       }
     }
+  }
+}
 
-    completedWork.subtreeFlags |= subtreeFlags;
-  } else {
-    // Bubble up the earliest expiration time.
-    if ((completedWork.mode & ProfileMode) !== NoMode) {
-      // In profiling mode, resetChildExpirationTime is also used to reset
-      // profiler durations.
-      var _treeBaseDuration = completedWork.selfBaseDuration;
-      var _child2 = completedWork.child;
-
-      while (_child2 !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child2.lanes, _child2.childLanes)
-        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
-        // so we should bubble those up even during a bailout. All the other
-        // flags have a lifetime only of a single render + commit, so we should
-        // ignore them.
-
-        subtreeFlags |= _child2.subtreeFlags & StaticMask;
-        subtreeFlags |= _child2.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent: {
+      var retryCache = finishedWork.stateNode;
 
-        _treeBaseDuration += _child2.treeBaseDuration;
-        _child2 = _child2.sibling;
+      if (retryCache === null) {
+        retryCache = finishedWork.stateNode = new PossiblyWeakSet();
       }
 
-      completedWork.treeBaseDuration = _treeBaseDuration;
-    } else {
-      var _child3 = completedWork.child;
-
-      while (_child3 !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child3.lanes, _child3.childLanes)
-        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
-        // so we should bubble those up even during a bailout. All the other
-        // flags have a lifetime only of a single render + commit, so we should
-        // ignore them.
+      return retryCache;
+    }
 
-        subtreeFlags |= _child3.subtreeFlags & StaticMask;
-        subtreeFlags |= _child3.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
-        // smell because it assumes the commit phase is never concurrent with
-        // the render phase. Will address during refactor to alternate model.
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
+      var _retryCache = instance._retryCache;
 
-        _child3.return = completedWork;
-        _child3 = _child3.sibling;
+      if (_retryCache === null) {
+        _retryCache = instance._retryCache = new PossiblyWeakSet();
       }
+
+      return _retryCache;
     }
 
-    completedWork.subtreeFlags |= subtreeFlags;
+    default: {
+      throw new Error(
+        "Unexpected Suspense handler tag (" +
+          finishedWork.tag +
+          "). This is a " +
+          "bug in React."
+      );
+    }
   }
+}
 
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
+function detachOffscreenInstance(instance) {
+  var fiber = instance._current;
+
+  if (fiber === null) {
+    throw new Error(
+      "Calling Offscreen.detach before instance handle has been set."
+    );
+  }
+
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
+
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
 }
+function attachOffscreenInstance(instance) {
+  var fiber = instance._current;
 
-function completeDehydratedSuspenseBoundary(
-  current,
-  workInProgress,
-  nextState
-) {
-  if (
-    hasUnhydratedTailNodes() &&
-    (workInProgress.mode & ConcurrentMode) !== NoMode &&
-    (workInProgress.flags & DidCapture) === NoFlags$1
-  ) {
-    warnIfUnhydratedTailNodes(workInProgress);
-    resetHydrationState();
-    workInProgress.flags |= ForceClientRender | Incomplete | ShouldCapture;
-    return false;
+  if (fiber === null) {
+    throw new Error(
+      "Calling Offscreen.detach before instance handle has been set."
+    );
   }
 
-  var wasHydrated = popHydrationState(workInProgress);
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
+  }
 
-  if (nextState !== null && nextState.dehydrated !== null) {
-    // We might be inside a hydration state the first time we're picking up this
-    // Suspense boundary, and also after we've reentered it for further hydration.
-    if (current === null) {
-      if (!wasHydrated) {
-        throw new Error(
-          "A dehydrated suspense component was completed without a hydrated node. " +
-            "This is probably a bug in React."
-        );
-      }
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-      prepareToHydrateHostSuspenseInstance(workInProgress);
-      bubbleProperties(workInProgress);
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
+}
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          var isTimedOutSuspense = nextState !== null;
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  var retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(function (wakeable) {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
 
-          if (isTimedOutSuspense) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var primaryChildFragment = workInProgress.child;
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
 
-            if (primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                primaryChildFragment.treeBaseDuration;
-            }
+      {
+        if (isDevToolsPresent) {
+          if (inProgressLanes !== null && inProgressRoot !== null) {
+            // If we have pending work still, associate the original updaters with it.
+            restorePendingUpdaters(inProgressRoot, inProgressLanes);
+          } else {
+            throw Error(
+              "Expected finished root and lanes to be set. This is a bug in React."
+            );
           }
         }
       }
 
-      return false;
-    } else {
-      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
-      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
-      resetHydrationState();
+      wakeable.then(retry, retry);
+    }
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+// It returns false if the boundary is already hidden.
+// TODO: Use an effect tag.
 
-      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
-        // This boundary did not suspend so it's now hydrated and unsuspended.
-        workInProgress.memoizedState = null;
-      } // If nothing suspended, we need to schedule an effect to mark this boundary
-      // as having hydrated so events know that they're free to be invoked.
-      // It's also a signal to replay events and the suspense callback.
-      // If something suspended, schedule an effect to attach retry listeners.
-      // So we might as well always mark this.
+function isSuspenseBoundaryBeingHidden(current, finishedWork) {
+  if (current !== null) {
+    var oldState = current.memoizedState;
 
-      workInProgress.flags |= Update;
-      bubbleProperties(workInProgress);
+    if (oldState === null || oldState.dehydrated !== null) {
+      var newState = finishedWork.memoizedState;
+      return newState !== null && newState.dehydrated === null;
+    }
+  }
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          var _isTimedOutSuspense = nextState !== null;
+  return false;
+}
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  setCurrentFiber(finishedWork);
+  commitMutationEffectsOnFiber(finishedWork, root);
+  setCurrentFiber(finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
+}
 
-          if (_isTimedOutSuspense) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var _primaryChildFragment = workInProgress.child;
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  var deletions = parentFiber.deletions;
 
-            if (_primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                _primaryChildFragment.treeBaseDuration;
-            }
-          }
-        }
-      }
+  if (deletions !== null) {
+    for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i];
 
-      return false;
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
     }
-  } else {
-    // Successfully completed this tree. If this was a forced client render,
-    // there may have been recoverable errors during first hydration
-    // attempt. If so, add them to a queue so we can log them in the
-    // commit phase.
-    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+  }
 
-    return true;
+  var prevDebugFiber = getCurrentFiber();
+
+  if (parentFiber.subtreeFlags & MutationMask) {
+    var child = parentFiber.child;
+
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
+    }
   }
+
+  setCurrentFiber(prevDebugFiber);
 }
 
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
+var currentHoistableRoot = null;
 
-  popTreeContext(workInProgress);
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  var current = finishedWork.alternate;
+  var flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
 
-  switch (workInProgress.tag) {
-    case IndeterminateComponent:
-    case LazyComponent:
-    case SimpleMemoComponent:
+  switch (finishedWork.tag) {
     case FunctionComponent:
     case ForwardRef:
-    case Fragment:
-    case Mode:
-    case Profiler:
-    case ContextConsumer:
     case MemoComponent:
-      bubbleProperties(workInProgress);
-      return null;
-
-    case ClassComponent: {
-      var Component = workInProgress.type;
-
-      if (isContextProvider(Component)) {
-        popContext(workInProgress);
-      }
-
-      bubbleProperties(workInProgress);
-      return null;
-    }
+    case SimpleMemoComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-    case HostRoot: {
-      var fiberRoot = workInProgress.stateNode;
+      if (flags & Update) {
+        try {
+          commitHookEffectListUnmount(
+            Insertion | HasEffect,
+            finishedWork,
+            finishedWork.return
+          );
+          commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        } // Layout effects are destroyed during the mutation phase so that all
+        // destroy functions for all fibers are called before any create functions.
+        // This prevents sibling component effects from interfering with each other,
+        // e.g. a destroy function in one component should never override a ref set
+        // by a create function in another component during the same commit.
 
-      if (enableTransitionTracing) {
-        var transitions = getWorkInProgressTransitions(); // We set the Passive flag here because if there are new transitions,
-        // we will need to schedule callbacks and process the transitions,
-        // which we do in the passive phase
+        if (shouldProfile(finishedWork)) {
+          try {
+            startLayoutEffectTimer();
+            commitHookEffectListUnmount(
+              Layout | HasEffect,
+              finishedWork,
+              finishedWork.return
+            );
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
 
-        if (transitions !== null) {
-          workInProgress.flags |= Passive$1;
+          recordLayoutEffectDuration(finishedWork);
+        } else {
+          try {
+            commitHookEffectListUnmount(
+              Layout | HasEffect,
+              finishedWork,
+              finishedWork.return
+            );
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
         }
       }
 
-      {
-        var previousCache = null;
+      return;
+    }
+
+    case ClassComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
+      if (flags & Ref) {
         if (current !== null) {
-          previousCache = current.memoizedState.cache;
+          safelyDetachRef(current, current.return);
         }
+      }
 
-        var cache = workInProgress.memoizedState.cache;
+      if (flags & Callback && offscreenSubtreeIsHidden) {
+        var updateQueue = finishedWork.updateQueue;
 
-        if (cache !== previousCache) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
+        if (updateQueue !== null) {
+          deferHiddenCallbacks(updateQueue);
         }
-
-        popCacheProvider(workInProgress);
       }
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(workInProgress);
-      }
+      return;
+    }
 
-      popRootTransition(workInProgress);
-      popHostContainer(workInProgress);
-      popTopLevelContextObject(workInProgress);
-      resetWorkInProgressVersions();
+    case HostHoistable: {
+      {
+        // We cast because we always set the root at the React root and so it cannot be
+        // null while we are processing mutation effects
+        var hoistableRoot = currentHoistableRoot;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
 
-      if (fiberRoot.pendingContext) {
-        fiberRoot.context = fiberRoot.pendingContext;
-        fiberRoot.pendingContext = null;
-      }
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
 
-      if (current === null || current.child === null) {
-        // If we hydrated, pop so that we can delete any remaining children
-        // that weren't hydrated.
-        var wasHydrated = popHydrationState(workInProgress);
+        if (flags & Update) {
+          var currentResource = current !== null ? current.memoizedState : null;
+          var newResource = finishedWork.memoizedState;
 
-        if (wasHydrated) {
-          // If we hydrated, then we'll need to schedule an update for
-          // the commit side-effects on the root.
-          markUpdate(workInProgress);
-        } else {
-          if (current !== null) {
-            var prevState = current.memoizedState;
+          if (current === null) {
+            // We are mounting a new HostHoistable Fiber. We fork the mount
+            // behavior based on whether this instance is a Hoistable Instance
+            // or a Hoistable Resource
+            if (newResource === null) {
+              if (finishedWork.stateNode === null) {
+                finishedWork.stateNode = hydrateHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.memoizedProps,
+                  finishedWork
+                );
+              } else {
+                mountHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.stateNode
+                );
+              }
+            } else {
+              finishedWork.stateNode = acquireResource(
+                hoistableRoot,
+                newResource,
+                finishedWork.memoizedProps
+              );
+            }
+          } else if (currentResource !== newResource) {
+            // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+            if (currentResource === null) {
+              if (current.stateNode !== null) {
+                unmountHoistable(current.stateNode);
+              }
+            } else {
+              releaseResource(currentResource);
+            }
 
-            if (
-              // Check if this is a client root
-              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
-              (workInProgress.flags & ForceClientRender) !== NoFlags$1
-            ) {
-              // Schedule an effect to clear this container at the start of the
-              // next commit. This handles the case of React rendering into a
-              // container with previous children. It's also safe to do for
-              // updates too, because current.child would only be null if the
-              // previous render was null (so the container would already
-              // be empty).
-              workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
-              // recoverable errors during first hydration attempt. If so, add
-              // them to a queue so we can log them in the commit phase.
+            if (newResource === null) {
+              mountHoistable(
+                hoistableRoot,
+                finishedWork.type,
+                finishedWork.stateNode
+              );
+            } else {
+              acquireResource(
+                hoistableRoot,
+                newResource,
+                finishedWork.memoizedProps
+              );
+            }
+          } else if (newResource === null && finishedWork.stateNode !== null) {
+            // We may have an update on a Hoistable element
+            var updatePayload = finishedWork.updateQueue;
+            finishedWork.updateQueue = null;
 
-              upgradeHydrationErrorsToRecoverable();
+            if (updatePayload !== null) {
+              try {
+                commitUpdate(
+                  finishedWork.stateNode,
+                  updatePayload,
+                  finishedWork.type,
+                  current.memoizedProps,
+                  finishedWork.memoizedProps,
+                  finishedWork
+                );
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
             }
           }
         }
-      }
-      bubbleProperties(workInProgress);
 
-      if (enableTransitionTracing) {
-        if ((workInProgress.subtreeFlags & Visibility) !== NoFlags$1) {
-          // If any of our suspense children toggle visibility, this means that
-          // the pending boundaries array needs to be updated, which we only
-          // do in the passive phase.
-          workInProgress.flags |= Passive$1;
-        }
+        return;
       }
-
-      return null;
     }
+    // eslint-disable-next-line-no-fallthrough
 
-    case HostHoistable: {
+    case HostSingleton: {
       {
-        var currentRef = current ? current.ref : null;
+        if (flags & Update) {
+          var previousWork = finishedWork.alternate;
 
-        if (currentRef !== workInProgress.ref) {
-          markRef(workInProgress);
-        }
+          if (previousWork === null) {
+            var singleton = finishedWork.stateNode;
+            var props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
 
-        if (
-          // We are mounting and must Update this Hoistable in this commit
-          current === null || // We are transitioning to, from, or between Hoistable Resources
-          // and require an update
-          current.memoizedState !== workInProgress.memoizedState
-        ) {
-          markUpdate(workInProgress);
-        } else if (workInProgress.memoizedState === null) {
-          // We may have props to update on the Hoistable instance. We use the
-          // updateHostComponent path becuase it produces the update queue
-          // we need for Hoistables
-          updateHostComponent(
-            current,
-            workInProgress,
-            workInProgress.type,
-            workInProgress.pendingProps
-          );
+            clearSingleton(singleton);
+            acquireSingletonInstance(
+              finishedWork.type,
+              props,
+              singleton,
+              finishedWork
+            );
+          }
         }
-
-        bubbleProperties(workInProgress);
-        return null;
       }
     }
     // eslint-disable-next-line-no-fallthrough
 
-    case HostSingleton: {
-      {
-        popHostContext(workInProgress);
-        var rootContainerInstance = getRootHostContainer();
-        var type = workInProgress.type;
+    case HostComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-        if (current !== null && workInProgress.stateNode != null) {
-          updateHostComponent(current, workInProgress, type, newProps);
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
+      }
 
-          if (current.ref !== workInProgress.ref) {
-            markRef(workInProgress);
-          }
-        } else {
-          if (!newProps) {
-            if (workInProgress.stateNode === null) {
-              throw new Error(
-                "We must have new props for new mounts. This error is likely " +
-                  "caused by a bug in React. Please file an issue."
-              );
-            } // This can happen when we abort work.
+      {
+        // TODO: ContentReset gets cleared by the children during the commit
+        // phase. This is a refactor hazard because it means we must read
+        // flags the flags after `commitReconciliationEffects` has already run;
+        // the order matters. We should refactor so that ContentReset does not
+        // rely on mutating the flag during commit. Like by setting a flag
+        // during the render phase instead.
+        if (finishedWork.flags & ContentReset) {
+          var instance = finishedWork.stateNode;
 
-            bubbleProperties(workInProgress);
-            return null;
+          try {
+            resetTextContent(instance);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
           }
+        }
 
-          var currentHostContext = getHostContext();
+        if (flags & Update) {
+          var _instance2 = finishedWork.stateNode;
 
-          var _wasHydrated = popHydrationState(workInProgress);
+          if (_instance2 != null) {
+            // Commit the work prepared earlier.
+            var newProps = finishedWork.memoizedProps; // 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.
 
-          if (_wasHydrated) {
-            // We ignore the boolean indicating there is an updateQueue because
-            // it is used only to set text children and HostSingletons do not
-            // use them.
-            prepareToHydrateHostInstance(workInProgress, currentHostContext);
-          } else {
-            workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              rootContainerInstance,
-              currentHostContext,
-              true
-            );
-            markUpdate(workInProgress);
-          }
+            var oldProps = current !== null ? current.memoizedProps : newProps;
+            var type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
 
-          if (workInProgress.ref !== null) {
-            // If there is a ref on a host node we need to schedule a callback
-            markRef(workInProgress);
+            var _updatePayload = finishedWork.updateQueue;
+            finishedWork.updateQueue = null;
+
+            if (_updatePayload !== null) {
+              try {
+                commitUpdate(
+                  _instance2,
+                  _updatePayload,
+                  type,
+                  oldProps,
+                  newProps,
+                  finishedWork
+                );
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
           }
         }
-
-        bubbleProperties(workInProgress);
-        return null;
       }
-    }
-    // eslint-disable-next-line-no-fallthrough
 
-    case HostComponent: {
-      popHostContext(workInProgress);
-      var _type = workInProgress.type;
+      return;
+    }
 
-      if (current !== null && workInProgress.stateNode != null) {
-        updateHostComponent(current, workInProgress, _type, newProps);
+    case HostText: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-        if (current.ref !== workInProgress.ref) {
-          markRef(workInProgress);
-        }
-      } else {
-        if (!newProps) {
-          if (workInProgress.stateNode === null) {
+      if (flags & Update) {
+        {
+          if (finishedWork.stateNode === null) {
             throw new Error(
-              "We must have new props for new mounts. This error is likely " +
+              "This should have a text node initialized. This error is likely " +
                 "caused by a bug in React. Please file an issue."
             );
-          } // This can happen when we abort work.
-
-          bubbleProperties(workInProgress);
-          return null;
-        }
+          }
 
-        var _currentHostContext2 = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
-        // "stack" as the parent. Then append children as we go in beginWork
-        // or completeWork depending on whether we want to add them top->down or
-        // bottom->up. Top->down is faster in IE11.
+          var textInstance = finishedWork.stateNode;
+          var newText = finishedWork.memoizedProps; // 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 _wasHydrated2 = popHydrationState(workInProgress);
+          var oldText = current !== null ? current.memoizedProps : newText;
 
-        if (_wasHydrated2) {
-          // TODO: Move this and createInstance step into the beginPhase
-          // to consolidate.
-          if (
-            prepareToHydrateHostInstance(workInProgress, _currentHostContext2)
-          ) {
-            // If changes to the hydrated node need to be applied at the
-            // commit-phase we mark this as such.
-            markUpdate(workInProgress);
+          try {
+            commitTextUpdate(textInstance, oldText, newText);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
           }
-        } else {
-          var _rootContainerInstance = getRootHostContainer();
+        }
+      }
 
-          var instance = createInstance(
-            _type,
-            newProps,
-            _rootContainerInstance,
-            _currentHostContext2,
-            workInProgress
-          );
-          appendAllChildren(instance, workInProgress);
-          workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
-          // (eg DOM renderer supports auto-focus for certain elements).
-          // Make sure such renderers get scheduled for later work.
+      return;
+    }
 
-          if (finalizeInitialChildren(instance, _type, newProps)) {
-            markUpdate(workInProgress);
-          }
-        }
+    case HostRoot: {
+      {
+        prepareToCommitHoistables();
+        var previousHoistableRoot = currentHoistableRoot;
+        currentHoistableRoot = getHoistableRoot(root.containerInfo);
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        currentHoistableRoot = previousHoistableRoot;
+        commitReconciliationEffects(finishedWork);
+      }
 
-        if (workInProgress.ref !== null) {
-          // If there is a ref on a host node we need to schedule a callback
-          markRef(workInProgress);
+      if (flags & Update) {
+        {
+          if (current !== null) {
+            var prevRootState = current.memoizedState;
+
+            if (prevRootState.isDehydrated) {
+              try {
+                commitHydratedContainer(root.containerInfo);
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          }
         }
       }
 
-      bubbleProperties(workInProgress);
-      return null;
+      return;
     }
 
-    case HostText: {
-      var newText = newProps;
-
-      if (current && workInProgress.stateNode != null) {
-        var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
-        // to schedule a side-effect to do the updates.
+    case HostPortal: {
+      {
+        var _previousHoistableRoot = currentHoistableRoot;
+        currentHoistableRoot = getHoistableRoot(
+          finishedWork.stateNode.containerInfo
+        );
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        currentHoistableRoot = _previousHoistableRoot;
+      }
 
-        updateHostText(current, workInProgress, oldText, newText);
-      } else {
-        if (typeof newText !== "string") {
-          if (workInProgress.stateNode === null) {
-            throw new Error(
-              "We must have new props for new mounts. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          } // This can happen when we abort work.
-        }
+      return;
+    }
 
-        var _rootContainerInstance2 = getRootHostContainer();
+    case SuspenseComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      var offscreenFiber = finishedWork.child;
 
-        var _currentHostContext3 = getHostContext();
+      if (offscreenFiber.flags & Visibility) {
+        var newState = offscreenFiber.memoizedState;
+        var isHidden = newState !== null;
 
-        var _wasHydrated3 = popHydrationState(workInProgress);
+        if (isHidden) {
+          var wasHidden =
+            offscreenFiber.alternate !== null &&
+            offscreenFiber.alternate.memoizedState !== null;
 
-        if (_wasHydrated3) {
-          if (prepareToHydrateHostTextInstance(workInProgress)) {
-            markUpdate(workInProgress);
+          if (!wasHidden) {
+            // TODO: Move to passive phase
+            markCommitTimeOfFallback();
           }
-        } else {
-          workInProgress.stateNode = createTextInstance(
-            newText,
-            _rootContainerInstance2,
-            _currentHostContext3,
-            workInProgress
-          );
         }
       }
 
-      bubbleProperties(workInProgress);
-      return null;
-    }
+      if (flags & Update) {
+        try {
+          commitSuspenseCallback(finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
 
-    case SuspenseComponent: {
-      popSuspenseHandler(workInProgress);
-      var nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
-      // to its own fiber type so that we can add other kinds of hydration
-      // boundaries that aren't associated with a Suspense tree. In anticipation
-      // of such a refactor, all the hydration logic is contained in
-      // this branch.
+        var wakeables = finishedWork.updateQueue;
 
-      if (
-        current === null ||
-        (current.memoizedState !== null &&
-          current.memoizedState.dehydrated !== null)
-      ) {
-        var fallthroughToNormalSuspensePath =
-          completeDehydratedSuspenseBoundary(
-            current,
-            workInProgress,
-            nextState
-          );
+        if (wakeables !== null) {
+          finishedWork.updateQueue = null;
+          attachSuspenseRetryListeners(finishedWork, wakeables);
+        }
+      }
 
-        if (!fallthroughToNormalSuspensePath) {
-          if (workInProgress.flags & ShouldCapture) {
-            // Special case. There were remaining unhydrated nodes. We treat
-            // this as a mismatch. Revert to client rendering.
-            return workInProgress;
-          } else {
-            // Did not finish hydrating, either because this is the initial
-            // render or because something suspended.
-            return null;
-          }
-        } // Continue with the normal Suspense path.
+      return;
+    }
+
+    case OffscreenComponent: {
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
       }
 
-      if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
-        // Something suspended. Re-render with the fallback children.
-        workInProgress.lanes = renderLanes; // Do not reset the effect list.
+      var _newState = finishedWork.memoizedState;
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        } // Don't bubble properties in this case.
+      var _isHidden = _newState !== null;
 
-        return workInProgress;
+      var _wasHidden = current !== null && current.memoizedState !== null;
+
+      if (finishedWork.mode & ConcurrentMode) {
+        // Before committing the children, track on the stack whether this
+        // offscreen subtree was already hidden, so that we don't unmount the
+        // effects again.
+        var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || _isHidden;
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || _wasHidden;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+      } else {
+        recursivelyTraverseMutationEffects(root, finishedWork);
       }
 
-      var nextDidTimeout = nextState !== null;
-      var prevDidTimeout = current !== null && current.memoizedState !== null;
+      commitReconciliationEffects(finishedWork);
+      var offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
 
-      if (nextDidTimeout) {
-        var offscreenFiber = workInProgress.child;
-        var _previousCache = null;
+      offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+      // to support batching of `attach` and `detach` calls.
 
-        if (
-          offscreenFiber.alternate !== null &&
-          offscreenFiber.alternate.memoizedState !== null &&
-          offscreenFiber.alternate.memoizedState.cachePool !== null
-        ) {
-          _previousCache =
-            offscreenFiber.alternate.memoizedState.cachePool.pool;
+      offscreenInstance._visibility &= ~OffscreenDetached;
+      offscreenInstance._visibility |=
+        offscreenInstance._pendingVisibility & OffscreenDetached;
+
+      if (flags & Visibility) {
+        // Track the current state on the Offscreen instance so we can
+        // read it during an event
+        if (_isHidden) {
+          offscreenInstance._visibility &= ~OffscreenVisible;
+        } else {
+          offscreenInstance._visibility |= OffscreenVisible;
         }
 
-        var _cache = null;
+        if (_isHidden) {
+          var isUpdate = current !== null;
+          var wasHiddenByAncestorOffscreen =
+            offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+          //   - This is an update, not first mount.
+          //   - This Offscreen was not hidden before.
+          //   - Ancestor Offscreen was not hidden in previous commit.
 
-        if (
-          offscreenFiber.memoizedState !== null &&
-          offscreenFiber.memoizedState.cachePool !== null
-        ) {
-          _cache = offscreenFiber.memoizedState.cachePool.pool;
-        }
+          if (isUpdate && !_wasHidden && !wasHiddenByAncestorOffscreen) {
+            if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+              // Disappear the layout effects of all the children
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+            }
+          }
+        } // Offscreen with manual mode manages visibility manually.
 
-        if (_cache !== _previousCache) {
-          // Run passive effects to retain/release the cache.
-          offscreenFiber.flags |= Passive$1;
+        if (!isOffscreenManual(finishedWork)) {
+          // TODO: This needs to run whenever there's an insertion or update
+          // inside a hidden Offscreen tree.
+          hideOrUnhideAllChildren(finishedWork, _isHidden);
         }
-      } // If the suspended state of the boundary changes, we need to schedule
-      // a passive effect, which is when we process the transitions
+      } // TODO: Move to passive phase
 
-      if (nextDidTimeout !== prevDidTimeout) {
-        if (enableTransitionTracing) {
-          var _offscreenFiber = workInProgress.child;
-          _offscreenFiber.flags |= Passive$1;
-        } // If the suspended state of the boundary changes, we need to schedule
-        // an effect to toggle the subtree's visibility. When we switch from
-        // fallback -> primary, the inner Offscreen fiber schedules this effect
-        // as part of its normal complete phase. But when we switch from
-        // primary -> fallback, the inner Offscreen fiber does not have a complete
-        // phase. So we need to schedule its effect here.
-        //
-        // We also use this flag to connect/disconnect the effects, but the same
-        // logic applies: when re-connecting, the Offscreen fiber's complete
-        // phase will handle scheduling the effect. It's only when the fallback
-        // is active that we have to do anything special.
+      if (flags & Update) {
+        var offscreenQueue = finishedWork.updateQueue;
 
-        if (nextDidTimeout) {
-          var _offscreenFiber2 = workInProgress.child;
-          _offscreenFiber2.flags |= Visibility;
+        if (offscreenQueue !== null) {
+          var _wakeables = offscreenQueue.wakeables;
+
+          if (_wakeables !== null) {
+            offscreenQueue.wakeables = null;
+            attachSuspenseRetryListeners(finishedWork, _wakeables);
+          }
         }
       }
 
-      var wakeables = workInProgress.updateQueue;
+      return;
+    }
 
-      if (wakeables !== null) {
-        // Schedule an effect to attach a retry listener to the promise.
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+    case SuspenseListComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-      if (
-        workInProgress.updateQueue !== null &&
-        workInProgress.memoizedProps.suspenseCallback != null
-      ) {
-        // Always notify the callback
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
+      if (flags & Update) {
+        var _wakeables2 = finishedWork.updateQueue;
+
+        if (_wakeables2 !== null) {
+          finishedWork.updateQueue = null;
+          attachSuspenseRetryListeners(finishedWork, _wakeables2);
+        }
       }
 
-      bubbleProperties(workInProgress);
+      return;
+    }
 
+    case ScopeComponent: {
       {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          if (nextDidTimeout) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var primaryChildFragment = workInProgress.child;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: This is a temporary solution that allowed us to transition away
+        // from React Flare on www.
 
-            if (primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                primaryChildFragment.treeBaseDuration;
-            }
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(finishedWork, finishedWork.return);
           }
+
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        if (flags & Update) {
+          var scopeInstance = finishedWork.stateNode;
+          prepareScopeUpdate(scopeInstance, finishedWork);
         }
       }
 
-      return null;
+      return;
     }
 
-    case HostPortal:
-      popHostContainer(workInProgress);
+    default: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      return;
+    }
+  }
+}
 
-      if (current === null) {
-        preparePortalMount(workInProgress.stateNode.containerInfo);
-      }
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  var flags = finishedWork.flags;
 
-      bubbleProperties(workInProgress);
-      return null;
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
 
-    case ContextProvider:
-      // Pop provider fiber
-      var context = workInProgress.type._context;
-      popProvider(context, workInProgress);
-      bubbleProperties(workInProgress);
-      return null;
+    finishedWork.flags &= ~Placement;
+  }
 
-    case IncompleteClassComponent: {
-      // Same as class component case. I put it down here so that the tags are
-      // sequential to ensure this switch is compiled to a jump table.
-      var _Component = workInProgress.type;
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
+  }
+}
 
-      if (isContextProvider(_Component)) {
-        popContext(workInProgress);
-      }
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  var current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
+}
 
-      bubbleProperties(workInProgress);
-      return null;
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+  var prevDebugFiber = getCurrentFiber();
+
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    var child = parentFiber.child;
+
+    while (child !== null) {
+      setCurrentFiber(child);
+      var current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
     }
+  }
 
-    case SuspenseListComponent: {
-      popSuspenseListContext(workInProgress);
-      var renderState = workInProgress.memoizedState;
+  setCurrentFiber(prevDebugFiber);
+}
 
-      if (renderState === null) {
-        // We're running in the default, "independent" mode.
-        // We don't do anything in this mode.
-        bubbleProperties(workInProgress);
-        return null;
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      // TODO (Offscreen) Check: flags & LayoutStatic
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          commitHookEffectListUnmount(
+            Layout,
+            finishedWork,
+            finishedWork.return
+          );
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
+        commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
       }
 
-      var didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
-      var renderedTail = renderState.rendering;
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
 
-      if (renderedTail === null) {
-        // We just rendered the head.
-        if (!didSuspendAlready) {
-          // This is the first pass. We need to figure out if anything is still
-          // suspended in the rendered set.
-          // If new content unsuspended, but there's still some content that
-          // didn't. Then we need to do a second pass that forces everything
-          // to keep showing their fallbacks.
-          // We might be suspended if something in this render pass suspended, or
-          // something in the previous committed pass suspended. Otherwise,
-          // there's no chance so we can skip the expensive call to
-          // findFirstSuspended.
-          var cannotBeSuspended =
-            renderHasNotSuspendedYet() &&
-            (current === null || (current.flags & DidCapture) === NoFlags$1);
+    case ClassComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      var instance = finishedWork.stateNode;
 
-          if (!cannotBeSuspended) {
-            var row = workInProgress.child;
+      if (typeof instance.componentWillUnmount === "function") {
+        safelyCallComponentWillUnmount(
+          finishedWork,
+          finishedWork.return,
+          instance
+        );
+      }
 
-            while (row !== null) {
-              var suspended = findFirstSuspended(row);
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
 
-              if (suspended !== null) {
-                didSuspendAlready = true;
-                workInProgress.flags |= DidCapture;
-                cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
-                // part of the second pass. In that case nothing will subscribe to
-                // its thenables. Instead, we'll transfer its thenables to the
-                // SuspenseList so that it can retry if they resolve.
-                // There might be multiple of these in the list but since we're
-                // going to wait for all of them anyway, it doesn't really matter
-                // which ones gets to ping. In theory we could get clever and keep
-                // track of how many dependencies remain but it gets tricky because
-                // in the meantime, we can add/remove/change items and dependencies.
-                // We might bail out of the loop before finding any but that
-                // doesn't matter since that means that the other boundaries that
-                // we did find already has their listeners attached.
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
 
-                var newThenables = suspended.updateQueue;
+    case OffscreenComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      var isHidden = finishedWork.memoizedState !== null;
 
-                if (newThenables !== null) {
-                  workInProgress.updateQueue = newThenables;
-                  workInProgress.flags |= Update;
-                } // Rerender the whole list, but this time, we'll force fallbacks
-                // to stay in place.
-                // Reset the effect flags before doing the second pass since that's now invalid.
-                // Reset the child fibers to their original state.
+      if (isHidden);
+      else {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      }
 
-                workInProgress.subtreeFlags = NoFlags$1;
-                resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
-                // immediately rerender the children.
+      break;
+    }
 
-                pushSuspenseListContext(
-                  workInProgress,
-                  setShallowSuspenseListContext(
-                    suspenseStackCursor.current,
-                    ForceSuspenseFallback
-                  )
-                ); // Don't bubble properties in this case.
+    default: {
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
+  }
+}
 
-                return workInProgress.child;
-              }
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  var child = parentFiber.child;
 
-              row = row.sibling;
-            }
-          }
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
 
-          if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
-            // We have already passed our CPU deadline but we still have rows
-            // left in the tail. We'll just give up further attempts to render
-            // the main content and only render fallbacks.
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true;
-            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
-            // to get it started back up to attempt the next item. While in terms
-            // of priority this work has the same priority as this current render,
-            // it's not part of the same transition once the transition has
-            // committed. If it's sync, we still want to yield so that it can be
-            // painted. Conceptually, this is really the same as pinging.
-            // We can use any RetryLane even if it's the one currently rendering
-            // since we're leaving it behind on this node.
+function reappearLayoutEffects(
+  finishedRoot,
+  current,
+  finishedWork, // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  includeWorkInProgressEffects
+) {
+  // Turn on layout effects in a tree that previously disappeared.
+  var flags = finishedWork.flags;
 
-            workInProgress.lanes = SomeRetryLane;
-          }
-        } else {
-          cutOffTailIfNeeded(renderState, false);
-        } // Next we're going to render the tail.
-      } else {
-        // Append the rendered row to the child list.
-        if (!didSuspendAlready) {
-          var _suspended = findFirstSuspended(renderedTail);
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Check flags & LayoutStatic
 
-          if (_suspended !== null) {
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
-            // get lost if this row ends up dropped during a second pass.
+      commitHookLayoutEffects(finishedWork, Layout);
+      break;
+    }
 
-            var _newThenables = _suspended.updateQueue;
+    case ClassComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Check for LayoutStatic flag
 
-            if (_newThenables !== null) {
-              workInProgress.updateQueue = _newThenables;
-              workInProgress.flags |= Update;
-            }
+      var instance = finishedWork.stateNode;
 
-            cutOffTailIfNeeded(renderState, true); // This might have been modified.
+      if (typeof instance.componentDidMount === "function") {
+        try {
+          instance.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      } // Commit any callbacks that would have fired while the component
+      // was hidden.
 
-            if (
-              renderState.tail === null &&
-              renderState.tailMode === "hidden" &&
-              !renderedTail.alternate &&
-              !getIsHydrating() // We don't cut it if we're hydrating.
-            ) {
-              // We're done.
-              bubbleProperties(workInProgress);
-              return null;
-            }
-          } else if (
-            // The time it took to render last row is greater than the remaining
-            // time we have to render. So rendering one more row would likely
-            // exceed it.
-            now$1() * 2 - renderState.renderingStartTime >
-              getRenderTargetTime() &&
-            renderLanes !== OffscreenLane
-          ) {
-            // We have now passed our CPU deadline and we'll just give up further
-            // attempts to render the main content and only render fallbacks.
-            // The assumption is that this is usually faster.
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true;
-            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
-            // to get it started back up to attempt the next item. While in terms
-            // of priority this work has the same priority as this current render,
-            // it's not part of the same transition once the transition has
-            // committed. If it's sync, we still want to yield so that it can be
-            // painted. Conceptually, this is really the same as pinging.
-            // We can use any RetryLane even if it's the one currently rendering
-            // since we're leaving it behind on this node.
+      var updateQueue = finishedWork.updateQueue;
 
-            workInProgress.lanes = SomeRetryLane;
-          }
-        }
+      if (updateQueue !== null) {
+        commitHiddenCallbacks(updateQueue, instance);
+      } // If this is newly finished work, check for setState callbacks
 
-        if (renderState.isBackwards) {
-          // The effect list of the backwards tail will have been added
-          // to the end. This breaks the guarantee that life-cycles fire in
-          // sibling order but that isn't a strong guarantee promised by React.
-          // Especially since these might also just pop in during future commits.
-          // Append to the beginning of the list.
-          renderedTail.sibling = workInProgress.child;
-          workInProgress.child = renderedTail;
-        } else {
-          var previousSibling = renderState.last;
+      if (includeWorkInProgressEffects && flags & Callback) {
+        commitClassCallbacks(finishedWork);
+      } // TODO: Check flags & RefStatic
 
-          if (previousSibling !== null) {
-            previousSibling.sibling = renderedTail;
-          } else {
-            workInProgress.child = renderedTail;
-          }
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
 
-          renderState.last = renderedTail;
-        }
-      }
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // Renderers may schedule work to be done after host components are mounted
+      // (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 (renderState.tail !== null) {
-        // We still have tail rows to render.
-        // Pop a row.
-        var next = renderState.tail;
-        renderState.rendering = next;
-        renderState.tail = next.sibling;
-        renderState.renderingStartTime = now$1();
-        next.sibling = null; // Restore the context.
-        // TODO: We can probably just avoid popping it instead and only
-        // setting it the first time we go from not suspended to suspended.
+      if (includeWorkInProgressEffects && current === null && flags & Update) {
+        commitHostComponentMount(finishedWork);
+      } // TODO: Check flags & Ref
 
-        var suspenseContext = suspenseStackCursor.current;
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    }
 
-        if (didSuspendAlready) {
-          suspenseContext = setShallowSuspenseListContext(
-            suspenseContext,
-            ForceSuspenseFallback
-          );
-        } else {
-          suspenseContext =
-            setDefaultShallowSuspenseListContext(suspenseContext);
-        }
+    case Profiler: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Figure out how Profiler updates should work with Offscreen
 
-        pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
-        // Don't bubble properties in this case.
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
+      }
 
-        return next;
+      break;
+    }
+
+    case SuspenseComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Figure out how Suspense hydration callbacks should work
+      // with Offscreen.
+
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
       }
 
-      bubbleProperties(workInProgress);
-      return null;
+      break;
     }
 
-    case ScopeComponent: {
-      {
-        if (current === null) {
-          var scopeInstance = createScopeInstance();
-          workInProgress.stateNode = scopeInstance;
-          prepareScopeUpdate(scopeInstance, workInProgress);
+    case OffscreenComponent: {
+      var offscreenState = finishedWork.memoizedState;
+      var isHidden = offscreenState !== null;
 
-          if (workInProgress.ref !== null) {
-            markRef(workInProgress);
-            markUpdate(workInProgress);
-          }
-        } else {
-          if (workInProgress.ref !== null) {
-            markUpdate(workInProgress);
-          }
+      if (isHidden);
+      else {
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+      } // TODO: Check flags & Ref
 
-          if (current.ref !== workInProgress.ref) {
-            markRef(workInProgress);
-          }
-        }
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    }
 
-        bubbleProperties(workInProgress);
-        return null;
-      }
+    default: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      );
+      break;
     }
+  }
+}
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      popSuspenseHandler(workInProgress);
-      popHiddenContext(workInProgress);
-      var _nextState = workInProgress.memoizedState;
-      var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
+function recursivelyTraverseReappearLayoutEffects(
+  finishedRoot,
+  parentFiber,
+  includeWorkInProgressEffects
+) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  var childShouldIncludeWorkInProgressEffects =
+    includeWorkInProgressEffects &&
+    (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
 
-      if (workInProgress.tag === LegacyHiddenComponent);
-      else {
-        if (current !== null) {
-          var _prevState = current.memoizedState;
-          var prevIsHidden = _prevState !== null;
+  var prevDebugFiber = getCurrentFiber();
+  var child = parentFiber.child;
 
-          if (prevIsHidden !== nextIsHidden) {
-            workInProgress.flags |= Visibility;
-          }
-        } else {
-          // On initial mount, we only need a Visibility effect if the tree
-          // is hidden.
-          if (nextIsHidden) {
-            workInProgress.flags |= Visibility;
-          }
-        }
-      }
+  while (child !== null) {
+    var current = child.alternate;
+    reappearLayoutEffects(
+      finishedRoot,
+      current,
+      child,
+      childShouldIncludeWorkInProgressEffects
+    );
+    child = child.sibling;
+  }
+
+  setCurrentFiber(prevDebugFiber);
+}
 
-      if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
-        bubbleProperties(workInProgress);
-      } else {
-        // Don't bubble properties for hidden children unless we're rendering
-        // at offscreen priority.
-        if (
-          includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
-          (workInProgress.flags & DidCapture) === NoLanes
-        ) {
-          bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
-          // If so, we need to hide those nodes in the commit phase, so
-          // schedule a visibility effect.
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
 
-          if (
-            workInProgress.tag !== LegacyHiddenComponent &&
-            workInProgress.subtreeFlags & (Placement | Update)
-          ) {
-            workInProgress.flags |= Visibility;
-          }
-        }
-      }
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
 
-      if (workInProgress.updateQueue !== null) {
-        // Schedule an effect to attach Suspense retry listeners
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
 
-      {
-        var _previousCache2 = null;
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  {
+    var previousCache = null;
 
-        if (
-          current !== null &&
-          current.memoizedState !== null &&
-          current.memoizedState.cachePool !== null
-        ) {
-          _previousCache2 = current.memoizedState.cachePool.pool;
-        }
+    if (
+      current !== null &&
+      current.memoizedState !== null &&
+      current.memoizedState.cachePool !== null
+    ) {
+      previousCache = current.memoizedState.cachePool.pool;
+    }
 
-        var _cache2 = null;
+    var nextCache = null;
 
-        if (
-          workInProgress.memoizedState !== null &&
-          workInProgress.memoizedState.cachePool !== null
-        ) {
-          _cache2 = workInProgress.memoizedState.cachePool.pool;
-        }
+    if (
+      finishedWork.memoizedState !== null &&
+      finishedWork.memoizedState.cachePool !== null
+    ) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
 
-        if (_cache2 !== _previousCache2) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
-        }
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
       }
 
-      popTransition(workInProgress, current);
-      return null;
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
     }
+  }
 
-    case CacheComponent: {
-      {
-        var _previousCache3 = null;
+  if (enableTransitionTracing) {
+    // TODO: Pre-rendering should not be counted as part of a transition. We
+    // may add separate logs for pre-rendering, but it's not part of the
+    // primary metrics.
+    var offscreenState = finishedWork.memoizedState;
+    var queue = finishedWork.updateQueue;
+    var isHidden = offscreenState !== null;
 
-        if (current !== null) {
-          _previousCache3 = current.memoizedState.cache;
-        }
+    if (queue !== null) {
+      if (isHidden) {
+        var transitions = queue.transitions;
 
-        var _cache3 = workInProgress.memoizedState.cache;
+        if (transitions !== null) {
+          transitions.forEach(function (transition) {
+            // Add all the transitions saved in the update queue during
+            // the render phase (ie the transitions associated with this boundary)
+            // into the transitions set.
+            if (instance._transitions === null) {
+              instance._transitions = new Set();
+            }
 
-        if (_cache3 !== _previousCache3) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
+            instance._transitions.add(transition);
+          });
         }
 
-        popCacheProvider(workInProgress);
-        bubbleProperties(workInProgress);
-      }
+        var markerInstances = queue.markerInstances;
 
-      return null;
-    }
+        if (markerInstances !== null) {
+          markerInstances.forEach(function (markerInstance) {
+            var markerTransitions = markerInstance.transitions; // There should only be a few tracing marker transitions because
+            // they should be only associated with the transition that
+            // caused them
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        var _instance3 = workInProgress.stateNode;
+            if (markerTransitions !== null) {
+              markerTransitions.forEach(function (transition) {
+                if (instance._transitions === null) {
+                  instance._transitions = new Set();
+                } else if (instance._transitions.has(transition)) {
+                  if (markerInstance.pendingBoundaries === null) {
+                    markerInstance.pendingBoundaries = new Map();
+                  }
 
-        if (_instance3 !== null) {
-          popMarkerInstance(workInProgress);
-        }
+                  if (instance._pendingMarkers === null) {
+                    instance._pendingMarkers = new Set();
+                  }
 
-        bubbleProperties(workInProgress);
+                  instance._pendingMarkers.add(markerInstance);
+                }
+              });
+            }
+          });
+        }
       }
 
-      return null;
+      finishedWork.updateQueue = null;
     }
-  }
 
-  throw new Error(
-    "Unknown unit of work tag (" +
-      workInProgress.tag +
-      "). This error is likely caused by a bug in " +
-      "React. Please file an issue."
-  );
-}
-
-function unwindWork(current, workInProgress, renderLanes) {
-  // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
-  popTreeContext(workInProgress);
+    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
 
-  switch (workInProgress.tag) {
-    case ClassComponent: {
-      var Component = workInProgress.type;
+    if (!isHidden) {
+      instance._transitions = null;
+      instance._pendingMarkers = null;
+    }
+  }
+}
 
-      if (isContextProvider(Component)) {
-        popContext(workInProgress);
-      }
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    var previousCache = null;
 
-      var flags = workInProgress.flags;
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
 
-      if (flags & ShouldCapture) {
-        workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
+    var nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        }
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
 
-        return workInProgress;
+      if (previousCache != null) {
+        releaseCache(previousCache);
       }
-
-      return null;
     }
+  }
+}
 
-    case HostRoot: {
-      {
-        popCacheProvider(workInProgress);
-      }
+function commitTracingMarkerPassiveMountEffect(finishedWork) {
+  // Get the transitions that were initiatized during the render
+  // and add a start transition callback for each of them
+  // We will only call this on initial mount of the tracing marker
+  // only if there are no suspense children
+  var instance = finishedWork.stateNode;
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(workInProgress);
-      }
+  if (instance.transitions !== null && instance.pendingBoundaries === null) {
+    addMarkerCompleteCallbackToPendingTransition(
+      finishedWork.memoizedProps.name,
+      instance.transitions
+    );
+    instance.transitions = null;
+    instance.pendingBoundaries = null;
+    instance.aborts = null;
+    instance.name = null;
+  }
+}
 
-      popRootTransition(workInProgress);
-      popHostContainer(workInProgress);
-      popTopLevelContextObject(workInProgress);
-      resetWorkInProgressVersions();
-      var _flags = workInProgress.flags;
+function commitPassiveMountEffects(
+  root,
+  finishedWork,
+  committedLanes,
+  committedTransitions
+) {
+  setCurrentFiber(finishedWork);
+  commitPassiveMountOnFiber(
+    root,
+    finishedWork,
+    committedLanes,
+    committedTransitions
+  );
+  resetCurrentFiber();
+}
 
-      if (
-        (_flags & ShouldCapture) !== NoFlags$1 &&
-        (_flags & DidCapture) === NoFlags$1
-      ) {
-        // There was an error during render that wasn't captured by a suspense
-        // boundary. Do a second pass on the root to unmount the children.
-        workInProgress.flags = (_flags & ~ShouldCapture) | DidCapture;
-        return workInProgress;
-      } // We unwound to the root without completing it. Exit.
+function recursivelyTraversePassiveMountEffects(
+  root,
+  parentFiber,
+  committedLanes,
+  committedTransitions
+) {
+  var prevDebugFiber = getCurrentFiber();
 
-      return null;
-    }
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      // TODO: popHydrationState
-      popHostContext(workInProgress);
-      return null;
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitPassiveMountOnFiber(
+        root,
+        child,
+        committedLanes,
+        committedTransitions
+      );
+      child = child.sibling;
     }
+  }
 
-    case SuspenseComponent: {
-      popSuspenseHandler(workInProgress);
-      var suspenseState = workInProgress.memoizedState;
-
-      if (suspenseState !== null && suspenseState.dehydrated !== null) {
-        if (workInProgress.alternate === null) {
-          throw new Error(
-            "Threw in newly mounted dehydrated component. This is likely a bug in " +
-              "React. Please file an issue."
-          );
-        }
-
-        resetHydrationState();
-      }
-
-      var _flags2 = workInProgress.flags;
+  setCurrentFiber(prevDebugFiber);
+}
 
-      if (_flags2 & ShouldCapture) {
-        workInProgress.flags = (_flags2 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+function commitPassiveMountOnFiber(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions
+) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  var flags = finishedWork.flags;
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        }
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-        return workInProgress;
+      if (flags & Passive$1) {
+        commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
       }
 
-      return null;
+      break;
     }
 
-    case SuspenseListComponent: {
-      popSuspenseListContext(workInProgress); // SuspenseList doesn't actually catch anything. It should've been
-      // caught by a nested boundary. If not, it should bubble through.
-
-      return null;
-    }
+    case HostRoot: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-    case HostPortal:
-      popHostContainer(workInProgress);
-      return null;
+      if (flags & Passive$1) {
+        {
+          var previousCache = null;
 
-    case ContextProvider:
-      var context = workInProgress.type._context;
-      popProvider(context, workInProgress);
-      return null;
+          if (finishedWork.alternate !== null) {
+            previousCache = finishedWork.alternate.memoizedState.cache;
+          }
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      popSuspenseHandler(workInProgress);
-      popHiddenContext(workInProgress);
-      popTransition(workInProgress, current);
-      var _flags3 = workInProgress.flags;
+          var nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+          // Note that on initial mount, previousCache and nextCache will be the same
+          // and this retain won't occur. To counter this, we instead retain the HostRoot's
+          // initial cache when creating the root itself (see createFiberRoot() in
+          // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+          // here, such that previous/next caches are retained correctly.
 
-      if (_flags3 & ShouldCapture) {
-        workInProgress.flags = (_flags3 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+          if (nextCache !== previousCache) {
+            retainCache(nextCache);
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
+            if (previousCache != null) {
+              releaseCache(previousCache);
+            }
+          }
         }
 
-        return workInProgress;
-      }
+        if (enableTransitionTracing) {
+          // Get the transitions that were initiatized during the render
+          // and add a start transition callback for each of them
+          var root = finishedWork.stateNode;
+          var incompleteTransitions = root.incompleteTransitions; // Initial render
 
-      return null;
-    }
+          if (committedTransitions !== null) {
+            committedTransitions.forEach(function (transition) {
+              addTransitionStartCallbackToPendingTransition(transition);
+            });
+            clearTransitionsForLanes(finishedRoot, committedLanes);
+          }
 
-    case CacheComponent:
-      {
-        popCacheProvider(workInProgress);
-      }
+          incompleteTransitions.forEach(function (markerInstance, transition) {
+            var pendingBoundaries = markerInstance.pendingBoundaries;
 
-      return null;
+            if (pendingBoundaries === null || pendingBoundaries.size === 0) {
+              if (markerInstance.aborts === null) {
+                addTransitionCompleteCallbackToPendingTransition(transition);
+              }
 
-    case TracingMarkerComponent:
-      if (enableTransitionTracing) {
-        if (workInProgress.stateNode !== null) {
-          popMarkerInstance(workInProgress);
+              incompleteTransitions.delete(transition);
+            }
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
         }
       }
 
-      return null;
-
-    default:
-      return null;
-  }
-}
-
-function unwindInterruptedWork(current, interruptedWork, renderLanes) {
-  // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
-  popTreeContext(interruptedWork);
+      break;
+    }
 
-  switch (interruptedWork.tag) {
-    case ClassComponent: {
-      var childContextTypes = interruptedWork.type.childContextTypes;
+    case LegacyHiddenComponent: {
+      {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
 
-      if (childContextTypes !== null && childContextTypes !== undefined) {
-        popContext(interruptedWork);
+        if (flags & Passive$1) {
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+        }
       }
 
       break;
     }
 
-    case HostRoot: {
-      {
-        popCacheProvider(interruptedWork);
+    case OffscreenComponent: {
+      // TODO: Pass `current` as argument to this function
+      var _instance3 = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
+
+      if (isHidden) {
+        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          );
+        } else {
+          if (finishedWork.mode & ConcurrentMode) {
+            // The effects are currently disconnected. Since the tree is hidden,
+            // don't connect them. This also applies to the initial render.
+            {
+              // "Atomic" effects are ones that need to fire on every commit,
+              // even during pre-rendering. An example is updating the reference
+              // count on cache instances.
+              recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              );
+            }
+          } else {
+            // Legacy Mode: Fire the effects even if the tree is hidden.
+            _instance3._visibility |= OffscreenPassiveEffectsConnected;
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+          }
+        }
+      } else {
+        // Tree is visible
+        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          );
+        } else {
+          // The effects are currently disconnected. Reconnect them, while also
+          // firing effects inside newly mounted trees. This also applies to
+          // the initial render.
+          _instance3._visibility |= OffscreenPassiveEffectsConnected;
+          var includeWorkInProgressEffects =
+            (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+        }
       }
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(interruptedWork);
+      if (flags & Passive$1) {
+        var _current = finishedWork.alternate;
+        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
       }
 
-      popRootTransition(interruptedWork);
-      popHostContainer(interruptedWork);
-      popTopLevelContextObject(interruptedWork);
-      resetWorkInProgressVersions();
-      break;
-    }
-
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      popHostContext(interruptedWork);
       break;
     }
 
-    case HostPortal:
-      popHostContainer(interruptedWork);
-      break;
-
-    case SuspenseComponent:
-      popSuspenseHandler(interruptedWork);
-      break;
-
-    case SuspenseListComponent:
-      popSuspenseListContext(interruptedWork);
-      break;
-
-    case ContextProvider:
-      var context = interruptedWork.type._context;
-      popProvider(context, interruptedWork);
-      break;
-
-    case OffscreenComponent:
-    case LegacyHiddenComponent:
-      popSuspenseHandler(interruptedWork);
-      popHiddenContext(interruptedWork);
-      popTransition(interruptedWork, current);
-      break;
+    case CacheComponent: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-    case CacheComponent:
-      {
-        popCacheProvider(interruptedWork);
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current2 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current2, finishedWork);
       }
 
       break;
+    }
 
-    case TracingMarkerComponent:
+    case TracingMarkerComponent: {
       if (enableTransitionTracing) {
-        var instance = interruptedWork.stateNode;
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
 
-        if (instance !== null) {
-          popMarkerInstance(interruptedWork);
+        if (flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
         }
-      }
 
+        break;
+      } // Intentional fallthrough to next branch
+    }
+    // eslint-disable-next-line-no-fallthrough
+
+    default: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
       break;
+    }
   }
 }
 
-var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
-
-{
-  didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
-} // Used during the commit phase to track the state of the Offscreen component stack.
-// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
-
-var offscreenSubtreeIsHidden = false;
-var offscreenSubtreeWasHidden = false;
-var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
-var nextEffect = null; // Used for Profiling builds to track updaters.
-
-var inProgressLanes = null;
-var inProgressRoot = null;
+function recursivelyTraverseReconnectPassiveEffects(
+  finishedRoot,
+  parentFiber,
+  committedLanes,
+  committedTransitions,
+  includeWorkInProgressEffects
+) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  var childShouldIncludeWorkInProgressEffects =
+    includeWorkInProgressEffects &&
+    (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
 
-function shouldProfile(current) {
-  return (
-    (current.mode & ProfileMode) !== NoMode &&
-    (getExecutionContext() & CommitContext) !== NoContext
-  );
-}
+  var prevDebugFiber = getCurrentFiber();
+  var child = parentFiber.child;
 
-function reportUncaughtErrorInDEV(error) {
-  // Wrapping each small part of the commit phase into a guarded
-  // callback is a bit too slow (https://github.com/facebook/react/pull/21666).
-  // But we rely on it to surface errors to DEV tools like overlays
-  // (https://github.com/facebook/react/issues/21712).
-  // As a compromise, rethrow only caught errors in a guard.
-  {
-    invokeGuardedCallback(null, function () {
-      throw error;
-    });
-    clearCaughtError();
+  while (child !== null) {
+    reconnectPassiveEffects(
+      finishedRoot,
+      child,
+      committedLanes,
+      committedTransitions,
+      childShouldIncludeWorkInProgressEffects
+    );
+    child = child.sibling;
   }
-}
-
-function callComponentWillUnmountWithTimer(current, instance) {
-  instance.props = current.memoizedProps;
-  instance.state = current.memoizedState;
 
-  if (shouldProfile(current)) {
-    try {
-      startLayoutEffectTimer();
-      instance.componentWillUnmount();
-    } finally {
-      recordLayoutEffectDuration(current);
-    }
-  } else {
-    instance.componentWillUnmount();
-  }
-} // Capture errors so they don't interrupt unmounting.
+  setCurrentFiber(prevDebugFiber);
+}
 
-function safelyCallComponentWillUnmount(
-  current,
-  nearestMountedAncestor,
-  instance
+function reconnectPassiveEffects(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions, // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  includeWorkInProgressEffects
 ) {
-  try {
-    callComponentWillUnmountWithTimer(current, instance);
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
-  }
-} // Capture errors so they don't interrupt mounting.
-
-function safelyAttachRef(current, nearestMountedAncestor) {
-  try {
-    commitAttachRef(current);
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
-  }
-}
+  var flags = finishedWork.flags;
 
-function safelyDetachRef(current, nearestMountedAncestor) {
-  var ref = current.ref;
-  var refCleanup = current.refCleanup;
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      ); // TODO: Check for PassiveStatic flag
 
-  if (ref !== null) {
-    if (typeof refCleanup === "function") {
-      try {
-        if (shouldProfile(current)) {
-          try {
-            startLayoutEffectTimer();
-            refCleanup();
-          } finally {
-            recordLayoutEffectDuration(current);
-          }
-        } else {
-          refCleanup();
-        }
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      } finally {
-        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
-        current.refCleanup = null;
-        var finishedWork = current.alternate;
+      commitHookPassiveMountEffects(finishedWork, Passive);
+      break;
+    }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
 
-        if (finishedWork != null) {
-          finishedWork.refCleanup = null;
-        }
-      }
-    } else if (typeof ref === "function") {
-      var retVal;
+    case LegacyHiddenComponent: {
+      {
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
 
-      try {
-        if (shouldProfile(current)) {
-          try {
-            startLayoutEffectTimer();
-            retVal = ref(null);
-          } finally {
-            recordLayoutEffectDuration(current);
-          }
-        } else {
-          retVal = ref(null);
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
         }
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
       }
 
-      {
-        if (typeof retVal === "function") {
-          error(
-            "Unexpected return value from a callback ref in %s. " +
-              "A callback ref should not return a function.",
-            getComponentNameFromFiber(current)
-          );
-        }
-      }
-    } else {
-      // $FlowFixMe unable to narrow type to RefObject
-      ref.current = null;
+      break;
     }
-  }
-}
-
-function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
-  try {
-    destroy();
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
-  }
-}
-
-var focusedInstanceHandle = null;
-var shouldFireAfterActiveInstanceBlur = false;
-function commitBeforeMutationEffects(root, firstChild) {
-  focusedInstanceHandle = prepareForCommit();
-  nextEffect = firstChild;
-  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
-
-  var shouldFire = shouldFireAfterActiveInstanceBlur;
-  shouldFireAfterActiveInstanceBlur = false;
-  focusedInstanceHandle = null;
-  return shouldFire;
-}
-
-function commitBeforeMutationEffects_begin() {
-  while (nextEffect !== null) {
-    var fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
-    // Let's skip the whole loop if it's off.
 
-    {
-      // TODO: Should wrap this in flags check, too, as optimization
-      var deletions = fiber.deletions;
+    case OffscreenComponent: {
+      var _instance4 = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
 
-      if (deletions !== null) {
-        for (var i = 0; i < deletions.length; i++) {
-          var deletion = deletions[i];
-          commitBeforeMutationEffectsDeletion(deletion);
+      if (isHidden) {
+        if (_instance4._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+        } else {
+          if (finishedWork.mode & ConcurrentMode) {
+            // The effects are currently disconnected. Since the tree is hidden,
+            // don't connect them. This also applies to the initial render.
+            {
+              // "Atomic" effects are ones that need to fire on every commit,
+              // even during pre-rendering. An example is updating the reference
+              // count on cache instances.
+              recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              );
+            }
+          } else {
+            // Legacy Mode: Fire the effects even if the tree is hidden.
+            _instance4._visibility |= OffscreenPassiveEffectsConnected;
+            recursivelyTraverseReconnectPassiveEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions,
+              includeWorkInProgressEffects
+            );
+          }
         }
+      } else {
+        // Tree is visible
+        // Since we're already inside a reconnecting tree, it doesn't matter
+        // whether the effects are currently connected. In either case, we'll
+        // continue traversing the tree and firing all the effects.
+        //
+        // We do need to set the "connected" flag on the instance, though.
+        _instance4._visibility |= OffscreenPassiveEffectsConnected;
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
       }
-    }
-
-    var child = fiber.child;
-
-    if (
-      (fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 &&
-      child !== null
-    ) {
-      child.return = fiber;
-      nextEffect = child;
-    } else {
-      commitBeforeMutationEffects_complete();
-    }
-  }
-}
-
-function commitBeforeMutationEffects_complete() {
-  while (nextEffect !== null) {
-    var fiber = nextEffect;
-    setCurrentFiber(fiber);
-
-    try {
-      commitBeforeMutationEffectsOnFiber(fiber);
-    } catch (error) {
-      captureCommitPhaseError(fiber, fiber.return, error);
-    }
 
-    resetCurrentFiber();
-    var sibling = fiber.sibling;
+      if (includeWorkInProgressEffects && flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current3 = finishedWork.alternate;
+        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
+      }
 
-    if (sibling !== null) {
-      sibling.return = fiber.return;
-      nextEffect = sibling;
-      return;
+      break;
     }
 
-    nextEffect = fiber.return;
-  }
-}
-
-function commitBeforeMutationEffectsOnFiber(finishedWork) {
-  var current = finishedWork.alternate;
-  var flags = finishedWork.flags;
+    case CacheComponent: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      );
 
-  {
-    if (!shouldFireAfterActiveInstanceBlur && focusedInstanceHandle !== null) {
-      // Check to see if the focused element was inside of a hidden (Suspense) subtree.
-      // TODO: Move this out of the hot path using a dedicated effect tag.
-      if (
-        finishedWork.tag === SuspenseComponent &&
-        isSuspenseBoundaryBeingHidden(current, finishedWork) && // $FlowFixMe[incompatible-call] found when upgrading Flow
-        doesFiberContain(finishedWork, focusedInstanceHandle)
-      ) {
-        shouldFireAfterActiveInstanceBlur = true;
-        beforeActiveInstanceBlur(finishedWork);
+      if (includeWorkInProgressEffects && flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current4 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current4, finishedWork);
       }
+
+      break;
     }
-  }
 
-  if ((flags & Snapshot) !== NoFlags$1) {
-    setCurrentFiber(finishedWork);
-  }
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
 
-  switch (finishedWork.tag) {
-    case FunctionComponent: {
-      {
-        if ((flags & Update) !== NoFlags$1) {
-          commitUseEffectEventMount(finishedWork);
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
         }
-      }
 
-      break;
+        break;
+      } // Intentional fallthrough to next branch
     }
+    // eslint-disable-next-line-no-fallthrough
 
-    case ForwardRef:
-    case SimpleMemoComponent: {
+    default: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      );
       break;
     }
+  }
+}
 
-    case ClassComponent: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        if (current !== null) {
-          var prevProps = current.memoizedProps;
-          var prevState = current.memoizedState;
-          var instance = finishedWork.stateNode; // We could update instance props and state here,
-          // but instead we rely on them being set during last render.
-          // TODO: revisit this when we implement resuming.
-
-          {
-            if (
-              finishedWork.type === finishedWork.elementType &&
-              !didWarnAboutReassigningProps
-            ) {
-              if (instance.props !== finishedWork.memoizedProps) {
-                error(
-                  "Expected %s props to match memoized props before " +
-                    "getSnapshotBeforeUpdate. " +
-                    "This might either be because of a bug in React, or because " +
-                    "a component reassigns its own `this.props`. " +
-                    "Please file an issue.",
-                  getComponentNameFromFiber(finishedWork) || "instance"
-                );
-              }
-
-              if (instance.state !== finishedWork.memoizedState) {
-                error(
-                  "Expected %s state to match memoized state before " +
-                    "getSnapshotBeforeUpdate. " +
-                    "This might either be because of a bug in React, or because " +
-                    "a component reassigns its own `this.state`. " +
-                    "Please file an issue.",
-                  getComponentNameFromFiber(finishedWork) || "instance"
-                );
-              }
-            }
-          }
+function recursivelyTraverseAtomicPassiveEffects(
+  finishedRoot,
+  parentFiber,
+  committedLanes,
+  committedTransitions
+) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  var prevDebugFiber = getCurrentFiber(); // TODO: Add special flag for atomic effects
 
-          var snapshot = instance.getSnapshotBeforeUpdate(
-            finishedWork.elementType === finishedWork.type
-              ? prevProps
-              : resolveDefaultProps(finishedWork.type, prevProps),
-            prevState
-          );
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-          {
-            var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
+    }
+  }
 
-            if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
-              didWarnSet.add(finishedWork.type);
+  setCurrentFiber(prevDebugFiber);
+}
 
-              error(
-                "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
-                  "must be returned. You have returned undefined.",
-                getComponentNameFromFiber(finishedWork)
-              );
-            }
-          }
+function commitAtomicPassiveEffects(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions
+) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  var flags = finishedWork.flags;
 
-          instance.__reactInternalSnapshotBeforeUpdate = snapshot;
-        }
+  switch (finishedWork.tag) {
+    case OffscreenComponent: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var current = finishedWork.alternate;
+        var instance = finishedWork.stateNode;
+        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
       }
 
       break;
     }
 
-    case HostRoot: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        {
-          var root = finishedWork.stateNode;
-          clearContainer(root.containerInfo);
-        }
+    case CacheComponent: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current5 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current5, finishedWork);
       }
 
       break;
     }
-
-    case HostComponent:
-    case HostHoistable:
-    case HostSingleton:
-    case HostText:
-    case HostPortal:
-    case IncompleteClassComponent:
-      // Nothing to do for these component types
-      break;
+    // eslint-disable-next-line-no-fallthrough
 
     default: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        throw new Error(
-          "This unit of work tag should not have side-effects. This error is " +
-            "likely caused by a bug in React. Please file an issue."
-        );
-      }
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+      break;
     }
   }
+}
 
-  if ((flags & Snapshot) !== NoFlags$1) {
-    resetCurrentFiber();
-  }
+function commitPassiveUnmountEffects(finishedWork) {
+  setCurrentFiber(finishedWork);
+  commitPassiveUnmountOnFiber(finishedWork);
+  resetCurrentFiber();
 }
 
-function commitBeforeMutationEffectsDeletion(deletion) {
-  {
-    // TODO (effects) It would be nice to avoid calling doesFiberContain()
-    // Maybe we can repurpose one of the subtreeFlags positions for this instead?
-    // Use it to store which part of the tree the focused instance is in?
-    // This assumes we can safely determine that instance during the "render" phase.
-    if (doesFiberContain(deletion, focusedInstanceHandle)) {
-      shouldFireAfterActiveInstanceBlur = true;
-      beforeActiveInstanceBlur(deletion);
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  var previousFiber = parentFiber.alternate;
+
+  if (previousFiber !== null) {
+    var detachedChild = previousFiber.child;
+
+    if (detachedChild !== null) {
+      previousFiber.child = null;
+
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        var detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
     }
   }
 }
 
-function commitHookEffectListUnmount(
-  flags,
+function commitHookPassiveUnmountEffects(
   finishedWork,
-  nearestMountedAncestor
+  nearestMountedAncestor,
+  hookFlags
 ) {
-  var updateQueue = finishedWork.updateQueue;
-  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
-
-  if (lastEffect !== null) {
-    var firstEffect = lastEffect.next;
-    var effect = firstEffect;
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+  }
+}
 
-    do {
-      if ((effect.tag & flags) === flags) {
-        // Unmount
-        var destroy = effect.destroy;
-        effect.destroy = undefined;
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  var deletions = parentFiber.deletions;
 
-        if (destroy !== undefined) {
-          if (enableSchedulingProfiler) {
-            if ((flags & Passive) !== NoFlags) {
-              markComponentPassiveEffectUnmountStarted(finishedWork);
-            } else if ((flags & Layout) !== NoFlags) {
-              markComponentLayoutEffectUnmountStarted(finishedWork);
-            }
-          }
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
 
-          {
-            if ((flags & Insertion) !== NoFlags) {
-              setIsRunningInsertionEffect(true);
-            }
-          }
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
+    }
 
-          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+    detachAlternateSiblings(parentFiber);
+  }
 
-          {
-            if ((flags & Insertion) !== NoFlags) {
-              setIsRunningInsertionEffect(false);
-            }
-          }
+  var prevDebugFiber = getCurrentFiber(); // TODO: Split PassiveMask into separate masks for mount and unmount?
 
-          if (enableSchedulingProfiler) {
-            if ((flags & Passive) !== NoFlags) {
-              markComponentPassiveEffectUnmountStopped();
-            } else if ((flags & Layout) !== NoFlags) {
-              markComponentLayoutEffectUnmountStopped();
-            }
-          }
-        }
-      }
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-      effect = effect.next;
-    } while (effect !== firstEffect);
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
+    }
   }
+
+  setCurrentFiber(prevDebugFiber);
 }
 
-function commitHookEffectListMount(flags, finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
 
-  if (lastEffect !== null) {
-    var firstEffect = lastEffect.next;
-    var effect = firstEffect;
+      if (finishedWork.flags & Passive$1) {
+        commitHookPassiveUnmountEffects(
+          finishedWork,
+          finishedWork.return,
+          Passive | HasEffect
+        );
+      }
 
-    do {
-      if ((effect.tag & flags) === flags) {
-        if (enableSchedulingProfiler) {
-          if ((flags & Passive) !== NoFlags) {
-            markComponentPassiveEffectMountStarted(finishedWork);
-          } else if ((flags & Layout) !== NoFlags) {
-            markComponentLayoutEffectMountStarted(finishedWork);
-          }
-        } // Mount
+      break;
+    }
 
-        var create = effect.create;
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
 
-        {
-          if ((flags & Insertion) !== NoFlags) {
-            setIsRunningInsertionEffect(true);
-          }
-        }
+      if (
+        isHidden &&
+        instance._visibility & OffscreenPassiveEffectsConnected && // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        (finishedWork.return === null ||
+          finishedWork.return.tag !== SuspenseComponent)
+      ) {
+        // The effects are currently connected. Disconnect them.
+        // TODO: Add option or heuristic to delay before disconnecting the
+        // effects. Then if the tree reappears before the delay has elapsed, we
+        // can skip toggling the effects entirely.
+        instance._visibility &= ~OffscreenPassiveEffectsConnected;
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      } else {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+      }
 
-        effect.destroy = create();
+      break;
+    }
 
-        {
-          if ((flags & Insertion) !== NoFlags) {
-            setIsRunningInsertionEffect(false);
-          }
-        }
+    default: {
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
+      break;
+    }
+  }
+}
 
-        if (enableSchedulingProfiler) {
-          if ((flags & Passive) !== NoFlags) {
-            markComponentPassiveEffectMountStopped();
-          } else if ((flags & Layout) !== NoFlags) {
-            markComponentLayoutEffectMountStopped();
-          }
-        }
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  var deletions = parentFiber.deletions;
 
-        {
-          var destroy = effect.destroy;
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
 
-          if (destroy !== undefined && typeof destroy !== "function") {
-            var hookName = void 0;
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
+    }
 
-            if ((effect.tag & Layout) !== NoFlags$1) {
-              hookName = "useLayoutEffect";
-            } else if ((effect.tag & Insertion) !== NoFlags$1) {
-              hookName = "useInsertionEffect";
-            } else {
-              hookName = "useEffect";
-            }
+    detachAlternateSiblings(parentFiber);
+  }
 
-            var addendum = void 0;
+  var prevDebugFiber = getCurrentFiber(); // TODO: Check PassiveStatic flag
 
-            if (destroy === null) {
-              addendum =
-                " You returned null. If your effect does not require clean " +
-                "up, return undefined (or nothing).";
-            } else if (typeof destroy.then === "function") {
-              addendum =
-                "\n\nIt looks like you wrote " +
-                hookName +
-                "(async () => ...) or returned a Promise. " +
-                "Instead, write the async function inside your effect " +
-                "and call it immediately:\n\n" +
-                hookName +
-                "(() => {\n" +
-                "  async function fetchData() {\n" +
-                "    // You can await here\n" +
-                "    const response = await MyAPI.getData(someId);\n" +
-                "    // ...\n" +
-                "  }\n" +
-                "  fetchData();\n" +
-                "}, [someId]); // Or [] if effect doesn't need props or state\n\n" +
-                "Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching";
-            } else {
-              addendum = " You returned: " + destroy;
-            }
+  var child = parentFiber.child;
 
-            error(
-              "%s must not return anything besides a function, " +
-                "which is used for clean-up.%s",
-              hookName,
-              addendum
-            );
-          }
-        }
+  while (child !== null) {
+    setCurrentFiber(child);
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
+
+  setCurrentFiber(prevDebugFiber);
+}
+
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      // TODO: Check PassiveStatic flag
+      commitHookPassiveUnmountEffects(
+        finishedWork,
+        finishedWork.return,
+        Passive
+      ); // When disconnecting passive effects, we fire the effects in the same
+      // order as during a deletiong: parent before child
+
+      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      break;
+    }
+
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
+
+      if (instance._visibility & OffscreenPassiveEffectsConnected) {
+        instance._visibility &= ~OffscreenPassiveEffectsConnected;
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
       }
 
-      effect = effect.next;
-    } while (effect !== firstEffect);
+      break;
+    }
+
+    default: {
+      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      break;
+    }
   }
 }
 
-function commitUseEffectEventMount(finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  var eventPayloads = updateQueue !== null ? updateQueue.events : null;
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+  deletedSubtreeRoot,
+  nearestMountedAncestor
+) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect; // Deletion effects fire in parent -> child order
+    // TODO: Check if fiber has a PassiveStatic flag
 
-  if (eventPayloads !== null) {
-    for (var ii = 0; ii < eventPayloads.length; ii++) {
-      var _eventPayloads$ii = eventPayloads[ii],
-        ref = _eventPayloads$ii.ref,
-        nextImpl = _eventPayloads$ii.nextImpl;
-      ref.impl = nextImpl;
+    setCurrentFiber(fiber);
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    resetCurrentFiber();
+    var child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
+        deletedSubtreeRoot
+      );
     }
   }
 }
 
-function commitPassiveEffectDurations(finishedRoot, finishedWork) {
-  if (getExecutionContext() & CommitContext) {
-    // Only Profilers with work in their subtree will have an Update effect scheduled.
-    if ((finishedWork.flags & Update) !== NoFlags$1) {
-      switch (finishedWork.tag) {
-        case Profiler: {
-          var passiveEffectDuration =
-            finishedWork.stateNode.passiveEffectDuration;
-          var _finishedWork$memoize = finishedWork.memoizedProps,
-            id = _finishedWork$memoize.id,
-            onPostCommit = _finishedWork$memoize.onPostCommit; // This value will still reflect the previous commit phase.
-          // It does not get reset until the start of the next commit phase.
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
+  deletedSubtreeRoot
+) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    var sibling = fiber.sibling;
+    var returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
 
-          var commitTime = getCommitTime();
-          var phase = finishedWork.alternate === null ? "mount" : "update";
+    detachFiberAfterEffects(fiber);
 
-          {
-            if (isCurrentUpdateNested()) {
-              phase = "nested-update";
-            }
-          }
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
+    }
 
-          if (typeof onPostCommit === "function") {
-            onPostCommit(id, phase, passiveEffectDuration, commitTime);
-          } // Bubble times to the next nearest ancestor Profiler.
-          // After we process that Profiler, we'll bubble further up.
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
+    }
 
-          var parentFiber = finishedWork.return;
+    nextEffect = returnFiber;
+  }
+}
 
-          outer: while (parentFiber !== null) {
-            switch (parentFiber.tag) {
-              case HostRoot:
-                var root = parentFiber.stateNode;
-                root.passiveEffectDuration += passiveEffectDuration;
-                break outer;
+function commitPassiveUnmountInsideDeletedTreeOnFiber(
+  current,
+  nearestMountedAncestor
+) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+      break;
+    }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
 
-              case Profiler:
-                var parentStateNode = parentFiber.stateNode;
-                parentStateNode.passiveEffectDuration += passiveEffectDuration;
-                break outer;
-            }
+    case LegacyHiddenComponent:
+    case OffscreenComponent: {
+      {
+        if (
+          current.memoizedState !== null &&
+          current.memoizedState.cachePool !== null
+        ) {
+          var cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+          // Note that this is only reached in the non-suspended/visible case:
+          // when the content is suspended/hidden, the retain/release occurs
+          // via the parent Suspense component (see case above).
 
-            parentFiber = parentFiber.return;
+          if (cache != null) {
+            retainCache(cache);
           }
-
-          break;
         }
       }
-    }
-  }
-}
 
-function commitHookLayoutEffects(finishedWork, hookFlags) {
-  // At this point layout effects have already been destroyed (during mutation phase).
-  // This is done to prevent sibling component effects from interfering with each other,
-  // e.g. a destroy function in one component should never override a ref set
-  // by a create function in another component during the same commit.
-  if (shouldProfile(finishedWork)) {
-    try {
-      startLayoutEffectTimer();
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      break;
     }
 
-    recordLayoutEffectDuration(finishedWork);
-  } else {
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
-  }
-}
+    case SuspenseComponent: {
+      if (enableTransitionTracing) {
+        // We need to mark this fiber's parents as deleted
+        var offscreenFiber = current.child;
+        var instance = offscreenFiber.stateNode;
+        var transitions = instance._transitions;
 
-function commitClassLayoutLifecycles(finishedWork, current) {
-  var instance = finishedWork.stateNode;
+        if (transitions !== null) {
+          var abortReason = {
+            reason: "suspense",
+            name: current.memoizedProps.unstable_name || null
+          };
 
-  if (current === null) {
-    // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
-    {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "componentDidMount. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+          if (
+            current.memoizedState === null ||
+            current.memoizedState.dehydrated === null
+          ) {
+            abortParentMarkerTransitionsForDeletedFiber(
+              offscreenFiber,
+              abortReason,
+              transitions,
+              instance,
+              true
+            );
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "componentDidMount. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
+            if (nearestMountedAncestor !== null) {
+              abortParentMarkerTransitionsForDeletedFiber(
+                nearestMountedAncestor,
+                abortReason,
+                transitions,
+                instance,
+                false
+              );
+            }
+          }
         }
       }
+
+      break;
     }
 
-    if (shouldProfile(finishedWork)) {
-      try {
-        startLayoutEffectTimer();
-        instance.componentDidMount();
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    case CacheComponent: {
+      {
+        var _cache = current.memoizedState.cache;
+        releaseCache(_cache);
       }
 
-      recordLayoutEffectDuration(finishedWork);
-    } else {
-      try {
-        instance.componentDidMount();
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
+      break;
     }
-  } else {
-    var prevProps =
-      finishedWork.elementType === finishedWork.type
-        ? current.memoizedProps
-        : resolveDefaultProps(finishedWork.type, current.memoizedProps);
-    var prevState = current.memoizedState; // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
 
-    {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "componentDidUpdate. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        // We need to mark this fiber's parents as deleted
+        var _instance5 = current.stateNode;
+        var _transitions = _instance5.transitions;
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "componentDidUpdate. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
+        if (_transitions !== null) {
+          var _abortReason = {
+            reason: "marker",
+            name: current.memoizedProps.name
+          };
+          abortParentMarkerTransitionsForDeletedFiber(
+            current,
+            _abortReason,
+            _transitions,
+            null,
+            true
           );
-        }
-      }
-    }
 
-    if (shouldProfile(finishedWork)) {
-      try {
-        startLayoutEffectTimer();
-        instance.componentDidUpdate(
-          prevProps,
-          prevState,
-          instance.__reactInternalSnapshotBeforeUpdate
-        );
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          if (nearestMountedAncestor !== null) {
+            abortParentMarkerTransitionsForDeletedFiber(
+              nearestMountedAncestor,
+              _abortReason,
+              _transitions,
+              null,
+              false
+            );
+          }
+        }
       }
 
-      recordLayoutEffectDuration(finishedWork);
-    } else {
-      try {
-        instance.componentDidUpdate(
-          prevProps,
-          prevState,
-          instance.__reactInternalSnapshotBeforeUpdate
-        );
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
+      break;
     }
   }
 }
 
-function commitClassCallbacks(finishedWork) {
-  // TODO: I think this is now always non-null by the time it reaches the
-  // commit phase. Consider removing the type check.
-  var updateQueue = finishedWork.updateQueue;
+function invokeLayoutEffectMountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListMount(Layout | HasEffect, fiber);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-  if (updateQueue !== null) {
-    var instance = finishedWork.stateNode;
+        break;
+      }
 
-    {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "processing the update queue. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+      case ClassComponent: {
+        var instance = fiber.stateNode;
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "processing the update queue. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
+        try {
+          instance.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
         }
-      }
-    } // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
 
-    try {
-      commitCallbacks(updateQueue, instance);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        break;
+      }
     }
   }
 }
 
-function commitHostComponentMount(finishedWork) {
-  var type = finishedWork.type;
-  var props = finishedWork.memoizedProps;
-  var instance = finishedWork.stateNode;
+function invokePassiveEffectMountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListMount(Passive | HasEffect, fiber);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-  try {
-    commitMount(instance, type, props, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        break;
+      }
+    }
   }
 }
 
-function commitProfilerUpdate(finishedWork, current) {
-  if (getExecutionContext() & CommitContext) {
-    try {
-      var _finishedWork$memoize2 = finishedWork.memoizedProps,
-        onCommit = _finishedWork$memoize2.onCommit,
-        onRender = _finishedWork$memoize2.onRender;
-      var effectDuration = finishedWork.stateNode.effectDuration;
-      var commitTime = getCommitTime();
-      var phase = current === null ? "mount" : "update";
-
-      if (enableProfilerNestedUpdatePhase) {
-        if (isCurrentUpdateNested()) {
-          phase = "nested-update";
+function invokeLayoutEffectUnmountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
         }
-      }
 
-      if (typeof onRender === "function") {
-        onRender(
-          finishedWork.memoizedProps.id,
-          phase,
-          finishedWork.actualDuration,
-          finishedWork.treeBaseDuration,
-          finishedWork.actualStartTime,
-          commitTime
-        );
+        break;
       }
 
-      if (enableProfilerCommitHooks) {
-        if (typeof onCommit === "function") {
-          onCommit(
-            finishedWork.memoizedProps.id,
-            phase,
-            effectDuration,
-            commitTime
-          );
-        } // Schedule a passive effect for this Profiler to call onPostCommit hooks.
-        // This effect should be scheduled even if there is no onPostCommit callback for this Profiler,
-        // because the effect is also where times bubble to parent Profilers.
-
-        enqueuePendingPassiveProfilerEffect(finishedWork); // Propagate layout effect durations to the next nearest Profiler ancestor.
-        // Do not reset these values until the next render so DevTools has a chance to read them first.
-
-        var parentFiber = finishedWork.return;
+      case ClassComponent: {
+        var instance = fiber.stateNode;
 
-        outer: while (parentFiber !== null) {
-          switch (parentFiber.tag) {
-            case HostRoot:
-              var root = parentFiber.stateNode;
-              root.effectDuration += effectDuration;
-              break outer;
+        if (typeof instance.componentWillUnmount === "function") {
+          safelyCallComponentWillUnmount(fiber, fiber.return, instance);
+        }
 
-            case Profiler:
-              var parentStateNode = parentFiber.stateNode;
-              parentStateNode.effectDuration += effectDuration;
-              break outer;
-          }
+        break;
+      }
+    }
+  }
+}
 
-          parentFiber = parentFiber.return;
+function invokePassiveEffectUnmountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
         }
       }
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
   }
 }
 
-function commitLayoutEffectOnFiber(
-  finishedRoot,
-  current,
-  finishedWork,
-  committedLanes
-) {
-  // When updating this function, also update reappearLayoutEffects, which does
-  // most of the same things when an offscreen tree goes from hidden -> visible.
-  var flags = finishedWork.flags;
+function getCacheSignal() {
+  var cache = readContext(CacheContext);
+  return cache.controller.signal;
+}
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+function getCacheForType(resourceType) {
+  var cache = readContext(CacheContext);
+  var cacheForType = cache.data.get(resourceType);
 
-      if (flags & Update) {
-        commitHookLayoutEffects(finishedWork, Layout | HasEffect);
-      }
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
+  }
 
-      break;
+  return cacheForType;
+}
+
+var DefaultCacheDispatcher = {
+  getCacheSignal: getCacheSignal,
+  getCacheForType: getCacheForType
+};
+
+if (typeof Symbol === "function" && Symbol.for) {
+  var symbolFor = Symbol.for;
+  symbolFor("selector.component");
+  symbolFor("selector.has_pseudo_class");
+  symbolFor("selector.role");
+  symbolFor("selector.test_id");
+  symbolFor("selector.text");
+}
+var commitHooks = [];
+function onCommitRoot() {
+  {
+    commitHooks.forEach(function (commitHook) {
+      return commitHook();
+    });
+  }
+}
+
+var ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;
+function isLegacyActEnvironment(fiber) {
+  {
+    // Legacy mode. We preserve the behavior of React 17's act. It assumes an
+    // act environment whenever `jest` is defined, but you can still turn off
+    // spurious warnings by setting IS_REACT_ACT_ENVIRONMENT explicitly
+    // to false.
+    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
+        ? IS_REACT_ACT_ENVIRONMENT
+        : undefined; // $FlowFixMe - Flow doesn't know about jest
+
+    var jestIsDefined = typeof jest !== "undefined";
+    return jestIsDefined && isReactActEnvironmentGlobal !== false;
+  }
+}
+function isConcurrentActEnvironment() {
+  {
+    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
+        ? IS_REACT_ACT_ENVIRONMENT
+        : undefined;
+
+    if (
+      !isReactActEnvironmentGlobal &&
+      ReactCurrentActQueue$1.current !== null
+    ) {
+      // TODO: Include link to relevant documentation page.
+      error(
+        "The current testing environment is not configured to support " +
+          "act(...)"
+      );
     }
 
-    case ClassComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    return isReactActEnvironmentGlobal;
+  }
+}
 
-      if (flags & Update) {
-        commitClassLayoutLifecycles(finishedWork, current);
-      }
+var postPaintCallbackScheduled = false;
+var callbacks = [];
+function schedulePostPaintCallback(callback) {
+  callbacks.push(callback);
 
-      if (flags & Callback) {
-        commitClassCallbacks(finishedWork);
+  if (!postPaintCallbackScheduled) {
+    postPaintCallbackScheduled = true;
+    requestPostPaintCallback(function (endTime) {
+      for (var i = 0; i < callbacks.length; i++) {
+        callbacks[i](endTime);
       }
 
-      if (flags & Ref) {
-        safelyAttachRef(finishedWork, finishedWork.return);
-      }
+      postPaintCallbackScheduled = false;
+      callbacks = [];
+    });
+  }
+}
 
-      break;
-    }
+var ceil = Math.ceil;
+var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+  ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+  ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+var NoContext =
+  /*             */
+  0;
+var BatchedContext =
+  /*               */
+  1;
+var RenderContext =
+  /*         */
+  2;
+var CommitContext =
+  /*         */
+  4;
+var RootInProgress = 0;
+var RootFatalErrored = 1;
+var RootErrored = 2;
+var RootSuspended = 3;
+var RootSuspendedWithDelay = 4;
+var RootCompleted = 5;
+var RootDidNotComplete = 6; // Describes where we are in the React execution stack
 
-    case HostRoot: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+var executionContext = NoContext; // The root we're working on
 
-      if (flags & Callback) {
-        // TODO: I think this is now always non-null by the time it reaches the
-        // commit phase. Consider removing the type check.
-        var updateQueue = finishedWork.updateQueue;
+var workInProgressRoot = null; // The fiber we're working on
 
-        if (updateQueue !== null) {
-          var instance = null;
+var workInProgress = null; // The lanes we're rendering
 
-          if (finishedWork.child !== null) {
-            switch (finishedWork.child.tag) {
-              case HostSingleton:
-              case HostComponent:
-                instance = getPublicInstance(finishedWork.child.stateNode);
-                break;
+var workInProgressRootRenderLanes = NoLanes;
+var NotSuspended = 0;
+var SuspendedOnError = 1;
+var SuspendedOnData = 2;
+var SuspendedOnImmediate = 3;
+var SuspendedOnDeprecatedThrowPromise = 4;
+var SuspendedAndReadyToContinue = 5;
+var SuspendedOnHydration = 6; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
 
-              case ClassComponent:
-                instance = finishedWork.child.stateNode;
-                break;
-            }
-          }
+var workInProgressSuspendedReason = NotSuspended;
+var workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
 
-          try {
-            commitCallbacks(updateQueue, instance);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
+var workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with renderLanes.
 
-      break;
-    }
+var renderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
 
-    case HostHoistable: {
-      {
-        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
 
-        if (flags & Ref) {
-          safelyAttachRef(finishedWork, finishedWork.return);
-        }
+var workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
 
-        break;
-      }
-    }
-    // eslint-disable-next-line-no-fallthrough
+var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
 
-    case HostSingleton:
-    case HostComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
-      // (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.
+var workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
 
-      if (current === null && flags & Update) {
-        commitHostComponentMount(finishedWork);
-      }
+var workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.
 
-      if (flags & Ref) {
-        safelyAttachRef(finishedWork, finishedWork.return);
-      }
+var workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
 
-      break;
-    }
+var workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train
+// model where we don't commit new loading states in too quick succession.
 
-    case Profiler: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
-      // fire when the tree becomes visible again.
+var globalMostRecentFallbackTime = 0;
+var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
 
-      if (flags & Update) {
-        commitProfilerUpdate(finishedWork, current);
-      }
+var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
 
-      break;
+var RENDER_TIMEOUT_MS = 500;
+var workInProgressTransitions = null;
+function getWorkInProgressTransitions() {
+  return workInProgressTransitions;
+}
+var currentPendingTransitionCallbacks = null;
+var currentEndTime = null;
+function addTransitionStartCallbackToPendingTransition(transition) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: [],
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
     }
 
-    case SuspenseComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-
-      if (flags & Update) {
-        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
-      }
+    if (currentPendingTransitionCallbacks.transitionStart === null) {
+      currentPendingTransitionCallbacks.transitionStart = [];
+    }
 
-      break;
+    currentPendingTransitionCallbacks.transitionStart.push(transition);
+  }
+}
+function addMarkerProgressCallbackToPendingTransition(
+  markerName,
+  transitions,
+  pendingBoundaries
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: new Map(),
+        markerIncomplete: null,
+        markerComplete: null
+      };
     }
 
-    case OffscreenComponent: {
-      var isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
+    if (currentPendingTransitionCallbacks.markerProgress === null) {
+      currentPendingTransitionCallbacks.markerProgress = new Map();
+    }
 
-      if (isModernRoot) {
-        var isHidden = finishedWork.memoizedState !== null;
-        var newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
+      pendingBoundaries: pendingBoundaries,
+      transitions: transitions
+    });
+  }
+}
+function addMarkerIncompleteCallbackToPendingTransition(
+  markerName,
+  transitions,
+  aborts
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: new Map(),
+        markerComplete: null
+      };
+    }
 
-        if (newOffscreenSubtreeIsHidden);
-        else {
-          // The Offscreen tree is visible.
-          var wasHidden = current !== null && current.memoizedState !== null;
-          var newOffscreenSubtreeWasHidden =
-            wasHidden || offscreenSubtreeWasHidden;
-          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
-          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-          offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+    if (currentPendingTransitionCallbacks.markerIncomplete === null) {
+      currentPendingTransitionCallbacks.markerIncomplete = new Map();
+    }
 
-          if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
-            // This is the root of a reappearing boundary. As we continue
-            // traversing the layout effects, we must also re-mount layout
-            // effects that were unmounted when the Offscreen subtree was
-            // hidden. So this is a superset of the normal commitLayoutEffects.
-            var includeWorkInProgressEffects =
-              (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
-            recursivelyTraverseReappearLayoutEffects(
-              finishedRoot,
-              finishedWork,
-              includeWorkInProgressEffects
-            );
-          } else {
-            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-          }
+    currentPendingTransitionCallbacks.markerIncomplete.set(markerName, {
+      transitions: transitions,
+      aborts: aborts
+    });
+  }
+}
+function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: new Map()
+      };
+    }
 
-          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-        }
-      } else {
-        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      }
+    if (currentPendingTransitionCallbacks.markerComplete === null) {
+      currentPendingTransitionCallbacks.markerComplete = new Map();
+    }
 
-      if (flags & Ref) {
-        var props = finishedWork.memoizedProps;
+    currentPendingTransitionCallbacks.markerComplete.set(
+      markerName,
+      transitions
+    );
+  }
+}
+function addTransitionProgressCallbackToPendingTransition(
+  transition,
+  boundaries
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: new Map(),
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
+    }
 
-        if (props.mode === "manual") {
-          safelyAttachRef(finishedWork, finishedWork.return);
-        } else {
-          safelyDetachRef(finishedWork, finishedWork.return);
-        }
-      }
+    if (currentPendingTransitionCallbacks.transitionProgress === null) {
+      currentPendingTransitionCallbacks.transitionProgress = new Map();
+    }
 
-      break;
+    currentPendingTransitionCallbacks.transitionProgress.set(
+      transition,
+      boundaries
+    );
+  }
+}
+function addTransitionCompleteCallbackToPendingTransition(transition) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: [],
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
     }
 
-    default: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      break;
+    if (currentPendingTransitionCallbacks.transitionComplete === null) {
+      currentPendingTransitionCallbacks.transitionComplete = [];
     }
+
+    currentPendingTransitionCallbacks.transitionComplete.push(transition);
   }
 }
 
-function abortRootTransitions(
-  root,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var rootTransitions = root.incompleteTransitions;
-    deletedTransitions.forEach(function (transition) {
-      if (rootTransitions.has(transition)) {
-        var transitionInstance = rootTransitions.get(transition);
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+}
 
-        if (transitionInstance.aborts === null) {
-          transitionInstance.aborts = [];
-        }
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+var hasUncaughtError = false;
+var firstUncaughtError = null;
+var legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+// to track which root is currently committing layout effects.
 
-        transitionInstance.aborts.push(abort);
+var rootCommittingMutationOrLayoutEffects = null;
+var rootDoesHavePassiveEffects = false;
+var rootWithPendingPassiveEffects = null;
+var pendingPassiveEffectsLanes = NoLanes;
+var pendingPassiveProfilerEffects = [];
+var pendingPassiveEffectsRemainingLanes = NoLanes;
+var pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
 
-        if (deletedOffscreenInstance !== null) {
-          if (
-            transitionInstance.pendingBoundaries !== null &&
-            transitionInstance.pendingBoundaries.has(deletedOffscreenInstance)
-          ) {
-            // $FlowFixMe[incompatible-use] found when upgrading Flow
-            transitionInstance.pendingBoundaries.delete(
-              deletedOffscreenInstance
-            );
-          }
-        }
-      }
-    });
-  }
+var NESTED_UPDATE_LIMIT = 50;
+var nestedUpdateCount = 0;
+var rootWithNestedUpdates = null;
+var isFlushingPassiveEffects = false;
+var didScheduleUpdateDuringPassiveEffects = false;
+var NESTED_PASSIVE_UPDATE_LIMIT = 50;
+var nestedPassiveUpdateCount = 0;
+var rootWithPassiveNestedUpdates = null; // If two updates are scheduled within the same event, we should treat their
+// event times as simultaneous, even if the actual clock time has advanced
+// between the first and second call.
+
+var currentEventTime = NoTimestamp;
+var currentEventTransitionLane = NoLanes;
+var isRunningInsertionEffect = false;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
 }
+function requestEventTime() {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    // We're inside React, so it's fine to read the actual time.
+    return now$1();
+  } // We're not inside React, so we may be in the middle of a browser event.
 
-function abortTracingMarkerTransitions(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var markerInstance = abortedFiber.stateNode;
-    var markerTransitions = markerInstance.transitions;
-    var pendingBoundaries = markerInstance.pendingBoundaries;
+  if (currentEventTime !== NoTimestamp) {
+    // Use the same start time for all updates until we enter React again.
+    return currentEventTime;
+  } // This is the first update since React yielded. Compute a new start time.
 
-    if (markerTransitions !== null) {
-      // TODO: Refactor this code. Is there a way to move this code to
-      // the deletions phase instead of calculating it here while making sure
-      // complete is called appropriately?
-      deletedTransitions.forEach(function (transition) {
-        // If one of the transitions on the tracing marker is a transition
-        // that was in an aborted subtree, we will abort that tracing marker
-        if (
-          abortedFiber !== null &&
-          markerTransitions.has(transition) &&
-          (markerInstance.aborts === null ||
-            !markerInstance.aborts.includes(abort))
-        ) {
-          if (markerInstance.transitions !== null) {
-            if (markerInstance.aborts === null) {
-              markerInstance.aborts = [abort];
-              addMarkerIncompleteCallbackToPendingTransition(
-                abortedFiber.memoizedProps.name,
-                markerInstance.transitions,
-                markerInstance.aborts
-              );
-            } else {
-              markerInstance.aborts.push(abort);
-            } // We only want to call onTransitionProgress when the marker hasn't been
-            // deleted
+  currentEventTime = now$1();
+  return currentEventTime;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  var mode = fiber.mode;
 
-            if (
-              deletedOffscreenInstance !== null &&
-              !isInDeletedTree &&
-              pendingBoundaries !== null &&
-              pendingBoundaries.has(deletedOffscreenInstance)
-            ) {
-              pendingBoundaries.delete(deletedOffscreenInstance);
-              addMarkerProgressCallbackToPendingTransition(
-                abortedFiber.memoizedProps.name,
-                deletedTransitions,
-                pendingBoundaries
-              );
-            }
-          }
-        }
-      });
-    }
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    (executionContext & RenderContext) !== NoContext &&
+    workInProgressRootRenderLanes !== NoLanes
+  ) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
   }
-}
 
-function abortParentMarkerTransitionsForDeletedFiber(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    // Find all pending markers that are waiting on child suspense boundaries in the
-    // aborted subtree and cancels them
-    var fiber = abortedFiber;
+  var isTransition = requestCurrentTransition() !== NoTransition;
 
-    while (fiber !== null) {
-      switch (fiber.tag) {
-        case TracingMarkerComponent:
-          abortTracingMarkerTransitions(
-            fiber,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance,
-            isInDeletedTree
-          );
-          break;
+  if (isTransition) {
+    if (ReactCurrentBatchConfig$1.transition !== null) {
+      var transition = ReactCurrentBatchConfig$1.transition;
 
-        case HostRoot:
-          var root = fiber.stateNode;
-          abortRootTransitions(
-            root,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance
-          );
-          break;
+      if (!transition._updatedFibers) {
+        transition._updatedFibers = new Set();
       }
 
-      fiber = fiber.return;
+      transition._updatedFibers.add(fiber);
+    } // The algorithm for assigning an update to a lane should be stable for all
+    // updates at the same priority within the same event. To do this, the
+    // inputs to the algorithm must be the same.
+    //
+    // The trick we use is to cache the first of each of these inputs within an
+    // event. Then reset the cached values once we can be sure the event is
+    // over. Our heuristic for that is whenever we enter a concurrent work loop.
+
+    if (currentEventTransitionLane === NoLane) {
+      // All transitions within the same event are assigned the same lane.
+      currentEventTransitionLane = claimNextTransitionLane();
     }
-  }
-}
 
-function commitTransitionProgress(offscreenFiber) {
-  if (enableTransitionTracing) {
-    // This function adds suspense boundaries to the root
-    // or tracing marker's pendingBoundaries map.
-    // When a suspense boundary goes from a resolved to a fallback
-    // state we add the boundary to the map, and when it goes from
-    // a fallback to a resolved state, we remove the boundary from
-    // the map.
-    // We use stateNode on the Offscreen component as a stable object
-    // that doesnt change from render to render. This way we can
-    // distinguish between different Offscreen instances (vs. the same
-    // Offscreen instance with different fibers)
-    var offscreenInstance = offscreenFiber.stateNode;
-    var prevState = null;
-    var previousFiber = offscreenFiber.alternate;
+    return currentEventTransitionLane;
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
 
-    if (previousFiber !== null && previousFiber.memoizedState !== null) {
-      prevState = previousFiber.memoizedState;
-    }
+  var updateLane = getCurrentUpdatePriority();
 
-    var nextState = offscreenFiber.memoizedState;
-    var wasHidden = prevState !== null;
-    var isHidden = nextState !== null;
-    var pendingMarkers = offscreenInstance._pendingMarkers; // If there is a name on the suspense boundary, store that in
-    // the pending boundaries.
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
 
-    var name = null;
-    var parent = offscreenFiber.return;
+  var eventLane = getCurrentEventPriority();
+  return eventLane;
+}
 
-    if (
-      parent !== null &&
-      parent.tag === SuspenseComponent &&
-      parent.memoizedProps.unstable_name
-    ) {
-      name = parent.memoizedProps.unstable_name;
-    }
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  var mode = fiber.mode;
 
-    if (!wasHidden && isHidden) {
-      // The suspense boundaries was just hidden. Add the boundary
-      // to the pending boundary set if it's there
-      if (pendingMarkers !== null) {
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries;
-          var transitions = markerInstance.transitions;
-          var markerName = markerInstance.name;
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  }
 
-          if (
-            pendingBoundaries !== null &&
-            !pendingBoundaries.has(offscreenInstance)
-          ) {
-            pendingBoundaries.set(offscreenInstance, {
-              name: name
-            });
+  return claimNextRetryLane();
+}
 
-            if (transitions !== null) {
-              if (
-                markerInstance.tag === TransitionTracingMarker &&
-                markerName !== null
-              ) {
-                addMarkerProgressCallbackToPendingTransition(
-                  markerName,
-                  transitions,
-                  pendingBoundaries
-                );
-              } else if (markerInstance.tag === TransitionRoot) {
-                transitions.forEach(function (transition) {
-                  addTransitionProgressCallbackToPendingTransition(
-                    transition,
-                    pendingBoundaries
-                  );
-                });
-              }
-            }
-          }
-        });
-      }
-    } else if (wasHidden && !isHidden) {
-      // The suspense boundary went from hidden to visible. Remove
-      // the boundary from the pending suspense boundaries set
-      // if it's there
-      if (pendingMarkers !== null) {
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries;
-          var transitions = markerInstance.transitions;
-          var markerName = markerInstance.name;
+function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+  {
+    if (isRunningInsertionEffect) {
+      error("useInsertionEffect must not schedule updates.");
+    }
+  }
 
-          if (
-            pendingBoundaries !== null &&
-            pendingBoundaries.has(offscreenInstance)
-          ) {
-            pendingBoundaries.delete(offscreenInstance);
+  {
+    if (isFlushingPassiveEffects) {
+      didScheduleUpdateDuringPassiveEffects = true;
+    }
+  } // Check if the work loop is currently suspended and waiting for data to
+  // finish loading.
 
-            if (transitions !== null) {
-              if (
-                markerInstance.tag === TransitionTracingMarker &&
-                markerName !== null
-              ) {
-                addMarkerProgressCallbackToPendingTransition(
-                  markerName,
-                  transitions,
-                  pendingBoundaries
-                ); // If there are no more unresolved suspense boundaries, the interaction
-                // is considered finished
+  if (
+    workInProgressSuspendedReason === SuspendedOnData &&
+    root === workInProgressRoot
+  ) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes);
+  } // Mark that the root has a pending update.
 
-                if (pendingBoundaries.size === 0) {
-                  if (markerInstance.aborts === null) {
-                    addMarkerCompleteCallbackToPendingTransition(
-                      markerName,
-                      transitions
-                    );
-                  }
+  markRootUpdated(root, lane, eventTime);
 
-                  markerInstance.transitions = null;
-                  markerInstance.pendingBoundaries = null;
-                  markerInstance.aborts = null;
-                }
-              } else if (markerInstance.tag === TransitionRoot) {
-                transitions.forEach(function (transition) {
-                  addTransitionProgressCallbackToPendingTransition(
-                    transition,
-                    pendingBoundaries
-                  );
-                });
-              }
-            }
-          }
-        });
+  if (
+    (executionContext & RenderContext) !== NoLanes &&
+    root === workInProgressRoot
+  ) {
+    // This update was dispatched during the render phase. This is a mistake
+    // if the update originates from user space (with the exception of local
+    // hook updates, which are handled differently and don't reach this
+    // function), but there are some internal React features that use this as
+    // an implementation detail, like selective hydration.
+    warnAboutRenderPhaseUpdatesInDEV(fiber); // Track lanes that were updated during the render phase
+  } else {
+    // This is a normal update, scheduled from outside the render phase. For
+    // example, during an input event.
+    {
+      if (isDevToolsPresent) {
+        addFiberToLanesMap(root, fiber, lane);
       }
     }
-  }
-}
-
-function hideOrUnhideAllChildren(finishedWork, isHidden) {
-  // Only hide or unhide the top-most host nodes.
-  var hostSubtreeRoot = null;
 
-  {
-    // We only have the top Fiber that was inserted but we need to recurse down its
-    // children to find all the terminal nodes.
-    var node = finishedWork;
+    warnIfUpdatesNotWrappedWithActDEV(fiber);
 
-    while (true) {
+    if (enableProfilerNestedUpdateScheduledHook) {
       if (
-        node.tag === HostComponent ||
-        node.tag === HostHoistable ||
-        node.tag === HostSingleton
+        (executionContext & CommitContext) !== NoContext &&
+        root === rootCommittingMutationOrLayoutEffects
       ) {
-        if (hostSubtreeRoot === null) {
-          hostSubtreeRoot = node;
+        if (fiber.mode & ProfileMode) {
+          var current = fiber;
 
-          try {
-            var instance = node.stateNode;
+          while (current !== null) {
+            if (current.tag === Profiler) {
+              var _current$memoizedProp = current.memoizedProps,
+                id = _current$memoizedProp.id,
+                onNestedUpdateScheduled =
+                  _current$memoizedProp.onNestedUpdateScheduled;
 
-            if (isHidden) {
-              hideInstance(instance);
-            } else {
-              unhideInstance(node.stateNode, node.memoizedProps);
+              if (typeof onNestedUpdateScheduled === "function") {
+                onNestedUpdateScheduled(id);
+              }
             }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      } else if (node.tag === HostText) {
-        if (hostSubtreeRoot === null) {
-          try {
-            var _instance = node.stateNode;
 
-            if (isHidden) {
-              hideTextInstance(_instance);
-            } else {
-              unhideTextInstance(_instance, node.memoizedProps);
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            current = current.return;
           }
         }
-      } else if (
-        (node.tag === OffscreenComponent ||
-          node.tag === LegacyHiddenComponent) &&
-        node.memoizedState !== null &&
-        node !== finishedWork
-      );
-      else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
-
-      if (node === finishedWork) {
-        return;
       }
+    }
 
-      while (node.sibling === null) {
-        if (node.return === null || node.return === finishedWork) {
-          return;
-        }
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig$1.transition;
 
-        if (hostSubtreeRoot === node) {
-          hostSubtreeRoot = null;
+      if (transition !== null && transition.name != null) {
+        if (transition.startTime === -1) {
+          transition.startTime = now$1();
         }
 
-        node = node.return;
-      }
-
-      if (hostSubtreeRoot === node) {
-        hostSubtreeRoot = null;
+        addTransitionToLanesMap(root, transition, lane);
       }
-
-      node.sibling.return = node.return;
-      node = node.sibling;
     }
-  }
-}
-
-function commitAttachRef(finishedWork) {
-  var ref = finishedWork.ref;
 
-  if (ref !== null) {
-    var instance = finishedWork.stateNode;
-    var instanceToUse;
-
-    switch (finishedWork.tag) {
-      case HostHoistable:
-      case HostSingleton:
-      case HostComponent:
-        instanceToUse = getPublicInstance(instance);
-        break;
-
-      default:
-        instanceToUse = instance;
-    } // Moved outside to ensure DCE works with this flag
+    if (root === workInProgressRoot) {
+      // Received an update to a tree that's in the middle of rendering. Mark
+      // that there was an interleaved update work on this root. Unless the
+      // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
+      // phase update. In that case, we don't treat render phase updates as if
+      // they were interleaved, for backwards compat reasons.
+      if (
+        deferRenderPhaseUpdateToNextBatch ||
+        (executionContext & RenderContext) === NoContext
+      ) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(
+          workInProgressRootInterleavedUpdatedLanes,
+          lane
+        );
+      }
 
-    if (finishedWork.tag === ScopeComponent) {
-      instanceToUse = instance;
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes);
+      }
     }
 
-    if (typeof ref === "function") {
-      if (shouldProfile(finishedWork)) {
-        try {
-          startLayoutEffectTimer();
-          finishedWork.refCleanup = ref(instanceToUse);
-        } finally {
-          recordLayoutEffectDuration(finishedWork);
-        }
-      } else {
-        finishedWork.refCleanup = ref(instanceToUse);
-      }
-    } else {
-      {
-        if (!ref.hasOwnProperty("current")) {
-          error(
-            "Unexpected ref object provided for %s. " +
-              "Use either a ref-setter function or React.createRef().",
-            getComponentNameFromFiber(finishedWork)
-          );
-        }
-      } // $FlowFixMe unable to narrow type to the non-function case
+    ensureRootIsScheduled(root, eventTime);
 
-      ref.current = instanceToUse;
+    if (
+      lane === SyncLane &&
+      executionContext === NoContext &&
+      (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+      !ReactCurrentActQueue.isBatchingLegacy
+    ) {
+      // Flush the synchronous work now, unless we're already working or inside
+      // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+      // scheduleCallbackForFiber to preserve the ability to schedule a callback
+      // without immediately flushing it. We only do this for user-initiated
+      // updates, to preserve historical behavior of legacy mode.
+      resetRenderTimer();
+      flushSyncCallbacksOnlyInLegacyMode();
     }
   }
 }
-
-function detachFiberMutation(fiber) {
-  // Cut off the return pointer to disconnect it from the tree.
-  // This enables us to detect and warn against state updates on an unmounted component.
-  // It also prevents events from bubbling from within disconnected components.
-  //
-  // Ideally, we should also 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.
-  //
-  // Note that we can't clear child or sibling pointers yet.
-  // They're needed for passive effects and for findDOMNode.
-  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+function scheduleInitialHydrationOnRoot(root, lane, eventTime) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
   //
-  // Don't reset the alternate yet, either. We need that so we can detach the
-  // alternate's fields in the passive phase. Clearing the return pointer is
-  // sufficient for findDOMNode semantics.
-  var alternate = fiber.alternate;
-
-  if (alternate !== null) {
-    alternate.return = null;
-  }
-
-  fiber.return = null;
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  var current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane, eventTime);
+  ensureRootIsScheduled(root, eventTime);
 }
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (
+    // TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We
+    // decided not to enable it.
+    (!deferRenderPhaseUpdateToNextBatch ||
+      (fiber.mode & ConcurrentMode) === NoMode) &&
+    (executionContext & RenderContext) !== NoContext
+  );
+} // Use this function to schedule a task for a root. There's only one task per
+// root; if a task was already scheduled, we'll check to make sure the priority
+// of the existing task is the same as the priority of the next level that the
+// root has work on. This function is called on every update, and right before
+// exiting a task.
 
-function detachFiberAfterEffects(fiber) {
-  var alternate = fiber.alternate;
-
-  if (alternate !== null) {
-    fiber.alternate = null;
-    detachFiberAfterEffects(alternate);
-  } // Clear cyclical Fiber fields. This level alone is designed to roughly
-  // approximate the planned Fiber refactor. In that world, `setState` will be
-  // bound to a special "instance" object instead of a Fiber. The Instance
-  // object will not have any of these fields. It will only be connected to
-  // the fiber tree via a single link at the root. So if this level alone is
-  // sufficient to fix memory issues, that bodes well for our plans.
-
-  fiber.child = null;
-  fiber.deletions = null;
-  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
-  // tree, which has its own pointers to children, parents, and siblings.
-  // The other host nodes also point back to fibers, so we should detach that
-  // one, too.
-
-  if (fiber.tag === HostComponent) {
-    var hostInstance = fiber.stateNode;
-
-    if (hostInstance !== null) {
-      detachDeletedInstance(hostInstance);
-    }
-  }
-
-  fiber.stateNode = null;
-
-  {
-    fiber._debugOwner = null;
-  } // Theoretically, nothing in here should be necessary, because we already
-  // disconnected the fiber from the tree. So even if something leaks this
-  // particular fiber, it won't leak anything else.
-
-  fiber.return = null;
-  fiber.dependencies = null;
-  fiber.memoizedProps = null;
-  fiber.memoizedState = null;
-  fiber.pendingProps = null;
-  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+function ensureRootIsScheduled(root, currentTime) {
+  var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
 
-  fiber.updateQueue = null;
-}
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
 
-function getHostParentFiber(fiber) {
-  var parent = fiber.return;
+  var nextLanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
+  );
 
-  while (parent !== null) {
-    if (isHostParent(parent)) {
-      return parent;
+  if (nextLanes === NoLanes) {
+    // Special case: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
     }
 
-    parent = parent.return;
-  }
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
+    return;
+  } // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
 
-  throw new Error(
-    "Expected to find a host parent. This error is likely caused by a bug " +
-      "in React. Please file an issue."
-  );
-}
+  if (
+    workInProgressSuspendedReason === SuspendedOnData &&
+    workInProgressRoot === root
+  ) {
+    root.callbackPriority = NoLane;
+    root.callbackNode = null;
+    return;
+  } // We use the highest priority lane to represent the priority of the callback.
 
-function isHostParent(fiber) {
-  return (
-    fiber.tag === HostComponent ||
-    fiber.tag === HostRoot ||
-    fiber.tag === HostHoistable ||
-    fiber.tag === HostSingleton ||
-    fiber.tag === HostPortal
-  );
-}
+  var newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.
 
-function getHostSibling(fiber) {
-  // We're going to search forward into the tree until we find a sibling host
-  // node. Unfortunately, if multiple insertions are done in a row we have to
-  // search past them. This leads to exponential search for the next sibling.
-  // TODO: Find a more efficient way to do this.
-  var node = fiber;
+  var existingCallbackPriority = root.callbackPriority;
 
-  siblings: while (true) {
-    // If we didn't find anything, let's try the next sibling.
-    while (node.sibling === null) {
-      if (node.return === null || isHostParent(node.return)) {
-        // If we pop out of the root or hit the parent the fiber we are the
-        // last sibling.
-        return null;
-      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+  if (
+    existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-scheduled
+    // on the `act` queue.
+    !(
+      ReactCurrentActQueue.current !== null &&
+      existingCallbackNode !== fakeActCallbackNode
+    )
+  ) {
+    {
+      // If we're going to re-use an existing task, it needs to exist.
+      // Assume that discrete update microtasks are non-cancellable and null.
+      // TODO: Temporary until we confirm this warning is not fired.
+      if (
+        existingCallbackNode == null &&
+        !includesSyncLane(existingCallbackPriority)
+      ) {
+        error(
+          "Expected scheduled callback to exist. This error is likely caused by a bug in React. Please file an issue."
+        );
+      }
+    } // The priority hasn't changed. We can reuse the existing task. Exit.
 
-      node = node.return;
-    }
+    return;
+  }
 
-    node.sibling.return = node.return;
-    node = node.sibling;
+  if (existingCallbackNode != null) {
+    // Cancel the existing callback. We'll schedule a new one below.
+    cancelCallback(existingCallbackNode);
+  } // Schedule a new callback.
 
-    while (
-      node.tag !== HostComponent &&
-      node.tag !== HostText &&
-      node.tag !== HostSingleton &&
-      node.tag !== DehydratedFragment
-    ) {
-      // If it is not host node and, we might have a host node inside it.
-      // Try to search down until we find one.
-      if (node.flags & Placement) {
-        // If we don't have a child, try the siblings instead.
-        continue siblings;
-      } // If we don't have a child, try the siblings instead.
-      // We also skip portals because they are not part of this host tree.
+  var newCallbackNode;
 
-      if (node.child === null || node.tag === HostPortal) {
-        continue siblings;
-      } else {
-        node.child.return = node;
-        node = node.child;
+  if (includesSyncLane(newCallbackPriority)) {
+    // Special case: Sync React callbacks are scheduled on a special
+    // internal queue
+    if (root.tag === LegacyRoot) {
+      if (ReactCurrentActQueue.isBatchingLegacy !== null) {
+        ReactCurrentActQueue.didScheduleLegacyUpdate = true;
       }
-    } // Check if this host node is stable or about to be placed.
 
-    if (!(node.flags & Placement)) {
-      // Found it!
-      return node.stateNode;
+      scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));
+    } else {
+      scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
     }
-  }
-}
 
-function commitPlacement(finishedWork) {
-  {
-    if (finishedWork.tag === HostSingleton) {
-      // Singletons are already in the Host and don't need to be placed
-      // Since they operate somewhat like Portals though their children will
-      // have Placement and will get placed inside them
-      return;
+    {
+      // Flush the queue in a microtask.
+      if (ReactCurrentActQueue.current !== null) {
+        // Inside `act`, use our internal `act` queue so that these get flushed
+        // at the end of the current scope even when using the sync version
+        // of `act`.
+        ReactCurrentActQueue.current.push(flushSyncCallbacks);
+      } else {
+        scheduleMicrotask(function () {
+          // In Safari, appending an iframe forces microtasks to run.
+          // https://github.com/facebook/react/issues/22459
+          // We don't support running callbacks in the middle of render
+          // or commit so we need to check against that.
+          if (
+            (executionContext & (RenderContext | CommitContext)) ===
+            NoContext
+          ) {
+            // Note that this would still prematurely flush the callbacks
+            // if this happens outside render or commit phase (e.g. in an event).
+            flushSyncCallbacks();
+          }
+        });
+      }
     }
-  } // Recursively insert all host nodes into the parent.
 
-  var parentFiber = getHostParentFiber(finishedWork);
-
-  switch (parentFiber.tag) {
-    case HostSingleton: {
-      {
-        var parent = parentFiber.stateNode;
-        var before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
-        // children to find all the terminal nodes.
+    newCallbackNode = null;
+  } else {
+    var schedulerPriorityLevel;
 
-        insertOrAppendPlacementNode(finishedWork, before, parent);
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
         break;
-      }
-    }
-    // eslint-disable-next-line no-fallthrough
-
-    case HostComponent: {
-      var _parent = parentFiber.stateNode;
 
-      if (parentFiber.flags & ContentReset) {
-        // Reset the text content of the parent before doing any insertions
-        resetTextContent(_parent); // Clear ContentReset from the effect tag
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
 
-        parentFiber.flags &= ~ContentReset;
-      }
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
 
-      var _before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
-      // children to find all the terminal nodes.
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
 
-      insertOrAppendPlacementNode(finishedWork, _before, _parent);
-      break;
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
     }
 
-    case HostRoot:
-    case HostPortal: {
-      var _parent2 = parentFiber.stateNode.containerInfo;
+    newCallbackNode = scheduleCallback(
+      schedulerPriorityLevel,
+      performConcurrentWorkOnRoot.bind(null, root)
+    );
+  }
 
-      var _before2 = getHostSibling(finishedWork);
+  root.callbackPriority = newCallbackPriority;
+  root.callbackNode = newCallbackNode;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
 
-      insertOrAppendPlacementNodeIntoContainer(
-        finishedWork,
-        _before2,
-        _parent2
-      );
-      break;
-    }
-    // eslint-disable-next-line-no-fallthrough
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  {
+    resetNestedUpdateFlag();
+  } // Since we know we're in a React event, we can clear the current
+  // event time. The next update will compute a new event time.
 
-    default:
-      throw new Error(
-        "Invalid host parent fiber. This error is likely caused by a bug " +
-          "in React. Please file an issue."
-      );
-  }
-}
+  currentEventTime = NoTimestamp;
+  currentEventTransitionLane = NoLanes;
 
-function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
-  var tag = node.tag;
-  var isHost = tag === HostComponent || tag === HostText;
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
 
-  if (isHost) {
-    var stateNode = node.stateNode;
+  var originalCallbackNode = root.callbackNode;
+  var didFlushPassiveEffects = flushPassiveEffects();
 
-    if (before) {
-      insertInContainerBefore(parent, stateNode, before);
-    } else {
-      appendChildToContainer(parent, stateNode);
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
     }
-  } else if (tag === HostPortal || tag === HostSingleton);
-  else {
-    var child = node.child;
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
 
-    if (child !== null) {
-      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
-      var sibling = child.sibling;
+  var lanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
+  );
 
-      while (sibling !== null) {
-        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
-        sibling = sibling.sibling;
-      }
-    }
-  }
-}
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
 
-function insertOrAppendPlacementNode(node, before, parent) {
-  var tag = node.tag;
-  var isHost = tag === HostComponent || tag === HostText;
+  var shouldTimeSlice =
+    !includesBlockingLane(root, lanes) &&
+    !includesExpiredLane(root, lanes) &&
+    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
+  var exitStatus = shouldTimeSlice
+    ? renderRootConcurrent(root, lanes)
+    : renderRootSync(root, lanes);
 
-  if (isHost) {
-    var stateNode = node.stateNode;
+  if (exitStatus !== RootInProgress) {
+    if (exitStatus === RootErrored) {
+      // If something threw an error, try rendering one more time. We'll
+      // render synchronously to block concurrent data mutations, and we'll
+      // includes all pending updates are included. If it still fails after
+      // the second attempt, we'll give up and commit the resulting tree.
+      var originallyAttemptedLanes = lanes;
+      var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+        root,
+        originallyAttemptedLanes
+      );
 
-    if (before) {
-      insertBefore(parent, stateNode, before);
-    } else {
-      appendChild(parent, stateNode);
+      if (errorRetryLanes !== NoLanes) {
+        lanes = errorRetryLanes;
+        exitStatus = recoverFromConcurrentError(
+          root,
+          originallyAttemptedLanes,
+          errorRetryLanes
+        );
+      }
     }
-  } else if (tag === HostPortal || tag === HostSingleton);
-  else {
-    var child = node.child;
-
-    if (child !== null) {
-      insertOrAppendPlacementNode(child, before, parent);
-      var sibling = child.sibling;
 
-      while (sibling !== null) {
-        insertOrAppendPlacementNode(sibling, before, parent);
-        sibling = sibling.sibling;
-      }
+    if (exitStatus === RootFatalErrored) {
+      var fatalError = workInProgressRootFatalError;
+      prepareFreshStack(root, NoLanes);
+      markRootSuspended(root, lanes);
+      ensureRootIsScheduled(root, now$1());
+      throw fatalError;
     }
-  }
-} // These are tracked on the stack as we recursively traverse a
-// deleted subtree.
-// TODO: Update these during the whole mutation phase, not just during
-// a deletion.
 
-var hostParent = null;
-var hostParentIsContainer = false;
+    if (exitStatus === RootDidNotComplete) {
+      // The render unwound without completing the tree. This happens in special
+      // cases where need to exit the current render without producing a
+      // consistent tree or committing.
+      markRootSuspended(root, lanes);
+    } else {
+      // The render completed.
+      // Check if this render may have yielded to a concurrent event, and if so,
+      // confirm that any newly rendered stores are consistent.
+      // TODO: It's possible that even a concurrent render may never have yielded
+      // to the main thread, if it was fast enough, or if it expired. We could
+      // skip the consistency check in that case, too.
+      var renderWasConcurrent = !includesBlockingLane(root, lanes);
+      var finishedWork = root.current.alternate;
 
-function commitDeletionEffects(root, returnFiber, deletedFiber) {
-  {
-    // We only have the top Fiber that was deleted but we need to recurse down its
-    // children to find all the terminal nodes.
-    // Recursively delete all host nodes from the parent, detach refs, clean
-    // up mounted layout effects, and call componentWillUnmount.
-    // We only need to remove the topmost host child in each branch. But then we
-    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
-    // could split this into two separate traversals functions, where the second
-    // one doesn't include any removeChild logic. This is maybe the same
-    // function as "disappearLayoutEffects" (or whatever that turns into after
-    // the layout phase is refactored to use recursion).
-    // Before starting, find the nearest host parent on the stack so we know
-    // which instance/container to remove the children from.
-    // TODO: Instead of searching up the fiber return path on every deletion, we
-    // can track the nearest host component on the JS stack as we traverse the
-    // tree during the commit phase. This would make insertions faster, too.
-    var parent = returnFiber;
+      if (
+        renderWasConcurrent &&
+        !isRenderConsistentWithExternalStores(finishedWork)
+      ) {
+        // A store was mutated in an interleaved event. Render again,
+        // synchronously, to block further mutations.
+        exitStatus = renderRootSync(root, lanes); // We need to check again if something threw
 
-    findParent: while (parent !== null) {
-      switch (parent.tag) {
-        case HostSingleton:
-        case HostComponent: {
-          hostParent = parent.stateNode;
-          hostParentIsContainer = false;
-          break findParent;
-        }
+        if (exitStatus === RootErrored) {
+          var _originallyAttemptedLanes = lanes;
 
-        case HostRoot: {
-          hostParent = parent.stateNode.containerInfo;
-          hostParentIsContainer = true;
-          break findParent;
-        }
+          var _errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+            root,
+            _originallyAttemptedLanes
+          );
 
-        case HostPortal: {
-          hostParent = parent.stateNode.containerInfo;
-          hostParentIsContainer = true;
-          break findParent;
+          if (_errorRetryLanes !== NoLanes) {
+            lanes = _errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(
+              root,
+              _originallyAttemptedLanes,
+              _errorRetryLanes
+            ); // We assume the tree is now consistent because we didn't yield to any
+            // concurrent events.
+          }
         }
-      }
 
-      parent = parent.return;
-    }
+        if (exitStatus === RootFatalErrored) {
+          var _fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes);
+          ensureRootIsScheduled(root, now$1());
+          throw _fatalError;
+        } // FIXME: Need to check for RootDidNotComplete again. The factoring here
+        // isn't ideal.
+      } // We now have a consistent tree. The next step is either to commit it,
+      // or, if something suspended, wait to commit it after a timeout.
 
-    if (hostParent === null) {
-      throw new Error(
-        "Expected to find a host parent. This error is likely caused by " +
-          "a bug in React. Please file an issue."
-      );
+      root.finishedWork = finishedWork;
+      root.finishedLanes = lanes;
+      finishConcurrentRender(root, exitStatus, lanes);
     }
-
-    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
-    hostParent = null;
-    hostParentIsContainer = false;
   }
 
-  detachFiberMutation(deletedFiber);
-}
-
-function recursivelyTraverseDeletionEffects(
-  finishedRoot,
-  nearestMountedAncestor,
-  parent
-) {
-  // TODO: Use a static flag to skip trees that don't have unmount effects
-  var child = parent.child;
+  ensureRootIsScheduled(root, now$1());
 
-  while (child !== null) {
-    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
-    child = child.sibling;
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
   }
+
+  return null;
 }
 
-function commitDeletionEffectsOnFiber(
-  finishedRoot,
-  nearestMountedAncestor,
-  deletedFiber
+function recoverFromConcurrentError(
+  root,
+  originallyAttemptedLanes,
+  errorRetryLanes
 ) {
-  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
-  // into their subtree. There are simpler cases in the inner switch
-  // that don't modify the stack.
-
-  switch (deletedFiber.tag) {
-    case HostHoistable: {
-      {
-        if (!offscreenSubtreeWasHidden) {
-          safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        }
-
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-
-        if (deletedFiber.memoizedState) {
-          releaseResource(deletedFiber.memoizedState);
-        } else if (deletedFiber.stateNode) {
-          unmountHoistable(deletedFiber.stateNode);
-        }
-
-        return;
-      }
-    }
-    // eslint-disable-next-line no-fallthrough
-
-    case HostSingleton: {
-      {
-        if (!offscreenSubtreeWasHidden) {
-          safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        }
-
-        var prevHostParent = hostParent;
-        var prevHostParentIsContainer = hostParentIsContainer;
-        hostParent = deletedFiber.stateNode;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        ); // Normally this is called in passive unmount effect phase however with
-        // HostSingleton we warn if you acquire one that is already associated to
-        // a different fiber. To increase our chances of avoiding this, specifically
-        // if you keyed a HostSingleton so there will be a delete followed by a Placement
-        // we treat detach eagerly here
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  var wasRootDehydrated = isRootDehydrated(root);
 
-        releaseSingletonInstance(deletedFiber.stateNode);
-        hostParent = prevHostParent;
-        hostParentIsContainer = prevHostParentIsContainer;
-        return;
-      }
-    }
-    // eslint-disable-next-line no-fallthrough
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    var rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
 
-    case HostComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      } // Intentional fallthrough to next branch
+    {
+      errorHydratingContainer(root.containerInfo);
     }
-    // eslint-disable-next-line-no-fallthrough
+  }
 
-    case HostText: {
-      // We only need to remove the nearest host child. Set the host parent
-      // to `null` on the stack to indicate that nested children don't
-      // need to be removed.
-      {
-        var _prevHostParent = hostParent;
-        var _prevHostParentIsContainer = hostParentIsContainer;
-        hostParent = null;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        hostParent = _prevHostParent;
-        hostParentIsContainer = _prevHostParentIsContainer;
+  var exitStatus = renderRootSync(root, errorRetryLanes);
 
-        if (hostParent !== null) {
-          // Now that all the child effects have unmounted, we can remove the
-          // node from the tree.
-          if (hostParentIsContainer) {
-            removeChildFromContainer(hostParent, deletedFiber.stateNode);
-          } else {
-            removeChild(hostParent, deletedFiber.stateNode);
-          }
-        }
-      }
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(
+        root.errorRecoveryDisabledLanes,
+        originallyAttemptedLanes
+      ); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
 
-      return;
-    }
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
 
-    case DehydratedFragment: {
-      {
-        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+    var errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
 
-        if (hydrationCallbacks !== null) {
-          var onDeleted = hydrationCallbacks.onDeleted;
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
+  }
 
-          if (onDeleted) {
-            onDeleted(deletedFiber.stateNode);
-          }
-        }
-      } // Dehydrated fragments don't have any children
-      // Delete the dehydrated suspense boundary and all of its content.
+  return exitStatus;
+}
 
-      {
-        if (hostParent !== null) {
-          if (hostParentIsContainer) {
-            clearSuspenseBoundaryFromContainer(
-              hostParent,
-              deletedFiber.stateNode
-            );
-          } else {
-            clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
-          }
-        }
-      }
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(
+      workInProgressRootRecoverableErrors,
+      errors
+    );
+  }
+}
 
-      return;
+function finishConcurrentRender(root, exitStatus, lanes) {
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored: {
+      throw new Error("Root did not complete. This is a bug in React.");
     }
+    // Flow knows about invariant, so it complains if I add a break
+    // statement, but eslint doesn't know about invariant, so it complains
+    // if I do. eslint-disable-next-line no-fallthrough
 
-    case HostPortal: {
-      {
-        // When we go into a portal, it becomes the parent to remove from.
-        var _prevHostParent2 = hostParent;
-        var _prevHostParentIsContainer2 = hostParentIsContainer;
-        hostParent = deletedFiber.stateNode.containerInfo;
-        hostParentIsContainer = true;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        hostParent = _prevHostParent2;
-        hostParentIsContainer = _prevHostParentIsContainer2;
-      }
-
-      return;
+    case RootErrored: {
+      // We should have already attempted to retry this tree. If we reached
+      // this point, it errored again. Commit it.
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
     }
 
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        var updateQueue = deletedFiber.updateQueue;
+    case RootSuspended: {
+      markRootSuspended(root, lanes); // We have an acceptable loading state. We need to figure out if we
+      // should immediately commit it or wait a bit.
 
-        if (updateQueue !== null) {
-          var lastEffect = updateQueue.lastEffect;
+      if (
+        includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
+        !shouldForceFlushFallbacksInDEV()
+      ) {
+        // This render only included retries, no updates. Throttle committing
+        // retries so that we don't show too many loading states too quickly.
+        var msUntilTimeout =
+          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
 
-          if (lastEffect !== null) {
-            var firstEffect = lastEffect.next;
-            var effect = firstEffect;
+        if (msUntilTimeout > 10) {
+          var nextLanes = getNextLanes(root, NoLanes);
 
-            do {
-              var _effect = effect,
-                destroy = _effect.destroy,
-                tag = _effect.tag;
+          if (nextLanes !== NoLanes) {
+            // There's additional work on this root.
+            break;
+          } // The render is suspended, it hasn't timed out, and there's no
+          // lower priority work to do. Instead of committing the fallback
+          // immediately, wait for more data to arrive.
 
-              if (destroy !== undefined) {
-                if ((tag & Insertion) !== NoFlags) {
-                  safelyCallDestroy(
-                    deletedFiber,
-                    nearestMountedAncestor,
-                    destroy
-                  );
-                } else if ((tag & Layout) !== NoFlags) {
-                  if (enableSchedulingProfiler) {
-                    markComponentLayoutEffectUnmountStarted(deletedFiber);
-                  }
+          root.timeoutHandle = scheduleTimeout(
+            commitRoot.bind(
+              null,
+              root,
+              workInProgressRootRecoverableErrors,
+              workInProgressTransitions
+            ),
+            msUntilTimeout
+          );
+          break;
+        }
+      } // The work expired. Commit immediately.
 
-                  if (shouldProfile(deletedFiber)) {
-                    startLayoutEffectTimer();
-                    safelyCallDestroy(
-                      deletedFiber,
-                      nearestMountedAncestor,
-                      destroy
-                    );
-                    recordLayoutEffectDuration(deletedFiber);
-                  } else {
-                    safelyCallDestroy(
-                      deletedFiber,
-                      nearestMountedAncestor,
-                      destroy
-                    );
-                  }
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
+    }
 
-                  if (enableSchedulingProfiler) {
-                    markComponentLayoutEffectUnmountStopped();
-                  }
-                }
-              }
+    case RootSuspendedWithDelay: {
+      markRootSuspended(root, lanes);
 
-              effect = effect.next;
-            } while (effect !== firstEffect);
-          }
-        }
+      if (includesOnlyTransitions(lanes)) {
+        // This is a transition, so we should exit without committing a
+        // placeholder and without scheduling a timeout. Delay indefinitely
+        // until we receive more data.
+        break;
       }
 
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
-    }
+      if (!shouldForceFlushFallbacksInDEV()) {
+        // This is not a transition, but we did trigger an avoided state.
+        // Schedule a placeholder to display after a short delay, using the Just
+        // Noticeable Difference.
+        // TODO: Is the JND optimization worth the added complexity? If this is
+        // the only reason we track the event time, then probably not.
+        // Consider removing.
+        var mostRecentEventTime = getMostRecentEventTime(root, lanes);
+        var eventTimeMs = mostRecentEventTime;
+        var timeElapsedMs = now$1() - eventTimeMs;
 
-    case ClassComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        var instance = deletedFiber.stateNode;
+        var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
 
-        if (typeof instance.componentWillUnmount === "function") {
-          safelyCallComponentWillUnmount(
-            deletedFiber,
-            nearestMountedAncestor,
-            instance
+        if (_msUntilTimeout > 10) {
+          // Instead of committing the fallback immediately, wait for more data
+          // to arrive.
+          root.timeoutHandle = scheduleTimeout(
+            commitRoot.bind(
+              null,
+              root,
+              workInProgressRootRecoverableErrors,
+              workInProgressTransitions
+            ),
+            _msUntilTimeout
           );
+          break;
         }
-      }
+      } // Commit the placeholder.
 
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
       );
-      return;
+      break;
     }
 
-    case ScopeComponent: {
-      {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      }
-
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+    case RootCompleted: {
+      // The work completed. Ready to commit.
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
       );
-      return;
-    }
-
-    case OffscreenComponent: {
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
-
-      if (deletedFiber.mode & ConcurrentMode) {
-        // If this offscreen component is hidden, we already unmounted it. Before
-        // deleting the children, track that it's already unmounted so that we
-        // don't attempt to unmount the effects again.
-        // TODO: If the tree is hidden, in most cases we should be able to skip
-        // over the nested children entirely. An exception is we haven't yet found
-        // the topmost host node to delete, which we already track on the stack.
-        // But the other case is portals, which need to be detached no matter how
-        // deeply they are nested. We should use a subtree flag to track whether a
-        // subtree includes a nested portal.
-        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-        offscreenSubtreeWasHidden =
-          prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-      } else {
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-      }
-
       break;
     }
 
     default: {
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
+      throw new Error("Unknown root exit status.");
     }
   }
 }
 
-function commitSuspenseCallback(finishedWork) {
-  // TODO: Move this to passive phase
-  var newState = finishedWork.memoizedState;
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  var node = finishedWork;
 
-  if (newState !== null) {
-    var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      var updateQueue = node.updateQueue;
 
-    if (typeof suspenseCallback === "function") {
-      var wakeables = finishedWork.updateQueue;
+      if (updateQueue !== null) {
+        var checks = updateQueue.stores;
 
-      if (wakeables !== null) {
-        suspenseCallback(new Set(wakeables));
-      }
-    } else {
-      if (suspenseCallback !== undefined) {
-        error("Unexpected type for suspenseCallback.");
+        if (checks !== null) {
+          for (var i = 0; i < checks.length; i++) {
+            var check = checks[i];
+            var getSnapshot = check.getSnapshot;
+            var renderedValue = check.value;
+
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
+          }
+        }
       }
     }
-  }
-}
 
-function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
-  var newState = finishedWork.memoizedState;
-
-  if (newState === null) {
-    var current = finishedWork.alternate;
+    var child = node.child;
 
-    if (current !== null) {
-      var prevState = current.memoizedState;
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
+    }
 
-      if (prevState !== null) {
-        var suspenseInstance = prevState.dehydrated;
+    if (node === finishedWork) {
+      return true;
+    }
 
-        if (suspenseInstance !== null) {
-          try {
-            commitHydratedSuspenseInstance(suspenseInstance);
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
+      }
 
-            if (enableSuspenseCallback) {
-              var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+      node = node.return;
+    }
 
-              if (hydrationCallbacks !== null) {
-                var onHydrated = hydrationCallbacks.onHydrated;
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
 
-                if (onHydrated) {
-                  onHydrated(suspenseInstance);
-                }
-              }
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
-    }
-  }
+  return true;
 }
 
-function getRetryCache(finishedWork) {
-  // TODO: Unify the interface for the retry cache so we don't have to switch
-  // on the tag like this.
-  switch (finishedWork.tag) {
-    case SuspenseComponent:
-    case SuspenseListComponent: {
-      var retryCache = finishedWork.stateNode;
+function markRootSuspended(root, suspendedLanes) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(
+    suspendedLanes,
+    workInProgressRootInterleavedUpdatedLanes
+  );
+  markRootSuspended$1(root, suspendedLanes);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
 
-      if (retryCache === null) {
-        retryCache = finishedWork.stateNode = new PossiblyWeakSet();
-      }
+function performSyncWorkOnRoot(root) {
+  {
+    syncNestedUpdateFlag();
+  }
 
-      return retryCache;
-    }
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
+  }
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-      var _retryCache = instance._retryCache;
+  flushPassiveEffects();
+  var lanes = getNextLanes(root, NoLanes);
 
-      if (_retryCache === null) {
-        _retryCache = instance._retryCache = new PossiblyWeakSet();
-      }
+  if (!includesSyncLane(lanes)) {
+    // There's no remaining sync work left.
+    ensureRootIsScheduled(root, now$1());
+    return null;
+  }
 
-      return _retryCache;
-    }
+  var exitStatus = renderRootSync(root, lanes);
 
-    default: {
-      throw new Error(
-        "Unexpected Suspense handler tag (" +
-          finishedWork.tag +
-          "). This is a " +
-          "bug in React."
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    var originallyAttemptedLanes = lanes;
+    var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+      root,
+      originallyAttemptedLanes
+    );
+
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(
+        root,
+        originallyAttemptedLanes,
+        errorRetryLanes
       );
     }
   }
+
+  if (exitStatus === RootFatalErrored) {
+    var fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes);
+    ensureRootIsScheduled(root, now$1());
+    throw fatalError;
+  }
+
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes);
+    ensureRootIsScheduled(root, now$1());
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
+
+  var finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(
+    root,
+    workInProgressRootRecoverableErrors,
+    workInProgressTransitions
+  ); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
+
+  ensureRootIsScheduled(root, now$1());
+  return null;
 }
 
-function detachOffscreenInstance(instance) {
-  var fiber = instance._current;
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    markRootEntangled(root, mergeLanes(lanes, SyncLane));
+    ensureRootIsScheduled(root, now$1());
 
-  if (fiber === null) {
-    throw new Error(
-      "Calling Offscreen.detach before instance handle has been set."
-    );
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer();
+      flushSyncCallbacks();
+    }
   }
+}
+function getExecutionContext() {
+  return executionContext;
+}
+function batchedUpdates$1(fn, a) {
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
 
-  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
-    // The instance is already detached, this is a noop.
-    return;
-  } // TODO: There is an opportunity to optimise this by not entering commit phase
-  // and unmounting effects directly.
-
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
 
-  if (root !== null) {
-    instance._pendingVisibility |= OffscreenDetached;
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    if (
+      executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+      !ReactCurrentActQueue.isBatchingLegacy
+    ) {
+      resetRenderTimer();
+      flushSyncCallbacksOnlyInLegacyMode();
+    }
   }
 }
-function attachOffscreenInstance(instance) {
-  var fiber = instance._current;
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
 
-  if (fiber === null) {
-    throw new Error(
-      "Calling Offscreen.detach before instance handle has been set."
-    );
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (
+    rootWithPendingPassiveEffects !== null &&
+    rootWithPendingPassiveEffects.tag === LegacyRoot &&
+    (executionContext & (RenderContext | CommitContext)) === NoContext
+  ) {
+    flushPassiveEffects();
   }
 
-  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
-    // The instance is already attached, this is a noop.
-    return;
-  }
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+  var previousPriority = getCurrentUpdatePriority();
 
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
 
-  if (root !== null) {
-    instance._pendingVisibility &= ~OffscreenDetached;
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
+
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncCallbacks();
+    }
   }
 }
+function isAlreadyRendering() {
+  // Used by the renderer to print a warning if certain APIs are called from
+  // the wrong context.
+  return (executionContext & (RenderContext | CommitContext)) !== NoContext;
+}
+function isInvalidExecutionContextForEventFunction() {
+  // Used to throw if certain APIs are called from the wrong context.
+  return (executionContext & RenderContext) !== NoContext;
+}
+function flushControlled(fn) {
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+  var previousPriority = getCurrentUpdatePriority();
 
-function attachSuspenseRetryListeners(finishedWork, wakeables) {
-  // If this boundary just timed out, then it will have a set of wakeables.
-  // For each wakeable, attach a listener so that when it resolves, React
-  // attempts to re-render the boundary in the primary (pre-timeout) state.
-  var retryCache = getRetryCache(finishedWork);
-  wakeables.forEach(function (wakeable) {
-    // Memoize using the boundary fiber to prevent redundant listeners.
-    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    fn();
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext;
 
-    if (!retryCache.has(wakeable)) {
-      retryCache.add(wakeable);
+    if (executionContext === NoContext) {
+      // Flush the immediate callbacks that were scheduled during this batch
+      resetRenderTimer();
+      flushSyncCallbacks();
+    }
+  }
+} // This is called by the HiddenContext module when we enter or leave a
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
 
-      {
-        if (isDevToolsPresent) {
-          if (inProgressLanes !== null && inProgressRoot !== null) {
-            // If we have pending work still, associate the original updaters with it.
-            restorePendingUpdaters(inProgressRoot, inProgressLanes);
-          } else {
-            throw Error(
-              "Expected finished root and lanes to be set. This is a bug in React."
-            );
-          }
-        }
-      }
+function setRenderLanes(subtreeRenderLanes) {
+  renderLanes = subtreeRenderLanes;
+}
+function getRenderLanes() {
+  return renderLanes;
+}
 
-      wakeable.then(retry, retry);
-    }
-  });
-} // This function detects when a Suspense boundary goes from visible to hidden.
-// It returns false if the boundary is already hidden.
-// TODO: Use an effect tag.
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  var interruptedWork;
 
-function isSuspenseBoundaryBeingHidden(current, finishedWork) {
-  if (current !== null) {
-    var oldState = current.memoizedState;
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind();
+    interruptedWork = workInProgress;
+  }
 
-    if (oldState === null || oldState.dehydrated !== null) {
-      var newState = finishedWork.memoizedState;
-      return newState !== null && newState.dehydrated === null;
-    }
+  while (interruptedWork !== null) {
+    var current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
   }
 
-  return false;
-}
-function commitMutationEffects(root, finishedWork, committedLanes) {
-  inProgressLanes = committedLanes;
-  inProgressRoot = root;
-  setCurrentFiber(finishedWork);
-  commitMutationEffectsOnFiber(finishedWork, root);
-  setCurrentFiber(finishedWork);
-  inProgressLanes = null;
-  inProgressRoot = null;
+  workInProgress = null;
 }
 
-function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects hae fired.
-  var deletions = parentFiber.deletions;
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  var timeoutHandle = root.timeoutHandle;
 
-  if (deletions !== null) {
-    for (var i = 0; i < deletions.length; i++) {
-      var childToDelete = deletions[i];
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
 
-      try {
-        commitDeletionEffects(root, parentFiber, childToDelete);
-      } catch (error) {
-        captureCommitPhaseError(childToDelete, parentFiber, error);
-      }
-    }
+    cancelTimeout(timeoutHandle);
   }
 
-  var prevDebugFiber = getCurrentFiber();
-
-  if (parentFiber.subtreeFlags & MutationMask) {
-    var child = parentFiber.child;
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  var rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = renderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null;
+  finishQueueingConcurrentUpdates();
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitMutationEffectsOnFiber(child, root);
-      child = child.sibling;
-    }
+  {
+    ReactStrictModeWarnings.discardPendingWarnings();
   }
 
-  setCurrentFiber(prevDebugFiber);
+  return rootWorkInProgress;
 }
 
-var currentHoistableRoot = null;
-
-function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
-  var current = finishedWork.alternate;
-  var flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
-  // because the fiber tag is more specific. An exception is any flag related
-  // to reconciliation, because those can be set on all fiber types.
+function resetSuspendedWorkLoopOnUnwind() {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind();
+  resetChildReconcilerOnUnwind();
+}
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  resetCurrentFiber();
+  ReactCurrentOwner$1.current = null;
 
-      if (flags & Update) {
-        try {
-          commitHookEffectListUnmount(
-            Insertion | HasEffect,
-            finishedWork,
-            finishedWork.return
-          );
-          commitHookEffectListMount(Insertion | HasEffect, finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        } // Layout effects are destroyed during the mutation phase so that all
-        // destroy functions for all fibers are called before any create functions.
-        // This prevents sibling component effects from interfering with each other,
-        // e.g. a destroy function in one component should never override a ref set
-        // by a create function in another component during the same commit.
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
+      ? SuspendedOnData
+      : SuspendedOnImmediate;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    var isWakeable =
+      thrownValue !== null &&
+      typeof thrownValue === "object" &&
+      typeof thrownValue.then === "function";
+    workInProgressSuspendedReason = isWakeable // A wakeable object was thrown by a legacy Suspense implementation.
+      ? // This has slightly different behavior than suspending with `use`.
+        SuspendedOnDeprecatedThrowPromise // This is a regular error. If something earlier in the component already
+      : // suspended, we must clear the thenable state to unblock the work loop.
+        SuspendedOnError;
+  }
 
-        if (shouldProfile(finishedWork)) {
-          try {
-            startLayoutEffectTimer();
-            commitHookEffectListUnmount(
-              Layout | HasEffect,
-              finishedWork,
-              finishedWork.return
-            );
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
+  workInProgressThrownValue = thrownValue;
+  var erroredWork = workInProgress;
 
-          recordLayoutEffectDuration(finishedWork);
-        } else {
-          try {
-            commitHookEffectListUnmount(
-              Layout | HasEffect,
-              finishedWork,
-              finishedWork.return
-            );
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue;
+    return;
+  }
 
-      return;
-    }
+  if (erroredWork.mode & ProfileMode) {
+    // Record the time spent rendering before an error was thrown. This
+    // avoids inaccurate Profiler durations in the case of a
+    // suspended render.
+    stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
+  }
 
-    case ClassComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
 
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
+    switch (workInProgressSuspendedReason) {
+      case SuspendedOnError: {
+        markComponentErrored(
+          erroredWork,
+          thrownValue,
+          workInProgressRootRenderLanes
+        );
+        break;
       }
 
-      if (flags & Callback && offscreenSubtreeIsHidden) {
-        var updateQueue = finishedWork.updateQueue;
-
-        if (updateQueue !== null) {
-          deferHiddenCallbacks(updateQueue);
-        }
+      case SuspendedOnData:
+      case SuspendedOnImmediate:
+      case SuspendedOnDeprecatedThrowPromise:
+      case SuspendedAndReadyToContinue: {
+        var wakeable = thrownValue;
+        markComponentSuspended(
+          erroredWork,
+          wakeable,
+          workInProgressRootRenderLanes
+        );
+        break;
       }
-
-      return;
     }
+  }
+}
 
-    case HostHoistable: {
-      {
-        // We cast because we always set the root at the React root and so it cannot be
-        // null while we are processing mutation effects
-        var hoistableRoot = currentHoistableRoot;
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork);
-
-        if (flags & Ref) {
-          if (current !== null) {
-            safelyDetachRef(current, current.return);
-          }
-        }
+function shouldAttemptToSuspendUntilDataResolves() {
+  // Check if there are other pending updates that might possibly unblock this
+  // component from suspending. This mirrors the check in
+  // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+  // TODO: Consider unwinding immediately, using the
+  // SuspendedOnHydration mechanism.
+  if (
+    includesNonIdleWork(workInProgressRootSkippedLanes) ||
+    includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)
+  ) {
+    // Suspend normally. renderDidSuspendDelayIfPossible will handle
+    // interrupting the work loop.
+    return false;
+  } // TODO: We should be able to remove the equivalent check in
+  // finishConcurrentRender, and rely just on this one.
 
-        if (flags & Update) {
-          var currentResource = current !== null ? current.memoizedState : null;
-          var newResource = finishedWork.memoizedState;
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    // If we're rendering inside the "shell" of the app, it's better to suspend
+    // rendering and wait for the data to resolve. Otherwise, we should switch
+    // to a fallback and continue rendering.
+    return getShellBoundary() === null;
+  }
 
-          if (current === null) {
-            // We are mounting a new HostHoistable Fiber. We fork the mount
-            // behavior based on whether this instance is a Hoistable Instance
-            // or a Hoistable Resource
-            if (newResource === null) {
-              if (finishedWork.stateNode === null) {
-                finishedWork.stateNode = hydrateHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.memoizedProps,
-                  finishedWork
-                );
-              } else {
-                mountHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.stateNode
-                );
-              }
-            } else {
-              finishedWork.stateNode = acquireResource(
-                hoistableRoot,
-                newResource,
-                finishedWork.memoizedProps
-              );
-            }
-          } else if (currentResource !== newResource) {
-            // We are moving to or from Hoistable Resource, or between different Hoistable Resources
-            if (currentResource === null) {
-              if (current.stateNode !== null) {
-                unmountHoistable(current.stateNode);
-              }
-            } else {
-              releaseResource(currentResource);
-            }
+  var handler = getSuspenseHandler();
 
-            if (newResource === null) {
-              mountHoistable(
-                hoistableRoot,
-                finishedWork.type,
-                finishedWork.stateNode
-              );
-            } else {
-              acquireResource(
-                hoistableRoot,
-                newResource,
-                finishedWork.memoizedProps
-              );
-            }
-          } else if (newResource === null && finishedWork.stateNode !== null) {
-            // We may have an update on a Hoistable element
-            var updatePayload = finishedWork.updateQueue;
-            finishedWork.updateQueue = null;
+  if (handler === null);
+  else {
+    if (includesOnlyRetries(workInProgressRootRenderLanes)) {
+      // During a retry, we can suspend rendering if the nearest Suspense boundary
+      // is the boundary of the "shell", because we're guaranteed not to block
+      // any new content from appearing.
+      return handler === getShellBoundary();
+    }
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+  // TODO: We should wait during Offscreen prerendering, too.
 
-            if (updatePayload !== null) {
-              try {
-                commitUpdate(
-                  finishedWork.stateNode,
-                  updatePayload,
-                  finishedWork.type,
-                  current.memoizedProps,
-                  finishedWork.memoizedProps,
-                  finishedWork
-                );
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
+  return false;
+}
 
-        return;
-      }
-    }
-    // eslint-disable-next-line-no-fallthrough
+function pushDispatcher(container) {
+  prepareRendererToRender(container);
+  var prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
 
-    case HostSingleton: {
-      {
-        if (flags & Update) {
-          var previousWork = finishedWork.alternate;
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
+  }
+}
 
-          if (previousWork === null) {
-            var singleton = finishedWork.stateNode;
-            var props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+function popDispatcher(prevDispatcher) {
+  resetRendererAfterRender();
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
 
-            clearSingleton(singleton);
-            acquireSingletonInstance(
-              finishedWork.type,
-              props,
-              singleton,
-              finishedWork
-            );
-          }
-        }
-      }
-    }
-    // eslint-disable-next-line-no-fallthrough
+function pushCacheDispatcher() {
+  {
+    var prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
 
-    case HostComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
 
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
-      }
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now$1();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(
+    lane,
+    workInProgressRootSkippedLanes
+  );
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
 
-      {
-        // TODO: ContentReset gets cleared by the children during the commit
-        // phase. This is a refactor hazard because it means we must read
-        // flags the flags after `commitReconciliationEffects` has already run;
-        // the order matters. We should refactor so that ContentReset does not
-        // rely on mutating the flag during commit. Like by setting a flag
-        // during the render phase instead.
-        if (finishedWork.flags & ContentReset) {
-          var instance = finishedWork.stateNode;
+  if (
+    workInProgressRoot !== null &&
+    (includesNonIdleWork(workInProgressRootSkippedLanes) ||
+      includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))
+  ) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    // $FlowFixMe[incompatible-call] need null check workInProgressRoot
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
 
-          try {
-            resetTextContent(instance);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
+  } else {
+    workInProgressRootConcurrentErrors.push(error);
+  }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
 
-        if (flags & Update) {
-          var _instance2 = finishedWork.stateNode;
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
 
-          if (_instance2 != null) {
-            // Commit the work prepared earlier.
-            var newProps = finishedWork.memoizedProps; // 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.
+function renderRootSync(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  var prevDispatcher = pushDispatcher(root.containerInfo);
+  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
 
-            var oldProps = current !== null ? current.memoizedProps : newProps;
-            var type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        var memoizedUpdaters = root.memoizedUpdaters;
 
-            var _updatePayload = finishedWork.updateQueue;
-            finishedWork.updateQueue = null;
+        if (memoizedUpdaters.size > 0) {
+          restorePendingUpdaters(root, workInProgressRootRenderLanes);
+          memoizedUpdaters.clear();
+        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
+        // If we bailout on this work, we'll move them back (like above).
+        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
+        // That way we can keep the current update and future updates separate.
 
-            if (_updatePayload !== null) {
-              try {
-                commitUpdate(
-                  _instance2,
-                  _updatePayload,
-                  type,
-                  oldProps,
-                  newProps,
-                  finishedWork
-                );
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
+        movePendingFibersToMemoized(root, lanes);
       }
-
-      return;
     }
 
-    case HostText: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    prepareFreshStack(root, lanes);
+  }
 
-      if (flags & Update) {
-        {
-          if (finishedWork.stateNode === null) {
-            throw new Error(
-              "This should have a text node initialized. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          }
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
+    }
+  }
 
-          var textInstance = finishedWork.stateNode;
-          var newText = finishedWork.memoizedProps; // 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.
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
 
-          var oldText = current !== null ? current.memoizedProps : newText;
+  outer: do {
+    try {
+      if (
+        workInProgressSuspendedReason !== NotSuspended &&
+        workInProgress !== null
+      ) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        var unitOfWork = workInProgress;
+        var thrownValue = workInProgressThrownValue;
 
-          try {
-            commitTextUpdate(textInstance, oldText, newText);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration: {
+            // Selective hydration. An update flowed into a dehydrated tree.
+            // Interrupt the current render so the work loop can switch to the
+            // hydration lane.
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootDidNotComplete;
+            break outer;
+          }
+
+          default: {
+            // Continue with the normal work loop.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
           }
         }
       }
 
-      return;
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
     }
+  } while (true);
 
-    case HostRoot: {
-      {
-        prepareToCommitHoistables();
-        var previousHoistableRoot = currentHoistableRoot;
-        currentHoistableRoot = getHoistableRoot(root.containerInfo);
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        currentHoistableRoot = previousHoistableRoot;
-        commitReconciliationEffects(finishedWork);
-      }
-
-      if (flags & Update) {
-        {
-          if (current !== null) {
-            var prevRootState = current.memoizedState;
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
 
-            if (prevRootState.isDehydrated) {
-              try {
-                commitHydratedContainer(root.containerInfo);
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
-      }
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw new Error(
+      "Cannot commit an incomplete root. This error is likely caused by a " +
+        "bug in React. Please file an issue."
+    );
+  }
 
-      return;
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
     }
+  }
 
-    case HostPortal: {
-      {
-        var _previousHoistableRoot = currentHoistableRoot;
-        currentHoistableRoot = getHoistableRoot(
-          finishedWork.stateNode.containerInfo
-        );
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork);
-        currentHoistableRoot = _previousHoistableRoot;
-      }
+  if (enableSchedulingProfiler) {
+    markRenderStopped();
+  } // Set this to null to indicate there's no in-progress render.
 
-      return;
-    }
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
 
-    case SuspenseComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      var offscreenFiber = finishedWork.child;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
 
-      if (offscreenFiber.flags & Visibility) {
-        var newState = offscreenFiber.memoizedState;
-        var isHidden = newState !== null;
+/** @noinline */
 
-        if (isHidden) {
-          var wasHidden =
-            offscreenFiber.alternate !== null &&
-            offscreenFiber.alternate.memoizedState !== null;
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
+  }
+}
 
-          if (!wasHidden) {
-            // TODO: Move to passive phase
-            markCommitTimeOfFallback();
-          }
-        }
-      }
+function renderRootConcurrent(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  var prevDispatcher = pushDispatcher(root.containerInfo);
+  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
 
-      if (flags & Update) {
-        try {
-          commitSuspenseCallback(finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        var memoizedUpdaters = root.memoizedUpdaters;
 
-        var wakeables = finishedWork.updateQueue;
+        if (memoizedUpdaters.size > 0) {
+          restorePendingUpdaters(root, workInProgressRootRenderLanes);
+          memoizedUpdaters.clear();
+        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
+        // If we bailout on this work, we'll move them back (like above).
+        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
+        // That way we can keep the current update and future updates separate.
 
-        if (wakeables !== null) {
-          finishedWork.updateQueue = null;
-          attachSuspenseRetryListeners(finishedWork, wakeables);
-        }
+        movePendingFibersToMemoized(root, lanes);
       }
+    }
 
-      return;
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
     }
+  }
 
-    case OffscreenComponent: {
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
-      }
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
 
-      var _newState = finishedWork.memoizedState;
+  outer: do {
+    try {
+      if (
+        workInProgressSuspendedReason !== NotSuspended &&
+        workInProgress !== null
+      ) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        var unitOfWork = workInProgress;
+        var thrownValue = workInProgressThrownValue;
 
-      var _isHidden = _newState !== null;
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnError: {
+            // Unwind then continue with the normal work loop.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
+          }
 
-      var _wasHidden = current !== null && current.memoizedState !== null;
+          case SuspendedOnData: {
+            var thenable = thrownValue;
 
-      if (finishedWork.mode & ConcurrentMode) {
-        // Before committing the children, track on the stack whether this
-        // offscreen subtree was already hidden, so that we don't unmount the
-        // effects again.
-        var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
-        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || _isHidden;
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || _wasHidden;
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-      } else {
-        recursivelyTraverseMutationEffects(root, finishedWork);
-      }
+            if (isThenableResolved(thenable)) {
+              // The data resolved. Try rendering the component again.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(unitOfWork);
+              break;
+            } // The work loop is suspended on data. We should wait for it to
+            // resolve before continuing to render.
+            // TODO: Handle the case where the promise resolves synchronously.
+            // Usually this is handled when we instrument the promise to add a
+            // `status` field, but if the promise already has a status, we won't
+            // have added a listener until right here.
 
-      commitReconciliationEffects(finishedWork);
-      var offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
+            var onResolution = function () {
+              // Check if the root is still suspended on this promise.
+              if (
+                workInProgressSuspendedReason === SuspendedOnData &&
+                workInProgressRoot === root
+              ) {
+                // Mark the root as ready to continue rendering.
+                workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              } // Ensure the root is scheduled. We should do this even if we're
+              // currently working on a different root, so that we resume
+              // rendering later.
 
-      offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
-      // to support batching of `attach` and `detach` calls.
+              ensureRootIsScheduled(root, now$1());
+            };
 
-      offscreenInstance._visibility &= ~OffscreenDetached;
-      offscreenInstance._visibility |=
-        offscreenInstance._pendingVisibility & OffscreenDetached;
+            thenable.then(onResolution, onResolution);
+            break outer;
+          }
 
-      if (flags & Visibility) {
-        // Track the current state on the Offscreen instance so we can
-        // read it during an event
-        if (_isHidden) {
-          offscreenInstance._visibility &= ~OffscreenVisible;
-        } else {
-          offscreenInstance._visibility |= OffscreenVisible;
-        }
+          case SuspendedOnImmediate: {
+            // If this fiber just suspended, it's possible the data is already
+            // cached. Yield to the main thread to give it a chance to ping. If
+            // it does, we can retry immediately without unwinding the stack.
+            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+            break outer;
+          }
 
-        if (_isHidden) {
-          var isUpdate = current !== null;
-          var wasHiddenByAncestorOffscreen =
-            offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
-          //   - This is an update, not first mount.
-          //   - This Offscreen was not hidden before.
-          //   - Ancestor Offscreen was not hidden in previous commit.
+          case SuspendedAndReadyToContinue: {
+            var _thenable = thrownValue;
 
-          if (isUpdate && !_wasHidden && !wasHiddenByAncestorOffscreen) {
-            if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
-              // Disappear the layout effects of all the children
-              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+            if (isThenableResolved(_thenable)) {
+              // The data resolved. Try rendering the component again.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(unitOfWork);
+            } else {
+              // Otherwise, unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
             }
-          }
-        } // Offscreen with manual mode manages visibility manually.
 
-        if (!isOffscreenManual(finishedWork)) {
-          // TODO: This needs to run whenever there's an insertion or update
-          // inside a hidden Offscreen tree.
-          hideOrUnhideAllChildren(finishedWork, _isHidden);
-        }
-      } // TODO: Move to passive phase
+            break;
+          }
 
-      if (flags & Update) {
-        var offscreenQueue = finishedWork.updateQueue;
+          case SuspendedOnDeprecatedThrowPromise: {
+            // Suspended by an old implementation that uses the `throw promise`
+            // pattern. The newer replaying behavior can cause subtle issues
+            // like infinite ping loops. So we maintain the old behavior and
+            // always unwind.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
+          }
 
-        if (offscreenQueue !== null) {
-          var _wakeables = offscreenQueue.wakeables;
+          case SuspendedOnHydration: {
+            // Selective hydration. An update flowed into a dehydrated tree.
+            // Interrupt the current render so the work loop can switch to the
+            // hydration lane.
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootDidNotComplete;
+            break outer;
+          }
 
-          if (_wakeables !== null) {
-            offscreenQueue.wakeables = null;
-            attachSuspenseRetryListeners(finishedWork, _wakeables);
+          default: {
+            throw new Error(
+              "Unexpected SuspendedReason. This is a bug in React."
+            );
           }
         }
       }
 
-      return;
-    }
-
-    case SuspenseListComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-
-      if (flags & Update) {
-        var _wakeables2 = finishedWork.updateQueue;
-
-        if (_wakeables2 !== null) {
-          finishedWork.updateQueue = null;
-          attachSuspenseRetryListeners(finishedWork, _wakeables2);
-        }
+      if (true && ReactCurrentActQueue.current !== null) {
+        // `act` special case: If we're inside an `act` scope, don't consult
+        // `shouldYield`. Always keep working until the render is complete.
+        // This is not just an optimization: in a unit test environment, we
+        // can't trust the result of `shouldYield`, because the host I/O is
+        // likely mocked.
+        workLoopSync();
+      } else {
+        workLoopConcurrent();
       }
 
-      return;
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
     }
+  } while (true);
 
-    case ScopeComponent: {
-      {
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork); // TODO: This is a temporary solution that allowed us to transition away
-        // from React Flare on www.
-
-        if (flags & Ref) {
-          if (current !== null) {
-            safelyDetachRef(finishedWork, finishedWork.return);
-          }
-
-          safelyAttachRef(finishedWork, finishedWork.return);
-        }
-
-        if (flags & Update) {
-          var scopeInstance = finishedWork.stateNode;
-          prepareScopeUpdate(scopeInstance, finishedWork);
-        }
-      }
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
 
-      return;
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
     }
+  } // Check if the tree has completed.
 
-    default: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      return;
+  if (workInProgress !== null) {
+    // Still work remaining.
+    if (enableSchedulingProfiler) {
+      markRenderYielded();
     }
-  }
-}
 
-function commitReconciliationEffects(finishedWork) {
-  // Placement effects (insertions, reorders) can be scheduled on any fiber
-  // type. They needs to happen after the children effects have fired, but
-  // before the effects on this fiber have fired.
-  var flags = finishedWork.flags;
+    return RootInProgress;
+  } else {
+    // Completed the tree.
+    if (enableSchedulingProfiler) {
+      markRenderStopped();
+    } // Set this to null to indicate there's no in-progress render.
 
-  if (flags & Placement) {
-    try {
-      commitPlacement(finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    } // Clear the "placement" from effect tag so that we know that this is
-    // inserted, before any life-cycles like componentDidMount gets called.
-    // TODO: findDOMNode doesn't rely on this any more but isMounted does
-    // and isMounted is deprecated anyway so we should be able to kill this.
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
 
-    finishedWork.flags &= ~Placement;
-  }
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
 
-  if (flags & Hydrating) {
-    finishedWork.flags &= ~Hydrating;
+    return workInProgressRootExitStatus;
   }
 }
+/** @noinline */
 
-function commitLayoutEffects(finishedWork, root, committedLanes) {
-  inProgressLanes = committedLanes;
-  inProgressRoot = root;
-  var current = finishedWork.alternate;
-  commitLayoutEffectOnFiber(root, current, finishedWork);
-  inProgressLanes = null;
-  inProgressRoot = null;
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
+  }
 }
 
-function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
-  var prevDebugFiber = getCurrentFiber();
-
-  if (parentFiber.subtreeFlags & LayoutMask) {
-    var child = parentFiber.child;
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. 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 = unitOfWork.alternate;
+  setCurrentFiber(unitOfWork);
+  var next;
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      var current = child.alternate;
-      commitLayoutEffectOnFiber(root, current, child);
-      child = child.sibling;
-    }
+  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
+    startProfilerTimer(unitOfWork);
+    next = beginWork(current, unitOfWork, renderLanes);
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } else {
+    next = beginWork(current, unitOfWork, renderLanes);
   }
 
-  setCurrentFiber(prevDebugFiber);
-}
+  resetCurrentFiber();
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
 
-function disappearLayoutEffects(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      // TODO (Offscreen) Check: flags & LayoutStatic
-      if (shouldProfile(finishedWork)) {
-        try {
-          startLayoutEffectTimer();
-          commitHookEffectListUnmount(
-            Layout,
-            finishedWork,
-            finishedWork.return
-          );
-        } finally {
-          recordLayoutEffectDuration(finishedWork);
-        }
-      } else {
-        commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
-      }
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
 
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
-    }
+  ReactCurrentOwner$1.current = null;
+}
 
-    case ClassComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      var instance = finishedWork.stateNode;
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  var current = unitOfWork.alternate;
+  setCurrentFiber(unitOfWork);
+  var next;
+  setCurrentFiber(unitOfWork);
+  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
 
-      if (typeof instance.componentWillUnmount === "function") {
-        safelyCallComponentWillUnmount(
-          finishedWork,
-          finishedWork.return,
-          instance
-        );
-      }
+  if (isProfilingMode) {
+    startProfilerTimer(unitOfWork);
+  }
 
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent: {
+      // Because it suspended with `use`, we can assume it's a
+      // function component.
+      unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
     }
+    // eslint-disable-next-line no-fallthrough
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+    case FunctionComponent:
+    case ForwardRef: {
+      // Resolve `defaultProps`. This logic is copied from `beginWork`.
+      // TODO: Consider moving this switch statement into that module. Also,
+      // could maybe use this as an opportunity to say `use` doesn't work with
+      // `defaultProps` :)
+      var Component = unitOfWork.type;
+      var unresolvedProps = unitOfWork.pendingProps;
+      var resolvedProps =
+        unitOfWork.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      next = replayFunctionComponent(
+        current,
+        unitOfWork,
+        resolvedProps,
+        Component,
+        workInProgressRootRenderLanes
+      );
       break;
     }
 
-    case OffscreenComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      var isHidden = finishedWork.memoizedState !== null;
-
-      if (isHidden);
-      else {
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      }
-
+    case SimpleMemoComponent: {
+      var _Component = unitOfWork.type;
+      var nextProps = unitOfWork.pendingProps;
+      next = replayFunctionComponent(
+        current,
+        unitOfWork,
+        nextProps,
+        _Component,
+        workInProgressRootRenderLanes
+      );
       break;
     }
 
     default: {
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      // Other types besides function components are reset completely before
+      // being replayed. Currently this only happens when a Usable type is
+      // reconciled — the reconciler will suspend.
+      //
+      // We reset the fiber back to its original state; however, this isn't
+      // a full "unwind" because we're going to reuse the promises that were
+      // reconciled previously. So it's intentional that we don't call
+      // resetSuspendedWorkLoopOnUnwind here.
+      unwindInterruptedWork(current, unitOfWork);
+      unitOfWork = workInProgress = resetWorkInProgress(
+        unitOfWork,
+        renderLanes
+      );
+      next = beginWork(current, unitOfWork, renderLanes);
       break;
     }
   }
+
+  if (isProfilingMode) {
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } // The begin phase finished successfully without suspending. Return to the
+  // normal work loop.
+
+  resetCurrentFiber();
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner$1.current = null;
 }
 
-function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
-  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
-  var child = parentFiber.child;
+function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind();
+  var returnFiber = unitOfWork.return;
 
-  while (child !== null) {
-    disappearLayoutEffects(child);
-    child = child.sibling;
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
   }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(
+      workInProgressRoot,
+      returnFiber,
+      unitOfWork,
+      thrownValue,
+      workInProgressRootRenderLanes
+    );
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  } // Return to the normal work loop.
+
+  completeUnitOfWork(unitOfWork);
 }
 
-function reappearLayoutEffects(
-  finishedRoot,
-  current,
-  finishedWork, // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  includeWorkInProgressEffects
-) {
-  // Turn on layout effects in a tree that previously disappeared.
-  var flags = finishedWork.flags;
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  var completedWork = unitOfWork;
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Check flags & LayoutStatic
+  do {
+    // The current, flushed, state of this fiber is the alternate. 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 = completedWork.alternate;
+    var returnFiber = completedWork.return; // Check if the work completed or if something threw.
 
-      commitHookLayoutEffects(finishedWork, Layout);
-      break;
-    }
+    if ((completedWork.flags & Incomplete) === NoFlags$1) {
+      setCurrentFiber(completedWork);
+      var next = void 0;
 
-    case ClassComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Check for LayoutStatic flag
+      if ((completedWork.mode & ProfileMode) === NoMode) {
+        next = completeWork(current, completedWork, renderLanes);
+      } else {
+        startProfilerTimer(completedWork);
+        next = completeWork(current, completedWork, renderLanes); // Update render duration assuming we didn't error.
 
-      var instance = finishedWork.stateNode;
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
+      }
 
-      if (typeof instance.componentDidMount === "function") {
-        try {
-          instance.componentDidMount();
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
-      } // Commit any callbacks that would have fired while the component
-      // was hidden.
+      resetCurrentFiber();
 
-      var updateQueue = finishedWork.updateQueue;
+      if (next !== null) {
+        // Completing this fiber spawned new work. Work on that next.
+        workInProgress = next;
+        return;
+      }
+    } else {
+      // This fiber did not complete because something threw. Pop values off
+      // the stack without entering the complete phase. If this is a boundary,
+      // capture values if possible.
+      var _next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.
 
-      if (updateQueue !== null) {
-        commitHiddenCallbacks(updateQueue, instance);
-      } // If this is newly finished work, check for setState callbacks
+      if (_next !== null) {
+        // 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
+        // from the effect tag.
+        _next.flags &= HostEffectMask;
+        workInProgress = _next;
+        return;
+      }
 
-      if (includeWorkInProgressEffects && flags & Callback) {
-        commitClassCallbacks(finishedWork);
-      } // TODO: Check flags & RefStatic
+      if ((completedWork.mode & ProfileMode) !== NoMode) {
+        // Record the render duration for the fiber that errored.
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
+        var actualDuration = completedWork.actualDuration;
+        var child = completedWork.child;
+
+        while (child !== null) {
+          // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+          actualDuration += child.actualDuration;
+          child = child.sibling;
+        }
+
+        completedWork.actualDuration = actualDuration;
+      }
+
+      if (returnFiber !== null) {
+        // Mark the parent fiber as incomplete and clear its subtree flags.
+        returnFiber.flags |= Incomplete;
+        returnFiber.subtreeFlags = NoFlags$1;
+        returnFiber.deletions = null;
+      } else {
+        // We've unwound all the way to the root.
+        workInProgressRootExitStatus = RootDidNotComplete;
+        workInProgress = null;
+        return;
+      }
     }
-    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
-    // because this function only visits nodes that are inside an
-    // Offscreen fiber.
-    // case HostRoot: {
-    //  ...
-    // }
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // Renderers may schedule work to be done after host components are mounted
-      // (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.
+    var siblingFiber = completedWork.sibling;
 
-      if (includeWorkInProgressEffects && current === null && flags & Update) {
-        commitHostComponentMount(finishedWork);
-      } // TODO: Check flags & Ref
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
+
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
+  }
+}
+
+function commitRoot(root, recoverableErrors, transitions) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  var previousUpdateLanePriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(
+      root,
+      recoverableErrors,
+      transitions,
+      previousUpdateLanePriority
+    );
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
+
+  return null;
+}
+
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
+) {
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    }
+  flushRenderPhaseStrictModeWarningsInDEV();
 
-    case Profiler: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Figure out how Profiler updates should work with Offscreen
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
+  }
 
-      if (includeWorkInProgressEffects && flags & Update) {
-        commitProfilerUpdate(finishedWork, current);
-      }
+  var finishedWork = root.finishedWork;
+  var lanes = root.finishedLanes;
 
-      break;
+  {
+    if (enableDebugTracing) {
+      logCommitStarted(lanes);
     }
+  }
 
-    case SuspenseComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Figure out how Suspense hydration callbacks should work
-      // with Offscreen.
+  if (enableSchedulingProfiler) {
+    markCommitStarted(lanes);
+  }
 
-      if (includeWorkInProgressEffects && flags & Update) {
-        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+  if (finishedWork === null) {
+    {
+      if (enableDebugTracing) {
+        logCommitStopped();
       }
-
-      break;
     }
 
-    case OffscreenComponent: {
-      var offscreenState = finishedWork.memoizedState;
-      var isHidden = offscreenState !== null;
-
-      if (isHidden);
-      else {
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-      } // TODO: Check flags & Ref
-
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
+    if (enableSchedulingProfiler) {
+      markCommitStopped();
     }
 
-    default: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      );
-      break;
+    return null;
+  } else {
+    {
+      if (lanes === NoLanes) {
+        error(
+          "root.finishedLanes should not be empty during a commit. This is a " +
+            "bug in React."
+        );
+      }
     }
   }
-}
-
-function recursivelyTraverseReappearLayoutEffects(
-  finishedRoot,
-  parentFiber,
-  includeWorkInProgressEffects
-) {
-  // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  var childShouldIncludeWorkInProgressEffects =
-    includeWorkInProgressEffects &&
-    (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
 
-  var prevDebugFiber = getCurrentFiber();
-  var child = parentFiber.child;
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
 
-  while (child !== null) {
-    var current = child.alternate;
-    reappearLayoutEffects(
-      finishedRoot,
-      current,
-      child,
-      childShouldIncludeWorkInProgressEffects
+  if (finishedWork === root.current) {
+    throw new Error(
+      "Cannot commit the same tree as before. This error is likely caused by " +
+        "a bug in React. Please file an issue."
     );
-    child = child.sibling;
-  }
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
 
-  setCurrentFiber(prevDebugFiber);
-}
+  root.callbackNode = null;
+  root.callbackPriority = NoLane; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
 
-function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  if (shouldProfile(finishedWork)) {
-    startPassiveEffectTimer();
+  var remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
 
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
+  var concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes);
 
-    recordPassiveEffectDuration(finishedWork);
-  } else {
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
-  }
-}
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
 
-function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
-  {
-    var previousCache = null;
+  if (
+    (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 ||
+    (finishedWork.flags & PassiveMask) !== NoFlags$1
+  ) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
 
-    if (
-      current !== null &&
-      current.memoizedState !== null &&
-      current.memoizedState.cachePool !== null
-    ) {
-      previousCache = current.memoizedState.cachePool.pool;
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+
+        return null;
+      });
     }
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
 
-    var nextCache = null;
+  var subtreeHasEffects =
+    (finishedWork.subtreeFlags &
+      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
+    NoFlags$1;
+  var rootHasEffect =
+    (finishedWork.flags &
+      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
+    NoFlags$1;
 
-    if (
-      finishedWork.memoizedState !== null &&
-      finishedWork.memoizedState.cachePool !== null
-    ) {
-      nextCache = finishedWork.memoizedState.cachePool.pool;
-    } // Retain/release the cache used for pending (suspended) nodes.
-    // Note that this is only reached in the non-suspended/visible case:
-    // when the content is suspended/hidden, the retain/release occurs
-    // via the parent Suspense component (see case above).
+  if (subtreeHasEffects || rootHasEffect) {
+    var prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    var prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
 
-    if (nextCache !== previousCache) {
-      if (nextCache != null) {
-        retainCache(nextCache);
-      }
+    ReactCurrentOwner$1.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
 
-      if (previousCache != null) {
-        releaseCache(previousCache);
-      }
+    var shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
+
+    {
+      // Mark the current commit time to be shared by all Profilers in this
+      // batch. This enables them to be grouped later.
+      recordCommitTime();
     }
-  }
 
-  if (enableTransitionTracing) {
-    // TODO: Pre-rendering should not be counted as part of a transition. We
-    // may add separate logs for pre-rendering, but it's not part of the
-    // primary metrics.
-    var offscreenState = finishedWork.memoizedState;
-    var queue = finishedWork.updateQueue;
-    var isHidden = offscreenState !== null;
+    if (enableProfilerNestedUpdateScheduledHook) {
+      // Track the root here, rather than in commitLayoutEffects(), because of ref setters.
+      // Updates scheduled during ref detachment should also be flagged.
+      rootCommittingMutationOrLayoutEffects = root;
+    } // The next phase is the mutation phase, where we mutate the host tree.
 
-    if (queue !== null) {
-      if (isHidden) {
-        var transitions = queue.transitions;
+    commitMutationEffects(root, finishedWork, lanes);
 
-        if (transitions !== null) {
-          transitions.forEach(function (transition) {
-            // Add all the transitions saved in the update queue during
-            // the render phase (ie the transitions associated with this boundary)
-            // into the transitions set.
-            if (instance._transitions === null) {
-              instance._transitions = new Set();
-            }
+    {
+      if (shouldFireAfterActiveInstanceBlur) {
+        afterActiveInstanceBlur();
+      }
+    }
 
-            instance._transitions.add(transition);
-          });
-        }
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
 
-        var markerInstances = queue.markerInstances;
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+    // the host tree after it's been mutated. The idiomatic use case for this is
+    // layout, but class component lifecycles also fire here for legacy reasons.
 
-        if (markerInstances !== null) {
-          markerInstances.forEach(function (markerInstance) {
-            var markerTransitions = markerInstance.transitions; // There should only be a few tracing marker transitions because
-            // they should be only associated with the transition that
-            // caused them
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStarted(lanes);
+      }
+    }
 
-            if (markerTransitions !== null) {
-              markerTransitions.forEach(function (transition) {
-                if (instance._transitions === null) {
-                  instance._transitions = new Set();
-                } else if (instance._transitions.has(transition)) {
-                  if (markerInstance.pendingBoundaries === null) {
-                    markerInstance.pendingBoundaries = new Map();
-                  }
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStarted(lanes);
+    }
 
-                  if (instance._pendingMarkers === null) {
-                    instance._pendingMarkers = new Set();
-                  }
+    commitLayoutEffects(finishedWork, root, lanes);
 
-                  instance._pendingMarkers.add(markerInstance);
-                }
-              });
-            }
-          });
-        }
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStopped();
       }
+    }
 
-      finishedWork.updateQueue = null;
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStopped();
     }
 
-    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
+    if (enableProfilerNestedUpdateScheduledHook) {
+      rootCommittingMutationOrLayoutEffects = null;
+    } // Tell Scheduler to yield at the end of the frame, so the browser has an
+    // opportunity to paint.
 
-    if (!isHidden) {
-      instance._transitions = null;
-      instance._pendingMarkers = null;
-    }
-  }
-}
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
 
-function commitCachePassiveMountEffect(current, finishedWork) {
-  {
-    var previousCache = null;
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+    // no effects.
+    // TODO: Maybe there's a better way to report this.
 
-    if (finishedWork.alternate !== null) {
-      previousCache = finishedWork.alternate.memoizedState.cache;
+    {
+      recordCommitTime();
     }
+  }
 
-    var nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
-    // could be "borrowing" a cache instance owned by some parent,
-    // in which case we could avoid retaining/releasing. But it
-    // is non-trivial to determine when that is the case, so we
-    // always retain/release.
+  var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
 
-    if (nextCache !== previousCache) {
-      retainCache(nextCache);
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
 
-      if (previousCache != null) {
-        releaseCache(previousCache);
-      }
+    {
+      nestedPassiveUpdateCount = 0;
+      rootWithPassiveNestedUpdates = null;
     }
-  }
-}
+  } // Read this again, since an effect might have updated it
 
-function commitTracingMarkerPassiveMountEffect(finishedWork) {
-  // Get the transitions that were initiatized during the render
-  // and add a start transition callback for each of them
-  // We will only call this on initial mount of the tracing marker
-  // only if there are no suspense children
-  var instance = finishedWork.stateNode;
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
 
-  if (instance.transitions !== null && instance.pendingBoundaries === null) {
-    addMarkerCompleteCallbackToPendingTransition(
-      finishedWork.memoizedProps.name,
-      instance.transitions
-    );
-    instance.transitions = null;
-    instance.pendingBoundaries = null;
-    instance.aborts = null;
-    instance.name = null;
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
   }
-}
 
-function commitPassiveMountEffects(
-  root,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  setCurrentFiber(finishedWork);
-  commitPassiveMountOnFiber(
-    root,
-    finishedWork,
-    committedLanes,
-    committedTransitions
-  );
-  resetCurrentFiber();
-}
-
-function recursivelyTraversePassiveMountEffects(
-  root,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  var prevDebugFiber = getCurrentFiber();
+  {
+    if (!rootDidHavePassiveEffects) {
+      commitDoubleInvokeEffectsInDEV(root, false);
+    }
+  }
 
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+  onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitPassiveMountOnFiber(
-        root,
-        child,
-        committedLanes,
-        committedTransitions
-      );
-      child = child.sibling;
+  {
+    if (isDevToolsPresent) {
+      root.memoizedUpdaters.clear();
     }
   }
 
-  setCurrentFiber(prevDebugFiber);
-}
-
-function commitPassiveMountOnFiber(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  // When updating this function, also update reconnectPassiveEffects, which does
-  // most of the same things when an offscreen tree goes from hidden -> visible,
-  // or when toggling effects inside a hidden tree.
-  var flags = finishedWork.flags;
+  {
+    onCommitRoot();
+  } // Always call this before exiting `commitRoot`, to ensure that any
+  // additional work on this root is scheduled.
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
+  ensureRootIsScheduled(root, now$1());
 
-      if (flags & Passive$1) {
-        commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
-      }
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    var onRecoverableError = root.onRecoverableError;
 
-      break;
+    for (var i = 0; i < recoverableErrors.length; i++) {
+      var recoverableError = recoverableErrors[i];
+      var errorInfo = makeErrorInfo(
+        recoverableError.digest,
+        recoverableError.stack
+      );
+      onRecoverableError(recoverableError.value, errorInfo);
     }
+  }
 
-    case HostRoot: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    var error$1 = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error$1;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
 
-      if (flags & Passive$1) {
-        {
-          var previousCache = null;
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
 
-          if (finishedWork.alternate !== null) {
-            previousCache = finishedWork.alternate.memoizedState.cache;
-          }
+  remainingLanes = root.pendingLanes;
 
-          var nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
-          // Note that on initial mount, previousCache and nextCache will be the same
-          // and this retain won't occur. To counter this, we instead retain the HostRoot's
-          // initial cache when creating the root itself (see createFiberRoot() in
-          // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
-          // here, such that previous/next caches are retained correctly.
+  if (includesSyncLane(remainingLanes)) {
+    {
+      markNestedUpdateScheduled();
+    } // Count the number of times the root synchronously re-renders without
+    // finishing. If there are too many, it indicates an infinite update loop.
 
-          if (nextCache !== previousCache) {
-            retainCache(nextCache);
+    if (root === rootWithNestedUpdates) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
+    }
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
 
-            if (previousCache != null) {
-              releaseCache(previousCache);
-            }
-          }
-        }
+  flushSyncCallbacks();
 
-        if (enableTransitionTracing) {
-          // Get the transitions that were initiatized during the render
-          // and add a start transition callback for each of them
-          var root = finishedWork.stateNode;
-          var incompleteTransitions = root.incompleteTransitions; // Initial render
+  {
+    if (enableDebugTracing) {
+      logCommitStopped();
+    }
+  }
 
-          if (committedTransitions !== null) {
-            committedTransitions.forEach(function (transition) {
-              addTransitionStartCallbackToPendingTransition(transition);
-            });
-            clearTransitionsForLanes(finishedRoot, committedLanes);
-          }
+  if (enableSchedulingProfiler) {
+    markCommitStopped();
+  }
 
-          incompleteTransitions.forEach(function (markerInstance, transition) {
-            var pendingBoundaries = markerInstance.pendingBoundaries;
+  if (enableTransitionTracing) {
+    // We process transitions during passive effects. However, passive effects can be
+    // processed synchronously during the commit phase as well as asynchronously after
+    // paint. At the end of the commit phase, we schedule a callback that will be called
+    // after the next paint. If the transitions have already been processed (passive
+    // effect phase happened synchronously), we will schedule a callback to process
+    // the transitions. However, if we don't have any pending transition callbacks, this
+    // means that the transitions have yet to be processed (passive effects processed after paint)
+    // so we will store the end time of paint so that we can process the transitions
+    // and then call the callback via the correct end time.
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
 
-            if (pendingBoundaries === null || pendingBoundaries.size === 0) {
-              if (markerInstance.aborts === null) {
-                addTransitionCompleteCallbackToPendingTransition(transition);
-              }
+    if (prevRootTransitionCallbacks !== null) {
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
 
-              incompleteTransitions.delete(transition);
-            }
+        if (prevPendingTransitionCallbacks !== null) {
+          currentPendingTransitionCallbacks = null;
+          scheduleCallback(IdlePriority, function () {
+            processTransitionCallbacks(
+              prevPendingTransitionCallbacks,
+              endTime,
+              prevRootTransitionCallbacks
+            );
           });
-          clearTransitionsForLanes(finishedRoot, committedLanes);
+        } else {
+          currentEndTime = endTime;
         }
-      }
-
-      break;
+      });
     }
+  }
 
-    case LegacyHiddenComponent: {
-      {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
+  return null;
+}
+
+function makeErrorInfo(digest, componentStack) {
+  {
+    var errorInfo = {
+      componentStack: componentStack,
+      digest: digest
+    };
+    Object.defineProperty(errorInfo, "digest", {
+      configurable: false,
+      enumerable: true,
+      get: function () {
+        error(
+          'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
+            " This property is deprecated and will be removed in a future version of React." +
+            " To access the digest of an Error look for this property on the Error instance itself."
         );
 
-        if (flags & Passive$1) {
-          var current = finishedWork.alternate;
-          var instance = finishedWork.stateNode;
-          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-        }
+        return digest;
       }
+    });
+    return errorInfo;
+  }
+}
 
-      break;
-    }
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    var pooledCacheLanes = (root.pooledCacheLanes &= remainingLanes);
 
-    case OffscreenComponent: {
-      // TODO: Pass `current` as argument to this function
-      var _instance3 = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      var pooledCache = root.pooledCache;
 
-      if (isHidden) {
-        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          );
-        } else {
-          if (finishedWork.mode & ConcurrentMode) {
-            // The effects are currently disconnected. Since the tree is hidden,
-            // don't connect them. This also applies to the initial render.
-            {
-              // "Atomic" effects are ones that need to fire on every commit,
-              // even during pre-rendering. An example is updating the reference
-              // count on cache instances.
-              recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              );
-            }
-          } else {
-            // Legacy Mode: Fire the effects even if the tree is hidden.
-            _instance3._visibility |= OffscreenPassiveEffectsConnected;
-            recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            );
-          }
-        }
-      } else {
-        // Tree is visible
-        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          );
-        } else {
-          // The effects are currently disconnected. Reconnect them, while also
-          // firing effects inside newly mounted trees. This also applies to
-          // the initial render.
-          _instance3._visibility |= OffscreenPassiveEffectsConnected;
-          var includeWorkInProgressEffects =
-            (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
-          );
-        }
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
       }
+    }
+  }
+}
 
-      if (flags & Passive$1) {
-        var _current = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
-      }
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    var root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
 
-      break;
-    }
+    var remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    var prevTransition = ReactCurrentBatchConfig$1.transition;
+    var previousPriority = getCurrentUpdatePriority();
 
-    case CacheComponent: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current2 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current2, finishedWork);
-      }
+      releaseRootPooledCache(root, remainingLanes);
+    }
+  }
 
-      break;
+  return false;
+}
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  {
+    pendingPassiveProfilerEffects.push(fiber);
+
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects();
+        return null;
+      });
     }
+  }
+}
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
-        );
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
 
-        if (flags & Passive$1) {
-          commitTracingMarkerPassiveMountEffect(finishedWork);
-        }
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects;
+  var lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
 
-        break;
-      } // Intentional fallthrough to next branch
-    }
-    // eslint-disable-next-line-no-fallthrough
+  pendingPassiveEffectsLanes = NoLanes;
 
-    default: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-      break;
-    }
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Cannot flush passive effects while already rendering.");
   }
-}
 
-function recursivelyTraverseReconnectPassiveEffects(
-  finishedRoot,
-  parentFiber,
-  committedLanes,
-  committedTransitions,
-  includeWorkInProgressEffects
-) {
-  // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  var childShouldIncludeWorkInProgressEffects =
-    includeWorkInProgressEffects &&
-    (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  {
+    isFlushingPassiveEffects = true;
+    didScheduleUpdateDuringPassiveEffects = false;
 
-  var prevDebugFiber = getCurrentFiber();
-  var child = parentFiber.child;
+    if (enableDebugTracing) {
+      logPassiveEffectsStarted(lanes);
+    }
+  }
 
-  while (child !== null) {
-    reconnectPassiveEffects(
-      finishedRoot,
-      child,
-      committedLanes,
-      committedTransitions,
-      childShouldIncludeWorkInProgressEffects
-    );
-    child = child.sibling;
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStarted(lanes);
   }
 
-  setCurrentFiber(prevDebugFiber);
-}
+  var prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
 
-function reconnectPassiveEffects(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions, // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  includeWorkInProgressEffects
-) {
-  var flags = finishedWork.flags;
+  {
+    var profilerEffects = pendingPassiveProfilerEffects;
+    pendingPassiveProfilerEffects = [];
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      ); // TODO: Check for PassiveStatic flag
+    for (var i = 0; i < profilerEffects.length; i++) {
+      var fiber = profilerEffects[i];
+      commitPassiveEffectDurations(root, fiber);
+    }
+  }
 
-      commitHookPassiveMountEffects(finishedWork, Passive);
-      break;
+  {
+    if (enableDebugTracing) {
+      logPassiveEffectsStopped();
     }
-    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
-    // because this function only visits nodes that are inside an
-    // Offscreen fiber.
-    // case HostRoot: {
-    //  ...
-    // }
+  }
 
-    case LegacyHiddenComponent: {
-      {
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStopped();
+  }
 
-        if (includeWorkInProgressEffects && flags & Passive$1) {
-          // TODO: Pass `current` as argument to this function
-          var current = finishedWork.alternate;
-          var instance = finishedWork.stateNode;
-          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-        }
-      }
+  {
+    commitDoubleInvokeEffectsInDEV(root, true);
+  }
 
-      break;
-    }
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
 
-    case OffscreenComponent: {
-      var _instance4 = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    var prevEndTime = currentEndTime;
 
-      if (isHidden) {
-        if (_instance4._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
-          );
-        } else {
-          if (finishedWork.mode & ConcurrentMode) {
-            // The effects are currently disconnected. Since the tree is hidden,
-            // don't connect them. This also applies to the initial render.
-            {
-              // "Atomic" effects are ones that need to fire on every commit,
-              // even during pre-rendering. An example is updating the reference
-              // count on cache instances.
-              recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              );
-            }
-          } else {
-            // Legacy Mode: Fire the effects even if the tree is hidden.
-            _instance4._visibility |= OffscreenPassiveEffectsConnected;
-            recursivelyTraverseReconnectPassiveEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions,
-              includeWorkInProgressEffects
-            );
-          }
-        }
-      } else {
-        // Tree is visible
-        // Since we're already inside a reconnecting tree, it doesn't matter
-        // whether the effects are currently connected. In either case, we'll
-        // continue traversing the tree and firing all the effects.
-        //
-        // We do need to set the "connected" flag on the instance, though.
-        _instance4._visibility |= OffscreenPassiveEffectsConnected;
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+    if (
+      prevPendingTransitionCallbacks !== null &&
+      prevRootTransitionCallbacks !== null &&
+      prevEndTime !== null
+    ) {
+      currentPendingTransitionCallbacks = null;
+      currentEndTime = null;
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
         );
-      }
+      });
+    }
+  }
 
-      if (includeWorkInProgressEffects && flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current3 = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
+  {
+    // If additional passive effects were scheduled, increment a counter. If this
+    // exceeds the limit, we'll fire a warning.
+    if (didScheduleUpdateDuringPassiveEffects) {
+      if (root === rootWithPassiveNestedUpdates) {
+        nestedPassiveUpdateCount++;
+      } else {
+        nestedPassiveUpdateCount = 0;
+        rootWithPassiveNestedUpdates = root;
       }
-
-      break;
+    } else {
+      nestedPassiveUpdateCount = 0;
     }
 
-    case CacheComponent: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      );
-
-      if (includeWorkInProgressEffects && flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current4 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current4, finishedWork);
-      }
+    isFlushingPassiveEffects = false;
+    didScheduleUpdateDuringPassiveEffects = false;
+  } // TODO: Move to commitPassiveMountEffects
 
-      break;
-    }
+  onPostCommitRoot(root);
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
+  {
+    var stateNode = root.current.stateNode;
+    stateNode.effectDuration = 0;
+    stateNode.passiveEffectDuration = 0;
+  }
 
-        if (includeWorkInProgressEffects && flags & Passive$1) {
-          commitTracingMarkerPassiveMountEffect(finishedWork);
-        }
+  return true;
+}
 
-        break;
-      } // Intentional fallthrough to next branch
-    }
-    // eslint-disable-next-line-no-fallthrough
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return (
+    legacyErrorBoundariesThatAlreadyFailed !== null &&
+    legacyErrorBoundariesThatAlreadyFailed.has(instance)
+  );
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
 
-    default: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      );
-      break;
-    }
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
   }
 }
 
-function recursivelyTraverseAtomicPassiveEffects(
-  finishedRoot,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  // "Atomic" effects are ones that need to fire on every commit, even during
-  // pre-rendering. We call this function when traversing a hidden tree whose
-  // regular effects are currently disconnected.
-  var prevDebugFiber = getCurrentFiber(); // TODO: Add special flag for atomic effects
+var onUncaughtError = prepareToThrowUncaughtError;
 
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  var errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  var root = enqueueUpdate(rootFiber, update, SyncLane);
+  var eventTime = requestEventTime();
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitAtomicPassiveEffects(finishedRoot, child);
-      child = child.sibling;
-    }
+  if (root !== null) {
+    markRootUpdated(root, SyncLane, eventTime);
+    ensureRootIsScheduled(root, eventTime);
   }
-
-  setCurrentFiber(prevDebugFiber);
 }
 
-function commitAtomicPassiveEffects(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  // "Atomic" effects are ones that need to fire on every commit, even during
-  // pre-rendering. We call this function when traversing a hidden tree whose
-  // regular effects are currently disconnected.
-  var flags = finishedWork.flags;
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
+  {
+    reportUncaughtErrorInDEV(error$1);
+    setIsRunningInsertionEffect(false);
+  }
 
-  switch (finishedWork.tag) {
-    case OffscreenComponent: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error$1);
+    return;
+  }
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var current = finishedWork.alternate;
-        var instance = finishedWork.stateNode;
-        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-      }
+  var fiber = null;
 
-      break;
-    }
+  if (skipUnmountedBoundaries) {
+    fiber = nearestMountedAncestor;
+  } else {
+    fiber = sourceFiber.return;
+  }
 
-    case CacheComponent: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error$1);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      var ctor = fiber.type;
+      var instance = fiber.stateNode;
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current5 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current5, finishedWork);
-      }
+      if (
+        typeof ctor.getDerivedStateFromError === "function" ||
+        (typeof instance.componentDidCatch === "function" &&
+          !isAlreadyFailedLegacyErrorBoundary(instance))
+      ) {
+        var errorInfo = createCapturedValueAtFiber(error$1, sourceFiber);
+        var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        var root = enqueueUpdate(fiber, update, SyncLane);
+        var eventTime = requestEventTime();
 
-      break;
-    }
-    // eslint-disable-next-line-no-fallthrough
+        if (root !== null) {
+          markRootUpdated(root, SyncLane, eventTime);
+          ensureRootIsScheduled(root, eventTime);
+        }
 
-    default: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-      break;
+        return;
+      }
     }
+
+    fiber = fiber.return;
   }
-}
 
-function commitPassiveUnmountEffects(finishedWork) {
-  setCurrentFiber(finishedWork);
-  commitPassiveUnmountOnFiber(finishedWork);
-  resetCurrentFiber();
+  {
+    // TODO: Until we re-land skipUnmountedBoundaries (see #20147), this warning
+    // will fire for errors that are thrown by destroy functions inside deleted
+    // trees. What it should instead do is propagate the error to the parent of
+    // the deleted tree. In the meantime, do not add this warning to the
+    // allowlist; this is only for our internal use.
+    error(
+      "Internal React error: Attempted to capture a commit phase error " +
+        "inside a detached tree. This indicates a bug in React. Likely " +
+        "causes include deleting the same fiber more than once, committing an " +
+        "already-finished tree, or an inconsistent return pointer.\n\n" +
+        "Error message:\n\n%s",
+      error$1
+    );
+  }
 }
-
-function detachAlternateSiblings(parentFiber) {
-  // A fiber was deleted from this parent fiber, but it's still part of the
-  // previous (alternate) parent fiber's list of children. Because children
-  // are a linked list, an earlier sibling that's still alive will be
-  // connected to the deleted fiber via its `alternate`:
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
   //
-  //   live fiber --alternate--> previous live fiber --sibling--> deleted
-  //   fiber
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
   //
-  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
-  // but we can disconnect the `sibling` and `child` pointers.
-  var previousFiber = parentFiber.alternate;
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  var pingCache = root.pingCache;
+  var threadIDs;
 
-  if (previousFiber !== null) {
-    var detachedChild = previousFiber.child;
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
 
-    if (detachedChild !== null) {
-      previousFiber.child = null;
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    }
+  }
 
-      do {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        var detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
 
-        detachedChild.sibling = null;
-        detachedChild = detachedSibling;
-      } while (detachedChild !== null);
+    threadIDs.add(lanes);
+    var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
+
+    {
+      if (isDevToolsPresent) {
+        // If we have pending work still, restore the original updaters
+        restorePendingUpdaters(root, lanes);
+      }
     }
-  }
-}
 
-function commitHookPassiveUnmountEffects(
-  finishedWork,
-  nearestMountedAncestor,
-  hookFlags
-) {
-  if (shouldProfile(finishedWork)) {
-    startPassiveEffectTimer();
-    commitHookEffectListUnmount(
-      hookFlags,
-      finishedWork,
-      nearestMountedAncestor
-    );
-    recordPassiveEffectDuration(finishedWork);
-  } else {
-    commitHookEffectListUnmount(
-      hookFlags,
-      finishedWork,
-      nearestMountedAncestor
-    );
+    wakeable.then(ping, ping);
   }
 }
 
-function recursivelyTraversePassiveUnmountEffects(parentFiber) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects have fired.
-  var deletions = parentFiber.deletions;
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
 
-  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
-    if (deletions !== null) {
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
 
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
+  var eventTime = requestEventTime();
+  markRootPinged(root, pingedLanes);
+  warnIfSuspenseResolutionNotWrappedWithActDEV(root);
+
+  if (
+    workInProgressRoot === root &&
+    isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)
+  ) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (
+      workInProgressRootExitStatus === RootSuspendedWithDelay ||
+      (workInProgressRootExitStatus === RootSuspended &&
+        includesOnlyRetries(workInProgressRootRenderLanes) &&
+        now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
+    ) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
       }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(
+        workInProgressRootPingedLanes,
+        pingedLanes
+      );
     }
-
-    detachAlternateSiblings(parentFiber);
   }
 
-  var prevDebugFiber = getCurrentFiber(); // TODO: Split PassiveMask into separate masks for mount and unmount?
+  ensureRootIsScheduled(root, eventTime);
+}
 
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitPassiveUnmountOnFiber(child);
-      child = child.sibling;
-    }
-  }
+  var eventTime = requestEventTime();
+  var root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
 
-  setCurrentFiber(prevDebugFiber);
+  if (root !== null) {
+    markRootUpdated(root, retryLane, eventTime);
+    ensureRootIsScheduled(root, eventTime);
+  }
 }
 
-function commitPassiveUnmountOnFiber(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState;
+  var retryLane = NoLane;
 
-      if (finishedWork.flags & Passive$1) {
-        commitHookPassiveUnmountEffects(
-          finishedWork,
-          finishedWork.return,
-          Passive | HasEffect
-        );
-      }
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
 
-      break;
-    }
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = NoLane; // Default
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+  var retryCache;
 
-      if (
-        isHidden &&
-        instance._visibility & OffscreenPassiveEffectsConnected && // For backwards compatibility, don't unmount when a tree suspends. In
-        // the future we may change this to unmount after a delay.
-        (finishedWork.return === null ||
-          finishedWork.return.tag !== SuspenseComponent)
-      ) {
-        // The effects are currently connected. Disconnect them.
-        // TODO: Add option or heuristic to delay before disconnecting the
-        // effects. Then if the tree reappears before the delay has elapsed, we
-        // can skip toggling the effects entirely.
-        instance._visibility &= ~OffscreenPassiveEffectsConnected;
-        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      } else {
-        recursivelyTraversePassiveUnmountEffects(finishedWork);
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
+
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
       }
 
       break;
-    }
 
-    default: {
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
+
+    case OffscreenComponent: {
+      var instance = boundaryFiber.stateNode;
+      retryCache = instance._retryCache;
       break;
     }
+
+    default:
+      throw new Error(
+        "Pinged unknown suspense boundary type. " +
+          "This is probably a bug in React."
+      );
   }
-}
 
-function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects have fired.
-  var deletions = parentFiber.deletions;
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
+  }
 
-  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
-    if (deletions !== null) {
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+} // Computes the next Just Noticeable Difference (JND) boundary.
+// The theory is that a person can't tell the difference between small differences in time.
+// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
+// difference in the experience. However, waiting for longer might mean that we can avoid
+// showing an intermediate loading state. The longer we have already waited, the harder it
+// is to tell small differences in time. Therefore, the longer we've already waited,
+// the longer we can wait additionally. At some point we have to give up though.
+// We pick a train model where the next boundary commits at a consistent schedule.
+// These particular numbers are vague estimates. We expect to adjust them based on research.
 
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    }
+function jnd(timeElapsed) {
+  return timeElapsed < 120
+    ? 120
+    : timeElapsed < 480
+    ? 480
+    : timeElapsed < 1080
+    ? 1080
+    : timeElapsed < 1920
+    ? 1920
+    : timeElapsed < 3000
+    ? 3000
+    : timeElapsed < 4320
+    ? 4320
+    : ceil(timeElapsed / 1960) * 1960;
+}
 
-    detachAlternateSiblings(parentFiber);
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    nestedPassiveUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    rootWithPassiveNestedUpdates = null;
+    throw new Error(
+      "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."
+    );
   }
 
-  var prevDebugFiber = getCurrentFiber(); // TODO: Check PassiveStatic flag
-
-  var child = parentFiber.child;
+  {
+    if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
+      nestedPassiveUpdateCount = 0;
+      rootWithPassiveNestedUpdates = null;
 
-  while (child !== null) {
-    setCurrentFiber(child);
-    disconnectPassiveEffect(child);
-    child = child.sibling;
+      error(
+        "Maximum update depth exceeded. This can happen when a component " +
+          "calls setState inside useEffect, but useEffect either doesn't " +
+          "have a dependency array, or one of the dependencies changes on " +
+          "every render."
+      );
+    }
   }
-
-  setCurrentFiber(prevDebugFiber);
 }
 
-function disconnectPassiveEffect(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      // TODO: Check PassiveStatic flag
-      commitHookPassiveUnmountEffects(
-        finishedWork,
-        finishedWork.return,
-        Passive
-      ); // When disconnecting passive effects, we fire the effects in the same
-      // order as during a deletiong: parent before child
+function flushRenderPhaseStrictModeWarningsInDEV() {
+  {
+    ReactStrictModeWarnings.flushLegacyContextWarning();
+    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+  }
+}
 
-      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      break;
+function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
+  {
+    {
+      legacyCommitDoubleInvokeEffectsInDEV(root.current, hasPassiveEffects);
     }
+  }
+}
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-
-      if (instance._visibility & OffscreenPassiveEffectsConnected) {
-        instance._visibility &= ~OffscreenPassiveEffectsConnected;
-        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      }
+function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
+  // TODO (StrictEffects) Should we set a marker on the root if it contains strict effects
+  // so we don't traverse unnecessarily? similar to subtreeFlags but just at the root level.
+  // Maybe not a big deal since this is DEV only behavior.
+  setCurrentFiber(fiber);
+  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectUnmountInDEV);
 
-      break;
-    }
+  if (hasPassiveEffects) {
+    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectUnmountInDEV);
+  }
 
-    default: {
-      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      break;
-    }
+  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectMountInDEV);
+
+  if (hasPassiveEffects) {
+    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectMountInDEV);
   }
+
+  resetCurrentFiber();
 }
 
-function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-  deletedSubtreeRoot,
-  nearestMountedAncestor
-) {
-  while (nextEffect !== null) {
-    var fiber = nextEffect; // Deletion effects fire in parent -> child order
-    // TODO: Check if fiber has a PassiveStatic flag
+function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
+  var current = firstChild;
+  var subtreeRoot = null;
 
-    setCurrentFiber(fiber);
-    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
-    resetCurrentFiber();
-    var child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+  while (current != null) {
+    var primarySubtreeFlag = current.subtreeFlags & fiberFlags;
 
-    if (child !== null) {
-      child.return = fiber;
-      nextEffect = child;
+    if (
+      current !== subtreeRoot &&
+      current.child != null &&
+      primarySubtreeFlag !== NoFlags$1
+    ) {
+      current = current.child;
     } else {
-      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
-        deletedSubtreeRoot
-      );
+      if ((current.flags & fiberFlags) !== NoFlags$1) {
+        invokeEffectFn(current);
+      }
+
+      if (current.sibling !== null) {
+        current = current.sibling;
+      } else {
+        current = subtreeRoot = current.return;
+      }
     }
   }
 }
 
-function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
-  deletedSubtreeRoot
-) {
-  while (nextEffect !== null) {
-    var fiber = nextEffect;
-    var sibling = fiber.sibling;
-    var returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
-    // This is more aggressive than ideal, and the long term goal is to only
-    // have to detach the deleted tree at the root.
-
-    detachFiberAfterEffects(fiber);
+var didWarnStateUpdateForNotYetMountedComponent = null;
+function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
+  {
+    if ((executionContext & RenderContext) !== NoContext) {
+      // We let the other warning about render phase updates deal with this one.
+      return;
+    }
 
-    if (fiber === deletedSubtreeRoot) {
-      nextEffect = null;
+    if (!(fiber.mode & ConcurrentMode)) {
       return;
     }
 
-    if (sibling !== null) {
-      sibling.return = returnFiber;
-      nextEffect = sibling;
+    var tag = fiber.tag;
+
+    if (
+      tag !== IndeterminateComponent &&
+      tag !== HostRoot &&
+      tag !== ClassComponent &&
+      tag !== FunctionComponent &&
+      tag !== ForwardRef &&
+      tag !== MemoComponent &&
+      tag !== SimpleMemoComponent
+    ) {
+      // Only warn for user-defined components, not internal ones like Suspense.
       return;
+    } // 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 = getComponentNameFromFiber(fiber) || "ReactComponent";
+
+    if (didWarnStateUpdateForNotYetMountedComponent !== null) {
+      if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      didWarnStateUpdateForNotYetMountedComponent.add(componentName);
+    } else {
+      didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
     }
 
-    nextEffect = returnFiber;
+    var previousFiber = current;
+
+    try {
+      setCurrentFiber(fiber);
+
+      error(
+        "Can't perform a React state update on a component that hasn't mounted yet. " +
+          "This indicates that you have a side-effect in your render function that " +
+          "asynchronously later calls tries to update the component. Move this work to " +
+          "useEffect instead."
+      );
+    } finally {
+      if (previousFiber) {
+        setCurrentFiber(fiber);
+      } else {
+        resetCurrentFiber();
+      }
+    }
   }
 }
+var beginWork;
 
-function commitPassiveUnmountInsideDeletedTreeOnFiber(
-  current,
-  nearestMountedAncestor
-) {
-  switch (current.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
-      break;
-    }
-    // TODO: run passive unmount effects when unmounting a root.
-    // Because passive unmount effects are not currently run,
-    // the cache instance owned by the root will never be freed.
-    // When effects are run, the cache should be freed here:
-    // case HostRoot: {
-    //   if (enableCache) {
-    //     const cache = current.memoizedState.cache;
-    //     releaseCache(cache);
-    //   }
-    //   break;
-    // }
+if (replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+  var dummyFiber = null;
 
-    case LegacyHiddenComponent:
-    case OffscreenComponent: {
-      {
-        if (
-          current.memoizedState !== null &&
-          current.memoizedState.cachePool !== null
-        ) {
-          var cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
-          // Note that this is only reached in the non-suspended/visible case:
-          // when the content is suspended/hidden, the retain/release occurs
-          // via the parent Suspense component (see case above).
+  beginWork = function (current, unitOfWork, lanes) {
+    // If a component throws an error, we replay it again in a synchronously
+    // dispatched event, so that the debugger will treat it as an uncaught
+    // error See ReactErrorUtils for more information.
+    // Before entering the begin phase, copy the work-in-progress onto a dummy
+    // fiber. If beginWork throws, we'll use this to reset the state.
+    var originalWorkInProgressCopy = assignFiberPropertiesInDEV(
+      dummyFiber,
+      unitOfWork
+    );
 
-          if (cache != null) {
-            retainCache(cache);
-          }
-        }
-      }
+    try {
+      return beginWork$1(current, unitOfWork, lanes);
+    } catch (originalError) {
+      if (
+        didSuspendOrErrorWhileHydratingDEV() ||
+        originalError === SuspenseException ||
+        originalError === SelectiveHydrationException ||
+        (originalError !== null &&
+          typeof originalError === "object" &&
+          typeof originalError.then === "function")
+      ) {
+        // Don't replay promises.
+        // Don't replay errors if we are hydrating and have already suspended or handled an error
+        throw originalError;
+      } // Don't reset current debug fiber, since we're about to work on the
+      // same fiber again.
+      // Unwind the failed stack frame
 
-      break;
-    }
+      resetSuspendedWorkLoopOnUnwind();
+      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
 
-    case SuspenseComponent: {
-      if (enableTransitionTracing) {
-        // We need to mark this fiber's parents as deleted
-        var offscreenFiber = current.child;
-        var instance = offscreenFiber.stateNode;
-        var transitions = instance._transitions;
+      assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
 
-        if (transitions !== null) {
-          var abortReason = {
-            reason: "suspense",
-            name: current.memoizedProps.unstable_name || null
-          };
+      if (unitOfWork.mode & ProfileMode) {
+        // Reset the profiler timer.
+        startProfilerTimer(unitOfWork);
+      } // Run beginWork again.
 
-          if (
-            current.memoizedState === null ||
-            current.memoizedState.dehydrated === null
-          ) {
-            abortParentMarkerTransitionsForDeletedFiber(
-              offscreenFiber,
-              abortReason,
-              transitions,
-              instance,
-              true
-            );
+      invokeGuardedCallback(
+        null,
+        beginWork$1,
+        null,
+        current,
+        unitOfWork,
+        lanes
+      );
 
-            if (nearestMountedAncestor !== null) {
-              abortParentMarkerTransitionsForDeletedFiber(
-                nearestMountedAncestor,
-                abortReason,
-                transitions,
-                instance,
-                false
-              );
-            }
-          }
+      if (hasCaughtError()) {
+        var replayError = clearCaughtError();
+
+        if (
+          typeof replayError === "object" &&
+          replayError !== null &&
+          replayError._suppressLogging &&
+          typeof originalError === "object" &&
+          originalError !== null &&
+          !originalError._suppressLogging
+        ) {
+          // If suppressed, let the flag carry over to the original error which is the one we'll rethrow.
+          originalError._suppressLogging = true;
         }
-      }
+      } // We always throw the original error in case the second render pass is not idempotent.
+      // This can happen if a memoized function or CommonJS module doesn't throw after first invocation.
 
-      break;
+      throw originalError;
     }
+  };
+} else {
+  beginWork = beginWork$1;
+}
 
-    case CacheComponent: {
-      {
-        var _cache = current.memoizedState.cache;
-        releaseCache(_cache);
-      }
+var didWarnAboutUpdateInRender = false;
+var didWarnAboutUpdateInRenderForAnotherComponent;
 
-      break;
-    }
+{
+  didWarnAboutUpdateInRenderForAnotherComponent = new Set();
+}
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        // We need to mark this fiber's parents as deleted
-        var _instance5 = current.stateNode;
-        var _transitions = _instance5.transitions;
+function warnAboutRenderPhaseUpdatesInDEV(fiber) {
+  {
+    if (isRendering) {
+      switch (fiber.tag) {
+        case FunctionComponent:
+        case ForwardRef:
+        case SimpleMemoComponent: {
+          var renderingComponentName =
+            (workInProgress && getComponentNameFromFiber(workInProgress)) ||
+            "Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
 
-        if (_transitions !== null) {
-          var _abortReason = {
-            reason: "marker",
-            name: current.memoizedProps.name
-          };
-          abortParentMarkerTransitionsForDeletedFiber(
-            current,
-            _abortReason,
-            _transitions,
-            null,
-            true
-          );
+          var dedupeKey = renderingComponentName;
 
-          if (nearestMountedAncestor !== null) {
-            abortParentMarkerTransitionsForDeletedFiber(
-              nearestMountedAncestor,
-              _abortReason,
-              _transitions,
-              null,
-              false
+          if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
+            didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
+            var setStateComponentName =
+              getComponentNameFromFiber(fiber) || "Unknown";
+
+            error(
+              "Cannot update a component (`%s`) while rendering a " +
+                "different component (`%s`). To locate the bad setState() call inside `%s`, " +
+                "follow the stack trace as described in https://reactjs.org/link/setstate-in-render",
+              setStateComponentName,
+              renderingComponentName,
+              renderingComponentName
             );
           }
-        }
-      }
-
-      break;
-    }
-  }
-}
 
-function invokeLayoutEffectMountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListMount(Layout | HasEffect, fiber);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
+          break;
         }
 
-        break;
-      }
+        case ClassComponent: {
+          if (!didWarnAboutUpdateInRender) {
+            error(
+              "Cannot update during an existing state transition (such as " +
+                "within `render`). Render methods should be a pure " +
+                "function of props and state."
+            );
 
-      case ClassComponent: {
-        var instance = fiber.stateNode;
+            didWarnAboutUpdateInRender = true;
+          }
 
-        try {
-          instance.componentDidMount();
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
+          break;
         }
-
-        break;
       }
     }
   }
 }
 
-function invokePassiveEffectMountInDEV(fiber) {
+function restorePendingUpdaters(root, lanes) {
   {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListMount(Passive | HasEffect, fiber);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
-
-        break;
-      }
+    if (isDevToolsPresent) {
+      var memoizedUpdaters = root.memoizedUpdaters;
+      memoizedUpdaters.forEach(function (schedulingFiber) {
+        addFiberToLanesMap(root, schedulingFiber, lanes);
+      }); // This function intentionally does not clear memoized updaters.
+      // Those may still be relevant to the current commit
+      // and a future one (e.g. Suspense).
     }
   }
 }
+var fakeActCallbackNode = {}; // $FlowFixMe[missing-local-annot]
 
-function invokeLayoutEffectUnmountInDEV(fiber) {
+function scheduleCallback(priorityLevel, callback) {
   {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
-
-        break;
-      }
-
-      case ClassComponent: {
-        var instance = fiber.stateNode;
-
-        if (typeof instance.componentWillUnmount === "function") {
-          safelyCallComponentWillUnmount(fiber, fiber.return, instance);
-        }
+    // If we're currently inside an `act` scope, bypass Scheduler and push to
+    // the `act` queue instead.
+    var actQueue = ReactCurrentActQueue.current;
 
-        break;
-      }
+    if (actQueue !== null) {
+      actQueue.push(callback);
+      return fakeActCallbackNode;
+    } else {
+      return scheduleCallback$2(priorityLevel, callback);
     }
   }
 }
 
-function invokePassiveEffectUnmountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
-      }
-    }
-  }
+function cancelCallback(callbackNode) {
+  if (callbackNode === fakeActCallbackNode) {
+    return;
+  } // In production, always call Scheduler. This function will be stripped out.
+
+  return cancelCallback$1(callbackNode);
 }
 
-function getCacheSignal() {
-  var cache = readContext(CacheContext);
-  return cache.controller.signal;
+function shouldForceFlushFallbacksInDEV() {
+  // Never force flush in production. This function should get stripped out.
+  return ReactCurrentActQueue.current !== null;
 }
 
-function getCacheForType(resourceType) {
-  var cache = readContext(CacheContext);
-  var cacheForType = cache.data.get(resourceType);
+function warnIfUpdatesNotWrappedWithActDEV(fiber) {
+  {
+    if (fiber.mode & ConcurrentMode) {
+      if (!isConcurrentActEnvironment()) {
+        // Not in an act environment. No need to warn.
+        return;
+      }
+    } else {
+      // Legacy mode has additional cases where we suppress a warning.
+      if (!isLegacyActEnvironment()) {
+        // Not in an act environment. No need to warn.
+        return;
+      }
 
-  if (cacheForType === undefined) {
-    cacheForType = resourceType();
-    cache.data.set(resourceType, cacheForType);
-  }
+      if (executionContext !== NoContext) {
+        // Legacy mode doesn't warn if the update is batched, i.e.
+        // batchedUpdates or flushSync.
+        return;
+      }
 
-  return cacheForType;
-}
+      if (
+        fiber.tag !== FunctionComponent &&
+        fiber.tag !== ForwardRef &&
+        fiber.tag !== SimpleMemoComponent
+      ) {
+        // For backwards compatibility with pre-hooks code, legacy mode only
+        // warns for updates that originate from a hook.
+        return;
+      }
+    }
 
-var DefaultCacheDispatcher = {
-  getCacheSignal: getCacheSignal,
-  getCacheForType: getCacheForType
-};
+    if (ReactCurrentActQueue.current === null) {
+      var previousFiber = current;
 
-if (typeof Symbol === "function" && Symbol.for) {
-  var symbolFor = Symbol.for;
-  symbolFor("selector.component");
-  symbolFor("selector.has_pseudo_class");
-  symbolFor("selector.role");
-  symbolFor("selector.test_id");
-  symbolFor("selector.text");
-}
-var commitHooks = [];
-function onCommitRoot() {
-  {
-    commitHooks.forEach(function (commitHook) {
-      return commitHook();
-    });
+      try {
+        setCurrentFiber(fiber);
+
+        error(
+          "An update to %s inside a test was not wrapped in act(...).\n\n" +
+            "When testing, code that causes React state updates should be " +
+            "wrapped into act(...):\n\n" +
+            "act(() => {\n" +
+            "  /* fire events that update state */\n" +
+            "});\n" +
+            "/* assert on the output */\n\n" +
+            "This ensures that you're testing the behavior the user would see " +
+            "in the browser." +
+            " Learn more at https://reactjs.org/link/wrap-tests-with-act",
+          getComponentNameFromFiber(fiber)
+        );
+      } finally {
+        if (previousFiber) {
+          setCurrentFiber(fiber);
+        } else {
+          resetCurrentFiber();
+        }
+      }
+    }
   }
 }
 
-var ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;
-function isLegacyActEnvironment(fiber) {
-  {
-    // Legacy mode. We preserve the behavior of React 17's act. It assumes an
-    // act environment whenever `jest` is defined, but you can still turn off
-    // spurious warnings by setting IS_REACT_ACT_ENVIRONMENT explicitly
-    // to false.
-    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
-      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
-        ? IS_REACT_ACT_ENVIRONMENT
-        : undefined; // $FlowFixMe - Flow doesn't know about jest
-
-    var jestIsDefined = typeof jest !== "undefined";
-    return jestIsDefined && isReactActEnvironmentGlobal !== false;
-  }
-}
-function isConcurrentActEnvironment() {
+function warnIfSuspenseResolutionNotWrappedWithActDEV(root) {
   {
-    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
-      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
-        ? IS_REACT_ACT_ENVIRONMENT
-        : undefined;
-
     if (
-      !isReactActEnvironmentGlobal &&
-      ReactCurrentActQueue$1.current !== null
+      root.tag !== LegacyRoot &&
+      isConcurrentActEnvironment() &&
+      ReactCurrentActQueue.current === null
     ) {
-      // TODO: Include link to relevant documentation page.
       error(
-        "The current testing environment is not configured to support " +
-          "act(...)"
+        "A suspended resource finished loading inside a test, but the event " +
+          "was not wrapped in act(...).\n\n" +
+          "When testing, code that resolves suspended data should be wrapped " +
+          "into act(...):\n\n" +
+          "act(() => {\n" +
+          "  /* finish loading suspended data */\n" +
+          "});\n" +
+          "/* assert on the output */\n\n" +
+          "This ensures that you're testing the behavior the user would see " +
+          "in the browser." +
+          " Learn more at https://reactjs.org/link/wrap-tests-with-act"
       );
     }
-
-    return isReactActEnvironmentGlobal;
   }
 }
 
-var postPaintCallbackScheduled = false;
-var callbacks = [];
-function schedulePostPaintCallback(callback) {
-  callbacks.push(callback);
+function setIsRunningInsertionEffect(isRunning) {
+  {
+    isRunningInsertionEffect = isRunning;
+  }
+}
 
-  if (!postPaintCallbackScheduled) {
-    postPaintCallbackScheduled = true;
-    requestPostPaintCallback(function (endTime) {
-      for (var i = 0; i < callbacks.length; i++) {
-        callbacks[i](endTime);
-      }
+/* eslint-disable react-internal/prod-error-codes */
+// Used by React Refresh runtime through DevTools Global Hook.
 
-      postPaintCallbackScheduled = false;
-      callbacks = [];
-    });
+var resolveFamily = null;
+var failedBoundaries = null;
+var setRefreshHandler = function (handler) {
+  {
+    resolveFamily = handler;
   }
-}
+};
+function resolveFunctionForHotReloading(type) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return type;
+    }
 
-var ceil = Math.ceil;
-var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
-var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
-  ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
-  ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
-var NoContext =
-  /*             */
-  0;
-var BatchedContext =
-  /*               */
-  1;
-var RenderContext =
-  /*         */
-  2;
-var CommitContext =
-  /*         */
-  4;
-var RootInProgress = 0;
-var RootFatalErrored = 1;
-var RootErrored = 2;
-var RootSuspended = 3;
-var RootSuspendedWithDelay = 4;
-var RootCompleted = 5;
-var RootDidNotComplete = 6; // Describes where we are in the React execution stack
+    var family = resolveFamily(type);
 
-var executionContext = NoContext; // The root we're working on
+    if (family === undefined) {
+      return type;
+    } // Use the latest known implementation.
 
-var workInProgressRoot = null; // The fiber we're working on
+    return family.current;
+  }
+}
+function resolveClassForHotReloading(type) {
+  // No implementation differences.
+  return resolveFunctionForHotReloading(type);
+}
+function resolveForwardRefForHotReloading(type) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return type;
+    }
 
-var workInProgress = null; // The lanes we're rendering
+    var family = resolveFamily(type);
 
-var workInProgressRootRenderLanes = NoLanes;
-var NotSuspended = 0;
-var SuspendedOnError = 1;
-var SuspendedOnData = 2;
-var SuspendedOnImmediate = 3;
-var SuspendedOnDeprecatedThrowPromise = 4;
-var SuspendedAndReadyToContinue = 5;
-var SuspendedOnHydration = 6; // When this is true, the work-in-progress fiber just suspended (or errored) and
-// we've yet to unwind the stack. In some cases, we may yield to the main thread
-// after this happens. If the fiber is pinged before we resume, we can retry
-// immediately instead of unwinding the stack.
+    if (family === undefined) {
+      // Check if we're dealing with a real forwardRef. Don't want to crash early.
+      if (
+        type !== null &&
+        type !== undefined &&
+        typeof type.render === "function"
+      ) {
+        // ForwardRef is special because its resolved .type is an object,
+        // but it's possible that we only have its inner render function in the map.
+        // If that inner render function is different, we'll build a new forwardRef type.
+        var currentRender = resolveFunctionForHotReloading(type.render);
 
-var workInProgressSuspendedReason = NotSuspended;
-var workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
-// different that whether something suspended, because we don't add multiple
-// listeners to a promise we've already seen (per root and lane).
+        if (type.render !== currentRender) {
+          var syntheticType = {
+            $$typeof: REACT_FORWARD_REF_TYPE,
+            render: currentRender
+          };
 
-var workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
-// the lanes that we started working on at the root. When we enter a subtree
-// that is currently hidden, we add the lanes that would have committed if
-// the hidden tree hadn't been deferred. This is modified by the
-// HiddenContext module.
-//
-// Most things in the work loop should deal with workInProgressRootRenderLanes.
-// Most things in begin/complete phases should deal with renderLanes.
+          if (type.displayName !== undefined) {
+            syntheticType.displayName = type.displayName;
+          }
 
-var renderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
+          return syntheticType;
+        }
+      }
 
-var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
+      return type;
+    } // Use the latest known implementation.
 
-var workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
-// includes unprocessed updates, not work in bailed out children.
+    return family.current;
+  }
+}
+function isCompatibleFamilyForHotReloading(fiber, element) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return false;
+    }
 
-var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
+    var prevType = fiber.elementType;
+    var nextType = element.type; // If we got here, we know types aren't === equal.
 
-var workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
+    var needsCompareFamilies = false;
+    var $$typeofNextType =
+      typeof nextType === "object" && nextType !== null
+        ? nextType.$$typeof
+        : null;
 
-var workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.
+    switch (fiber.tag) {
+      case ClassComponent: {
+        if (typeof nextType === "function") {
+          needsCompareFamilies = true;
+        }
 
-var workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
-// We will log them once the tree commits.
+        break;
+      }
 
-var workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train
-// model where we don't commit new loading states in too quick succession.
+      case FunctionComponent: {
+        if (typeof nextType === "function") {
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          // We don't know the inner type yet.
+          // We're going to assume that the lazy inner type is stable,
+          // and so it is sufficient to avoid reconciling it away.
+          // We're not going to unwrap or actually use the new lazy type.
+          needsCompareFamilies = true;
+        }
 
-var globalMostRecentFallbackTime = 0;
-var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
-// more and prefer CPU suspense heuristics instead.
+        break;
+      }
 
-var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
-// suspense heuristics and opt out of rendering more content.
+      case ForwardRef: {
+        if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          needsCompareFamilies = true;
+        }
 
-var RENDER_TIMEOUT_MS = 500;
-var workInProgressTransitions = null;
-function getWorkInProgressTransitions() {
-  return workInProgressTransitions;
-}
-var currentPendingTransitionCallbacks = null;
-var currentEndTime = null;
-function addTransitionStartCallbackToPendingTransition(transition) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: [],
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
+        break;
+      }
 
-    if (currentPendingTransitionCallbacks.transitionStart === null) {
-      currentPendingTransitionCallbacks.transitionStart = [];
-    }
+      case MemoComponent:
+      case SimpleMemoComponent: {
+        if ($$typeofNextType === REACT_MEMO_TYPE) {
+          // TODO: if it was but can no longer be simple,
+          // we shouldn't set this.
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          needsCompareFamilies = true;
+        }
 
-    currentPendingTransitionCallbacks.transitionStart.push(transition);
-  }
-}
-function addMarkerProgressCallbackToPendingTransition(
-  markerName,
-  transitions,
-  pendingBoundaries
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: new Map(),
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
+        break;
+      }
 
-    if (currentPendingTransitionCallbacks.markerProgress === null) {
-      currentPendingTransitionCallbacks.markerProgress = new Map();
-    }
+      default:
+        return false;
+    } // Check if both types have a family and it's the same one.
 
-    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
-      pendingBoundaries: pendingBoundaries,
-      transitions: transitions
-    });
-  }
-}
-function addMarkerIncompleteCallbackToPendingTransition(
-  markerName,
-  transitions,
-  aborts
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: new Map(),
-        markerComplete: null
-      };
-    }
+    if (needsCompareFamilies) {
+      // Note: memo() and forwardRef() we'll compare outer rather than inner type.
+      // This means both of them need to be registered to preserve state.
+      // If we unwrapped and compared the inner types for wrappers instead,
+      // then we would risk falsely saying two separate memo(Foo)
+      // calls are equivalent because they wrap the same Foo function.
+      var prevFamily = resolveFamily(prevType); // $FlowFixMe[not-a-function] found when upgrading Flow
 
-    if (currentPendingTransitionCallbacks.markerIncomplete === null) {
-      currentPendingTransitionCallbacks.markerIncomplete = new Map();
+      if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
+        return true;
+      }
     }
 
-    currentPendingTransitionCallbacks.markerIncomplete.set(markerName, {
-      transitions: transitions,
-      aborts: aborts
-    });
+    return false;
   }
 }
-function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: new Map()
-      };
-    }
-
-    if (currentPendingTransitionCallbacks.markerComplete === null) {
-      currentPendingTransitionCallbacks.markerComplete = new Map();
+function markFailedErrorBoundaryForHotReloading(fiber) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return;
     }
 
-    currentPendingTransitionCallbacks.markerComplete.set(
-      markerName,
-      transitions
-    );
-  }
-}
-function addTransitionProgressCallbackToPendingTransition(
-  transition,
-  boundaries
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: new Map(),
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
+    if (typeof WeakSet !== "function") {
+      return;
     }
 
-    if (currentPendingTransitionCallbacks.transitionProgress === null) {
-      currentPendingTransitionCallbacks.transitionProgress = new Map();
+    if (failedBoundaries === null) {
+      failedBoundaries = new WeakSet();
     }
 
-    currentPendingTransitionCallbacks.transitionProgress.set(
-      transition,
-      boundaries
-    );
+    failedBoundaries.add(fiber);
   }
 }
-function addTransitionCompleteCallbackToPendingTransition(transition) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: [],
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
+var scheduleRefresh = function (root, update) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return;
     }
 
-    if (currentPendingTransitionCallbacks.transitionComplete === null) {
-      currentPendingTransitionCallbacks.transitionComplete = [];
+    var staleFamilies = update.staleFamilies,
+      updatedFamilies = update.updatedFamilies;
+    flushPassiveEffects();
+    flushSync$1(function () {
+      scheduleFibersWithFamiliesRecursively(
+        root.current,
+        updatedFamilies,
+        staleFamilies
+      );
+    });
+  }
+};
+var scheduleRoot = function (root, element) {
+  {
+    if (root.context !== emptyContextObject) {
+      // Super edge case: root has a legacy _renderSubtree context
+      // but we don't know the parentComponent so we can't pass it.
+      // Just ignore. We'll delete this with _renderSubtree code path later.
+      return;
     }
 
-    currentPendingTransitionCallbacks.transitionComplete.push(transition);
+    flushPassiveEffects();
+    flushSync$1(function () {
+      updateContainer(element, root, null, null);
+    });
   }
-}
-
-function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
-}
-
-function getRenderTargetTime() {
-  return workInProgressRootRenderTargetTime;
-}
-var hasUncaughtError = false;
-var firstUncaughtError = null;
-var legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
-// to track which root is currently committing layout effects.
-
-var rootCommittingMutationOrLayoutEffects = null;
-var rootDoesHavePassiveEffects = false;
-var rootWithPendingPassiveEffects = null;
-var pendingPassiveEffectsLanes = NoLanes;
-var pendingPassiveProfilerEffects = [];
-var pendingPassiveEffectsRemainingLanes = NoLanes;
-var pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
-
-var NESTED_UPDATE_LIMIT = 50;
-var nestedUpdateCount = 0;
-var rootWithNestedUpdates = null;
-var isFlushingPassiveEffects = false;
-var didScheduleUpdateDuringPassiveEffects = false;
-var NESTED_PASSIVE_UPDATE_LIMIT = 50;
-var nestedPassiveUpdateCount = 0;
-var rootWithPassiveNestedUpdates = null; // If two updates are scheduled within the same event, we should treat their
-// event times as simultaneous, even if the actual clock time has advanced
-// between the first and second call.
-
-var currentEventTime = NoTimestamp;
-var currentEventTransitionLane = NoLanes;
-var isRunningInsertionEffect = false;
-function getWorkInProgressRoot() {
-  return workInProgressRoot;
-}
-function getWorkInProgressRootRenderLanes() {
-  return workInProgressRootRenderLanes;
-}
-function requestEventTime() {
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    // We're inside React, so it's fine to read the actual time.
-    return now$1();
-  } // We're not inside React, so we may be in the middle of a browser event.
-
-  if (currentEventTime !== NoTimestamp) {
-    // Use the same start time for all updates until we enter React again.
-    return currentEventTime;
-  } // This is the first update since React yielded. Compute a new start time.
-
-  currentEventTime = now$1();
-  return currentEventTime;
-}
-function requestUpdateLane(fiber) {
-  // Special cases
-  var mode = fiber.mode;
+};
 
-  if ((mode & ConcurrentMode) === NoMode) {
-    return SyncLane;
-  } else if (
-    !deferRenderPhaseUpdateToNextBatch &&
-    (executionContext & RenderContext) !== NoContext &&
-    workInProgressRootRenderLanes !== NoLanes
-  ) {
-    // This is a render phase update. These are not officially supported. The
-    // old behavior is to give this the same "thread" (lanes) as
-    // whatever is currently rendering. So if you call `setState` on a component
-    // that happens later in the same render, it will flush. Ideally, we want to
-    // remove the special case and treat them as if they came from an
-    // interleaved event. Regardless, this pattern is not officially supported.
-    // This behavior is only a fallback. The flag only exists until we can roll
-    // out the setState warning, since existing code might accidentally rely on
-    // the current behavior.
-    return pickArbitraryLane(workInProgressRootRenderLanes);
-  }
+function scheduleFibersWithFamiliesRecursively(
+  fiber,
+  updatedFamilies,
+  staleFamilies
+) {
+  {
+    var alternate = fiber.alternate,
+      child = fiber.child,
+      sibling = fiber.sibling,
+      tag = fiber.tag,
+      type = fiber.type;
+    var candidateType = null;
 
-  var isTransition = requestCurrentTransition() !== NoTransition;
+    switch (tag) {
+      case FunctionComponent:
+      case SimpleMemoComponent:
+      case ClassComponent:
+        candidateType = type;
+        break;
 
-  if (isTransition) {
-    if (ReactCurrentBatchConfig.transition !== null) {
-      var transition = ReactCurrentBatchConfig.transition;
+      case ForwardRef:
+        candidateType = type.render;
+        break;
+    }
 
-      if (!transition._updatedFibers) {
-        transition._updatedFibers = new Set();
-      }
+    if (resolveFamily === null) {
+      throw new Error("Expected resolveFamily to be set during hot reload.");
+    }
 
-      transition._updatedFibers.add(fiber);
-    } // The algorithm for assigning an update to a lane should be stable for all
-    // updates at the same priority within the same event. To do this, the
-    // inputs to the algorithm must be the same.
-    //
-    // The trick we use is to cache the first of each of these inputs within an
-    // event. Then reset the cached values once we can be sure the event is
-    // over. Our heuristic for that is whenever we enter a concurrent work loop.
+    var needsRender = false;
+    var needsRemount = false;
 
-    if (currentEventTransitionLane === NoLane) {
-      // All transitions within the same event are assigned the same lane.
-      currentEventTransitionLane = claimNextTransitionLane();
+    if (candidateType !== null) {
+      var family = resolveFamily(candidateType);
+
+      if (family !== undefined) {
+        if (staleFamilies.has(family)) {
+          needsRemount = true;
+        } else if (updatedFamilies.has(family)) {
+          if (tag === ClassComponent) {
+            needsRemount = true;
+          } else {
+            needsRender = true;
+          }
+        }
+      }
     }
 
-    return currentEventTransitionLane;
-  } // Updates originating inside certain React methods, like flushSync, have
-  // their priority set by tracking it with a context variable.
-  //
-  // The opaque type returned by the host config is internally a lane, so we can
-  // use that directly.
-  // TODO: Move this type conversion to the event priority module.
+    if (failedBoundaries !== null) {
+      if (
+        failedBoundaries.has(fiber) || // $FlowFixMe[incompatible-use] found when upgrading Flow
+        (alternate !== null && failedBoundaries.has(alternate))
+      ) {
+        needsRemount = true;
+      }
+    }
 
-  var updateLane = getCurrentUpdatePriority$1();
+    if (needsRemount) {
+      fiber._debugNeedsRemount = true;
+    }
 
-  if (updateLane !== NoLane) {
-    return updateLane;
-  } // This update originated outside React. Ask the host environment for an
-  // appropriate priority, based on the type of event.
-  //
-  // The opaque type returned by the host config is internally a lane, so we can
-  // use that directly.
-  // TODO: Move this type conversion to the event priority module.
+    if (needsRemount || needsRender) {
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  var eventLane = getCurrentEventPriority();
-  return eventLane;
-}
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
+    }
 
-function requestRetryLane(fiber) {
-  // This is a fork of `requestUpdateLane` designed specifically for Suspense
-  // "retries" — a special update that attempts to flip a Suspense boundary
-  // from its placeholder state to its primary/resolved state.
-  // Special cases
-  var mode = fiber.mode;
+    if (child !== null && !needsRemount) {
+      scheduleFibersWithFamiliesRecursively(
+        child,
+        updatedFamilies,
+        staleFamilies
+      );
+    }
 
-  if ((mode & ConcurrentMode) === NoMode) {
-    return SyncLane;
+    if (sibling !== null) {
+      scheduleFibersWithFamiliesRecursively(
+        sibling,
+        updatedFamilies,
+        staleFamilies
+      );
+    }
   }
-
-  return claimNextRetryLane();
 }
 
-function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+var findHostInstancesForRefresh = function (root, families) {
   {
-    if (isRunningInsertionEffect) {
-      error("useInsertionEffect must not schedule updates.");
-    }
+    var hostInstances = new Set();
+    var types = new Set(
+      families.map(function (family) {
+        return family.current;
+      })
+    );
+    findHostInstancesForMatchingFibersRecursively(
+      root.current,
+      types,
+      hostInstances
+    );
+    return hostInstances;
   }
+};
 
+function findHostInstancesForMatchingFibersRecursively(
+  fiber,
+  types,
+  hostInstances
+) {
   {
-    if (isFlushingPassiveEffects) {
-      didScheduleUpdateDuringPassiveEffects = true;
+    var child = fiber.child,
+      sibling = fiber.sibling,
+      tag = fiber.tag,
+      type = fiber.type;
+    var candidateType = null;
+
+    switch (tag) {
+      case FunctionComponent:
+      case SimpleMemoComponent:
+      case ClassComponent:
+        candidateType = type;
+        break;
+
+      case ForwardRef:
+        candidateType = type.render;
+        break;
     }
-  } // Check if the work loop is currently suspended and waiting for data to
-  // finish loading.
 
-  if (
-    workInProgressSuspendedReason === SuspendedOnData &&
-    root === workInProgressRoot
-  ) {
-    // The incoming update might unblock the current render. Interrupt the
-    // current attempt and restart from the top.
-    prepareFreshStack(root, NoLanes);
-    markRootSuspended(root, workInProgressRootRenderLanes);
-  } // Mark that the root has a pending update.
+    var didMatch = false;
 
-  markRootUpdated(root, lane, eventTime);
+    if (candidateType !== null) {
+      if (types.has(candidateType)) {
+        didMatch = true;
+      }
+    }
 
-  if (
-    (executionContext & RenderContext) !== NoLanes &&
-    root === workInProgressRoot
-  ) {
-    // This update was dispatched during the render phase. This is a mistake
-    // if the update originates from user space (with the exception of local
-    // hook updates, which are handled differently and don't reach this
-    // function), but there are some internal React features that use this as
-    // an implementation detail, like selective hydration.
-    warnAboutRenderPhaseUpdatesInDEV(fiber); // Track lanes that were updated during the render phase
-  } else {
-    // This is a normal update, scheduled from outside the render phase. For
-    // example, during an input event.
-    {
-      if (isDevToolsPresent) {
-        addFiberToLanesMap(root, fiber, lane);
+    if (didMatch) {
+      // We have a match. This only drills down to the closest host components.
+      // There's no need to search deeper because for the purpose of giving
+      // visual feedback, "flashing" outermost parent rectangles is sufficient.
+      findHostInstancesForFiberShallowly(fiber, hostInstances);
+    } else {
+      // If there's no match, maybe there will be one further down in the child tree.
+      if (child !== null) {
+        findHostInstancesForMatchingFibersRecursively(
+          child,
+          types,
+          hostInstances
+        );
       }
     }
 
-    warnIfUpdatesNotWrappedWithActDEV(fiber);
+    if (sibling !== null) {
+      findHostInstancesForMatchingFibersRecursively(
+        sibling,
+        types,
+        hostInstances
+      );
+    }
+  }
+}
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      if (
-        (executionContext & CommitContext) !== NoContext &&
-        root === rootCommittingMutationOrLayoutEffects
-      ) {
-        if (fiber.mode & ProfileMode) {
-          var current = fiber;
+function findHostInstancesForFiberShallowly(fiber, hostInstances) {
+  {
+    var foundHostInstances = findChildHostInstancesForFiberShallowly(
+      fiber,
+      hostInstances
+    );
 
-          while (current !== null) {
-            if (current.tag === Profiler) {
-              var _current$memoizedProp = current.memoizedProps,
-                id = _current$memoizedProp.id,
-                onNestedUpdateScheduled =
-                  _current$memoizedProp.onNestedUpdateScheduled;
+    if (foundHostInstances) {
+      return;
+    } // If we didn't find any host children, fallback to closest host parent.
 
-              if (typeof onNestedUpdateScheduled === "function") {
-                onNestedUpdateScheduled(id);
-              }
-            }
+    var node = fiber;
 
-            current = current.return;
-          }
-        }
-      }
-    }
+    while (true) {
+      switch (node.tag) {
+        case HostSingleton:
+        case HostComponent:
+          hostInstances.add(node.stateNode);
+          return;
 
-    if (enableTransitionTracing) {
-      var transition = ReactCurrentBatchConfig.transition;
+        case HostPortal:
+          hostInstances.add(node.stateNode.containerInfo);
+          return;
 
-      if (transition !== null && transition.name != null) {
-        if (transition.startTime === -1) {
-          transition.startTime = now$1();
-        }
+        case HostRoot:
+          hostInstances.add(node.stateNode.containerInfo);
+          return;
+      }
 
-        addTransitionToLanesMap(root, transition, lane);
+      if (node.return === null) {
+        throw new Error("Expected to reach root first.");
       }
+
+      node = node.return;
     }
+  }
+}
 
-    if (root === workInProgressRoot) {
-      // Received an update to a tree that's in the middle of rendering. Mark
-      // that there was an interleaved update work on this root. Unless the
-      // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
-      // phase update. In that case, we don't treat render phase updates as if
-      // they were interleaved, for backwards compat reasons.
+function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
+  {
+    var node = fiber;
+    var foundHostInstances = false;
+
+    while (true) {
       if (
-        deferRenderPhaseUpdateToNextBatch ||
-        (executionContext & RenderContext) === NoContext
+        node.tag === HostComponent ||
+        node.tag === HostHoistable ||
+        node.tag === HostSingleton
       ) {
-        workInProgressRootInterleavedUpdatedLanes = mergeLanes(
-          workInProgressRootInterleavedUpdatedLanes,
-          lane
-        );
+        // We got a match.
+        foundHostInstances = true;
+        hostInstances.add(node.stateNode); // There may still be more, so keep searching.
+      } else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
       }
 
-      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
-        // The root already suspended with a delay, which means this render
-        // definitely won't finish. Since we have a new update, let's mark it as
-        // suspended now, right before marking the incoming update. This has the
-        // effect of interrupting the current render and switching to the update.
-        // TODO: Make sure this doesn't override pings that happen while we've
-        // already started rendering.
-        markRootSuspended(root, workInProgressRootRenderLanes);
+      if (node === fiber) {
+        return foundHostInstances;
       }
-    }
 
-    ensureRootIsScheduled(root, eventTime);
+      while (node.sibling === null) {
+        if (node.return === null || node.return === fiber) {
+          return foundHostInstances;
+        }
 
-    if (
-      lane === SyncLane &&
-      executionContext === NoContext &&
-      (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
-      !ReactCurrentActQueue.isBatchingLegacy
-    ) {
-      // Flush the synchronous work now, unless we're already working or inside
-      // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
-      // scheduleCallbackForFiber to preserve the ability to schedule a callback
-      // without immediately flushing it. We only do this for user-initiated
-      // updates, to preserve historical behavior of legacy mode.
-      resetRenderTimer();
-      flushSyncCallbacksOnlyInLegacyMode();
+        node = node.return;
+      }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
     }
   }
+
+  return false;
 }
-function scheduleInitialHydrationOnRoot(root, lane, eventTime) {
-  // This is a special fork of scheduleUpdateOnFiber that is only used to
-  // schedule the initial hydration of a root that has just been created. Most
-  // of the stuff in scheduleUpdateOnFiber can be skipped.
-  //
-  // The main reason for this separate path, though, is to distinguish the
-  // initial children from subsequent updates. In fully client-rendered roots
-  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
-  // updates, but hydration roots are special because the initial render must
-  // match what was rendered on the server.
-  var current = root.current;
-  current.lanes = lane;
-  markRootUpdated(root, lane, eventTime);
-  ensureRootIsScheduled(root, eventTime);
+
+var hasBadMapPolyfill;
+
+{
+  hasBadMapPolyfill = false;
+
+  try {
+    var nonExtensibleObject = Object.preventExtensions({});
+    /* eslint-disable no-new */
+
+    new Map([[nonExtensibleObject, null]]);
+    new Set([nonExtensibleObject]);
+    /* eslint-enable no-new */
+  } catch (e) {
+    // TODO: Consider warning about bad polyfills
+    hasBadMapPolyfill = true;
+  }
 }
-function isUnsafeClassRenderPhaseUpdate(fiber) {
-  // Check if this is a render phase update. Only called by class components,
-  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
-  return (
-    // TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We
-    // decided not to enable it.
-    (!deferRenderPhaseUpdateToNextBatch ||
-      (fiber.mode & ConcurrentMode) === NoMode) &&
-    (executionContext & RenderContext) !== NoContext
-  );
-} // Use this function to schedule a task for a root. There's only one task per
-// root; if a task was already scheduled, we'll check to make sure the priority
-// of the existing task is the same as the priority of the next level that the
-// root has work on. This function is called on every update, and right before
-// exiting a task.
 
-function ensureRootIsScheduled(root, currentTime) {
-  var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
-  // expired so we know to work on those next.
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
 
-  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
 
-  var nextLanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
-  );
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  this.childLanes = NoLanes;
+  this.alternate = null;
 
-  if (nextLanes === NoLanes) {
-    // Special case: There's nothing to work on.
-    if (existingCallbackNode !== null) {
-      cancelCallback(existingCallbackNode);
-    }
+  {
+    // Note: The following is done to avoid a v8 performance cliff.
+    //
+    // Initializing the fields below to smis and later updating them with
+    // double values will cause Fibers to end up having separate shapes.
+    // This behavior/bug has something to do with Object.preventExtension().
+    // Fortunately this only impacts DEV builds.
+    // Unfortunately it makes React unusably slow for some applications.
+    // To work around this, initialize the fields below with doubles.
+    //
+    // Learn more about this here:
+    // https://github.com/facebook/react/issues/14365
+    // https://bugs.chromium.org/p/v8/issues/detail?id=8538
+    this.actualDuration = Number.NaN;
+    this.actualStartTime = Number.NaN;
+    this.selfBaseDuration = Number.NaN;
+    this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
+    // This won't trigger the performance cliff mentioned above,
+    // and it simplifies other profiler code (including DevTools).
 
-    root.callbackNode = null;
-    root.callbackPriority = NoLane;
-    return;
-  } // If this root is currently suspended and waiting for data to resolve, don't
-  // schedule a task to render it. We'll either wait for a ping, or wait to
-  // receive an update.
+    this.actualDuration = 0;
+    this.actualStartTime = -1;
+    this.selfBaseDuration = 0;
+    this.treeBaseDuration = 0;
+  }
 
-  if (
-    workInProgressSuspendedReason === SuspendedOnData &&
-    workInProgressRoot === root
-  ) {
-    root.callbackPriority = NoLane;
-    root.callbackNode = null;
-    return;
-  } // We use the highest priority lane to represent the priority of the callback.
+  {
+    // This isn't directly used but is handy for debugging internals:
+    this._debugSource = null;
+    this._debugOwner = null;
+    this._debugNeedsRemount = false;
+    this._debugHookTypes = null;
 
-  var newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.
+    if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
+      Object.preventExtensions(this);
+    }
+  }
+} // This is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
 
-  var existingCallbackPriority = root.callbackPriority;
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
 
-  if (
-    existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
-    // Scheduler task, rather than an `act` task, cancel it and re-scheduled
-    // on the `act` queue.
-    !(
-      ReactCurrentActQueue.current !== null &&
-      existingCallbackNode !== fakeActCallbackNode
-    )
-  ) {
-    {
-      // If we're going to re-use an existing task, it needs to exist.
-      // Assume that discrete update microtasks are non-cancellable and null.
-      // TODO: Temporary until we confirm this warning is not fired.
-      if (
-        existingCallbackNode == null &&
-        !includesSyncLane(existingCallbackPriority)
-      ) {
-        error(
-          "Expected scheduled callback to exist. This error is likely caused by a bug in React. Please file an issue."
-        );
-      }
-    } // The priority hasn't changed. We can reuse the existing task. Exit.
+function shouldConstruct(Component) {
+  var prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function isSimpleFunctionComponent(type) {
+  return (
+    typeof type === "function" &&
+    !shouldConstruct(type) &&
+    type.defaultProps === undefined
+  );
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === "function") {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    var $$typeof = Component.$$typeof;
 
-    return;
-  }
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
+    }
 
-  if (existingCallbackNode != null) {
-    // Cancel the existing callback. We'll schedule a new one below.
-    cancelCallback(existingCallbackNode);
-  } // Schedule a new callback.
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
+  }
 
-  var newCallbackNode;
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
 
-  if (includesSyncLane(newCallbackPriority)) {
-    // Special case: Sync React callbacks are scheduled on a special
-    // internal queue
-    if (root.tag === LegacyRoot) {
-      if (ReactCurrentActQueue.isBatchingLegacy !== null) {
-        ReactCurrentActQueue.didScheduleLegacyUpdate = true;
-      }
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
 
-      scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));
-    } else {
-      scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
-    }
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(
+      current.tag,
+      pendingProps,
+      current.key,
+      current.mode
+    );
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
 
     {
-      // Flush the queue in a microtask.
-      if (ReactCurrentActQueue.current !== null) {
-        // Inside `act`, use our internal `act` queue so that these get flushed
-        // at the end of the current scope even when using the sync version
-        // of `act`.
-        ReactCurrentActQueue.current.push(flushSyncCallbacks);
-      } else {
-        scheduleMicrotask(function () {
-          // In Safari, appending an iframe forces microtasks to run.
-          // https://github.com/facebook/react/issues/22459
-          // We don't support running callbacks in the middle of render
-          // or commit so we need to check against that.
-          if (
-            (executionContext & (RenderContext | CommitContext)) ===
-            NoContext
-          ) {
-            // Note that this would still prematurely flush the callbacks
-            // if this happens outside render or commit phase (e.g. in an event).
-            flushSyncCallbacks();
-          }
-        });
-      }
+      // DEV-only fields
+      workInProgress._debugSource = current._debugSource;
+      workInProgress._debugOwner = current._debugOwner;
+      workInProgress._debugHookTypes = current._debugHookTypes;
     }
 
-    newCallbackNode = null;
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
   } else {
-    var schedulerPriorityLevel;
-
-    switch (lanesToEventPriority(nextLanes)) {
-      case DiscreteEventPriority:
-        schedulerPriorityLevel = ImmediatePriority;
-        break;
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
 
-      case ContinuousEventPriority:
-        schedulerPriorityLevel = UserBlockingPriority;
-        break;
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
 
-      case DefaultEventPriority:
-        schedulerPriorityLevel = NormalPriority$1;
-        break;
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
 
-      case IdleEventPriority:
-        schedulerPriorityLevel = IdlePriority;
-        break;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
 
-      default:
-        schedulerPriorityLevel = NormalPriority$1;
-        break;
+    {
+      // We intentionally reset, rather than copy, actualDuration & actualStartTime.
+      // This prevents time from endlessly accumulating in new commits.
+      // This has the downside of resetting values for different priority renders,
+      // But works for yielding (the common case) and should support resuming.
+      workInProgress.actualDuration = 0;
+      workInProgress.actualStartTime = -1;
     }
+  } // Reset all effects except static ones.
+  // Static effects are not specific to a render.
 
-    newCallbackNode = scheduleCallback(
-      schedulerPriorityLevel,
-      performConcurrentWorkOnRoot.bind(null, root)
-    );
-  }
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
 
-  root.callbackPriority = newCallbackPriority;
-  root.callbackNode = newCallbackNode;
-} // This is the entry point for every concurrent task, i.e. anything that
-// goes through Scheduler.
+  var currentDependencies = current.dependencies;
+  workInProgress.dependencies =
+    currentDependencies === null
+      ? null
+      : {
+          lanes: currentDependencies.lanes,
+          firstContext: currentDependencies.firstContext
+        }; // These will be overridden during the parent's reconciliation
+
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
 
-function performConcurrentWorkOnRoot(root, didTimeout) {
   {
-    resetNestedUpdateFlag();
-  } // Since we know we're in a React event, we can clear the current
-  // event time. The next update will compute a new event time.
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
+  }
 
-  currentEventTime = NoTimestamp;
-  currentEventTransitionLane = NoLanes;
+  {
+    workInProgress._debugNeedsRemount = current._debugNeedsRemount;
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
-  } // Flush any pending passive effects before deciding which lanes to work on,
-  // in case they schedule additional work.
+    switch (workInProgress.tag) {
+      case IndeterminateComponent:
+      case FunctionComponent:
+      case SimpleMemoComponent:
+        workInProgress.type = resolveFunctionForHotReloading(current.type);
+        break;
 
-  var originalCallbackNode = root.callbackNode;
-  var didFlushPassiveEffects = flushPassiveEffects();
+      case ClassComponent:
+        workInProgress.type = resolveClassForHotReloading(current.type);
+        break;
 
-  if (didFlushPassiveEffects) {
-    // Something in the passive effect phase may have canceled the current task.
-    // Check if the task node for this root was changed.
-    if (root.callbackNode !== originalCallbackNode) {
-      // The current task was canceled. Exit. We don't need to call
-      // `ensureRootIsScheduled` because the check above implies either that
-      // there's a new task, or that there's no remaining work on this root.
-      return null;
+      case ForwardRef:
+        workInProgress.type = resolveForwardRefForHotReloading(current.type);
+        break;
     }
-  } // Determine the next lanes to work on, using the fields stored
-  // on the root.
-
-  var lanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
-  );
+  }
 
-  if (lanes === NoLanes) {
-    // Defensive coding. This is never expected to happen.
-    return null;
-  } // We disable time-slicing in some cases: if the work has been CPU-bound
-  // for too long ("expired" work, to prevent starvation), or we're in
-  // sync-updates-by-default mode.
-  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
-  // bug we're still investigating. Once the bug in Scheduler is fixed,
-  // we can remove this, since we track expiration ourselves.
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
 
-  var shouldTimeSlice =
-    !includesBlockingLane(root, lanes) &&
-    !includesExpiredLane(root, lanes) &&
-    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
-  var exitStatus = shouldTimeSlice
-    ? renderRootConcurrent(root, lanes)
-    : renderRootSync(root, lanes);
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
 
-  if (exitStatus !== RootInProgress) {
-    if (exitStatus === RootErrored) {
-      // If something threw an error, try rendering one more time. We'll
-      // render synchronously to block concurrent data mutations, and we'll
-      // includes all pending updates are included. If it still fails after
-      // the second attempt, we'll give up and commit the resulting tree.
-      var originallyAttemptedLanes = lanes;
-      var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-        root,
-        originallyAttemptedLanes
-      );
+  var current = workInProgress.alternate;
 
-      if (errorRetryLanes !== NoLanes) {
-        lanes = errorRetryLanes;
-        exitStatus = recoverFromConcurrentError(
-          root,
-          originallyAttemptedLanes,
-          errorRetryLanes
-        );
-      }
-    }
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
 
-    if (exitStatus === RootFatalErrored) {
-      var fatalError = workInProgressRootFatalError;
-      prepareFreshStack(root, NoLanes);
-      markRootSuspended(root, lanes);
-      ensureRootIsScheduled(root, now$1());
-      throw fatalError;
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = 0;
+      workInProgress.treeBaseDuration = 0;
     }
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
 
-    if (exitStatus === RootDidNotComplete) {
-      // The render unwound without completing the tree. This happens in special
-      // cases where need to exit the current render without producing a
-      // consistent tree or committing.
-      markRootSuspended(root, lanes);
-    } else {
-      // The render completed.
-      // Check if this render may have yielded to a concurrent event, and if so,
-      // confirm that any newly rendered stores are consistent.
-      // TODO: It's possible that even a concurrent render may never have yielded
-      // to the main thread, if it was fast enough, or if it expired. We could
-      // skip the consistency check in that case, too.
-      var renderWasConcurrent = !includesBlockingLane(root, lanes);
-      var finishedWork = root.current.alternate;
-
-      if (
-        renderWasConcurrent &&
-        !isRenderConsistentWithExternalStores(finishedWork)
-      ) {
-        // A store was mutated in an interleaved event. Render again,
-        // synchronously, to block further mutations.
-        exitStatus = renderRootSync(root, lanes); // We need to check again if something threw
-
-        if (exitStatus === RootErrored) {
-          var _originallyAttemptedLanes = lanes;
-
-          var _errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-            root,
-            _originallyAttemptedLanes
-          );
-
-          if (_errorRetryLanes !== NoLanes) {
-            lanes = _errorRetryLanes;
-            exitStatus = recoverFromConcurrentError(
-              root,
-              _originallyAttemptedLanes,
-              _errorRetryLanes
-            ); // We assume the tree is now consistent because we didn't yield to any
-            // concurrent events.
-          }
-        }
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
 
-        if (exitStatus === RootFatalErrored) {
-          var _fatalError = workInProgressRootFatalError;
-          prepareFreshStack(root, NoLanes);
-          markRootSuspended(root, lanes);
-          ensureRootIsScheduled(root, now$1());
-          throw _fatalError;
-        } // FIXME: Need to check for RootDidNotComplete again. The factoring here
-        // isn't ideal.
-      } // We now have a consistent tree. The next step is either to commit it,
-      // or, if something suspended, wait to commit it after a timeout.
+    var currentDependencies = current.dependencies;
+    workInProgress.dependencies =
+      currentDependencies === null
+        ? null
+        : {
+            lanes: currentDependencies.lanes,
+            firstContext: currentDependencies.firstContext
+          };
 
-      root.finishedWork = finishedWork;
-      root.finishedLanes = lanes;
-      finishConcurrentRender(root, exitStatus, lanes);
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = current.selfBaseDuration;
+      workInProgress.treeBaseDuration = current.treeBaseDuration;
     }
   }
 
-  ensureRootIsScheduled(root, now$1());
-
-  if (root.callbackNode === originalCallbackNode) {
-    // The task node scheduled for this root is the same one that's
-    // currently executed. Need to return a continuation.
-    return performConcurrentWorkOnRoot.bind(null, root);
-  }
-
-  return null;
+  return workInProgress;
 }
-
-function recoverFromConcurrentError(
-  root,
-  originallyAttemptedLanes,
-  errorRetryLanes
+function createHostRootFiber(
+  tag,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride
 ) {
-  // If an error occurred during hydration, discard server response and fall
-  // back to client side render.
-  // Before rendering again, save the errors from the previous attempt.
-  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
-  var wasRootDehydrated = isRootDehydrated(root);
+  var mode;
 
-  if (wasRootDehydrated) {
-    // The shell failed to hydrate. Set a flag to force a client rendering
-    // during the next attempt. To do this, we call prepareFreshStack now
-    // to create the root work-in-progress fiber. This is a bit weird in terms
-    // of factoring, because it relies on renderRootSync not calling
-    // prepareFreshStack again in the call below, which happens because the
-    // root and lanes haven't changed.
-    //
-    // TODO: I think what we should do is set ForceClientRender inside
-    // throwException, like we do for nested Suspense boundaries. The reason
-    // it's here instead is so we can switch to the synchronous work loop, too.
-    // Something to consider for a future refactor.
-    var rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
-    rootWorkInProgress.flags |= ForceClientRender;
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
 
-    {
-      errorHydratingContainer(root.containerInfo);
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
+    }
+
+    if (
+      // Only for internal experiments.
+      concurrentUpdatesByDefaultOverride
+    ) {
+      mode |= ConcurrentUpdatesByDefaultMode;
     }
+  } else {
+    mode = NoMode;
   }
 
-  var exitStatus = renderRootSync(root, errorRetryLanes);
+  if (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;
+  }
 
-  if (exitStatus !== RootErrored) {
-    // Successfully finished rendering on retry
-    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
-      // During the synchronous render, we attached additional ping listeners.
-      // This is highly suggestive of an uncached promise (though it's not the
-      // only reason this would happen). If it was an uncached promise, then
-      // it may have masked a downstream error from ocurring without actually
-      // fixing it. Example:
-      //
-      //    use(Promise.resolve('uncached'))
-      //    throw new Error('Oops!')
-      //
-      // When this happens, there's a conflict between blocking potential
-      // concurrent data races and unwrapping uncached promise values. We
-      // have to choose one or the other. Because the data race recovery is
-      // a last ditch effort, we'll disable it.
-      root.errorRecoveryDisabledLanes = mergeLanes(
-        root.errorRecoveryDisabledLanes,
-        originallyAttemptedLanes
-      ); // Mark the current render as suspended and force it to restart. Once
-      // these lanes finish successfully, we'll re-enable the error recovery
-      // mechanism for subsequent updates.
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(
+  type, // React$ElementType
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
+) {
+  var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
 
-      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
-      return RootSuspendedWithDelay;
-    } // The errors from the failed first attempt have been recovered. Add
-    // them to the collection of recoverable errors. We'll log them in the
-    // commit phase.
+  var resolvedType = type;
 
-    var errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
-    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
-    // from the first attempt, to preserve the causal sequence.
+  if (typeof type === "function") {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
 
-    if (errorsFromSecondAttempt !== null) {
-      queueRecoverableErrors(errorsFromSecondAttempt);
+      {
+        resolvedType = resolveClassForHotReloading(resolvedType);
+      }
+    } else {
+      {
+        resolvedType = resolveFunctionForHotReloading(resolvedType);
+      }
     }
-  }
+  } else if (typeof type === "string") {
+    {
+      var hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext)
+        ? HostHoistable
+        : isHostSingletonType(type)
+        ? HostSingleton
+        : HostComponent;
+    }
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
 
-  return exitStatus;
-}
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
 
-function queueRecoverableErrors(errors) {
-  if (workInProgressRootRecoverableErrors === null) {
-    workInProgressRootRecoverableErrors = errors;
-  } else {
-    // $FlowFixMe[method-unbinding]
-    workInProgressRootRecoverableErrors.push.apply(
-      workInProgressRootRecoverableErrors,
-      errors
-    );
-  }
-}
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
+        }
 
-function finishConcurrentRender(root, exitStatus, lanes) {
-  switch (exitStatus) {
-    case RootInProgress:
-    case RootFatalErrored: {
-      throw new Error("Root did not complete. This is a bug in React.");
-    }
-    // Flow knows about invariant, so it complains if I add a break
-    // statement, but eslint doesn't know about invariant, so it complains
-    // if I do. eslint-disable-next-line no-fallthrough
+        break;
 
-    case RootErrored: {
-      // We should have already attempted to retry this tree. If we reached
-      // this point, it errored again. Commit it.
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
-    }
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
 
-    case RootSuspended: {
-      markRootSuspended(root, lanes); // We have an acceptable loading state. We need to figure out if we
-      // should immediately commit it or wait a bit.
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
 
-      if (
-        includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
-        !shouldForceFlushFallbacksInDEV()
-      ) {
-        // This render only included retries, no updates. Throttle committing
-        // retries so that we don't show too many loading states too quickly.
-        var msUntilTimeout =
-          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
 
-        if (msUntilTimeout > 10) {
-          var nextLanes = getNextLanes(root, NoLanes);
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
 
-          if (nextLanes !== NoLanes) {
-            // There's additional work on this root.
-            break;
-          } // The render is suspended, it hasn't timed out, and there's no
-          // lower priority work to do. Instead of committing the fallback
-          // immediately, wait for more data to arrive.
+      case REACT_LEGACY_HIDDEN_TYPE: {
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      }
 
-          root.timeoutHandle = scheduleTimeout(
-            commitRoot.bind(
-              null,
-              root,
-              workInProgressRootRecoverableErrors,
-              workInProgressTransitions
-            ),
-            msUntilTimeout
-          );
-          break;
-        }
-      } // The work expired. Commit immediately.
+      // eslint-disable-next-line no-fallthrough
 
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
-    }
+      case REACT_SCOPE_TYPE: {
+        return createFiberFromScope(type, pendingProps, mode, lanes, key);
+      }
 
-    case RootSuspendedWithDelay: {
-      markRootSuspended(root, lanes);
+      // eslint-disable-next-line no-fallthrough
 
-      if (includesOnlyTransitions(lanes)) {
-        // This is a transition, so we should exit without committing a
-        // placeholder and without scheduling a timeout. Delay indefinitely
-        // until we receive more data.
-        break;
+      case REACT_CACHE_TYPE: {
+        return createFiberFromCache(pendingProps, mode, lanes, key);
       }
 
-      if (!shouldForceFlushFallbacksInDEV()) {
-        // This is not a transition, but we did trigger an avoided state.
-        // Schedule a placeholder to display after a short delay, using the Just
-        // Noticeable Difference.
-        // TODO: Is the JND optimization worth the added complexity? If this is
-        // the only reason we track the event time, then probably not.
-        // Consider removing.
-        var mostRecentEventTime = getMostRecentEventTime(root, lanes);
-        var eventTimeMs = mostRecentEventTime;
-        var timeElapsedMs = now$1() - eventTimeMs;
+      // eslint-disable-next-line no-fallthrough
 
-        var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing) {
+          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
+        }
 
-        if (_msUntilTimeout > 10) {
-          // Instead of committing the fallback immediately, wait for more data
-          // to arrive.
-          root.timeoutHandle = scheduleTimeout(
-            commitRoot.bind(
-              null,
-              root,
-              workInProgressRootRecoverableErrors,
-              workInProgressTransitions
-            ),
-            _msUntilTimeout
-          );
+      // eslint-disable-next-line no-fallthrough
+
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = Mode;
+          mode |= DebugTracingMode;
           break;
         }
-      } // Commit the placeholder.
 
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
-    }
+      // eslint-disable-next-line no-fallthrough
 
-    case RootCompleted: {
-      // The work completed. Ready to commit.
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
-    }
+      default: {
+        if (typeof type === "object" && type !== null) {
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = ContextProvider;
+              break getTag;
 
-    default: {
-      throw new Error("Unknown root exit status.");
-    }
-  }
-}
+            case REACT_CONTEXT_TYPE:
+              // This is a consumer
+              fiberTag = ContextConsumer;
+              break getTag;
 
-function isRenderConsistentWithExternalStores(finishedWork) {
-  // Search the rendered tree for external store reads, and check whether the
-  // stores were mutated in a concurrent event. Intentionally using an iterative
-  // loop instead of recursion so we can exit early.
-  var node = finishedWork;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = ForwardRef;
 
-  while (true) {
-    if (node.flags & StoreConsistency) {
-      var updateQueue = node.updateQueue;
+              {
+                resolvedType = resolveForwardRefForHotReloading(resolvedType);
+              }
 
-      if (updateQueue !== null) {
-        var checks = updateQueue.stores;
+              break getTag;
 
-        if (checks !== null) {
-          for (var i = 0; i < checks.length; i++) {
-            var check = checks[i];
-            var getSnapshot = check.getSnapshot;
-            var renderedValue = check.value;
+            case REACT_MEMO_TYPE:
+              fiberTag = MemoComponent;
+              break getTag;
 
-            try {
-              if (!objectIs(getSnapshot(), renderedValue)) {
-                // Found an inconsistent store.
-                return false;
-              }
-            } catch (error) {
-              // If `getSnapshot` throws, return `false`. This will schedule
-              // a re-render, and the error will be rethrown during render.
-              return false;
-            }
+            case REACT_LAZY_TYPE:
+              fiberTag = LazyComponent;
+              resolvedType = null;
+              break getTag;
           }
         }
-      }
-    }
 
-    var child = node.child;
+        var info = "";
 
-    if (node.subtreeFlags & StoreConsistency && child !== null) {
-      child.return = node;
-      node = child;
-      continue;
-    }
+        {
+          if (
+            type === undefined ||
+            (typeof type === "object" &&
+              type !== null &&
+              Object.keys(type).length === 0)
+          ) {
+            info +=
+              " You likely forgot to export your component from the file " +
+              "it's defined in, or you might have mixed up default and " +
+              "named imports.";
+          }
 
-    if (node === finishedWork) {
-      return true;
-    }
+          var ownerName = owner ? getComponentNameFromFiber(owner) : null;
 
-    while (node.sibling === null) {
-      if (node.return === null || node.return === finishedWork) {
-        return true;
-      }
+          if (ownerName) {
+            info += "\n\nCheck the render method of `" + ownerName + "`.";
+          }
+        }
 
-      node = node.return;
+        throw new Error(
+          "Element type is invalid: expected a string (for built-in " +
+            "components) or a class/function (for composite components) " +
+            ("but got: " + (type == null ? type : typeof type) + "." + info)
+        );
+      }
     }
+  }
 
-    node.sibling.return = node.return;
-    node = node.sibling;
-  } // Flow doesn't know this is unreachable, but eslint does
-  // eslint-disable-next-line no-unreachable
+  var fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
 
-  return true;
+  {
+    fiber._debugOwner = owner;
+  }
+
+  return fiber;
 }
+function createFiberFromElement(element, mode, lanes) {
+  var owner = null;
 
-function markRootSuspended(root, suspendedLanes) {
-  // When suspending, we should always exclude lanes that were pinged or (more
-  // rarely, since we try to avoid it) updated during the render phase.
-  // TODO: Lol maybe there's a better way to factor this besides this
-  // obnoxiously named function :)
-  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
-  suspendedLanes = removeLanes(
-    suspendedLanes,
-    workInProgressRootInterleavedUpdatedLanes
+  {
+    owner = element._owner;
+  }
+
+  var type = element.type;
+  var key = element.key;
+  var pendingProps = element.props;
+  var fiber = createFiberFromTypeAndProps(
+    type,
+    key,
+    pendingProps,
+    owner,
+    mode,
+    lanes
   );
-  markRootSuspended$1(root, suspendedLanes);
-} // This is the entry point for synchronous tasks that don't go
-// through Scheduler
 
-function performSyncWorkOnRoot(root) {
   {
-    syncNestedUpdateFlag();
+    fiber._debugSource = element._source;
+    fiber._debugOwner = element._owner;
   }
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  var fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromScope(scope, pendingProps, mode, lanes, key) {
+  var fiber = createFiber(ScopeComponent, pendingProps, key, mode);
+  fiber.type = scope;
+  fiber.elementType = scope;
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+  {
+    if (typeof pendingProps.id !== "string") {
+      error(
+        'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
+        typeof pendingProps.id
+      );
+    }
   }
 
-  flushPassiveEffects();
-  var lanes = getNextLanes(root, NoLanes);
+  var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
 
-  if (!includesSyncLane(lanes)) {
-    // There's no remaining sync work left.
-    ensureRootIsScheduled(root, now$1());
-    return null;
+  {
+    fiber.stateNode = {
+      effectDuration: 0,
+      passiveEffectDuration: 0
+    };
   }
 
-  var exitStatus = renderRootSync(root, lanes);
+  return fiber;
+}
 
-  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
-    // If something threw an error, try rendering one more time. We'll render
-    // synchronously to block concurrent data mutations, and we'll includes
-    // all pending updates are included. If it still fails after the second
-    // attempt, we'll give up and commit the resulting tree.
-    var originallyAttemptedLanes = lanes;
-    var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-      root,
-      originallyAttemptedLanes
-    );
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
+    }
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(LegacyHiddenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  fiber.lanes = lanes; // Adding a stateNode for legacy hidden because it's currently using
+  // the offscreen implementation, which depends on a state node
 
-    if (errorRetryLanes !== NoLanes) {
-      lanes = errorRetryLanes;
-      exitStatus = recoverFromConcurrentError(
-        root,
-        originallyAttemptedLanes,
-        errorRetryLanes
-      );
+  var instance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
     }
-  }
+  };
+  fiber.stateNode = instance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromTracingMarker(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(TracingMarkerComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_TRACING_MARKER_TYPE;
+  fiber.lanes = lanes;
+  var tracingMarkerInstance = {
+    tag: TransitionTracingMarker,
+    transitions: null,
+    pendingBoundaries: null,
+    aborts: null,
+    name: pendingProps.name
+  };
+  fiber.stateNode = tracingMarkerInstance;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  var fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  var fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = "DELETED";
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  var fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  var pendingProps = portal.children !== null ? portal.children : [];
+  var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
 
-  if (exitStatus === RootFatalErrored) {
-    var fatalError = workInProgressRootFatalError;
-    prepareFreshStack(root, NoLanes);
-    markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now$1());
-    throw fatalError;
-  }
+function assignFiberPropertiesInDEV(target, source) {
+  if (target === null) {
+    // This Fiber's initial properties will always be overwritten.
+    // We only use a Fiber to ensure the same hidden class so DEV isn't slow.
+    target = createFiber(IndeterminateComponent, null, null, NoMode);
+  } // This is intentionally written as a list of all properties.
+  // We tried to use Object.assign() instead but this is called in
+  // the hottest path, and Object.assign() was too slow:
+  // https://github.com/facebook/react/issues/12502
+  // This code is DEV-only so size is not a concern.
 
-  if (exitStatus === RootDidNotComplete) {
-    // The render unwound without completing the tree. This happens in special
-    // cases where need to exit the current render without producing a
-    // consistent tree or committing.
-    markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now$1());
-    return null;
-  } // We now have a consistent tree. Because this is a sync render, we
-  // will commit it even if something suspended.
+  target.tag = source.tag;
+  target.key = source.key;
+  target.elementType = source.elementType;
+  target.type = source.type;
+  target.stateNode = source.stateNode;
+  target.return = source.return;
+  target.child = source.child;
+  target.sibling = source.sibling;
+  target.index = source.index;
+  target.ref = source.ref;
+  target.refCleanup = source.refCleanup;
+  target.pendingProps = source.pendingProps;
+  target.memoizedProps = source.memoizedProps;
+  target.updateQueue = source.updateQueue;
+  target.memoizedState = source.memoizedState;
+  target.dependencies = source.dependencies;
+  target.mode = source.mode;
+  target.flags = source.flags;
+  target.subtreeFlags = source.subtreeFlags;
+  target.deletions = source.deletions;
+  target.lanes = source.lanes;
+  target.childLanes = source.childLanes;
+  target.alternate = source.alternate;
 
-  var finishedWork = root.current.alternate;
-  root.finishedWork = finishedWork;
-  root.finishedLanes = lanes;
-  commitRoot(
-    root,
-    workInProgressRootRecoverableErrors,
-    workInProgressTransitions
-  ); // Before exiting, make sure there's a callback scheduled for the next
-  // pending level.
+  {
+    target.actualDuration = source.actualDuration;
+    target.actualStartTime = source.actualStartTime;
+    target.selfBaseDuration = source.selfBaseDuration;
+    target.treeBaseDuration = source.treeBaseDuration;
+  }
 
-  ensureRootIsScheduled(root, now$1());
-  return null;
+  target._debugSource = source._debugSource;
+  target._debugOwner = source._debugOwner;
+  target._debugNeedsRemount = source._debugNeedsRemount;
+  target._debugHookTypes = source._debugHookTypes;
+  return target;
 }
 
-function flushRoot(root, lanes) {
-  if (lanes !== NoLanes) {
-    markRootEntangled(root, mergeLanes(lanes, SyncLane));
-    ensureRootIsScheduled(root, now$1());
+function FiberRootNode(
+  containerInfo, // $FlowFixMe[missing-local-annot]
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
+) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.context = null;
+  this.pendingContext = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.eventTimes = createLaneMap(NoLanes);
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.mutableReadLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
 
-    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
-      resetRenderTimer();
-      flushSyncCallbacks();
-    }
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
   }
-}
-function getExecutionContext() {
-  return executionContext;
-}
-function batchedUpdates(fn, a) {
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
 
-  try {
-    return fn(a);
-  } finally {
-    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
-    // most batchedUpdates-like method.
+  {
+    this.mutableSourceEagerHydrationData = null;
+  }
 
-    if (
-      executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
-      !ReactCurrentActQueue.isBatchingLegacy
-    ) {
-      resetRenderTimer();
-      flushSyncCallbacksOnlyInLegacyMode();
-    }
+  {
+    this.hydrationCallbacks = null;
   }
-}
-function discreteUpdates(fn, a, b, c, d) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig.transition;
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    return fn(a, b, c, d);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
+  this.incompleteTransitions = new Map();
 
-    if (executionContext === NoContext) {
-      resetRenderTimer();
+  if (enableTransitionTracing) {
+    this.transitionCallbacks = null;
+    var transitionLanesMap = (this.transitionLanes = []);
+
+    for (var i = 0; i < TotalLanes; i++) {
+      transitionLanesMap.push(null);
     }
   }
-} // Overload the definition to the two valid signatures.
-// Warning, this opts-out of checking the function body.
-// eslint-disable-next-line no-unused-vars
-// eslint-disable-next-line no-redeclare
-// eslint-disable-next-line no-redeclare
 
-function flushSync$1(fn) {
-  // In legacy mode, we flush pending passive effects at the beginning of the
-  // next event, not at the end of the previous one.
-  if (
-    rootWithPendingPassiveEffects !== null &&
-    rootWithPendingPassiveEffects.tag === LegacyRoot &&
-    (executionContext & (RenderContext | CommitContext)) === NoContext
-  ) {
-    flushPassiveEffects();
+  {
+    this.effectDuration = 0;
+    this.passiveEffectDuration = 0;
   }
 
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
-  var prevTransition = ReactCurrentBatchConfig.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
-
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
+  {
+    this.memoizedUpdaters = new Set();
+    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
 
-    if (fn) {
-      return fn();
-    } else {
-      return undefined;
+    for (var _i = 0; _i < TotalLanes; _i++) {
+      pendingUpdatersLaneMap.push(new Set());
     }
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
-    // Note that this will happen even if batchedUpdates is higher up
-    // the stack.
+  }
 
-    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
-      flushSyncCallbacks();
+  {
+    switch (tag) {
+      case ConcurrentRoot:
+        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
+        break;
+
+      case LegacyRoot:
+        this._debugRootType = hydrate ? "hydrate()" : "render()";
+        break;
     }
   }
 }
-function isAlreadyRendering() {
-  // Used by the renderer to print a warning if certain APIs are called from
-  // the wrong context.
-  return (executionContext & (RenderContext | CommitContext)) !== NoContext;
-}
-function isInvalidExecutionContextForEventFunction() {
-  // Used to throw if certain APIs are called from the wrong context.
-  return (executionContext & RenderContext) !== NoContext;
-}
-function flushControlled(fn) {
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
-  var prevTransition = ReactCurrentBatchConfig.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    fn();
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-    executionContext = prevExecutionContext;
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+  // host config, but because they are passed in at runtime, we have to thread
+  // them through the root constructor. Perhaps we should put them all into a
+  // single type, like a DynamicHostConfig that is defined by the renderer.
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  var root = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
+  );
 
-    if (executionContext === NoContext) {
-      // Flush the immediate callbacks that were scheduled during this batch
-      resetRenderTimer();
-      flushSyncCallbacks();
-    }
+  {
+    root.hydrationCallbacks = hydrationCallbacks;
   }
-} // This is called by the HiddenContext module when we enter or leave a
-// hidden subtree. The stack logic is managed there because that's the only
-// place that ever modifies it. Which module it lives in doesn't matter for
-// performance because this function will get inlined regardless
 
-function setRenderLanes(subtreeRenderLanes) {
-  renderLanes = subtreeRenderLanes;
-}
-function getRenderLanes() {
-  return renderLanes;
-}
+  if (enableTransitionTracing) {
+    root.transitionCallbacks = transitionCallbacks;
+  } // Cyclic construction. This cheats the type system right now because
+  // stateNode is any.
 
-function resetWorkInProgressStack() {
-  if (workInProgress === null) return;
-  var interruptedWork;
+  var uninitializedFiber = createHostRootFiber(
+    tag,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride
+  );
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
 
-  if (workInProgressSuspendedReason === NotSuspended) {
-    // Normal case. Work-in-progress hasn't started yet. Unwind all
-    // its parents.
-    interruptedWork = workInProgress.return;
-  } else {
-    // Work-in-progress is in suspended state. Reset the work loop and unwind
-    // both the suspended fiber and all its parents.
-    resetSuspendedWorkLoopOnUnwind();
-    interruptedWork = workInProgress;
-  }
+  {
+    var initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
 
-  while (interruptedWork !== null) {
-    var current = interruptedWork.alternate;
-    unwindInterruptedWork(current, interruptedWork);
-    interruptedWork = interruptedWork.return;
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    var initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
   }
 
-  workInProgress = null;
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
 }
 
-function prepareFreshStack(root, lanes) {
-  root.finishedWork = null;
-  root.finishedLanes = NoLanes;
-  var timeoutHandle = root.timeoutHandle;
-
-  if (timeoutHandle !== noTimeout) {
-    // The root previous suspended and scheduled a timeout to commit a fallback
-    // state. Now that we have additional work, cancel the timeout.
-    root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
-
-    cancelTimeout(timeoutHandle);
-  }
+var ReactVersion = "18.3.0-www-classic-036f93df";
 
-  resetWorkInProgressStack();
-  workInProgressRoot = root;
-  var rootWorkInProgress = createWorkInProgress(root.current, null);
-  workInProgress = rootWorkInProgress;
-  workInProgressRootRenderLanes = renderLanes = lanes;
-  workInProgressSuspendedReason = NotSuspended;
-  workInProgressThrownValue = null;
-  workInProgressRootDidAttachPingListener = false;
-  workInProgressRootExitStatus = RootInProgress;
-  workInProgressRootFatalError = null;
-  workInProgressRootSkippedLanes = NoLanes;
-  workInProgressRootInterleavedUpdatedLanes = NoLanes;
-  workInProgressRootPingedLanes = NoLanes;
-  workInProgressRootConcurrentErrors = null;
-  workInProgressRootRecoverableErrors = null;
-  finishQueueingConcurrentUpdates();
+function createPortal$1(
+  children,
+  containerInfo, // TODO: figure out the API for cross-renderer implementation.
+  implementation
+) {
+  var key =
+    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
 
   {
-    ReactStrictModeWarnings.discardPendingWarnings();
+    checkKeyStringCoercion(key);
   }
 
-  return rootWorkInProgress;
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
 }
 
-function resetSuspendedWorkLoopOnUnwind() {
-  // Reset module-level state that was set during the render phase.
-  resetContextDependencies();
-  resetHooksOnUnwind();
-  resetChildReconcilerOnUnwind();
-}
+// Might add PROFILE later.
 
-function handleThrow(root, thrownValue) {
-  // A component threw an exception. Usually this is because it suspended, but
-  // it also includes regular program errors.
-  //
-  // We're either going to unwind the stack to show a Suspense or error
-  // boundary, or we're going to replay the component again. Like after a
-  // promise resolves.
-  //
-  // Until we decide whether we're going to unwind or replay, we should preserve
-  // the current state of the work loop without resetting anything.
-  //
-  // If we do decide to unwind the stack, module-level variables will be reset
-  // in resetSuspendedWorkLoopOnUnwind.
-  // These should be reset immediately because they're only supposed to be set
-  // when React is executing user code.
-  resetHooksAfterThrow();
-  resetCurrentFiber();
-  ReactCurrentOwner$1.current = null;
+var didWarnAboutNestedUpdates;
+var didWarnAboutFindNodeInStrictMode;
 
-  if (thrownValue === SuspenseException) {
-    // This is a special type of exception used for Suspense. For historical
-    // reasons, the rest of the Suspense implementation expects the thrown value
-    // to be a thenable, because before `use` existed that was the (unstable)
-    // API for suspending. This implementation detail can change later, once we
-    // deprecate the old API in favor of `use`.
-    thrownValue = getSuspendedThenable();
-    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
-      ? SuspendedOnData
-      : SuspendedOnImmediate;
-  } else if (thrownValue === SelectiveHydrationException) {
-    // An update flowed into a dehydrated boundary. Before we can apply the
-    // update, we need to finish hydrating. Interrupt the work-in-progress
-    // render so we can restart at the hydration lane.
-    //
-    // The ideal implementation would be able to switch contexts without
-    // unwinding the current stack.
-    //
-    // We could name this something more general but as of now it's the only
-    // case where we think this should happen.
-    workInProgressSuspendedReason = SuspendedOnHydration;
-  } else {
-    // This is a regular error.
-    var isWakeable =
-      thrownValue !== null &&
-      typeof thrownValue === "object" &&
-      typeof thrownValue.then === "function";
-    workInProgressSuspendedReason = isWakeable // A wakeable object was thrown by a legacy Suspense implementation.
-      ? // This has slightly different behavior than suspending with `use`.
-        SuspendedOnDeprecatedThrowPromise // This is a regular error. If something earlier in the component already
-      : // suspended, we must clear the thenable state to unblock the work loop.
-        SuspendedOnError;
+{
+  didWarnAboutNestedUpdates = false;
+  didWarnAboutFindNodeInStrictMode = {};
+}
+
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
   }
 
-  workInProgressThrownValue = thrownValue;
-  var erroredWork = workInProgress;
+  var fiber = get(parentComponent);
+  var parentContext = findCurrentUnmaskedContext(fiber);
 
-  if (erroredWork === null) {
-    // This is a fatal error
-    workInProgressRootExitStatus = RootFatalErrored;
-    workInProgressRootFatalError = thrownValue;
-    return;
-  }
+  if (fiber.tag === ClassComponent) {
+    var Component = fiber.type;
 
-  if (erroredWork.mode & ProfileMode) {
-    // Record the time spent rendering before an error was thrown. This
-    // avoids inaccurate Profiler durations in the case of a
-    // suspended render.
-    stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
+    if (isContextProvider(Component)) {
+      return processChildContext(fiber, Component, parentContext);
+    }
   }
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
+  return parentContext;
+}
 
-    switch (workInProgressSuspendedReason) {
-      case SuspendedOnError: {
-        markComponentErrored(
-          erroredWork,
-          thrownValue,
-          workInProgressRootRenderLanes
-        );
-        break;
-      }
+function findHostInstanceWithWarning(component, methodName) {
+  {
+    var fiber = get(component);
 
-      case SuspendedOnData:
-      case SuspendedOnImmediate:
-      case SuspendedOnDeprecatedThrowPromise:
-      case SuspendedAndReadyToContinue: {
-        var wakeable = thrownValue;
-        markComponentSuspended(
-          erroredWork,
-          wakeable,
-          workInProgressRootRenderLanes
+    if (fiber === undefined) {
+      if (typeof component.render === "function") {
+        throw new Error("Unable to find node on an unmounted component.");
+      } else {
+        var keys = Object.keys(component).join(",");
+        throw new Error(
+          "Argument appears to not be a ReactComponent. Keys: " + keys
         );
-        break;
       }
     }
-  }
-}
 
-function shouldAttemptToSuspendUntilDataResolves() {
-  // Check if there are other pending updates that might possibly unblock this
-  // component from suspending. This mirrors the check in
-  // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
-  // TODO: Consider unwinding immediately, using the
-  // SuspendedOnHydration mechanism.
-  if (
-    includesNonIdleWork(workInProgressRootSkippedLanes) ||
-    includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)
-  ) {
-    // Suspend normally. renderDidSuspendDelayIfPossible will handle
-    // interrupting the work loop.
-    return false;
-  } // TODO: We should be able to remove the equivalent check in
-  // finishConcurrentRender, and rely just on this one.
+    var hostFiber = findCurrentHostFiber(fiber);
 
-  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
-    // If we're rendering inside the "shell" of the app, it's better to suspend
-    // rendering and wait for the data to resolve. Otherwise, we should switch
-    // to a fallback and continue rendering.
-    return getShellBoundary() === null;
-  }
+    if (hostFiber === null) {
+      return null;
+    }
 
-  var handler = getSuspenseHandler();
+    if (hostFiber.mode & StrictLegacyMode) {
+      var componentName = getComponentNameFromFiber(fiber) || "Component";
 
-  if (handler === null);
-  else {
-    if (includesOnlyRetries(workInProgressRootRenderLanes)) {
-      // During a retry, we can suspend rendering if the nearest Suspense boundary
-      // is the boundary of the "shell", because we're guaranteed not to block
-      // any new content from appearing.
-      return handler === getShellBoundary();
+      if (!didWarnAboutFindNodeInStrictMode[componentName]) {
+        didWarnAboutFindNodeInStrictMode[componentName] = true;
+        var previousFiber = current;
+
+        try {
+          setCurrentFiber(hostFiber);
+
+          if (fiber.mode & StrictLegacyMode) {
+            error(
+              "%s is deprecated in StrictMode. " +
+                "%s was passed an instance of %s which is inside StrictMode. " +
+                "Instead, add a ref directly to the element you want to reference. " +
+                "Learn more about using refs safely here: " +
+                "https://reactjs.org/link/strict-mode-find-node",
+              methodName,
+              methodName,
+              componentName
+            );
+          } else {
+            error(
+              "%s is deprecated in StrictMode. " +
+                "%s was passed an instance of %s which renders StrictMode children. " +
+                "Instead, add a ref directly to the element you want to reference. " +
+                "Learn more about using refs safely here: " +
+                "https://reactjs.org/link/strict-mode-find-node",
+              methodName,
+              methodName,
+              componentName
+            );
+          }
+        } finally {
+          // Ideally this should reset to previous but this shouldn't be called in
+          // render and there's another warning for that anyway.
+          if (previousFiber) {
+            setCurrentFiber(previousFiber);
+          } else {
+            resetCurrentFiber();
+          }
+        }
+      }
     }
-  } // For all other Lanes besides Transitions and Retries, we should not wait
-  // for the data to load.
-  // TODO: We should wait during Offscreen prerendering, too.
 
-  return false;
+    return getPublicInstance(hostFiber.stateNode);
+  }
 }
 
-function pushDispatcher(container) {
-  prepareRendererToRender(container);
-  var prevDispatcher = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+function createContainer(
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  var hydrate = false;
+  var initialChildren = null;
+  return createFiberRoot(
+    containerInfo,
+    tag,
+    hydrate,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
+  );
+}
+function createHydrationContainer(
+  initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+  callback,
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  var hydrate = true;
+  var root = createFiberRoot(
+    containerInfo,
+    tag,
+    hydrate,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
+  ); // TODO: Move this to FiberRoot constructor
 
-  if (prevDispatcher === null) {
-    // The React isomorphic package does not include a default dispatcher.
-    // Instead the first renderer will lazily attach one, in order to give
-    // nicer error messages.
-    return ContextOnlyDispatcher;
-  } else {
-    return prevDispatcher;
-  }
-}
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
 
-function popDispatcher(prevDispatcher) {
-  resetRendererAfterRender();
-  ReactCurrentDispatcher.current = prevDispatcher;
+  var current = root.current;
+  var lane = requestUpdateLane(current);
+  var update = createUpdate(lane);
+  update.callback =
+    callback !== undefined && callback !== null ? callback : null;
+  var eventTime = requestEventTime();
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane, eventTime);
+  return root;
 }
-
-function pushCacheDispatcher() {
+function updateContainer(element, container, parentComponent, callback) {
   {
-    var prevCacheDispatcher = ReactCurrentCache.current;
-    ReactCurrentCache.current = DefaultCacheDispatcher;
-    return prevCacheDispatcher;
+    onScheduleRoot(container, element);
   }
-}
 
-function popCacheDispatcher(prevCacheDispatcher) {
-  {
-    ReactCurrentCache.current = prevCacheDispatcher;
-  }
-}
+  var current$1 = container.current;
+  var lane = requestUpdateLane(current$1);
 
-function markCommitTimeOfFallback() {
-  globalMostRecentFallbackTime = now$1();
-}
-function markSkippedUpdateLanes(lane) {
-  workInProgressRootSkippedLanes = mergeLanes(
-    lane,
-    workInProgressRootSkippedLanes
-  );
-}
-function renderDidSuspend() {
-  if (workInProgressRootExitStatus === RootInProgress) {
-    workInProgressRootExitStatus = RootSuspended;
+  if (enableSchedulingProfiler) {
+    markRenderScheduled(lane);
   }
-}
-function renderDidSuspendDelayIfPossible() {
-  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
-  // this render.
 
-  if (
-    workInProgressRoot !== null &&
-    (includesNonIdleWork(workInProgressRootSkippedLanes) ||
-      includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))
-  ) {
-    // Mark the current render as suspended so that we switch to working on
-    // the updates that were skipped. Usually we only suspend at the end of
-    // the render phase.
-    // TODO: We should probably always mark the root as suspended immediately
-    // (inside this function), since by suspending at the end of the render
-    // phase introduces a potential mistake where we suspend lanes that were
-    // pinged or updated while we were rendering.
-    // TODO: Consider unwinding immediately, using the
-    // SuspendedOnHydration mechanism.
-    // $FlowFixMe[incompatible-call] need null check workInProgressRoot
-    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
-  }
-}
-function renderDidError(error) {
-  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
-    workInProgressRootExitStatus = RootErrored;
-  }
+  var context = getContextForSubtree(parentComponent);
 
-  if (workInProgressRootConcurrentErrors === null) {
-    workInProgressRootConcurrentErrors = [error];
+  if (container.context === null) {
+    container.context = context;
   } else {
-    workInProgressRootConcurrentErrors.push(error);
+    container.pendingContext = context;
   }
-} // Called during render to determine if anything has suspended.
-// Returns false if we're not sure.
 
-function renderHasNotSuspendedYet() {
-  // If something errored or completed, we can't really be sure,
-  // so those are false.
-  return workInProgressRootExitStatus === RootInProgress;
-} // TODO: Over time, this function and renderRootConcurrent have become more
-// and more similar. Not sure it makes sense to maintain forked paths. Consider
-// unifying them again.
+  {
+    if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
+      didWarnAboutNestedUpdates = true;
 
-function renderRootSync(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= RenderContext;
-  var prevDispatcher = pushDispatcher(root.containerInfo);
-  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
-  // and prepare a fresh one. Otherwise we'll continue where we left off.
+      error(
+        "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.",
+        getComponentNameFromFiber(current) || "Unknown"
+      );
+    }
+  }
 
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    {
-      if (isDevToolsPresent) {
-        var memoizedUpdaters = root.memoizedUpdaters;
+  var update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-        if (memoizedUpdaters.size > 0) {
-          restorePendingUpdaters(root, workInProgressRootRenderLanes);
-          memoizedUpdaters.clear();
-        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
-        // If we bailout on this work, we'll move them back (like above).
-        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
-        // That way we can keep the current update and future updates separate.
+  update.payload = {
+    element: element
+  };
+  callback = callback === undefined ? null : callback;
 
-        movePendingFibersToMemoized(root, lanes);
+  if (callback !== null) {
+    {
+      if (typeof callback !== "function") {
+        error(
+          "render(...): Expected the last optional `callback` argument to be a " +
+            "function. Instead received: %s.",
+          callback
+        );
       }
     }
 
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    prepareFreshStack(root, lanes);
+    update.callback = callback;
   }
 
-  {
-    if (enableDebugTracing) {
-      logRenderStarted(lanes);
-    }
+  var root = enqueueUpdate(current$1, update, lane);
+
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, current$1, lane, eventTime);
+    entangleTransitions(root, current$1, lane);
   }
 
-  if (enableSchedulingProfiler) {
-    markRenderStarted(lanes);
+  return lane;
+}
+function getPublicRootInstance(container) {
+  var containerFiber = container.current;
+
+  if (!containerFiber.child) {
+    return null;
   }
 
-  outer: do {
-    try {
-      if (
-        workInProgressSuspendedReason !== NotSuspended &&
-        workInProgress !== null
-      ) {
-        // The work loop is suspended. During a synchronous render, we don't
-        // yield to the main thread. Immediately unwind the stack. This will
-        // trigger either a fallback or an error boundary.
-        // TODO: For discrete and "default" updates (anything that's not
-        // flushSync), we want to wait for the microtasks the flush before
-        // unwinding. Will probably implement this using renderRootConcurrent,
-        // or merge renderRootSync and renderRootConcurrent into the same
-        // function and fork the behavior some other way.
-        var unitOfWork = workInProgress;
-        var thrownValue = workInProgressThrownValue;
+  switch (containerFiber.child.tag) {
+    case HostSingleton:
+    case HostComponent:
+      return getPublicInstance(containerFiber.child.stateNode);
 
-        switch (workInProgressSuspendedReason) {
-          case SuspendedOnHydration: {
-            // Selective hydration. An update flowed into a dehydrated tree.
-            // Interrupt the current render so the work loop can switch to the
-            // hydration lane.
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = RootDidNotComplete;
-            break outer;
-          }
+    default:
+      return containerFiber.child.stateNode;
+  }
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot: {
+      var root = fiber.stateNode;
 
-          default: {
-            // Continue with the normal work loop.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
-        }
+      if (isRootDehydrated(root)) {
+        // Flush the first scheduled "update".
+        var lanes = getHighestPriorityPendingLanes(root);
+        flushRoot(root, lanes);
       }
 
-      workLoopSync();
       break;
-    } catch (thrownValue) {
-      handleThrow(root, thrownValue);
     }
-  } while (true);
 
-  resetContextDependencies();
-  executionContext = prevExecutionContext;
-  popDispatcher(prevDispatcher);
-  popCacheDispatcher(prevCacheDispatcher);
+    case SuspenseComponent: {
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  if (workInProgress !== null) {
-    // This is a sync render, so we should have finished the whole tree.
-    throw new Error(
-      "Cannot commit an incomplete root. This error is likely caused by a " +
-        "bug in React. Please file an issue."
-    );
-  }
+        if (root !== null) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);
+        }
+      }); // If we're still blocked after this, we need to increase
+      // the priority of any promises resolving within this
+      // boundary so that they next attempt also has higher pri.
 
-  {
-    if (enableDebugTracing) {
-      logRenderStopped();
+      var retryLane = SyncLane;
+      markRetryLaneIfNotHydrated(fiber, retryLane);
+      break;
     }
   }
+}
 
-  if (enableSchedulingProfiler) {
-    markRenderStopped();
-  } // Set this to null to indicate there's no in-progress render.
-
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+function markRetryLaneImpl(fiber, retryLane) {
+  var suspenseState = fiber.memoizedState;
 
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
-} // The work loop is an extremely hot path. Tell Closure not to inline it.
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(
+      suspenseState.retryLane,
+      retryLane
+    );
+  }
+} // Increases the priority of thenables when they resolve within this boundary.
 
-/** @noinline */
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  var alternate = fiber.alternate;
 
-function workLoopSync() {
-  // Perform work without checking if we need to yield between fiber.
-  while (workInProgress !== null) {
-    performUnitOfWork(workInProgress);
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
   }
 }
 
-function renderRootConcurrent(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= RenderContext;
-  var prevDispatcher = pushDispatcher(root.containerInfo);
-  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
-  // and prepare a fresh one. Otherwise we'll continue where we left off.
+function attemptDiscreteHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
 
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    {
-      if (isDevToolsPresent) {
-        var memoizedUpdaters = root.memoizedUpdaters;
+  var lane = SyncLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
 
-        if (memoizedUpdaters.size > 0) {
-          restorePendingUpdaters(root, workInProgressRootRenderLanes);
-          memoizedUpdaters.clear();
-        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
-        // If we bailout on this work, we'll move them back (like above).
-        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
-        // That way we can keep the current update and future updates separate.
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+  }
 
-        movePendingFibersToMemoized(root, lanes);
-      }
-    }
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
 
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    resetRenderTimer();
-    prepareFreshStack(root, lanes);
+  var lane = SelectiveHydrationLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
   }
 
-  {
-    if (enableDebugTracing) {
-      logRenderStarted(lanes);
-    }
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
   }
 
-  if (enableSchedulingProfiler) {
-    markRenderStarted(lanes);
+  var lane = requestUpdateLane(fiber);
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
   }
 
-  outer: do {
-    try {
-      if (
-        workInProgressSuspendedReason !== NotSuspended &&
-        workInProgress !== null
-      ) {
-        // The work loop is suspended. We need to either unwind the stack or
-        // replay the suspended component.
-        var unitOfWork = workInProgress;
-        var thrownValue = workInProgressThrownValue;
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function findHostInstanceWithNoPortals(fiber) {
+  var hostFiber = findCurrentHostFiberWithNoPortals(fiber);
 
-        switch (workInProgressSuspendedReason) {
-          case SuspendedOnError: {
-            // Unwind then continue with the normal work loop.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
+  if (hostFiber === null) {
+    return null;
+  }
 
-          case SuspendedOnData: {
-            var thenable = thrownValue;
+  return getPublicInstance(hostFiber.stateNode);
+}
 
-            if (isThenableResolved(thenable)) {
-              // The data resolved. Try rendering the component again.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(unitOfWork);
-              break;
-            } // The work loop is suspended on data. We should wait for it to
-            // resolve before continuing to render.
-            // TODO: Handle the case where the promise resolves synchronously.
-            // Usually this is handled when we instrument the promise to add a
-            // `status` field, but if the promise already has a status, we won't
-            // have added a listener until right here.
+var shouldErrorImpl = function (fiber) {
+  return null;
+};
 
-            var onResolution = function () {
-              // Check if the root is still suspended on this promise.
-              if (
-                workInProgressSuspendedReason === SuspendedOnData &&
-                workInProgressRoot === root
-              ) {
-                // Mark the root as ready to continue rendering.
-                workInProgressSuspendedReason = SuspendedAndReadyToContinue;
-              } // Ensure the root is scheduled. We should do this even if we're
-              // currently working on a different root, so that we resume
-              // rendering later.
+function shouldError(fiber) {
+  return shouldErrorImpl(fiber);
+}
 
-              ensureRootIsScheduled(root, now$1());
-            };
+var shouldSuspendImpl = function (fiber) {
+  return false;
+};
 
-            thenable.then(onResolution, onResolution);
-            break outer;
-          }
+function shouldSuspend(fiber) {
+  return shouldSuspendImpl(fiber);
+}
+var overrideHookState = null;
+var overrideHookStateDeletePath = null;
+var overrideHookStateRenamePath = null;
+var overrideProps = null;
+var overridePropsDeletePath = null;
+var overridePropsRenamePath = null;
+var scheduleUpdate = null;
+var setErrorHandler = null;
+var setSuspenseHandler = null;
 
-          case SuspendedOnImmediate: {
-            // If this fiber just suspended, it's possible the data is already
-            // cached. Yield to the main thread to give it a chance to ping. If
-            // it does, we can retry immediately without unwinding the stack.
-            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
-            break outer;
-          }
+{
+  var copyWithDeleteImpl = function (obj, path, index) {
+    var key = path[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
 
-          case SuspendedAndReadyToContinue: {
-            var _thenable = thrownValue;
+    if (index + 1 === path.length) {
+      if (isArray(updated)) {
+        updated.splice(key, 1);
+      } else {
+        delete updated[key];
+      }
 
-            if (isThenableResolved(_thenable)) {
-              // The data resolved. Try rendering the component again.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(unitOfWork);
-            } else {
-              // Otherwise, unwind then continue with the normal work loop.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            }
+      return updated;
+    } // $FlowFixMe number or string is fine here
 
-            break;
-          }
+    updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
+    return updated;
+  };
 
-          case SuspendedOnDeprecatedThrowPromise: {
-            // Suspended by an old implementation that uses the `throw promise`
-            // pattern. The newer replaying behavior can cause subtle issues
-            // like infinite ping loops. So we maintain the old behavior and
-            // always unwind.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
+  var copyWithDelete = function (obj, path) {
+    return copyWithDeleteImpl(obj, path, 0);
+  };
 
-          case SuspendedOnHydration: {
-            // Selective hydration. An update flowed into a dehydrated tree.
-            // Interrupt the current render so the work loop can switch to the
-            // hydration lane.
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = RootDidNotComplete;
-            break outer;
-          }
+  var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
+    var oldKey = oldPath[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+
+    if (index + 1 === oldPath.length) {
+      var newKey = newPath[index]; // $FlowFixMe number or string is fine here
+
+      updated[newKey] = updated[oldKey];
+
+      if (isArray(updated)) {
+        updated.splice(oldKey, 1);
+      } else {
+        delete updated[oldKey];
+      }
+    } else {
+      // $FlowFixMe number or string is fine here
+      updated[oldKey] = copyWithRenameImpl(
+        // $FlowFixMe number or string is fine here
+        obj[oldKey],
+        oldPath,
+        newPath,
+        index + 1
+      );
+    }
+
+    return updated;
+  };
+
+  var copyWithRename = function (obj, oldPath, newPath) {
+    if (oldPath.length !== newPath.length) {
+      warn("copyWithRename() expects paths of the same length");
 
-          default: {
-            throw new Error(
-              "Unexpected SuspendedReason. This is a bug in React."
-            );
-          }
+      return;
+    } else {
+      for (var i = 0; i < newPath.length - 1; i++) {
+        if (oldPath[i] !== newPath[i]) {
+          warn(
+            "copyWithRename() expects paths to be the same except for the deepest key"
+          );
+
+          return;
         }
       }
+    }
 
-      if (true && ReactCurrentActQueue.current !== null) {
-        // `act` special case: If we're inside an `act` scope, don't consult
-        // `shouldYield`. Always keep working until the render is complete.
-        // This is not just an optimization: in a unit test environment, we
-        // can't trust the result of `shouldYield`, because the host I/O is
-        // likely mocked.
-        workLoopSync();
-      } else {
-        workLoopConcurrent();
-      }
+    return copyWithRenameImpl(obj, oldPath, newPath, 0);
+  };
 
-      break;
-    } catch (thrownValue) {
-      handleThrow(root, thrownValue);
+  var copyWithSetImpl = function (obj, path, index, value) {
+    if (index >= path.length) {
+      return value;
     }
-  } while (true);
 
-  resetContextDependencies();
-  popDispatcher(prevDispatcher);
-  popCacheDispatcher(prevCacheDispatcher);
-  executionContext = prevExecutionContext;
+    var key = path[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj); // $FlowFixMe number or string is fine here
 
-  {
-    if (enableDebugTracing) {
-      logRenderStopped();
+    updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
+    return updated;
+  };
+
+  var copyWithSet = function (obj, path, value) {
+    return copyWithSetImpl(obj, path, 0, value);
+  };
+
+  var findHook = function (fiber, id) {
+    // For now, the "id" of stateful hooks is just the stateful hook index.
+    // This may change in the future with e.g. nested hooks.
+    var currentHook = fiber.memoizedState;
+
+    while (currentHook !== null && id > 0) {
+      currentHook = currentHook.next;
+      id--;
     }
-  } // Check if the tree has completed.
 
-  if (workInProgress !== null) {
-    // Still work remaining.
-    if (enableSchedulingProfiler) {
-      markRenderYielded();
+    return currentHook;
+  }; // Support DevTools editable values for useState and useReducer.
+
+  overrideHookState = function (fiber, id, path, value) {
+    var hook = findHook(fiber, id);
+
+    if (hook !== null) {
+      var newState = copyWithSet(hook.memoizedState, path, value);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
     }
+  };
 
-    return RootInProgress;
-  } else {
-    // Completed the tree.
-    if (enableSchedulingProfiler) {
-      markRenderStopped();
-    } // Set this to null to indicate there's no in-progress render.
+  overrideHookStateDeletePath = function (fiber, id, path) {
+    var hook = findHook(fiber, id);
 
-    workInProgressRoot = null;
-    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+    if (hook !== null) {
+      var newState = copyWithDelete(hook.memoizedState, path);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
 
-    finishQueueingConcurrentUpdates(); // Return the final exit status.
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-    return workInProgressRootExitStatus;
-  }
-}
-/** @noinline */
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
+    }
+  };
 
-function workLoopConcurrent() {
-  // Perform work until Scheduler asks us to yield
-  while (workInProgress !== null && !shouldYield()) {
-    // $FlowFixMe[incompatible-call] found when upgrading Flow
-    performUnitOfWork(workInProgress);
-  }
-}
+  overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
+    var hook = findHook(fiber, id);
 
-function performUnitOfWork(unitOfWork) {
-  // The current, flushed, state of this fiber is the alternate. 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 = unitOfWork.alternate;
-  setCurrentFiber(unitOfWork);
-  var next;
+    if (hook !== null) {
+      var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
 
-  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
-    startProfilerTimer(unitOfWork);
-    next = beginWork(current, unitOfWork, renderLanes);
-    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
-  } else {
-    next = beginWork(current, unitOfWork, renderLanes);
-  }
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  resetCurrentFiber();
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
+    }
+  }; // Support DevTools props for function components, forwardRef, memo, host components, etc.
 
-  if (next === null) {
-    // If this doesn't spawn new work, complete the current work.
-    completeUnitOfWork(unitOfWork);
-  } else {
-    workInProgress = next;
-  }
+  overrideProps = function (fiber, path, value) {
+    fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
 
-  ReactCurrentOwner$1.current = null;
-}
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
+    }
 
-function replaySuspendedUnitOfWork(unitOfWork) {
-  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
-  // just suspended.
-  //
-  var current = unitOfWork.alternate;
-  setCurrentFiber(unitOfWork);
-  var next;
-  setCurrentFiber(unitOfWork);
-  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  if (isProfilingMode) {
-    startProfilerTimer(unitOfWork);
-  }
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    }
+  };
 
-  switch (unitOfWork.tag) {
-    case IndeterminateComponent: {
-      // Because it suspended with `use`, we can assume it's a
-      // function component.
-      unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
+  overridePropsDeletePath = function (fiber, path) {
+    fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
+
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
     }
-    // eslint-disable-next-line no-fallthrough
 
-    case FunctionComponent:
-    case ForwardRef: {
-      // Resolve `defaultProps`. This logic is copied from `beginWork`.
-      // TODO: Consider moving this switch statement into that module. Also,
-      // could maybe use this as an opportunity to say `use` doesn't work with
-      // `defaultProps` :)
-      var Component = unitOfWork.type;
-      var unresolvedProps = unitOfWork.pendingProps;
-      var resolvedProps =
-        unitOfWork.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      next = replayFunctionComponent(
-        current,
-        unitOfWork,
-        resolvedProps,
-        Component,
-        workInProgressRootRenderLanes
-      );
-      break;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
     }
+  };
 
-    case SimpleMemoComponent: {
-      var _Component = unitOfWork.type;
-      var nextProps = unitOfWork.pendingProps;
-      next = replayFunctionComponent(
-        current,
-        unitOfWork,
-        nextProps,
-        _Component,
-        workInProgressRootRenderLanes
-      );
-      break;
+  overridePropsRenamePath = function (fiber, oldPath, newPath) {
+    fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
+
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
     }
 
-    default: {
-      // Other types besides function components are reset completely before
-      // being replayed. Currently this only happens when a Usable type is
-      // reconciled — the reconciler will suspend.
-      //
-      // We reset the fiber back to its original state; however, this isn't
-      // a full "unwind" because we're going to reuse the promises that were
-      // reconciled previously. So it's intentional that we don't call
-      // resetSuspendedWorkLoopOnUnwind here.
-      unwindInterruptedWork(current, unitOfWork);
-      unitOfWork = workInProgress = resetWorkInProgress(
-        unitOfWork,
-        renderLanes
-      );
-      next = beginWork(current, unitOfWork, renderLanes);
-      break;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
     }
-  }
+  };
 
-  if (isProfilingMode) {
-    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
-  } // The begin phase finished successfully without suspending. Return to the
-  // normal work loop.
+  scheduleUpdate = function (fiber) {
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  resetCurrentFiber();
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    }
+  };
 
-  if (next === null) {
-    // If this doesn't spawn new work, complete the current work.
-    completeUnitOfWork(unitOfWork);
-  } else {
-    workInProgress = next;
-  }
+  setErrorHandler = function (newShouldErrorImpl) {
+    shouldErrorImpl = newShouldErrorImpl;
+  };
 
-  ReactCurrentOwner$1.current = null;
+  setSuspenseHandler = function (newShouldSuspendImpl) {
+    shouldSuspendImpl = newShouldSuspendImpl;
+  };
 }
 
-function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
-  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
-  // that threw an exception.
-  //
-  // Return to the normal work loop. This will unwind the stack, and potentially
-  // result in showing a fallback.
-  resetSuspendedWorkLoopOnUnwind();
-  var returnFiber = unitOfWork.return;
-
-  if (returnFiber === null || workInProgressRoot === null) {
-    // Expected to be working on a non-root fiber. This is a fatal error
-    // because there's no ancestor that can handle it; the root is
-    // supposed to capture all errors that weren't caught by an error
-    // boundary.
-    workInProgressRootExitStatus = RootFatalErrored;
-    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
-    // sibling, or the parent if there are no siblings. But since the root
-    // has no siblings nor a parent, we set it to null. Usually this is
-    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
-    // intentionally not calling those, we need set it here.
-    // TODO: Consider calling `unwindWork` to pop the contexts.
+function findHostInstanceByFiber(fiber) {
+  var hostFiber = findCurrentHostFiber(fiber);
 
-    workInProgress = null;
-    return;
+  if (hostFiber === null) {
+    return null;
   }
 
-  try {
-    // Find and mark the nearest Suspense or error boundary that can handle
-    // this "exception".
-    throwException(
-      workInProgressRoot,
-      returnFiber,
-      unitOfWork,
-      thrownValue,
-      workInProgressRootRenderLanes
-    );
-  } catch (error) {
-    // We had trouble processing the error. An example of this happening is
-    // when accessing the `componentDidCatch` property of an error boundary
-    // throws an error. A weird edge case. There's a regression test for this.
-    // To prevent an infinite loop, bubble the error up to the next parent.
-    workInProgress = returnFiber;
-    throw error;
-  } // Return to the normal work loop.
+  return hostFiber.stateNode;
+}
 
-  completeUnitOfWork(unitOfWork);
+function emptyFindFiberByHostInstance(instance) {
+  return null;
 }
 
-function completeUnitOfWork(unitOfWork) {
-  // Attempt to complete the current unit of work, then move to the next
-  // sibling. If there are no more siblings, return to the parent fiber.
-  var completedWork = unitOfWork;
+function getCurrentFiberForDevTools() {
+  return current;
+}
 
-  do {
-    // The current, flushed, state of this fiber is the alternate. 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 = completedWork.alternate;
-    var returnFiber = completedWork.return; // Check if the work completed or if something threw.
+function injectIntoDevTools(devToolsConfig) {
+  var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState: overrideHookState,
+    overrideHookStateDeletePath: overrideHookStateDeletePath,
+    overrideHookStateRenamePath: overrideHookStateRenamePath,
+    overrideProps: overrideProps,
+    overridePropsDeletePath: overridePropsDeletePath,
+    overridePropsRenamePath: overridePropsRenamePath,
+    setErrorHandler: setErrorHandler,
+    setSuspenseHandler: setSuspenseHandler,
+    scheduleUpdate: scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber: findHostInstanceByFiber,
+    findFiberByHostInstance:
+      findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: findHostInstancesForRefresh,
+    scheduleRefresh: scheduleRefresh,
+    scheduleRoot: scheduleRoot,
+    setRefreshHandler: setRefreshHandler,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: getCurrentFiberForDevTools,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
 
-    if ((completedWork.flags & Incomplete) === NoFlags$1) {
-      setCurrentFiber(completedWork);
-      var next = void 0;
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
 
-      if ((completedWork.mode & ProfileMode) === NoMode) {
-        next = completeWork(current, completedWork, renderLanes);
-      } else {
-        startProfilerTimer(completedWork);
-        next = completeWork(current, completedWork, renderLanes); // Update render duration assuming we didn't error.
+var isInsideEventHandler = false;
 
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
-      }
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  var controlledComponentsHavePendingUpdates = needsStateRestore();
 
-      resetCurrentFiber();
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
 
-      if (next !== null) {
-        // Completing this fiber spawned new work. Work on that next.
-        workInProgress = next;
-        return;
-      }
-    } else {
-      // This fiber did not complete because something threw. Pop values off
-      // the stack without entering the complete phase. If this is a boundary,
-      // capture values if possible.
-      var _next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
 
-      if (_next !== null) {
-        // 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
-        // from the effect tag.
-        _next.flags &= HostEffectMask;
-        workInProgress = _next;
-        return;
-      }
+  isInsideEventHandler = true;
 
-      if ((completedWork.mode & ProfileMode) !== NoMode) {
-        // Record the render duration for the fiber that errored.
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
 
-        var actualDuration = completedWork.actualDuration;
-        var child = completedWork.child;
+function isInteractive(tag) {
+  return (
+    tag === "button" ||
+    tag === "input" ||
+    tag === "select" ||
+    tag === "textarea"
+  );
+}
 
-        while (child !== null) {
-          // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
-          actualDuration += child.actualDuration;
-          child = child.sibling;
-        }
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      return !!(props.disabled && isInteractive(type));
 
-        completedWork.actualDuration = actualDuration;
-      }
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
 
-      if (returnFiber !== null) {
-        // Mark the parent fiber as incomplete and clear its subtree flags.
-        returnFiber.flags |= Incomplete;
-        returnFiber.subtreeFlags = NoFlags$1;
-        returnFiber.deletions = null;
-      } else {
-        // We've unwound all the way to the root.
-        workInProgressRootExitStatus = RootDidNotComplete;
-        workInProgress = null;
-        return;
-      }
-    }
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
 
-    var siblingFiber = completedWork.sibling;
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
 
-    if (siblingFiber !== null) {
-      // If there is more work to do in this returnFiber, do that next.
-      workInProgress = siblingFiber;
-      return;
-    } // Otherwise, return to the parent
-    // $FlowFixMe[incompatible-type] we bail out when we get a null
+  var props = getFiberCurrentPropsFromNode(stateNode);
 
-    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
 
-    workInProgress = completedWork;
-  } while (completedWork !== null); // We've reached the root.
+  var listener = props[registrationName];
 
-  if (workInProgressRootExitStatus === RootInProgress) {
-    workInProgressRootExitStatus = RootCompleted;
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
+
+  if (listener && typeof listener !== "function") {
+    throw new Error(
+      "Expected `" +
+        registrationName +
+        "` listener to be a function, instead got a value of `" +
+        typeof listener +
+        "` type."
+    );
   }
+
+  return listener;
 }
 
-function commitRoot(root, recoverableErrors, transitions) {
-  // TODO: This no longer makes any sense. We already wrap the mutation and
-  // layout phases. Should be able to remove.
-  var previousUpdateLanePriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig.transition;
+var passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
 
+if (canUseDOM) {
   try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    commitRootImpl(
-      root,
-      recoverableErrors,
-      transitions,
-      previousUpdateLanePriority
-    );
-  } finally {
-    ReactCurrentBatchConfig.transition = prevTransition;
-    setCurrentUpdatePriority(previousUpdateLanePriority);
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = true;
+      }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
   }
-
-  return null;
 }
 
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
+var EventListenerWWW = require("EventListener");
+
+function addEventBubbleListener(target, eventType, listener) {
+  return EventListenerWWW.listen(target, eventType, listener);
+}
+function addEventCaptureListener(target, eventType, listener) {
+  return EventListenerWWW.capture(target, eventType, listener);
+}
+function addEventCaptureListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
 ) {
-  do {
-    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
-    // means `flushPassiveEffects` will sometimes result in additional
-    // passive effects. So we need to keep flushing in a loop until there are
-    // no more pending effects.
-    // TODO: Might be better if `flushPassiveEffects` did not automatically
-    // flush synchronous work at the end, to avoid factoring hazards like this.
-    flushPassiveEffects();
-  } while (rootWithPendingPassiveEffects !== null);
+  return EventListenerWWW.captureWithPassiveFlag(
+    target,
+    eventType,
+    listener,
+    passive
+  );
+}
+function addEventBubbleListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  return EventListenerWWW.bubbleWithPassiveFlag(
+    target,
+    eventType,
+    listener,
+    passive
+  );
+}
+function removeEventListener(target, eventType, listener, capture) {
+  listener.remove();
+} // Flow magic to verify the exports of this file match the original version.
 
-  flushRenderPhaseStrictModeWarningsInDEV();
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+var root = null;
+var startText = null;
+var fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
+  var start;
+  var startValue = startText;
+  var startLength = startValue.length;
+  var end;
+  var endValue = getText();
+  var endLength = endValue.length;
+
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
+      break;
+    }
   }
 
-  var finishedWork = root.finishedWork;
-  var lanes = root.finishedLanes;
+  var minEnd = startLength - start;
 
-  {
-    if (enableDebugTracing) {
-      logCommitStarted(lanes);
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
+      break;
     }
   }
 
-  if (enableSchedulingProfiler) {
-    markCommitStarted(lanes);
+  var sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
+}
+function getText() {
+  if ("value" in root) {
+    return root.value;
   }
 
-  if (finishedWork === null) {
-    {
-      if (enableDebugTracing) {
-        logCommitStopped();
-      }
-    }
+  return root.textContent;
+}
 
-    if (enableSchedulingProfiler) {
-      markCommitStopped();
-    }
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  var charCode;
+  var keyCode = nativeEvent.keyCode;
 
-    return null;
-  } else {
-    {
-      if (lanes === NoLanes) {
-        error(
-          "root.finishedLanes should not be empty during a commit. This is a " +
-            "bug in React."
-        );
-      }
-    }
-  }
+  if ("charCode" in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
 
-  root.finishedWork = null;
-  root.finishedLanes = NoLanes;
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
 
-  if (finishedWork === root.current) {
-    throw new Error(
-      "Cannot commit the same tree as before. This error is likely caused by " +
-        "a bug in React. Please file an issue."
-    );
-  } // commitRoot never returns a continuation; it always finishes synchronously.
-  // So we can clear these now to allow a new callback to be scheduled.
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
 
-  root.callbackNode = null;
-  root.callbackPriority = NoLane; // Check which lanes no longer have any work scheduled on them, and mark
-  // those as finished.
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
 
-  var remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
-  // during the render phase; don't mark them as finished.
+  return 0;
+}
 
-  var concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
-  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
-  markRootFinished(root, remainingLanes);
+function functionThatReturnsTrue() {
+  return true;
+}
 
-  if (root === workInProgressRoot) {
-    // We can reset these now that they are finished.
-    workInProgressRoot = null;
-    workInProgress = null;
-    workInProgressRootRenderLanes = NoLanes;
-  } // If there are pending passive effects, schedule a callback to process them.
-  // Do this as early as possible, so it is queued before anything else that
-  // might get scheduled in the commit phase. (See #16714.)
-  // TODO: Delete all other places that schedule the passive effect callback
-  // They're redundant.
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
 
-  if (
-    (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 ||
-    (finishedWork.flags & PassiveMask) !== NoFlags$1
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
   ) {
-    if (!rootDoesHavePassiveEffects) {
-      rootDoesHavePassiveEffects = true;
-      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
-      // to store it in pendingPassiveTransitions until they get processed
-      // We need to pass this through as an argument to commitRoot
-      // because workInProgressTransitions might have changed between
-      // the previous render and commit if we throttle the commit
-      // with setTimeout
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
 
-      pendingPassiveTransitions = transitions;
-      scheduleCallback(NormalPriority$1, function () {
-        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
-        // *after* passive effects fire to avoid freeing a cache pool that may
-        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+    for (var propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
 
-        return null;
-      });
+      var normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
     }
-  } // Check if there are any effects in the whole tree.
-  // TODO: This is left over from the effect list implementation, where we had
-  // to check for the existence of `firstEffect` to satisfy Flow. I think the
-  // only other reason this optimization exists is because it affects profiling.
-  // Reconsider whether this is necessary.
 
-  var subtreeHasEffects =
-    (finishedWork.subtreeFlags &
-      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
-    NoFlags$1;
-  var rootHasEffect =
-    (finishedWork.flags &
-      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
-    NoFlags$1;
+    var defaultPrevented =
+      nativeEvent.defaultPrevented != null
+        ? nativeEvent.defaultPrevented
+        : nativeEvent.returnValue === false;
 
-  if (subtreeHasEffects || rootHasEffect) {
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = getCurrentUpdatePriority$1();
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    var prevExecutionContext = executionContext;
-    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
+    }
 
-    ReactCurrentOwner$1.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
-    // of the effect list for each phase: all mutation effects come before all
-    // layout effects, and so on.
-    // The first phase a "before mutation" phase. We use this phase to read the
-    // state of the host tree right before we mutate it. This is where
-    // getSnapshotBeforeUpdate is called.
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
 
-    var shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      var event = this.nativeEvent;
 
-    {
-      // Mark the current commit time to be shared by all Profilers in this
-      // batch. This enables them to be grouped later.
-      recordCommitTime();
-    }
+      if (!event) {
+        return;
+      }
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      // Track the root here, rather than in commitLayoutEffects(), because of ref setters.
-      // Updates scheduled during ref detachment should also be flagged.
-      rootCommittingMutationOrLayoutEffects = root;
-    } // The next phase is the mutation phase, where we mutate the host tree.
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== "unknown") {
+        event.returnValue = false;
+      }
 
-    commitMutationEffects(root, finishedWork, lanes);
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      var event = this.nativeEvent;
 
-    {
-      if (shouldFireAfterActiveInstanceBlur) {
-        afterActiveInstanceBlur();
+      if (!event) {
+        return;
       }
-    }
 
-    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
-    // the mutation phase, so that the previous tree is still current during
-    // componentWillUnmount, but before the layout phase, so that the finished
-    // work is current during componentDidMount/Update.
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== "unknown") {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
 
-    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
-    // the host tree after it's been mutated. The idiomatic use case for this is
-    // layout, but class component lifecycles also fire here for legacy reasons.
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
 
-    {
-      if (enableDebugTracing) {
-        logLayoutEffectsStarted(lanes);
-      }
-    }
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {
+      // Modern event system doesn't use pooling.
+    },
 
-    if (enableSchedulingProfiler) {
-      markLayoutEffectsStarted(lanes);
-    }
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-    commitLayoutEffects(finishedWork, root, lanes);
+var EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+var SyntheticEvent = createSyntheticEvent(EventInterface);
 
-    {
-      if (enableDebugTracing) {
-        logLayoutEffectsStopped();
-      }
-    }
+var UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
 
-    if (enableSchedulingProfiler) {
-      markLayoutEffectsStopped();
-    }
+var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+var lastMovementX;
+var lastMovementY;
+var lastMouseEvent;
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      rootCommittingMutationOrLayoutEffects = null;
-    } // Tell Scheduler to yield at the end of the frame, so the browser has an
-    // opportunity to paint.
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === "mousemove") {
+      // $FlowFixMe assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe assuming this is a number
 
-    requestPaint();
-    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
 
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-  } else {
-    // No effects.
-    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
-    // no effects.
-    // TODO: Maybe there's a better way to report this.
+    lastMouseEvent = event;
+  }
+}
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-    {
-      recordCommitTime();
+var MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined)
+      return event.fromElement === event.srcElement
+        ? event.toElement
+        : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ("movementX" in event) {
+      return event.movementX;
     }
+
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ("movementY" in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
+
+    return lastMovementY;
   }
+});
 
-  var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
+var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-  if (rootDoesHavePassiveEffects) {
-    // This commit has passive effects. Stash a reference to them. But don't
-    // schedule a callback until after flushing layout work.
-    rootDoesHavePassiveEffects = false;
-    rootWithPendingPassiveEffects = root;
-    pendingPassiveEffectsLanes = lanes;
-  } else {
-    // There were no passive effects, so we can immediately release the cache
-    // pool for this render.
-    releaseRootPooledCache(root, remainingLanes);
+var DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
 
-    {
-      nestedPassiveUpdateCount = 0;
-      rootWithPassiveNestedUpdates = null;
-    }
-  } // Read this again, since an effect might have updated it
+var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
-  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
-  // is to detect whether something might have called setState inside
-  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
-  // inside `componentDidCatch` is itself flawed — that's why we recommend
-  // `getDerivedStateFromError` instead. However, it could be improved by
-  // checking if remainingLanes includes Sync work, instead of whether there's
-  // any work remaining at all (which would also include stuff like Suspense
-  // retries or transitions). It's been like this for a while, though, so fixing
-  // it probably isn't that urgent.
+var FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
 
-  if (remainingLanes === NoLanes) {
-    // If there's no remaining work, we can clear the set of already failed
-    // error boundaries.
-    legacyErrorBoundariesThatAlreadyFailed = null;
-  }
+var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
 
-  {
-    if (!rootDidHavePassiveEffects) {
-      commitDoubleInvokeEffectsInDEV(root, false);
-    }
-  }
+var AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
 
-  onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
+var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
 
-  {
-    if (isDevToolsPresent) {
-      root.memoizedUpdaters.clear();
-    }
+var ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return "clipboardData" in event
+      ? event.clipboardData
+      : window.clipboardData;
   }
+});
 
-  {
-    onCommitRoot();
-  } // Always call this before exiting `commitRoot`, to ensure that any
-  // additional work on this root is scheduled.
-
-  ensureRootIsScheduled(root, now$1());
+var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
 
-  if (recoverableErrors !== null) {
-    // There were errors during this render, but recovered from them without
-    // needing to surface it to the UI. We log them here.
-    var onRecoverableError = root.onRecoverableError;
+var CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
 
-    for (var i = 0; i < recoverableErrors.length; i++) {
-      var recoverableError = recoverableErrors[i];
-      var errorInfo = makeErrorInfo(
-        recoverableError.digest,
-        recoverableError.stack
-      );
-      onRecoverableError(recoverableError.value, errorInfo);
-    }
-  }
+var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
 
-  if (hasUncaughtError) {
-    hasUncaughtError = false;
-    var error$1 = firstUncaughtError;
-    firstUncaughtError = null;
-    throw error$1;
-  } // If the passive effects are the result of a discrete render, flush them
-  // synchronously at the end of the current task so that the result is
-  // immediately observable. Otherwise, we assume that they are not
-  // order-dependent and do not need to be observed by external systems, so we
-  // can wait until after paint.
-  // TODO: We can optimize this by not scheduling the callback earlier. Since we
-  // currently schedule the callback in multiple places, will wait until those
-  // are consolidated.
+var SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
 
-  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
-    flushPassiveEffects();
-  } // Read this again, since a passive effect might have updated it
+var normalizeKey = {
+  Esc: "Escape",
+  Spacebar: " ",
+  Left: "ArrowLeft",
+  Up: "ArrowUp",
+  Right: "ArrowRight",
+  Down: "ArrowDown",
+  Del: "Delete",
+  Win: "OS",
+  Menu: "ContextMenu",
+  Apps: "ContextMenu",
+  Scroll: "ScrollLock",
+  MozPrintableKey: "Unidentified"
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
 
-  remainingLanes = root.pendingLanes;
+var translateToKey = {
+  "8": "Backspace",
+  "9": "Tab",
+  "12": "Clear",
+  "13": "Enter",
+  "16": "Shift",
+  "17": "Control",
+  "18": "Alt",
+  "19": "Pause",
+  "20": "CapsLock",
+  "27": "Escape",
+  "32": " ",
+  "33": "PageUp",
+  "34": "PageDown",
+  "35": "End",
+  "36": "Home",
+  "37": "ArrowLeft",
+  "38": "ArrowUp",
+  "39": "ArrowRight",
+  "40": "ArrowDown",
+  "45": "Insert",
+  "46": "Delete",
+  "112": "F1",
+  "113": "F2",
+  "114": "F3",
+  "115": "F4",
+  "116": "F5",
+  "117": "F6",
+  "118": "F7",
+  "119": "F8",
+  "120": "F9",
+  "121": "F10",
+  "122": "F11",
+  "123": "F12",
+  "144": "NumLock",
+  "145": "ScrollLock",
+  "224": "Meta"
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
 
-  if (includesSyncLane(remainingLanes)) {
-    {
-      markNestedUpdateScheduled();
-    } // Count the number of times the root synchronously re-renders without
-    // finishing. If there are too many, it indicates an infinite update loop.
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    var key = normalizeKey[nativeEvent.key] || nativeEvent.key; // $FlowFixMe unable to index with a `mixed` value
 
-    if (root === rootWithNestedUpdates) {
-      nestedUpdateCount++;
-    } else {
-      nestedUpdateCount = 0;
-      rootWithNestedUpdates = root;
+    if (key !== "Unidentified") {
+      return key;
     }
-  } else {
-    nestedUpdateCount = 0;
-  } // If layout work was scheduled, flush it now.
+  } // Browser does not implement `key`, polyfill as much of it as we can.
 
-  flushSyncCallbacks();
+  if (nativeEvent.type === "keypress") {
+    var charCode = getEventCharCode(
+      // $FlowFixMe unable to narrow to `KeyboardEvent`
+      nativeEvent
+    ); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
 
-  {
-    if (enableDebugTracing) {
-      logCommitStopped();
-    }
+    return charCode === 13 ? "Enter" : String.fromCharCode(charCode);
   }
 
-  if (enableSchedulingProfiler) {
-    markCommitStopped();
+  if (nativeEvent.type === "keydown" || nativeEvent.type === "keyup") {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || "Unidentified";
   }
 
-  if (enableTransitionTracing) {
-    // We process transitions during passive effects. However, passive effects can be
-    // processed synchronously during the commit phase as well as asynchronously after
-    // paint. At the end of the commit phase, we schedule a callback that will be called
-    // after the next paint. If the transitions have already been processed (passive
-    // effect phase happened synchronously), we will schedule a callback to process
-    // the transitions. However, if we don't have any pending transition callbacks, this
-    // means that the transitions have yet to be processed (passive effects processed after paint)
-    // so we will store the end time of paint so that we can process the transitions
-    // and then call the callback via the correct end time.
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
+  return "";
+}
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
 
-    if (prevRootTransitionCallbacks !== null) {
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+var modifierKeyToProp = {
+  Alt: "altKey",
+  Control: "ctrlKey",
+  Meta: "metaKey",
+  Shift: "shiftKey"
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
 
-        if (prevPendingTransitionCallbacks !== null) {
-          currentPendingTransitionCallbacks = null;
-          scheduleCallback(IdlePriority, function () {
-            processTransitionCallbacks(
-              prevPendingTransitionCallbacks,
-              endTime,
-              prevRootTransitionCallbacks
-            );
-          });
-        } else {
-          currentEndTime = endTime;
-        }
-      });
-    }
+function modifierStateGetter(keyArg) {
+  var syntheticEvent = this;
+  var nativeEvent = syntheticEvent.nativeEvent;
+
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
   }
 
-  return null;
+  var keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
 }
 
-function makeErrorInfo(digest, componentStack) {
-  {
-    var errorInfo = {
-      componentStack: componentStack,
-      digest: digest
-    };
-    Object.defineProperty(errorInfo, "digest", {
-      configurable: false,
-      enumerable: true,
-      get: function () {
-        error(
-          'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
-            " This property is deprecated and will be removed in a future version of React." +
-            " To access the digest of an Error look for this property on the Error instance itself."
-        );
-
-        return digest;
-      }
-    });
-    return errorInfo;
-  }
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
 }
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-function releaseRootPooledCache(root, remainingLanes) {
-  {
-    var pooledCacheLanes = (root.pooledCacheLanes &= remainingLanes);
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === "keypress") {
+      return getEventCharCode(
+        // $FlowFixMe unable to narrow to `KeyboardEvent`
+        event
+      );
+    }
 
-    if (pooledCacheLanes === NoLanes) {
-      // None of the remaining work relies on the cache pool. Clear it so
-      // subsequent requests get a new cache
-      var pooledCache = root.pooledCache;
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === "keydown" || event.type === "keyup") {
+      return event.keyCode;
+    }
 
-      if (pooledCache != null) {
-        root.pooledCache = null;
-        releaseCache(pooledCache);
-      }
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === "keypress") {
+      return getEventCharCode(
+        // $FlowFixMe unable to narrow to `KeyboardEvent`
+        event
+      );
+    }
+
+    if (event.type === "keydown" || event.type === "keyup") {
+      return event.keyCode;
     }
+
+    return 0;
   }
-}
+});
 
-function flushPassiveEffects() {
-  // Returns whether passive effects were flushed.
-  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
-  // probably just combine the two functions. I believe they were only separate
-  // in the first place because we used to wrap it with
-  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
-  // priority within React itself, so we can mutate the variable directly.
-  if (rootWithPendingPassiveEffects !== null) {
-    // Cache the root since rootWithPendingPassiveEffects is cleared in
-    // flushPassiveEffectsImpl
-    var root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
-    // method can be called from various places, not always from commitRoot
-    // where the remaining lanes are known
+var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
 
-    var remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = NoLanes;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    var previousPriority = getCurrentUpdatePriority$1();
+var PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
 
-    try {
-      ReactCurrentBatchConfig.transition = null;
-      setCurrentUpdatePriority(priority);
-      return flushPassiveEffectsImpl();
-    } finally {
-      setCurrentUpdatePriority(previousPriority);
-      ReactCurrentBatchConfig.transition = prevTransition; // Once passive effects have run for the tree - giving components a
-      // chance to retain cache instances they use - release the pooled
-      // cache at the root (if there is one)
+var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
 
-      releaseRootPooledCache(root, remainingLanes);
-    }
-  }
+var TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
 
-  return false;
-}
-function enqueuePendingPassiveProfilerEffect(fiber) {
-  {
-    pendingPassiveProfilerEffects.push(fiber);
+var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
 
-    if (!rootDoesHavePassiveEffects) {
-      rootDoesHavePassiveEffects = true;
-      scheduleCallback(NormalPriority$1, function () {
-        flushPassiveEffects();
-        return null;
-      });
-    }
-  }
-}
+var TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
 
-function flushPassiveEffectsImpl() {
-  if (rootWithPendingPassiveEffects === null) {
-    return false;
-  } // Cache and clear the transitions flag
+var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
+
+var WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX: function (event) {
+    return "deltaX" in event
+      ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+      : "wheelDeltaX" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDeltaX
+      : 0;
+  },
+  deltaY: function (event) {
+    return "deltaY" in event
+      ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+      : "wheelDeltaY" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+      : "wheelDelta" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDelta
+      : 0;
+  },
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
 
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects;
-  var lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
-  // Figure out why and fix it. It's not causing any known issues (probably
-  // because it's only used for profiling), but it's a refactor hazard.
+var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
 
-  pendingPassiveEffectsLanes = NoLanes;
+var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Cannot flush passive effects while already rendering.");
-  }
+var START_KEYCODE = 229;
+var canUseCompositionEvent = canUseDOM && "CompositionEvent" in window;
+var documentMode = null;
 
-  {
-    isFlushingPassiveEffects = true;
-    didScheduleUpdateDuringPassiveEffects = false;
+if (canUseDOM && "documentMode" in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
 
-    if (enableDebugTracing) {
-      logPassiveEffectsStarted(lanes);
-    }
-  }
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
 
-  if (enableSchedulingProfiler) {
-    markPassiveEffectsStarted(lanes);
-  }
+var useFallbackCompositionData =
+  canUseDOM &&
+  (!canUseCompositionEvent ||
+    (documentMode && documentMode > 8 && documentMode <= 11));
+var SPACEBAR_CODE = 32;
+var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
 
-  var prevExecutionContext = executionContext;
-  executionContext |= CommitContext;
-  commitPassiveUnmountEffects(root.current);
-  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+function registerEvents$3() {
+  registerTwoPhaseEvent("onBeforeInput", [
+    "compositionend",
+    "keypress",
+    "textInput",
+    "paste"
+  ]);
+  registerTwoPhaseEvent("onCompositionEnd", [
+    "compositionend",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+  registerTwoPhaseEvent("onCompositionStart", [
+    "compositionstart",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+  registerTwoPhaseEvent("onCompositionUpdate", [
+    "compositionupdate",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+} // Track whether we've ever handled a keypress on the space key.
 
-  {
-    var profilerEffects = pendingPassiveProfilerEffects;
-    pendingPassiveProfilerEffects = [];
+var hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
 
-    for (var i = 0; i < profilerEffects.length; i++) {
-      var fiber = profilerEffects[i];
-      commitPassiveEffectDurations(root, fiber);
-    }
-  }
+function isKeypressCommand(nativeEvent) {
+  return (
+    (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+    !(nativeEvent.ctrlKey && nativeEvent.altKey)
+  );
+}
+/**
+ * Translate native top level events into event types.
+ */
 
-  {
-    if (enableDebugTracing) {
-      logPassiveEffectsStopped();
-    }
-  }
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case "compositionstart":
+      return "onCompositionStart";
 
-  if (enableSchedulingProfiler) {
-    markPassiveEffectsStopped();
-  }
+    case "compositionend":
+      return "onCompositionEnd";
 
-  {
-    commitDoubleInvokeEffectsInDEV(root, true);
+    case "compositionupdate":
+      return "onCompositionUpdate";
   }
+}
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
 
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
-
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    var prevEndTime = currentEndTime;
-
-    if (
-      prevPendingTransitionCallbacks !== null &&
-      prevRootTransitionCallbacks !== null &&
-      prevEndTime !== null
-    ) {
-      currentPendingTransitionCallbacks = null;
-      currentEndTime = null;
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
-        );
-      });
-    }
-  }
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === "keydown" && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
 
-  {
-    // If additional passive effects were scheduled, increment a counter. If this
-    // exceeds the limit, we'll fire a warning.
-    if (didScheduleUpdateDuringPassiveEffects) {
-      if (root === rootWithPassiveNestedUpdates) {
-        nestedPassiveUpdateCount++;
-      } else {
-        nestedPassiveUpdateCount = 0;
-        rootWithPassiveNestedUpdates = root;
-      }
-    } else {
-      nestedPassiveUpdateCount = 0;
-    }
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
 
-    isFlushingPassiveEffects = false;
-    didScheduleUpdateDuringPassiveEffects = false;
-  } // TODO: Move to commitPassiveMountEffects
+    case "keydown":
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
 
-  onPostCommitRoot(root);
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      // Events are not possible without cancelling IME.
+      return true;
 
-  {
-    var stateNode = root.current.stateNode;
-    stateNode.effectDuration = 0;
-    stateNode.passiveEffectDuration = 0;
+    default:
+      return false;
   }
-
-  return true;
 }
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
 
-function isAlreadyFailedLegacyErrorBoundary(instance) {
-  return (
-    legacyErrorBoundariesThatAlreadyFailed !== null &&
-    legacyErrorBoundariesThatAlreadyFailed.has(instance)
-  );
-}
-function markLegacyErrorBoundaryAsFailed(instance) {
-  if (legacyErrorBoundariesThatAlreadyFailed === null) {
-    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
-  } else {
-    legacyErrorBoundariesThatAlreadyFailed.add(instance);
-  }
-}
+function getDataFromCustomEvent(nativeEvent) {
+  var detail = nativeEvent.detail;
 
-function prepareToThrowUncaughtError(error) {
-  if (!hasUncaughtError) {
-    hasUncaughtError = true;
-    firstUncaughtError = error;
+  if (typeof detail === "object" && "data" in detail) {
+    return detail.data;
   }
+
+  return null;
 }
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
 
-var onUncaughtError = prepareToThrowUncaughtError;
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === "ko";
+} // Track the current IME composition status, if any.
 
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  var errorInfo = createCapturedValueAtFiber(error, sourceFiber);
-  var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
-  var root = enqueueUpdate(rootFiber, update, SyncLane);
-  var eventTime = requestEventTime();
+var isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
 
-  if (root !== null) {
-    markRootUpdated(root, SyncLane, eventTime);
-    ensureRootIsScheduled(root, eventTime);
-  }
-}
+function extractCompositionEvent(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget
+) {
+  var eventType;
+  var fallbackData;
 
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
-  {
-    reportUncaughtErrorInDEV(error$1);
-    setIsRunningInsertionEffect(false);
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = "onCompositionStart";
+    }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = "onCompositionEnd";
   }
 
-  if (sourceFiber.tag === HostRoot) {
-    // Error was thrown at the root. There is no parent, so the root
-    // itself should capture it.
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error$1);
-    return;
+  if (!eventType) {
+    return null;
   }
 
-  var fiber = null;
-
-  if (skipUnmountedBoundaries) {
-    fiber = nearestMountedAncestor;
-  } else {
-    fiber = sourceFiber.return;
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === "onCompositionStart") {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === "onCompositionEnd") {
+      if (isComposing) {
+        fallbackData = getData();
+      }
+    }
   }
 
-  while (fiber !== null) {
-    if (fiber.tag === HostRoot) {
-      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error$1);
-      return;
-    } else if (fiber.tag === ClassComponent) {
-      var ctor = fiber.type;
-      var instance = fiber.stateNode;
+  var listeners = accumulateTwoPhaseListeners(targetInst, eventType);
 
-      if (
-        typeof ctor.getDerivedStateFromError === "function" ||
-        (typeof instance.componentDidCatch === "function" &&
-          !isAlreadyFailedLegacyErrorBoundary(instance))
-      ) {
-        var errorInfo = createCapturedValueAtFiber(error$1, sourceFiber);
-        var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
-        var root = enqueueUpdate(fiber, update, SyncLane);
-        var eventTime = requestEventTime();
+  if (listeners.length > 0) {
+    var event = new SyntheticCompositionEvent(
+      eventType,
+      domEventName,
+      null,
+      nativeEvent,
+      nativeEventTarget
+    );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
 
-        if (root !== null) {
-          markRootUpdated(root, SyncLane, eventTime);
-          ensureRootIsScheduled(root, eventTime);
-        }
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      var customData = getDataFromCustomEvent(nativeEvent);
 
-        return;
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
       }
     }
-
-    fiber = fiber.return;
-  }
-
-  {
-    // TODO: Until we re-land skipUnmountedBoundaries (see #20147), this warning
-    // will fire for errors that are thrown by destroy functions inside deleted
-    // trees. What it should instead do is propagate the error to the parent of
-    // the deleted tree. In the meantime, do not add this warning to the
-    // allowlist; this is only for our internal use.
-    error(
-      "Internal React error: Attempted to capture a commit phase error " +
-        "inside a detached tree. This indicates a bug in React. Likely " +
-        "causes include deleting the same fiber more than once, committing an " +
-        "already-finished tree, or an inconsistent return pointer.\n\n" +
-        "Error message:\n\n%s",
-      error$1
-    );
   }
 }
-function attachPingListener(root, wakeable, lanes) {
-  // Attach a ping listener
-  //
-  // The data might resolve before we have a chance to commit the fallback. Or,
-  // in the case of a refresh, we'll never commit a fallback. So we need to
-  // attach a listener now. When it resolves ("pings"), we can decide whether to
-  // try rendering the tree again.
-  //
-  // Only attach a listener if one does not already exist for the lanes
-  // we're currently rendering (which acts like a "thread ID" here).
-  //
-  // We only need to do this in concurrent mode. Legacy Suspense always
-  // commits fallbacks synchronously, so there are no pings.
-  var pingCache = root.pingCache;
-  var threadIDs;
 
-  if (pingCache === null) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else {
-    threadIDs = pingCache.get(wakeable);
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
 
-    if (threadIDs === undefined) {
-      threadIDs = new Set();
-      pingCache.set(wakeable, threadIDs);
-    }
-  }
+    case "keypress":
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      var which = nativeEvent.which;
 
-  if (!threadIDs.has(lanes)) {
-    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
+      if (which !== SPACEBAR_CODE) {
+        return null;
+      }
 
-    threadIDs.add(lanes);
-    var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
 
-    {
-      if (isDevToolsPresent) {
-        // If we have pending work still, restore the original updaters
-        restorePendingUpdaters(root, lanes);
+    case "textInput":
+      // Record the characters to be added to the DOM.
+      var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
+
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
       }
-    }
 
-    wakeable.then(ping, ping);
+      return chars;
+
+    default:
+      // For other native event types, do nothing.
+      return null;
   }
 }
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
 
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (
+      domEventName === "compositionend" ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+    ) {
+      var chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
+    }
 
-  if (pingCache !== null) {
-    // The wakeable resolved, so we no longer need to memoize, because it will
-    // never be thrown again.
-    pingCache.delete(wakeable);
+    return null;
   }
 
-  var eventTime = requestEventTime();
-  markRootPinged(root, pingedLanes);
-  warnIfSuspenseResolutionNotWrappedWithActDEV(root);
+  switch (domEventName) {
+    case "paste":
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
 
-  if (
-    workInProgressRoot === root &&
-    isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)
-  ) {
-    // Received a ping at the same priority level at which we're currently
-    // rendering. We might want to restart this render. This should mirror
-    // the logic of whether or not a root suspends once it completes.
-    // TODO: If we're rendering sync either due to Sync, Batched or expired,
-    // we should probably never restart.
-    // If we're suspended with delay, or if it's a retry, we'll always suspend
-    // so we can always restart.
-    if (
-      workInProgressRootExitStatus === RootSuspendedWithDelay ||
-      (workInProgressRootExitStatus === RootSuspended &&
-        includesOnlyRetries(workInProgressRootRenderLanes) &&
-        now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
-    ) {
-      // Force a restart from the root by unwinding the stack. Unless this is
-      // being called from the render phase, because that would cause a crash.
-      if ((executionContext & RenderContext) === NoContext) {
-        prepareFreshStack(root, NoLanes);
+    case "keypress":
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
+        }
       }
-    } else {
-      // Even though we can't restart right now, we might get an
-      // opportunity later. So we mark this render as having a ping.
-      workInProgressRootPingedLanes = mergeLanes(
-        workInProgressRootPingedLanes,
-        pingedLanes
-      );
-    }
-  }
 
-  ensureRootIsScheduled(root, eventTime);
-}
-
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  // The boundary fiber (a Suspense component or SuspenseList component)
-  // previously was rendered in its fallback state. One of the promises that
-  // suspended it has resolved, which means at least part of the tree was
-  // likely unblocked. Try rendering again, at a new lanes.
-  if (retryLane === NoLane) {
-    // TODO: Assign this to `suspenseState.retryLane`? to avoid
-    // unnecessary entanglement?
-    retryLane = requestRetryLane(boundaryFiber);
-  } // TODO: Special case idle priority?
+      return null;
 
-  var eventTime = requestEventTime();
-  var root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+    case "compositionend":
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)
+        ? null
+        : nativeEvent.data;
 
-  if (root !== null) {
-    markRootUpdated(root, retryLane, eventTime);
-    ensureRootIsScheduled(root, eventTime);
+    default:
+      return null;
   }
 }
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
 
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState;
-  var retryLane = NoLane;
+function extractBeforeInputEvent(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget
+) {
+  var chars;
 
-  if (suspenseState !== null) {
-    retryLane = suspenseState.retryLane;
-  }
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
+  } else {
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
 
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-}
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = NoLane; // Default
+  if (!chars) {
+    return null;
+  }
 
-  var retryCache;
+  var listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
 
-  switch (boundaryFiber.tag) {
-    case SuspenseComponent:
-      retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
+  if (listeners.length > 0) {
+    var event = new SyntheticInputEvent(
+      "onBeforeInput",
+      "beforeinput",
+      null,
+      nativeEvent,
+      nativeEventTarget
+    );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    }); // $FlowFixMe[incompatible-use]
 
-      if (suspenseState !== null) {
-        retryLane = suspenseState.retryLane;
-      }
+    event.data = chars;
+  }
+}
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
 
-      break;
+function extractEvents$5(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  extractCompositionEvent(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  );
+  extractBeforeInputEvent(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  );
+}
 
-    case SuspenseListComponent:
-      retryCache = boundaryFiber.stateNode;
-      break;
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+var supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  "datetime-local": true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
 
-    case OffscreenComponent: {
-      var instance = boundaryFiber.stateNode;
-      retryCache = instance._retryCache;
-      break;
-    }
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
 
-    default:
-      throw new Error(
-        "Pinged unknown suspense boundary type. " +
-          "This is probably a bug in React."
-      );
+  if (nodeName === "input") {
+    return !!supportedInputTypes[elem.type];
   }
 
-  if (retryCache !== null) {
-    // The wakeable resolved, so we no longer need to memoize, because it will
-    // never be thrown again.
-    retryCache.delete(wakeable);
+  if (nodeName === "textarea") {
+    return true;
   }
 
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-} // Computes the next Just Noticeable Difference (JND) boundary.
-// The theory is that a person can't tell the difference between small differences in time.
-// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
-// difference in the experience. However, waiting for longer might mean that we can avoid
-// showing an intermediate loading state. The longer we have already waited, the harder it
-// is to tell small differences in time. Therefore, the longer we've already waited,
-// the longer we can wait additionally. At some point we have to give up though.
-// We pick a train model where the next boundary commits at a consistent schedule.
-// These particular numbers are vague estimates. We expect to adjust them based on research.
-
-function jnd(timeElapsed) {
-  return timeElapsed < 120
-    ? 120
-    : timeElapsed < 480
-    ? 480
-    : timeElapsed < 1080
-    ? 1080
-    : timeElapsed < 1920
-    ? 1920
-    : timeElapsed < 3000
-    ? 3000
-    : timeElapsed < 4320
-    ? 4320
-    : ceil(timeElapsed / 1960) * 1960;
+  return false;
 }
 
-function throwIfInfiniteUpdateLoopDetected() {
-  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
-    nestedUpdateCount = 0;
-    nestedPassiveUpdateCount = 0;
-    rootWithNestedUpdates = null;
-    rootWithPassiveNestedUpdates = null;
-    throw new Error(
-      "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."
-    );
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
   }
 
-  {
-    if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
-      nestedPassiveUpdateCount = 0;
-      rootWithPassiveNestedUpdates = null;
+  var eventName = "on" + eventNameSuffix;
+  var isSupported = eventName in document;
 
-      error(
-        "Maximum update depth exceeded. This can happen when a component " +
-          "calls setState inside useEffect, but useEffect either doesn't " +
-          "have a dependency array, or one of the dependencies changes on " +
-          "every render."
-      );
-    }
+  if (!isSupported) {
+    var element = document.createElement("div");
+    element.setAttribute(eventName, "return;");
+    isSupported = typeof element[eventName] === "function";
   }
-}
 
-function flushRenderPhaseStrictModeWarningsInDEV() {
-  {
-    ReactStrictModeWarnings.flushLegacyContextWarning();
-    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
-  }
+  return isSupported;
 }
 
-function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
-  {
-    {
-      legacyCommitDoubleInvokeEffectsInDEV(root.current, hasPassiveEffects);
-    }
-  }
+function registerEvents$2() {
+  registerTwoPhaseEvent("onChange", [
+    "change",
+    "click",
+    "focusin",
+    "focusout",
+    "input",
+    "keydown",
+    "keyup",
+    "selectionchange"
+  ]);
 }
 
-function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
-  // TODO (StrictEffects) Should we set a marker on the root if it contains strict effects
-  // so we don't traverse unnecessarily? similar to subtreeFlags but just at the root level.
-  // Maybe not a big deal since this is DEV only behavior.
-  setCurrentFiber(fiber);
-  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectUnmountInDEV);
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
+) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  var listeners = accumulateTwoPhaseListeners(inst, "onChange");
 
-  if (hasPassiveEffects) {
-    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectUnmountInDEV);
+  if (listeners.length > 0) {
+    var event = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
   }
+}
+/**
+ * For IE shims
+ */
 
-  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectMountInDEV);
-
-  if (hasPassiveEffects) {
-    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectMountInDEV);
-  }
+var activeElement$1 = null;
+var activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
 
-  resetCurrentFiber();
+function shouldUseChangeEvent(elem) {
+  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName === "select" || (nodeName === "input" && elem.type === "file")
+  );
 }
 
-function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
-  var current = firstChild;
-  var subtreeRoot = null;
+function manualDispatchChangeEvent(nativeEvent) {
+  var dispatchQueue = [];
+  createAndAccumulateChangeEvent(
+    dispatchQueue,
+    activeElementInst$1,
+    nativeEvent,
+    getEventTarget(nativeEvent)
+  ); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
 
-  while (current != null) {
-    var primarySubtreeFlag = current.subtreeFlags & fiberFlags;
+  batchedUpdates(runEventInBatch, dispatchQueue);
+}
 
-    if (
-      current !== subtreeRoot &&
-      current.child != null &&
-      primarySubtreeFlag !== NoFlags$1
-    ) {
-      current = current.child;
-    } else {
-      if ((current.flags & fiberFlags) !== NoFlags$1) {
-        invokeEffectFn(current);
-      }
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
 
-      if (current.sibling !== null) {
-        current = current.sibling;
-      } else {
-        current = subtreeRoot = current.return;
-      }
-    }
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
+
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
   }
 }
 
-var didWarnStateUpdateForNotYetMountedComponent = null;
-function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
-  {
-    if ((executionContext & RenderContext) !== NoContext) {
-      // We let the other warning about render phase updates deal with this one.
-      return;
-    }
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === "change") {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
 
-    if (!(fiber.mode & ConcurrentMode)) {
-      return;
-    }
+var isInputEventSupported = false;
 
-    var tag = fiber.tag;
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported =
+    isEventSupported("input") &&
+    (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
 
-    if (
-      tag !== IndeterminateComponent &&
-      tag !== HostRoot &&
-      tag !== ClassComponent &&
-      tag !== FunctionComponent &&
-      tag !== ForwardRef &&
-      tag !== MemoComponent &&
-      tag !== SimpleMemoComponent
-    ) {
-      // Only warn for user-defined components, not internal ones like Suspense.
-      return;
-    } // We show the whole stack but dedupe on the top component's name because
-    // the problematic code almost always lies inside that component.
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent("onpropertychange", handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
 
-    var componentName = getComponentNameFromFiber(fiber) || "ReactComponent";
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
+  }
 
-    if (didWarnStateUpdateForNotYetMountedComponent !== null) {
-      if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
-        return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+  activeElement$1.detachEvent("onpropertychange", handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
 
-      didWarnStateUpdateForNotYetMountedComponent.add(componentName);
-    } else {
-      didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
-    }
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== "value") {
+    return;
+  }
 
-    var previousFiber = current;
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
+  }
+}
 
-    try {
-      setCurrentFiber(fiber);
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === "focusin") {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === "focusout") {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
 
-      error(
-        "Can't perform a React state update on a component that hasn't mounted yet. " +
-          "This indicates that you have a side-effect in your render function that " +
-          "asynchronously later calls tries to update the component. Move this work to " +
-          "useEffect instead."
-      );
-    } finally {
-      if (previousFiber) {
-        setCurrentFiber(fiber);
-      } else {
-        resetCurrentFiber();
-      }
-    }
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (
+    domEventName === "selectionchange" ||
+    domEventName === "keyup" ||
+    domEventName === "keydown"
+  ) {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
   }
 }
-var beginWork;
+/**
+ * SECTION: handle `click` event
+ */
 
-if (replayFailedUnitOfWorkWithInvokeGuardedCallback) {
-  var dummyFiber = null;
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  var nodeName = elem.nodeName;
+  return (
+    nodeName &&
+    nodeName.toLowerCase() === "input" &&
+    (elem.type === "checkbox" || elem.type === "radio")
+  );
+}
 
-  beginWork = function (current, unitOfWork, lanes) {
-    // If a component throws an error, we replay it again in a synchronously
-    // dispatched event, so that the debugger will treat it as an uncaught
-    // error See ReactErrorUtils for more information.
-    // Before entering the begin phase, copy the work-in-progress onto a dummy
-    // fiber. If beginWork throws, we'll use this to reset the state.
-    var originalWorkInProgressCopy = assignFiberPropertiesInDEV(
-      dummyFiber,
-      unitOfWork
-    );
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === "click") {
+    return getInstIfValueChanged(targetInst);
+  }
+}
 
-    try {
-      return beginWork$1(current, unitOfWork, lanes);
-    } catch (originalError) {
-      if (
-        didSuspendOrErrorWhileHydratingDEV() ||
-        originalError === SuspenseException ||
-        originalError === SelectiveHydrationException ||
-        (originalError !== null &&
-          typeof originalError === "object" &&
-          typeof originalError.then === "function")
-      ) {
-        // Don't replay promises.
-        // Don't replay errors if we are hydrating and have already suspended or handled an error
-        throw originalError;
-      } // Don't reset current debug fiber, since we're about to work on the
-      // same fiber again.
-      // Unwind the failed stack frame
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === "input" || domEventName === "change") {
+    return getInstIfValueChanged(targetInst);
+  }
+}
 
-      resetSuspendedWorkLoopOnUnwind();
-      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
+function handleControlledInputBlur(node) {
+  var state = node._wrapperState;
 
-      assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
+  if (!state || !state.controlled || node.type !== "number") {
+    return;
+  }
 
-      if (unitOfWork.mode & ProfileMode) {
-        // Reset the profiler timer.
-        startProfilerTimer(unitOfWork);
-      } // Run beginWork again.
+  if (!disableInputAttributeSyncing) {
+    // If controlled, assign the value attribute to the current value on blur
+    setDefaultValue(node, "number", node.value);
+  }
+}
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
 
-      invokeGuardedCallback(
-        null,
-        beginWork$1,
-        null,
-        current,
-        unitOfWork,
-        lanes
-      );
+function extractEvents$4(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  var getTargetInstFunc, handleEventFunc;
 
-      if (hasCaughtError()) {
-        var replayError = clearCaughtError();
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+    } else {
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
+    }
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else if (
+    enableCustomElementPropertySupport &&
+    targetInst &&
+    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
+  ) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  }
 
-        if (
-          typeof replayError === "object" &&
-          replayError !== null &&
-          replayError._suppressLogging &&
-          typeof originalError === "object" &&
-          originalError !== null &&
-          !originalError._suppressLogging
-        ) {
-          // If suppressed, let the flag carry over to the original error which is the one we'll rethrow.
-          originalError._suppressLogging = true;
-        }
-      } // We always throw the original error in case the second render pass is not idempotent.
-      // This can happen if a memoized function or CommonJS module doesn't throw after first invocation.
+  if (getTargetInstFunc) {
+    var inst = getTargetInstFunc(domEventName, targetInst);
 
-      throw originalError;
+    if (inst) {
+      createAndAccumulateChangeEvent(
+        dispatchQueue,
+        inst,
+        nativeEvent,
+        nativeEventTarget
+      );
+      return;
     }
-  };
-} else {
-  beginWork = beginWork$1;
-}
+  }
 
-var didWarnAboutUpdateInRender = false;
-var didWarnAboutUpdateInRenderForAnotherComponent;
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
 
-{
-  didWarnAboutUpdateInRenderForAnotherComponent = new Set();
+  if (domEventName === "focusout") {
+    handleControlledInputBlur(targetNode);
+  }
 }
 
-function warnAboutRenderPhaseUpdatesInDEV(fiber) {
-  {
-    if (isRendering) {
-      switch (fiber.tag) {
-        case FunctionComponent:
-        case ForwardRef:
-        case SimpleMemoComponent: {
-          var renderingComponentName =
-            (workInProgress && getComponentNameFromFiber(workInProgress)) ||
-            "Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
-
-          var dedupeKey = renderingComponentName;
-
-          if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
-            didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
-            var setStateComponentName =
-              getComponentNameFromFiber(fiber) || "Unknown";
-
-            error(
-              "Cannot update a component (`%s`) while rendering a " +
-                "different component (`%s`). To locate the bad setState() call inside `%s`, " +
-                "follow the stack trace as described in https://reactjs.org/link/setstate-in-render",
-              setStateComponentName,
-              renderingComponentName,
-              renderingComponentName
-            );
-          }
-
-          break;
-        }
+function registerEvents$1() {
+  registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+  registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+  registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+  registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
 
-        case ClassComponent: {
-          if (!didWarnAboutUpdateInRender) {
-            error(
-              "Cannot update during an existing state transition (such as " +
-                "within `render`). Render methods should be a pure " +
-                "function of props and state."
-            );
+function extractEvents$3(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var isOverEvent =
+    domEventName === "mouseover" || domEventName === "pointerover";
+  var isOutEvent = domEventName === "mouseout" || domEventName === "pointerout";
 
-            didWarnAboutUpdateInRender = true;
-          }
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
 
-          break;
-        }
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
+      if (
+        getClosestInstanceFromNode(related) ||
+        isContainerMarkedAsRoot(related)
+      ) {
+        return;
       }
     }
   }
-}
 
-function restorePendingUpdaters(root, lanes) {
-  {
-    if (isDevToolsPresent) {
-      var memoizedUpdaters = root.memoizedUpdaters;
-      memoizedUpdaters.forEach(function (schedulingFiber) {
-        addFiberToLanesMap(root, schedulingFiber, lanes);
-      }); // This function intentionally does not clear memoized updaters.
-      // Those may still be relevant to the current commit
-      // and a future one (e.g. Suspense).
-    }
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
   }
-}
-var fakeActCallbackNode = {}; // $FlowFixMe[missing-local-annot]
 
-function scheduleCallback(priorityLevel, callback) {
-  {
-    // If we're currently inside an `act` scope, bypass Scheduler and push to
-    // the `act` queue instead.
-    var actQueue = ReactCurrentActQueue.current;
+  var win; // TODO: why is this nullable in the types but we read from it?
 
-    if (actQueue !== null) {
-      actQueue.push(callback);
-      return fakeActCallbackNode;
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    var doc = nativeEventTarget.ownerDocument;
+
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
     } else {
-      return scheduleCallback$2(priorityLevel, callback);
+      win = window;
     }
   }
-}
-
-function cancelCallback(callbackNode) {
-  if (callbackNode === fakeActCallbackNode) {
-    return;
-  } // In production, always call Scheduler. This function will be stripped out.
 
-  return cancelCallback$1(callbackNode);
-}
+  var from;
+  var to;
 
-function shouldForceFlushFallbacksInDEV() {
-  // Never force flush in production. This function should get stripped out.
-  return ReactCurrentActQueue.current !== null;
-}
+  if (isOutEvent) {
+    var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
 
-function warnIfUpdatesNotWrappedWithActDEV(fiber) {
-  {
-    if (fiber.mode & ConcurrentMode) {
-      if (!isConcurrentActEnvironment()) {
-        // Not in an act environment. No need to warn.
-        return;
-      }
-    } else {
-      // Legacy mode has additional cases where we suppress a warning.
-      if (!isLegacyActEnvironment()) {
-        // Not in an act environment. No need to warn.
-        return;
-      }
+    from = targetInst;
+    to = _related ? getClosestInstanceFromNode(_related) : null;
 
-      if (executionContext !== NoContext) {
-        // Legacy mode doesn't warn if the update is batched, i.e.
-        // batchedUpdates or flushSync.
-        return;
-      }
+    if (to !== null) {
+      var nearestMounted = getNearestMountedFiber(to);
+      var tag = to.tag;
 
       if (
-        fiber.tag !== FunctionComponent &&
-        fiber.tag !== ForwardRef &&
-        fiber.tag !== SimpleMemoComponent
+        to !== nearestMounted ||
+        (tag !== HostComponent && tag !== HostSingleton && tag !== HostText)
       ) {
-        // For backwards compatibility with pre-hooks code, legacy mode only
-        // warns for updates that originate from a hook.
-        return;
+        to = null;
       }
     }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
+  }
 
-    if (ReactCurrentActQueue.current === null) {
-      var previousFiber = current;
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
+  }
 
-      try {
-        setCurrentFiber(fiber);
+  var SyntheticEventCtor = SyntheticMouseEvent;
+  var leaveEventType = "onMouseLeave";
+  var enterEventType = "onMouseEnter";
+  var eventTypePrefix = "mouse";
 
-        error(
-          "An update to %s inside a test was not wrapped in act(...).\n\n" +
-            "When testing, code that causes React state updates should be " +
-            "wrapped into act(...):\n\n" +
-            "act(() => {\n" +
-            "  /* fire events that update state */\n" +
-            "});\n" +
-            "/* assert on the output */\n\n" +
-            "This ensures that you're testing the behavior the user would see " +
-            "in the browser." +
-            " Learn more at https://reactjs.org/link/wrap-tests-with-act",
-          getComponentNameFromFiber(fiber)
-        );
-      } finally {
-        if (previousFiber) {
-          setCurrentFiber(fiber);
-        } else {
-          resetCurrentFiber();
-        }
-      }
-    }
+  if (domEventName === "pointerout" || domEventName === "pointerover") {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = "onPointerLeave";
+    enterEventType = "onPointerEnter";
+    eventTypePrefix = "pointer";
   }
-}
 
-function warnIfSuspenseResolutionNotWrappedWithActDEV(root) {
-  {
-    if (
-      root.tag !== LegacyRoot &&
-      isConcurrentActEnvironment() &&
-      ReactCurrentActQueue.current === null
-    ) {
-      error(
-        "A suspended resource finished loading inside a test, but the event " +
-          "was not wrapped in act(...).\n\n" +
-          "When testing, code that resolves suspended data should be wrapped " +
-          "into act(...):\n\n" +
-          "act(() => {\n" +
-          "  /* finish loading suspended data */\n" +
-          "});\n" +
-          "/* assert on the output */\n\n" +
-          "This ensures that you're testing the behavior the user would see " +
-          "in the browser." +
-          " Learn more at https://reactjs.org/link/wrap-tests-with-act"
-      );
-    }
+  var fromNode = from == null ? win : getNodeFromInstance(from);
+  var toNode = to == null ? win : getNodeFromInstance(to);
+  var leave = new SyntheticEventCtor(
+    leaveEventType,
+    eventTypePrefix + "leave",
+    from,
+    nativeEvent,
+    nativeEventTarget
+  );
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  var enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
+
+  var nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+
+  if (nativeTargetInst === targetInst) {
+    var enterEvent = new SyntheticEventCtor(
+      enterEventType,
+      eventTypePrefix + "enter",
+      to,
+      nativeEvent,
+      nativeEventTarget
+    );
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
   }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
 }
 
-function setIsRunningInsertionEffect(isRunning) {
-  {
-    isRunningInsertionEffect = isRunning;
-  }
+var skipSelectionChangeEvent =
+  canUseDOM && "documentMode" in document && document.documentMode <= 11;
+
+function registerEvents() {
+  registerTwoPhaseEvent("onSelect", [
+    "focusout",
+    "contextmenu",
+    "dragend",
+    "focusin",
+    "keydown",
+    "keyup",
+    "mousedown",
+    "mouseup",
+    "selectionchange"
+  ]);
 }
 
-/* eslint-disable react-internal/prod-error-codes */
-// Used by React Refresh runtime through DevTools Global Hook.
+var activeElement = null;
+var activeElementInst = null;
+var lastSelection = null;
+var mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
 
-var resolveFamily = null;
-var failedBoundaries = null;
-var setRefreshHandler = function (handler) {
-  {
-    resolveFamily = handler;
+function getSelection(node) {
+  if ("selectionStart" in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    var win = (node.ownerDocument && node.ownerDocument.defaultView) || window;
+    var selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
   }
-};
-function resolveFunctionForHotReloading(type) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return type;
-    }
+}
+/**
+ * Get document associated with the event target.
+ */
 
-    var family = resolveFamily(type);
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget
+    ? eventTarget.document
+    : eventTarget.nodeType === DOCUMENT_NODE
+    ? eventTarget
+    : eventTarget.ownerDocument;
+}
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
 
-    if (family === undefined) {
-      return type;
-    } // Use the latest known implementation.
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  var doc = getEventTargetDocument(nativeEventTarget);
+
+  if (
+    mouseDown ||
+    activeElement == null ||
+    activeElement !== getActiveElement(doc)
+  ) {
+    return;
+  } // Only fire when selection has actually changed.
+
+  var currentSelection = getSelection(activeElement);
 
-    return family.current;
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    var listeners = accumulateTwoPhaseListeners(activeElementInst, "onSelect");
+
+    if (listeners.length > 0) {
+      var event = new SyntheticEvent(
+        "onSelect",
+        "select",
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
+      dispatchQueue.push({
+        event: event,
+        listeners: listeners
+      });
+      event.target = activeElement;
+    }
   }
 }
-function resolveClassForHotReloading(type) {
-  // No implementation differences.
-  return resolveFunctionForHotReloading(type);
-}
-function resolveForwardRefForHotReloading(type) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return type;
-    }
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
 
-    var family = resolveFamily(type);
+function extractEvents$2(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
 
-    if (family === undefined) {
-      // Check if we're dealing with a real forwardRef. Don't want to crash early.
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case "focusin":
       if (
-        type !== null &&
-        type !== undefined &&
-        typeof type.render === "function"
+        isTextInputElement(targetNode) ||
+        targetNode.contentEditable === "true"
       ) {
-        // ForwardRef is special because its resolved .type is an object,
-        // but it's possible that we only have its inner render function in the map.
-        // If that inner render function is different, we'll build a new forwardRef type.
-        var currentRender = resolveFunctionForHotReloading(type.render);
-
-        if (type.render !== currentRender) {
-          var syntheticType = {
-            $$typeof: REACT_FORWARD_REF_TYPE,
-            render: currentRender
-          };
-
-          if (type.displayName !== undefined) {
-            syntheticType.displayName = type.displayName;
-          }
-
-          return syntheticType;
-        }
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
       }
 
-      return type;
-    } // Use the latest known implementation.
-
-    return family.current;
-  }
-}
-function isCompatibleFamilyForHotReloading(fiber, element) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return false;
-    }
+      break;
 
-    var prevType = fiber.elementType;
-    var nextType = element.type; // If we got here, we know types aren't === equal.
+    case "focusout":
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
 
-    var needsCompareFamilies = false;
-    var $$typeofNextType =
-      typeof nextType === "object" && nextType !== null
-        ? nextType.$$typeof
-        : null;
+    case "mousedown":
+      mouseDown = true;
+      break;
 
-    switch (fiber.tag) {
-      case ClassComponent: {
-        if (typeof nextType === "function") {
-          needsCompareFamilies = true;
-        }
+    case "contextmenu":
+    case "mouseup":
+    case "dragend":
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
+    //
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
 
+    case "selectionchange":
+      if (skipSelectionChangeEvent) {
         break;
       }
 
-      case FunctionComponent: {
-        if (typeof nextType === "function") {
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          // We don't know the inner type yet.
-          // We're going to assume that the lazy inner type is stable,
-          // and so it is sufficient to avoid reconciling it away.
-          // We're not going to unwrap or actually use the new lazy type.
-          needsCompareFamilies = true;
-        }
+    // falls through
 
-        break;
-      }
+    case "keydown":
+    case "keyup":
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
+}
 
-      case ForwardRef: {
-        if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          needsCompareFamilies = true;
-        }
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
 
-        break;
-      }
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
+}
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
 
-      case MemoComponent:
-      case SimpleMemoComponent: {
-        if ($$typeofNextType === REACT_MEMO_TYPE) {
-          // TODO: if it was but can no longer be simple,
-          // we shouldn't set this.
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          needsCompareFamilies = true;
-        }
+var vendorPrefixes = {
+  animationend: makePrefixMap("Animation", "AnimationEnd"),
+  animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+  animationstart: makePrefixMap("Animation", "AnimationStart"),
+  transitionend: makePrefixMap("Transition", "TransitionEnd")
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
 
-        break;
-      }
+var prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
 
-      default:
-        return false;
-    } // Check if both types have a family and it's the same one.
+var style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
 
-    if (needsCompareFamilies) {
-      // Note: memo() and forwardRef() we'll compare outer rather than inner type.
-      // This means both of them need to be registered to preserve state.
-      // If we unwrapped and compared the inner types for wrappers instead,
-      // then we would risk falsely saying two separate memo(Foo)
-      // calls are equivalent because they wrap the same Foo function.
-      var prevFamily = resolveFamily(prevType); // $FlowFixMe[not-a-function] found when upgrading Flow
+if (canUseDOM) {
+  style = document.createElement("div").style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
 
-      if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
-        return true;
-      }
-    }
+  if (!("AnimationEvent" in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
 
-    return false;
+  if (!("TransitionEvent" in window)) {
+    delete vendorPrefixes.transitionend.transition;
   }
 }
-function markFailedErrorBoundaryForHotReloading(fiber) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return;
-    }
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
 
-    if (typeof WeakSet !== "function") {
-      return;
-    }
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
+  }
 
-    if (failedBoundaries === null) {
-      failedBoundaries = new WeakSet();
-    }
+  var prefixMap = vendorPrefixes[eventName];
 
-    failedBoundaries.add(fiber);
-  }
-}
-var scheduleRefresh = function (root, update) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return;
+  for (var styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
     }
-
-    var staleFamilies = update.staleFamilies,
-      updatedFamilies = update.updatedFamilies;
-    flushPassiveEffects();
-    flushSync$1(function () {
-      scheduleFibersWithFamiliesRecursively(
-        root.current,
-        updatedFamilies,
-        staleFamilies
-      );
-    });
   }
-};
-var scheduleRoot = function (root, element) {
-  {
-    if (root.context !== emptyContextObject) {
-      // Super edge case: root has a legacy _renderSubtree context
-      // but we don't know the parentComponent so we can't pass it.
-      // Just ignore. We'll delete this with _renderSubtree code path later.
-      return;
-    }
 
-    flushPassiveEffects();
-    flushSync$1(function () {
-      updateContainer(element, root, null, null);
-    });
-  }
-};
+  return eventName;
+}
 
-function scheduleFibersWithFamiliesRecursively(
-  fiber,
-  updatedFamilies,
-  staleFamilies
-) {
-  {
-    var alternate = fiber.alternate,
-      child = fiber.child,
-      sibling = fiber.sibling,
-      tag = fiber.tag,
-      type = fiber.type;
-    var candidateType = null;
+var ANIMATION_END = getVendorPrefixedEventName("animationend");
+var ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration");
+var ANIMATION_START = getVendorPrefixedEventName("animationstart");
+var TRANSITION_END = getVendorPrefixedEventName("transitionend");
 
-    switch (tag) {
-      case FunctionComponent:
-      case SimpleMemoComponent:
-      case ClassComponent:
-        candidateType = type;
-        break;
+var topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
 
-      case ForwardRef:
-        candidateType = type.render;
-        break;
-    }
+var simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'toggle', 'touchMove', 'waiting', 'wheel'];
 
-    if (resolveFamily === null) {
-      throw new Error("Expected resolveFamily to be set during hot reload.");
-    }
+{
+  // Special case: these two events don't have on* React handler
+  // and are only accessible via the createEventHandle API.
+  topLevelEventsToReactNames.set("beforeblur", null);
+  topLevelEventsToReactNames.set("afterblur", null);
+}
 
-    var needsRender = false;
-    var needsRemount = false;
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
 
-    if (candidateType !== null) {
-      var family = resolveFamily(candidateType);
+function registerSimpleEvents() {
+  for (var i = 0; i < simpleEventPluginEvents.length; i++) {
+    var eventName = simpleEventPluginEvents[i];
+    var domEventName = eventName.toLowerCase();
+    var capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, "on" + capitalizedEvent);
+  } // Special cases where event names don't match.
 
-      if (family !== undefined) {
-        if (staleFamilies.has(family)) {
-          needsRemount = true;
-        } else if (updatedFamilies.has(family)) {
-          if (tag === ClassComponent) {
-            needsRemount = true;
-          } else {
-            needsRender = true;
-          }
-        }
-      }
-    }
+  registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+  registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+  registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+  registerSimpleEvent("dblclick", "onDoubleClick");
+  registerSimpleEvent("focusin", "onFocus");
+  registerSimpleEvent("focusout", "onBlur");
+  registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+}
 
-    if (failedBoundaries !== null) {
-      if (
-        failedBoundaries.has(fiber) || // $FlowFixMe[incompatible-use] found when upgrading Flow
-        (alternate !== null && failedBoundaries.has(alternate))
-      ) {
-        needsRemount = true;
-      }
-    }
+function extractEvents$1(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var reactName = topLevelEventsToReactNames.get(domEventName);
 
-    if (needsRemount) {
-      fiber._debugNeedsRemount = true;
-    }
+  if (reactName === undefined) {
+    return;
+  }
 
-    if (needsRemount || needsRender) {
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  var SyntheticEventCtor = SyntheticEvent;
+  var reactEventType = domEventName;
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  switch (domEventName) {
+    case "keypress":
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
       }
-    }
-
-    if (child !== null && !needsRemount) {
-      scheduleFibersWithFamiliesRecursively(
-        child,
-        updatedFamilies,
-        staleFamilies
-      );
-    }
-
-    if (sibling !== null) {
-      scheduleFibersWithFamiliesRecursively(
-        sibling,
-        updatedFamilies,
-        staleFamilies
-      );
-    }
-  }
-}
-
-var findHostInstancesForRefresh = function (root, families) {
-  {
-    var hostInstances = new Set();
-    var types = new Set(
-      families.map(function (family) {
-        return family.current;
-      })
-    );
-    findHostInstancesForMatchingFibersRecursively(
-      root.current,
-      types,
-      hostInstances
-    );
-    return hostInstances;
-  }
-};
 
-function findHostInstancesForMatchingFibersRecursively(
-  fiber,
-  types,
-  hostInstances
-) {
-  {
-    var child = fiber.child,
-      sibling = fiber.sibling,
-      tag = fiber.tag,
-      type = fiber.type;
-    var candidateType = null;
+    /* falls through */
 
-    switch (tag) {
-      case FunctionComponent:
-      case SimpleMemoComponent:
-      case ClassComponent:
-        candidateType = type;
-        break;
+    case "keydown":
+    case "keyup":
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
 
-      case ForwardRef:
-        candidateType = type.render;
-        break;
-    }
+    case "focusin":
+      reactEventType = "focus";
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-    var didMatch = false;
+    case "focusout":
+      reactEventType = "blur";
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-    if (candidateType !== null) {
-      if (types.has(candidateType)) {
-        didMatch = true;
-      }
-    }
+    case "beforeblur":
+    case "afterblur":
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-    if (didMatch) {
-      // We have a match. This only drills down to the closest host components.
-      // There's no need to search deeper because for the purpose of giving
-      // visual feedback, "flashing" outermost parent rectangles is sufficient.
-      findHostInstancesForFiberShallowly(fiber, hostInstances);
-    } else {
-      // If there's no match, maybe there will be one further down in the child tree.
-      if (child !== null) {
-        findHostInstancesForMatchingFibersRecursively(
-          child,
-          types,
-          hostInstances
-        );
+    case "click":
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      if (nativeEvent.button === 2) {
+        return;
       }
-    }
 
-    if (sibling !== null) {
-      findHostInstancesForMatchingFibersRecursively(
-        sibling,
-        types,
-        hostInstances
-      );
-    }
-  }
-}
+    /* falls through */
 
-function findHostInstancesForFiberShallowly(fiber, hostInstances) {
-  {
-    var foundHostInstances = findChildHostInstancesForFiberShallowly(
-      fiber,
-      hostInstances
-    );
+    case "auxclick":
+    case "dblclick":
+    case "mousedown":
+    case "mousemove":
+    case "mouseup": // TODO: Disabled elements should not respond to mouse events
 
-    if (foundHostInstances) {
-      return;
-    } // If we didn't find any host children, fallback to closest host parent.
+    /* falls through */
 
-    var node = fiber;
+    case "mouseout":
+    case "mouseover":
+    case "contextmenu":
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
 
-    while (true) {
-      switch (node.tag) {
-        case HostSingleton:
-        case HostComponent:
-          hostInstances.add(node.stateNode);
-          return;
+    case "drag":
+    case "dragend":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "dragstart":
+    case "drop":
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
 
-        case HostPortal:
-          hostInstances.add(node.stateNode.containerInfo);
-          return;
+    case "touchcancel":
+    case "touchend":
+    case "touchmove":
+    case "touchstart":
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
 
-        case HostRoot:
-          hostInstances.add(node.stateNode.containerInfo);
-          return;
-      }
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
 
-      if (node.return === null) {
-        throw new Error("Expected to reach root first.");
-      }
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
 
-      node = node.return;
-    }
+    case "scroll":
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
+
+    case "wheel":
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
+
+    case "copy":
+    case "cut":
+    case "paste":
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
+
+    case "gotpointercapture":
+    case "lostpointercapture":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "pointerup":
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
   }
-}
 
-function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
-  {
-    var node = fiber;
-    var foundHostInstances = false;
+  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
 
-    while (true) {
-      if (
-        node.tag === HostComponent ||
-        node.tag === HostHoistable ||
-        node.tag === HostSingleton
-      ) {
-        // We got a match.
-        foundHostInstances = true;
-        hostInstances.add(node.stateNode); // There may still be more, so keep searching.
-      } else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
+  if (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) {
+    var listeners = accumulateEventHandleNonManagedNodeListeners(
+      // TODO: this cast may not make sense for events like
+      // "focus" where React listens to e.g. "focusin".
+      reactEventType,
+      targetContainer,
+      inCapturePhase
+    );
 
-      if (node === fiber) {
-        return foundHostInstances;
-      }
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      var event = new SyntheticEventCtor(
+        reactName,
+        reactEventType,
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
+      dispatchQueue.push({
+        event: event,
+        listeners: listeners
+      });
+    }
+  } else {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    var accumulateTargetOnly =
+      !inCapturePhase && // TODO: ideally, we'd eventually add all events from
+      // nonDelegatedEvents list in DOMPluginEventSystem.
+      // Then we can remove this special list.
+      // This is a breaking change that can wait until React 18.
+      domEventName === "scroll";
 
-      while (node.sibling === null) {
-        if (node.return === null || node.return === fiber) {
-          return foundHostInstances;
-        }
+    var _listeners = accumulateSinglePhaseListeners(
+      targetInst,
+      reactName,
+      nativeEvent.type,
+      inCapturePhase,
+      accumulateTargetOnly,
+      nativeEvent
+    );
 
-        node = node.return;
-      }
+    if (_listeners.length > 0) {
+      // Intentionally create event lazily.
+      var _event = new SyntheticEventCtor(
+        reactName,
+        reactEventType,
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
 
-      node.sibling.return = node.return;
-      node = node.sibling;
+      dispatchQueue.push({
+        event: _event,
+        listeners: _listeners
+      });
     }
   }
-
-  return false;
 }
 
-var hasBadMapPolyfill;
-
-{
-  hasBadMapPolyfill = false;
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
 
-  try {
-    var nonExtensibleObject = Object.preventExtensions({});
-    /* eslint-disable no-new */
+function extractEvents(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget,
+    eventSystemFlags,
+    targetContainer
+  );
+  var shouldProcessPolyfillPlugins =
+    (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
 
-    new Map([[nonExtensibleObject, null]]);
-    new Set([nonExtensibleObject]);
-    /* eslint-enable no-new */
-  } catch (e) {
-    // TODO: Consider warning about bad polyfills
-    hasBadMapPolyfill = true;
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$4(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$2(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$5(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
   }
-}
+} // List of events that need to be individually attached to media elements.
 
-function FiberNode(tag, pendingProps, key, mode) {
-  // Instance
-  this.tag = tag;
-  this.key = key;
-  this.elementType = null;
-  this.type = null;
-  this.stateNode = null; // Fiber
+var mediaEventTypes = [
+  "abort",
+  "canplay",
+  "canplaythrough",
+  "durationchange",
+  "emptied",
+  "encrypted",
+  "ended",
+  "error",
+  "loadeddata",
+  "loadedmetadata",
+  "loadstart",
+  "pause",
+  "play",
+  "playing",
+  "progress",
+  "ratechange",
+  "resize",
+  "seeked",
+  "seeking",
+  "stalled",
+  "suspend",
+  "timeupdate",
+  "volumechange",
+  "waiting"
+]; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
 
-  this.return = null;
-  this.child = null;
-  this.sibling = null;
-  this.index = 0;
-  this.ref = null;
-  this.refCleanup = null;
-  this.pendingProps = pendingProps;
-  this.memoizedProps = null;
-  this.updateQueue = null;
-  this.memoizedState = null;
-  this.dependencies = null;
-  this.mode = mode; // Effects
+var nonDelegatedEvents = new Set(
+  ["cancel", "close", "invalid", "load", "scroll", "toggle"].concat(
+    mediaEventTypes
+  )
+);
 
-  this.flags = NoFlags$1;
-  this.subtreeFlags = NoFlags$1;
-  this.deletions = null;
-  this.lanes = NoLanes;
-  this.childLanes = NoLanes;
-  this.alternate = null;
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
 
-  {
-    // Note: The following is done to avoid a v8 performance cliff.
-    //
-    // Initializing the fields below to smis and later updating them with
-    // double values will cause Fibers to end up having separate shapes.
-    // This behavior/bug has something to do with Object.preventExtension().
-    // Fortunately this only impacts DEV builds.
-    // Unfortunately it makes React unusably slow for some applications.
-    // To work around this, initialize the fields below with doubles.
-    //
-    // Learn more about this here:
-    // https://github.com/facebook/react/issues/14365
-    // https://bugs.chromium.org/p/v8/issues/detail?id=8538
-    this.actualDuration = Number.NaN;
-    this.actualStartTime = Number.NaN;
-    this.selfBaseDuration = Number.NaN;
-    this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
-    // This won't trigger the performance cliff mentioned above,
-    // and it simplifies other profiler code (including DevTools).
+function processDispatchQueueItemsInOrder(
+  event,
+  dispatchListeners,
+  inCapturePhase
+) {
+  var previousInstance;
 
-    this.actualDuration = 0;
-    this.actualStartTime = -1;
-    this.selfBaseDuration = 0;
-    this.treeBaseDuration = 0;
-  }
+  if (inCapturePhase) {
+    for (var i = dispatchListeners.length - 1; i >= 0; i--) {
+      var _dispatchListeners$i = dispatchListeners[i],
+        instance = _dispatchListeners$i.instance,
+        currentTarget = _dispatchListeners$i.currentTarget,
+        listener = _dispatchListeners$i.listener;
 
-  {
-    // This isn't directly used but is handy for debugging internals:
-    this._debugSource = null;
-    this._debugOwner = null;
-    this._debugNeedsRemount = false;
-    this._debugHookTypes = null;
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
 
-    if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
-      Object.preventExtensions(this);
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
     }
-  }
-} // This is a constructor function, rather than a POJO constructor, still
-// please ensure we do the following:
-// 1) Nobody should add any instance methods on this. Instance methods can be
-//    more difficult to predict when they get optimized and they are almost
-//    never inlined properly in static compilers.
-// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
-//    always know when it is a fiber.
-// 3) We might want to experiment with using numeric keys since they are easier
-//    to optimize in a non-JIT environment.
-// 4) We can easily go from a constructor to a createFiber object literal if that
-//    is faster.
-// 5) It should be easy to port this to a C struct and keep a C implementation
-//    compatible.
+  } else {
+    for (var _i = 0; _i < dispatchListeners.length; _i++) {
+      var _dispatchListeners$_i = dispatchListeners[_i],
+        _instance = _dispatchListeners$_i.instance,
+        _currentTarget = _dispatchListeners$_i.currentTarget,
+        _listener = _dispatchListeners$_i.listener;
 
-function createFiber(tag, pendingProps, key, mode) {
-  // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
-  return new FiberNode(tag, pendingProps, key, mode);
+      if (_instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
+
+      executeDispatch(event, _listener, _currentTarget);
+      previousInstance = _instance;
+    }
+  }
 }
 
-function shouldConstruct(Component) {
-  var prototype = Component.prototype;
-  return !!(prototype && prototype.isReactComponent);
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event,
+      listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
+
+  rethrowCaughtError();
 }
 
-function isSimpleFunctionComponent(type) {
-  return (
-    typeof type === "function" &&
-    !shouldConstruct(type) &&
-    type.defaultProps === undefined
+function dispatchEventsForPlugins(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst,
+  targetContainer
+) {
+  var nativeEventTarget = getEventTarget(nativeEvent);
+  var dispatchQueue = [];
+  extractEvents(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget,
+    eventSystemFlags,
+    targetContainer
   );
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
 }
-function resolveLazyComponentTag(Component) {
-  if (typeof Component === "function") {
-    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
-  } else if (Component !== undefined && Component !== null) {
-    var $$typeof = Component.$$typeof;
 
-    if ($$typeof === REACT_FORWARD_REF_TYPE) {
-      return ForwardRef;
-    }
-
-    if ($$typeof === REACT_MEMO_TYPE) {
-      return MemoComponent;
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+  {
+    if (!nonDelegatedEvents.has(domEventName)) {
+      error(
+        'Did not expect a listenToNonDelegatedEvent() call for "%s". ' +
+          "This is a bug in React. Please file an issue.",
+        domEventName
+      );
     }
   }
 
-  return IndeterminateComponent;
-} // This is used to create an alternate fiber to do work on.
-
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
-
-  if (workInProgress === null) {
-    // We use a double buffering pooling technique because we know that we'll
-    // only ever need at most two versions of a tree. We pool the "other" unused
-    // node that we're free to reuse. This is lazily created to avoid allocating
-    // extra objects for things that are never updated. It also allow us to
-    // reclaim the extra memory if needed.
-    workInProgress = createFiber(
-      current.tag,
-      pendingProps,
-      current.key,
-      current.mode
-    );
-    workInProgress.elementType = current.elementType;
-    workInProgress.type = current.type;
-    workInProgress.stateNode = current.stateNode;
+  var isCapturePhaseListener = false;
+  var listenerSet = getEventListenerSet(targetElement);
+  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
 
-    {
-      // DEV-only fields
-      workInProgress._debugSource = current._debugSource;
-      workInProgress._debugOwner = current._debugOwner;
-      workInProgress._debugHookTypes = current._debugHookTypes;
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(
+      targetElement,
+      domEventName,
+      IS_NON_DELEGATED,
+      isCapturePhaseListener
+    );
+    listenerSet.add(listenerSetKey);
+  }
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+  {
+    if (nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener) {
+      error(
+        'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. ' +
+          "This is a bug in React. Please file an issue.",
+        domEventName
+      );
     }
+  }
 
-    workInProgress.alternate = current;
-    current.alternate = workInProgress;
-  } else {
-    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+  var eventSystemFlags = 0;
 
-    workInProgress.type = current.type; // We already have an alternate.
-    // Reset the effect tag.
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
 
-    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
+} // This is only used by createEventHandle when the
+// target is not a DOM element. E.g. window.
 
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.deletions = null;
+function listenToNativeEventForNonManagedEventTarget(
+  domEventName,
+  isCapturePhaseListener,
+  target
+) {
+  var eventSystemFlags = IS_EVENT_HANDLE_NON_MANAGED_NODE;
+  var listenerSet = getEventListenerSet(target);
+  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
 
-    {
-      // We intentionally reset, rather than copy, actualDuration & actualStartTime.
-      // This prevents time from endlessly accumulating in new commits.
-      // This has the downside of resetting values for different priority renders,
-      // But works for yielding (the common case) and should support resuming.
-      workInProgress.actualDuration = 0;
-      workInProgress.actualStartTime = -1;
+  if (!listenerSet.has(listenerSetKey)) {
+    if (isCapturePhaseListener) {
+      eventSystemFlags |= IS_CAPTURE_PHASE;
     }
-  } // Reset all effects except static ones.
-  // Static effects are not specific to a render.
-
-  workInProgress.flags = current.flags & StaticMask;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
-  // it cannot be shared with the current fiber.
 
-  var currentDependencies = current.dependencies;
-  workInProgress.dependencies =
-    currentDependencies === null
-      ? null
-      : {
-          lanes: currentDependencies.lanes,
-          firstContext: currentDependencies.firstContext
-        }; // These will be overridden during the parent's reconciliation
+    addTrappedEventListener(
+      target,
+      domEventName,
+      eventSystemFlags,
+      isCapturePhaseListener
+    );
+    listenerSet.add(listenerSetKey);
+  }
+}
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(function (domEventName) {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== "selectionchange") {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
 
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    var ownerDocument =
+      rootContainerElement.nodeType === DOCUMENT_NODE
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
 
-  {
-    workInProgress.selfBaseDuration = current.selfBaseDuration;
-    workInProgress.treeBaseDuration = current.treeBaseDuration;
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent("selectionchange", false, ownerDocument);
+      }
+    }
   }
+}
 
-  {
-    workInProgress._debugNeedsRemount = current._debugNeedsRemount;
-
-    switch (workInProgress.tag) {
-      case IndeterminateComponent:
-      case FunctionComponent:
-      case SimpleMemoComponent:
-        workInProgress.type = resolveFunctionForHotReloading(current.type);
-        break;
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  var listener = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  ); // If passive option is not supported, then the event will be
+  // active and not passive.
 
-      case ClassComponent:
-        workInProgress.type = resolveClassForHotReloading(current.type);
-        break;
+  var isPassiveListener = undefined;
 
-      case ForwardRef:
-        workInProgress.type = resolveForwardRefForHotReloading(current.type);
-        break;
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (
+      domEventName === "touchstart" ||
+      domEventName === "touchmove" ||
+      domEventName === "wheel"
+    ) {
+      isPassiveListener = true;
     }
   }
 
-  return workInProgress;
-} // Used to reuse a Fiber for a second pass.
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  var unsubscribeListener; // When legacyFBSupport is enabled, it's for when we
+  // want to add a one time event listener to a container.
+  // This should only be used with enableLegacyFBSupport
+  // due to requirement to provide compatibility with
+  // internal FB www event tooling. This works by removing
+  // the event listener as soon as it is invoked. We could
+  // also attempt to use the {once: true} param on
+  // addEventListener, but that requires support and some
+  // browsers do not support this today, and given this is
+  // to support legacy code patterns, it's likely they'll
+  // need support for such browsers.
 
-function resetWorkInProgress(workInProgress, renderLanes) {
-  // This resets the Fiber to what createFiber or createWorkInProgress would
-  // have set the values to before during the first pass. Ideally this wouldn't
-  // be necessary but unfortunately many code paths reads from the workInProgress
-  // when they should be reading from current and writing to workInProgress.
-  // We assume pendingProps, index, key, ref, return are still untouched to
-  // avoid doing another reconciliation.
-  // Reset the effect flags but keep any Placement tags, since that's something
-  // that child fiber is setting, not the reconciliation.
-  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = listener; // $FlowFixMe[missing-this-annot]
+    // $FlowFixMe[definition-cycle]
 
-  var current = workInProgress.alternate;
+    listener = function () {
+      removeEventListener(targetContainer, domEventName, unsubscribeListener);
 
-  if (current === null) {
-    // Reset to createFiber's initial values.
-    workInProgress.childLanes = NoLanes;
-    workInProgress.lanes = renderLanes;
-    workInProgress.child = null;
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.memoizedProps = null;
-    workInProgress.memoizedState = null;
-    workInProgress.updateQueue = null;
-    workInProgress.dependencies = null;
-    workInProgress.stateNode = null;
+      for (
+        var _len = arguments.length, p = new Array(_len), _key = 0;
+        _key < _len;
+        _key++
+      ) {
+        p[_key] = arguments[_key];
+      }
 
-    {
-      // Note: We don't reset the actualTime counts. It's useful to accumulate
-      // actual time across multiple render passes.
-      workInProgress.selfBaseDuration = 0;
-      workInProgress.treeBaseDuration = 0;
+      return originalListener.apply(this, p);
+    };
+  } // TODO: There are too many combinations here. Consolidate them.
+
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        listener,
+        isPassiveListener
+      );
+    } else {
+      unsubscribeListener = addEventCaptureListener(
+        targetContainer,
+        domEventName,
+        listener
+      );
     }
   } else {
-    // Reset to the cloned values that createWorkInProgress would've.
-    workInProgress.childLanes = current.childLanes;
-    workInProgress.lanes = current.lanes;
-    workInProgress.child = current.child;
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.deletions = null;
-    workInProgress.memoizedProps = current.memoizedProps;
-    workInProgress.memoizedState = current.memoizedState;
-    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
-
-    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
-    // it cannot be shared with the current fiber.
-
-    var currentDependencies = current.dependencies;
-    workInProgress.dependencies =
-      currentDependencies === null
-        ? null
-        : {
-            lanes: currentDependencies.lanes,
-            firstContext: currentDependencies.firstContext
-          };
-
-    {
-      // Note: We don't reset the actualTime counts. It's useful to accumulate
-      // actual time across multiple render passes.
-      workInProgress.selfBaseDuration = current.selfBaseDuration;
-      workInProgress.treeBaseDuration = current.treeBaseDuration;
+    if (isPassiveListener !== undefined) {
+      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        listener,
+        isPassiveListener
+      );
+    } else {
+      unsubscribeListener = addEventBubbleListener(
+        targetContainer,
+        domEventName,
+        listener
+      );
     }
   }
+}
 
-  return workInProgress;
+function deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer) {
+  // We defer all click events with legacy FB support mode on.
+  // This means we add a one time event listener to trigger
+  // after the FB delegated listeners fire.
+  var isDeferredListenerForLegacyFBSupport = true;
+  addTrappedEventListener(
+    targetContainer,
+    domEventName,
+    IS_LEGACY_FB_SUPPORT_MODE,
+    false,
+    isDeferredListenerForLegacyFBSupport
+  );
 }
-function createHostRootFiber(
-  tag,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride
-) {
-  var mode;
 
-  if (tag === ConcurrentRoot) {
-    mode = ConcurrentMode;
+function isMatchingRootContainer(grandContainer, targetContainer) {
+  return (
+    grandContainer === targetContainer ||
+    (grandContainer.nodeType === COMMENT_NODE &&
+      grandContainer.parentNode === targetContainer)
+  );
+}
 
-    if (isStrictMode === true || createRootStrictEffectsByDefault) {
-      mode |= StrictLegacyMode | StrictEffectsMode;
-    }
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst,
+  targetContainer
+) {
+  var ancestorInst = targetInst;
+
+  if (
+    (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 &&
+    (eventSystemFlags & IS_NON_DELEGATED) === 0
+  ) {
+    var targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+    // defer the event to the null with a one
+    // time event listener so we can defer the event.
 
     if (
-      // Only for internal experiments.
-      concurrentUpdatesByDefaultOverride
+      enableLegacyFBSupport && // If our event flags match the required flags for entering
+      // FB legacy mode and we are processing the "click" event,
+      // then we can defer the event to the "document", to allow
+      // for legacy FB support, where the expected behavior was to
+      // match React < 16 behavior of delegated clicks to the doc.
+      domEventName === "click" &&
+      (eventSystemFlags & SHOULD_NOT_DEFER_CLICK_FOR_FB_SUPPORT_MODE) === 0 &&
+      !isReplayingEvent(nativeEvent)
     ) {
-      mode |= ConcurrentUpdatesByDefaultMode;
+      deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer);
+      return;
     }
-  } else {
-    mode = NoMode;
-  }
 
-  if (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;
-  }
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      var node = targetInst;
 
-  return createFiber(HostRoot, null, null, mode);
-}
-function createFiberFromTypeAndProps(
-  type, // React$ElementType
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
 
-  var resolvedType = type;
+        var nodeTag = node.tag;
 
-  if (typeof type === "function") {
-    if (shouldConstruct(type)) {
-      fiberTag = ClassComponent;
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          var container = node.stateNode.containerInfo;
 
-      {
-        resolvedType = resolveClassForHotReloading(resolvedType);
-      }
-    } else {
-      {
-        resolvedType = resolveFunctionForHotReloading(resolvedType);
-      }
-    }
-  } else if (typeof type === "string") {
-    {
-      var hostContext = getHostContext();
-      fiberTag = isHostHoistableType(type, pendingProps, hostContext)
-        ? HostHoistable
-        : isHostSingletonType(type)
-        ? HostSingleton
-        : HostComponent;
-    }
-  } else {
-    getTag: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
 
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = Mode;
-        mode |= StrictLegacyMode;
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            var grandNode = node.return;
 
-        if ((mode & ConcurrentMode) !== NoMode) {
-          // Strict effects should never run on legacy roots
-          mode |= StrictEffectsMode;
-        }
+            while (grandNode !== null) {
+              var grandTag = grandNode.tag;
 
-        break;
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                var grandContainer = grandNode.stateNode.containerInfo;
 
-      case REACT_PROFILER_TYPE:
-        return createFiberFromProfiler(pendingProps, mode, lanes, key);
+                if (
+                  isMatchingRootContainer(grandContainer, targetContainerNode)
+                ) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
 
-      case REACT_SUSPENSE_TYPE:
-        return createFiberFromSuspense(pendingProps, mode, lanes, key);
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
 
-      case REACT_SUSPENSE_LIST_TYPE:
-        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
+          while (container !== null) {
+            var parentNode = getClosestInstanceFromNode(container);
 
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+            if (parentNode === null) {
+              return;
+            }
 
-      case REACT_LEGACY_HIDDEN_TYPE: {
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      }
+            var parentTag = parentNode.tag;
 
-      // eslint-disable-next-line no-fallthrough
+            if (
+              parentTag === HostComponent ||
+              parentTag === HostText ||
+              parentTag === HostHoistable ||
+              parentTag === HostSingleton
+            ) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
 
-      case REACT_SCOPE_TYPE: {
-        return createFiberFromScope(type, pendingProps, mode, lanes, key);
+            container = container.parentNode;
+          }
+        }
+
+        node = node.return;
       }
+    }
+  }
 
-      // eslint-disable-next-line no-fallthrough
+  batchedUpdates(function () {
+    return dispatchEventsForPlugins(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      ancestorInst,
+      targetContainer
+    );
+  });
+}
 
-      case REACT_CACHE_TYPE: {
-        return createFiberFromCache(pendingProps, mode, lanes, key);
-      }
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
+
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  var captureName = reactName !== null ? reactName + "Capture" : null;
+  var reactEventName = inCapturePhase ? captureName : reactName;
+  var listeners = [];
+  var instance = targetFiber;
+  var lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    var _instance2 = instance,
+      stateNode = _instance2.stateNode,
+      tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      lastHostComponent = stateNode; // createEventHandle listeners
 
-      // eslint-disable-next-line no-fallthrough
+      {
+        var eventHandlerListeners = getEventHandlerListeners(lastHostComponent);
 
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing) {
-          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
+        if (eventHandlerListeners !== null) {
+          eventHandlerListeners.forEach(function (entry) {
+            if (
+              entry.type === nativeEventType &&
+              entry.capture === inCapturePhase
+            ) {
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+            }
+          });
         }
+      } // Standard React on* listeners, i.e. onClick or onClickCapture
 
-      // eslint-disable-next-line no-fallthrough
+      if (reactEventName !== null) {
+        var listener = getListener(instance, reactEventName);
 
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = Mode;
-          mode |= DebugTracingMode;
-          break;
+        if (listener != null) {
+          listeners.push(
+            createDispatchListener(instance, listener, lastHostComponent)
+          );
         }
+      }
+    } else if (
+      tag === ScopeComponent &&
+      lastHostComponent !== null &&
+      stateNode !== null
+    ) {
+      // Scopes
+      var reactScopeInstance = stateNode;
 
-      // eslint-disable-next-line no-fallthrough
+      var _eventHandlerListeners = getEventHandlerListeners(reactScopeInstance);
 
-      default: {
-        if (typeof type === "object" && type !== null) {
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = ContextProvider;
-              break getTag;
+      if (_eventHandlerListeners !== null) {
+        _eventHandlerListeners.forEach(function (entry) {
+          if (
+            entry.type === nativeEventType &&
+            entry.capture === inCapturePhase
+          ) {
+            listeners.push(
+              createDispatchListener(
+                instance,
+                entry.callback,
+                lastHostComponent
+              )
+            );
+          }
+        });
+      }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
 
-            case REACT_CONTEXT_TYPE:
-              // This is a consumer
-              fiberTag = ContextConsumer;
-              break getTag;
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+    // into consideration that part of the React tree might have been hidden
+    // or deleted (as we're invoking this event during commit). We can find
+    // this out by checking if intercept fiber set on the event matches the
+    // current instance fiber. In which case, we should clear all existing
+    // listeners.
 
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = ForwardRef;
+    if (nativeEvent.type === "beforeblur") {
+      // $FlowFixMe[prop-missing] internal field
+      var detachedInterceptFiber = nativeEvent._detachedInterceptFiber;
 
-              {
-                resolvedType = resolveForwardRefForHotReloading(resolvedType);
-              }
+      if (
+        detachedInterceptFiber !== null &&
+        (detachedInterceptFiber === instance ||
+          detachedInterceptFiber === instance.alternate)
+      ) {
+        listeners = [];
+      }
+    }
 
-              break getTag;
+    instance = instance.return;
+  }
 
-            case REACT_MEMO_TYPE:
-              fiberTag = MemoComponent;
-              break getTag;
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
 
-            case REACT_LAZY_TYPE:
-              fiberTag = LazyComponent;
-              resolvedType = null;
-              break getTag;
-          }
-        }
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  var captureName = reactName + "Capture";
+  var listeners = [];
+  var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
 
-        var info = "";
+  while (instance !== null) {
+    var _instance3 = instance,
+      stateNode = _instance3.stateNode,
+      tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e. <div>)
 
-        {
-          if (
-            type === undefined ||
-            (typeof type === "object" &&
-              type !== null &&
-              Object.keys(type).length === 0)
-          ) {
-            info +=
-              " You likely forgot to export your component from the file " +
-              "it's defined in, or you might have mixed up default and " +
-              "named imports.";
-          }
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      var currentTarget = stateNode;
+      var captureListener = getListener(instance, captureName);
 
-          var ownerName = owner ? getComponentNameFromFiber(owner) : null;
+      if (captureListener != null) {
+        listeners.unshift(
+          createDispatchListener(instance, captureListener, currentTarget)
+        );
+      }
 
-          if (ownerName) {
-            info += "\n\nCheck the render method of `" + ownerName + "`.";
-          }
-        }
+      var bubbleListener = getListener(instance, reactName);
 
-        throw new Error(
-          "Element type is invalid: expected a string (for built-in " +
-            "components) or a class/function (for composite components) " +
-            ("but got: " + (type == null ? type : typeof type) + "." + info)
+      if (bubbleListener != null) {
+        listeners.push(
+          createDispatchListener(instance, bubbleListener, currentTarget)
         );
       }
     }
-  }
-
-  var fiber = createFiber(fiberTag, pendingProps, key, mode);
-  fiber.elementType = type;
-  fiber.type = resolvedType;
-  fiber.lanes = lanes;
 
-  {
-    fiber._debugOwner = owner;
+    instance = instance.return;
   }
 
-  return fiber;
+  return listeners;
 }
-function createFiberFromElement(element, mode, lanes) {
-  var owner = null;
 
-  {
-    owner = element._owner;
+function getParent(inst) {
+  if (inst === null) {
+    return null;
   }
 
-  var type = element.type;
-  var key = element.key;
-  var pendingProps = element.props;
-  var fiber = createFiberFromTypeAndProps(
-    type,
-    key,
-    pendingProps,
-    owner,
-    mode,
-    lanes
-  );
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && inst.tag !== HostSingleton);
 
-  {
-    fiber._debugSource = element._source;
-    fiber._debugOwner = element._owner;
+  if (inst) {
+    return inst;
   }
 
-  return fiber;
-}
-function createFiberFromFragment(elements, mode, lanes, key) {
-  var fiber = createFiber(Fragment, elements, key, mode);
-  fiber.lanes = lanes;
-  return fiber;
+  return null;
 }
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
 
-function createFiberFromScope(scope, pendingProps, mode, lanes, key) {
-  var fiber = createFiber(ScopeComponent, pendingProps, key, mode);
-  fiber.type = scope;
-  fiber.elementType = scope;
-  fiber.lanes = lanes;
-  return fiber;
-}
+function getLowestCommonAncestor(instA, instB) {
+  var nodeA = instA;
+  var nodeB = instB;
+  var depthA = 0;
 
-function createFiberFromProfiler(pendingProps, mode, lanes, key) {
-  {
-    if (typeof pendingProps.id !== "string") {
-      error(
-        'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
-        typeof pendingProps.id
-      );
-    }
+  for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
   }
 
-  var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
-  fiber.elementType = REACT_PROFILER_TYPE;
-  fiber.lanes = lanes;
-
-  {
-    fiber.stateNode = {
-      effectDuration: 0,
-      passiveEffectDuration: 0
-    };
-  }
+  var depthB = 0;
 
-  return fiber;
-}
+  for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
 
-function createFiberFromSuspense(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_SUSPENSE_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_OFFSCREEN_TYPE;
-  fiber.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: OffscreenVisible,
-    _pendingVisibility: OffscreenVisible,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
-    }
-  };
-  fiber.stateNode = primaryChildInstance;
-  return fiber;
-}
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(LegacyHiddenComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  fiber.lanes = lanes; // Adding a stateNode for legacy hidden because it's currently using
-  // the offscreen implementation, which depends on a state node
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
 
-  var instance = {
-    _visibility: OffscreenVisible,
-    _pendingVisibility: OffscreenVisible,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
-    }
-  };
-  fiber.stateNode = instance;
-  return fiber;
-}
-function createFiberFromCache(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(CacheComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_CACHE_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromTracingMarker(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(TracingMarkerComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_TRACING_MARKER_TYPE;
-  fiber.lanes = lanes;
-  var tracingMarkerInstance = {
-    tag: TransitionTracingMarker,
-    transitions: null,
-    pendingBoundaries: null,
-    aborts: null,
-    name: pendingProps.name
-  };
-  fiber.stateNode = tracingMarkerInstance;
-  return fiber;
-}
-function createFiberFromText(content, mode, lanes) {
-  var fiber = createFiber(HostText, content, null, mode);
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromHostInstanceForDeletion() {
-  var fiber = createFiber(HostComponent, null, null, NoMode);
-  fiber.elementType = "DELETED";
-  return fiber;
-}
-function createFiberFromDehydratedFragment(dehydratedNode) {
-  var fiber = createFiber(DehydratedFragment, null, null, NoMode);
-  fiber.stateNode = dehydratedNode;
-  return fiber;
-}
-function createFiberFromPortal(portal, mode, lanes) {
-  var pendingProps = portal.children !== null ? portal.children : [];
-  var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
-  fiber.lanes = lanes;
-  fiber.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    // Used by persistent updates
-    implementation: portal.implementation
-  };
-  return fiber;
-} // Used for stashing WIP properties to replay failed work in DEV.
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
 
-function assignFiberPropertiesInDEV(target, source) {
-  if (target === null) {
-    // This Fiber's initial properties will always be overwritten.
-    // We only use a Fiber to ensure the same hidden class so DEV isn't slow.
-    target = createFiber(IndeterminateComponent, null, null, NoMode);
-  } // This is intentionally written as a list of all properties.
-  // We tried to use Object.assign() instead but this is called in
-  // the hottest path, and Object.assign() was too slow:
-  // https://github.com/facebook/react/issues/12502
-  // This code is DEV-only so size is not a concern.
+  var depth = depthA;
 
-  target.tag = source.tag;
-  target.key = source.key;
-  target.elementType = source.elementType;
-  target.type = source.type;
-  target.stateNode = source.stateNode;
-  target.return = source.return;
-  target.child = source.child;
-  target.sibling = source.sibling;
-  target.index = source.index;
-  target.ref = source.ref;
-  target.refCleanup = source.refCleanup;
-  target.pendingProps = source.pendingProps;
-  target.memoizedProps = source.memoizedProps;
-  target.updateQueue = source.updateQueue;
-  target.memoizedState = source.memoizedState;
-  target.dependencies = source.dependencies;
-  target.mode = source.mode;
-  target.flags = source.flags;
-  target.subtreeFlags = source.subtreeFlags;
-  target.deletions = source.deletions;
-  target.lanes = source.lanes;
-  target.childLanes = source.childLanes;
-  target.alternate = source.alternate;
+  while (depth--) {
+    if (nodeA === nodeB || (nodeB !== null && nodeA === nodeB.alternate)) {
+      return nodeA;
+    }
 
-  {
-    target.actualDuration = source.actualDuration;
-    target.actualStartTime = source.actualStartTime;
-    target.selfBaseDuration = source.selfBaseDuration;
-    target.treeBaseDuration = source.treeBaseDuration;
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
   }
 
-  target._debugSource = source._debugSource;
-  target._debugOwner = source._debugOwner;
-  target._debugNeedsRemount = source._debugNeedsRemount;
-  target._debugHookTypes = source._debugHookTypes;
-  return target;
+  return null;
 }
 
-function FiberRootNode(
-  containerInfo, // $FlowFixMe[missing-local-annot]
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
 ) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.pendingChildren = null;
-  this.current = null;
-  this.pingCache = null;
-  this.finishedWork = null;
-  this.timeoutHandle = noTimeout;
-  this.context = null;
-  this.pendingContext = null;
-  this.callbackNode = null;
-  this.callbackPriority = NoLane;
-  this.eventTimes = createLaneMap(NoLanes);
-  this.expirationTimes = createLaneMap(NoTimestamp);
-  this.pendingLanes = NoLanes;
-  this.suspendedLanes = NoLanes;
-  this.pingedLanes = NoLanes;
-  this.expiredLanes = NoLanes;
-  this.mutableReadLanes = NoLanes;
-  this.finishedLanes = NoLanes;
-  this.errorRecoveryDisabledLanes = NoLanes;
-  this.entangledLanes = NoLanes;
-  this.entanglements = createLaneMap(NoLanes);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
+  var registrationName = event._reactName;
+  var listeners = [];
+  var instance = target;
 
-  {
-    this.pooledCache = null;
-    this.pooledCacheLanes = NoLanes;
-  }
+  while (instance !== null) {
+    if (instance === common) {
+      break;
+    }
 
-  {
-    this.mutableSourceEagerHydrationData = null;
-  }
+    var _instance4 = instance,
+      alternate = _instance4.alternate,
+      stateNode = _instance4.stateNode,
+      tag = _instance4.tag;
 
-  {
-    this.hydrationCallbacks = null;
-  }
+    if (alternate !== null && alternate === common) {
+      break;
+    }
 
-  this.incompleteTransitions = new Map();
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      var currentTarget = stateNode;
 
-  if (enableTransitionTracing) {
-    this.transitionCallbacks = null;
-    var transitionLanesMap = (this.transitionLanes = []);
+      if (inCapturePhase) {
+        var captureListener = getListener(instance, registrationName);
 
-    for (var i = 0; i < TotalLanes; i++) {
-      transitionLanesMap.push(null);
+        if (captureListener != null) {
+          listeners.unshift(
+            createDispatchListener(instance, captureListener, currentTarget)
+          );
+        }
+      } else if (!inCapturePhase) {
+        var bubbleListener = getListener(instance, registrationName);
+
+        if (bubbleListener != null) {
+          listeners.push(
+            createDispatchListener(instance, bubbleListener, currentTarget)
+          );
+        }
+      }
     }
+
+    instance = instance.return;
   }
 
-  {
-    this.effectDuration = 0;
-    this.passiveEffectDuration = 0;
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
   }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
 
-  {
-    this.memoizedUpdaters = new Set();
-    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
+function accumulateEnterLeaveTwoPhaseListeners(
+  dispatchQueue,
+  leaveEvent,
+  enterEvent,
+  from,
+  to
+) {
+  var common = from && to ? getLowestCommonAncestor(from, to) : null;
 
-    for (var _i = 0; _i < TotalLanes; _i++) {
-      pendingUpdatersLaneMap.push(new Set());
-    }
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(
+      dispatchQueue,
+      leaveEvent,
+      from,
+      common,
+      false
+    );
   }
 
-  {
-    switch (tag) {
-      case ConcurrentRoot:
-        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
-        break;
-
-      case LegacyRoot:
-        this._debugRootType = hydrate ? "hydrate()" : "render()";
-        break;
-    }
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(
+      dispatchQueue,
+      enterEvent,
+      to,
+      common,
+      true
+    );
   }
 }
-
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
-  // host config, but because they are passed in at runtime, we have to thread
-  // them through the root constructor. Perhaps we should put them all into a
-  // single type, like a DynamicHostConfig that is defined by the renderer.
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
 ) {
-  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
-  var root = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
-  );
+  var listeners = [];
+  var eventListeners = getEventHandlerListeners(currentTarget);
 
-  {
-    root.hydrationCallbacks = hydrationCallbacks;
+  if (eventListeners !== null) {
+    eventListeners.forEach(function (entry) {
+      if (entry.type === reactEventType && entry.capture === inCapturePhase) {
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
+        );
+      }
+    });
   }
 
-  if (enableTransitionTracing) {
-    root.transitionCallbacks = transitionCallbacks;
-  } // Cyclic construction. This cheats the type system right now because
-  // stateNode is any.
-
-  var uninitializedFiber = createHostRootFiber(
-    tag,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride
-  );
-  root.current = uninitializedFiber;
-  uninitializedFiber.stateNode = root;
+  return listeners;
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? "capture" : "bubble");
+}
 
-  {
-    var initialCache = createCache();
-    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
-    // for newly mounted boundaries during a render. In general, the
-    // pooledCache is always cleared from the root at the end of a render:
-    // it is either released when render commits, or moved to an Offscreen
-    // component if rendering suspends. Because the lifetime of the pooled
-    // cache is distinct from the main memoizedState.cache, it must be
-    // retained separately.
+// has this definition built-in.
 
-    root.pooledCache = initialCache;
-    retainCache(initialCache);
-    var initialState = {
-      element: initialChildren,
-      isDehydrated: hydrate,
-      cache: initialCache
-    };
-    uninitializedFiber.memoizedState = initialState;
-  }
+var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
 
-  initializeUpdateQueue(uninitializedFiber);
-  return root;
-}
+var queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.
+// if the last target was dehydrated.
 
-var ReactVersion = "18.3.0-www-classic-ef5e99b7";
+var queuedFocus = null;
+var queuedDrag = null;
+var queuedMouse = null; // For pointer events there can be one latest event per pointerId.
 
-function createPortal$1(
-  children,
-  containerInfo, // TODO: figure out the API for cross-renderer implementation.
-  implementation
-) {
-  var key =
-    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+var queuedPointers = new Map();
+var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
 
-  {
-    checkKeyStringCoercion(key);
-  }
+var queuedExplicitHydrationTargets = [];
+function hasQueuedDiscreteEvents() {
+  return queuedDiscreteEvents.length > 0;
+}
+var discreteReplayableEvents = [
+  "mousedown",
+  "mouseup",
+  "touchcancel",
+  "touchend",
+  "touchstart",
+  "auxclick",
+  "dblclick",
+  "pointercancel",
+  "pointerdown",
+  "pointerup",
+  "dragend",
+  "dragstart",
+  "drop",
+  "compositionend",
+  "compositionstart",
+  "keydown",
+  "keypress",
+  "keyup",
+  "input",
+  "textInput", // Intentionally camelCase
+  "copy",
+  "cut",
+  "paste",
+  "click",
+  "change",
+  "contextmenu",
+  "reset",
+  "submit"
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
 
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
   return {
-    // This tag allow us to uniquely identify this as a React Portal
-    $$typeof: REACT_PORTAL_TYPE,
-    key: key == null ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
   };
 }
 
-// Might add PROFILE later.
-
-var didWarnAboutNestedUpdates;
-var didWarnAboutFindNodeInStrictMode;
-
-{
-  didWarnAboutNestedUpdates = false;
-  didWarnAboutFindNodeInStrictMode = {};
-}
-
-function getContextForSubtree(parentComponent) {
-  if (!parentComponent) {
-    return emptyContextObject;
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    return;
   }
 
-  var fiber = get(parentComponent);
-  var parentContext = findCurrentUnmaskedContext(fiber);
+  var queuedEvent = createQueuedReplayableEvent(
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
+  queuedDiscreteEvents.push(queuedEvent);
 
-  if (fiber.tag === ClassComponent) {
-    var Component = fiber.type;
+  if (queuedDiscreteEvents.length === 1) {
+    // If this was the first discrete event, we might be able to
+    // synchronously unblock it so that preventDefault still works.
+    while (queuedEvent.blockedOn !== null) {
+      var fiber = getInstanceFromNode(queuedEvent.blockedOn);
 
-    if (isContextProvider(Component)) {
-      return processChildContext(fiber, Component, parentContext);
-    }
-  }
+      if (fiber === null) {
+        break;
+      }
 
-  return parentContext;
-}
+      attemptSynchronousHydration(fiber);
 
-function findHostInstanceWithWarning(component, methodName) {
-  {
-    var fiber = get(component);
+      if (queuedEvent.blockedOn === null) {
+        // We got unblocked by hydration. Let's try again.
+        replayUnblockedEvents(); // If we're reblocked, on an inner boundary, we might need
+        // to attempt hydrating that one.
 
-    if (fiber === undefined) {
-      if (typeof component.render === "function") {
-        throw new Error("Unable to find node on an unmounted component.");
+        continue;
       } else {
-        var keys = Object.keys(component).join(",");
-        throw new Error(
-          "Argument appears to not be a ReactComponent. Keys: " + keys
-        );
+        // We're still blocked from hydration, we have to give up
+        // and replay later.
+        break;
       }
     }
+  }
+} // Resets the replaying for this type of continuous event to no event.
 
-    var hostFiber = findCurrentHostFiber(fiber);
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
 
-    if (hostFiber === null) {
-      return null;
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
+
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
+
+    case "pointerover":
+    case "pointerout": {
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.delete(pointerId);
+      break;
     }
 
-    if (hostFiber.mode & StrictLegacyMode) {
-      var componentName = getComponentNameFromFiber(fiber) || "Component";
+    case "gotpointercapture":
+    case "lostpointercapture": {
+      var _pointerId = nativeEvent.pointerId;
+      queuedPointerCaptures.delete(_pointerId);
+      break;
+    }
+  }
+}
 
-      if (!didWarnAboutFindNodeInStrictMode[componentName]) {
-        didWarnAboutFindNodeInStrictMode[componentName] = true;
-        var previousFiber = current;
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    existingQueuedEvent === null ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
+  ) {
+    var queuedEvent = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
 
-        try {
-          setCurrentFiber(hostFiber);
+    if (blockedOn !== null) {
+      var fiber = getInstanceFromNode(blockedOn);
 
-          if (fiber.mode & StrictLegacyMode) {
-            error(
-              "%s is deprecated in StrictMode. " +
-                "%s was passed an instance of %s which is inside StrictMode. " +
-                "Instead, add a ref directly to the element you want to reference. " +
-                "Learn more about using refs safely here: " +
-                "https://reactjs.org/link/strict-mode-find-node",
-              methodName,
-              methodName,
-              componentName
-            );
-          } else {
-            error(
-              "%s is deprecated in StrictMode. " +
-                "%s was passed an instance of %s which renders StrictMode children. " +
-                "Instead, add a ref directly to the element you want to reference. " +
-                "Learn more about using refs safely here: " +
-                "https://reactjs.org/link/strict-mode-find-node",
-              methodName,
-              methodName,
-              componentName
-            );
-          }
-        } finally {
-          // Ideally this should reset to previous but this shouldn't be called in
-          // render and there's another warning for that anyway.
-          if (previousFiber) {
-            setCurrentFiber(previousFiber);
-          } else {
-            resetCurrentFiber();
-          }
-        }
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
       }
     }
 
-    return getPublicInstance(hostFiber.stateNode);
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
+
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  var targetContainers = existingQueuedEvent.targetContainers;
+
+  if (
+    targetContainer !== null &&
+    targetContainers.indexOf(targetContainer) === -1
+  ) {
+    targetContainers.push(targetContainer);
   }
-}
 
-function createContainer(
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
-) {
-  var hydrate = false;
-  var initialChildren = null;
-  return createFiberRoot(
-    containerInfo,
-    tag,
-    hydrate,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
-  );
+  return existingQueuedEvent;
 }
-function createHydrationContainer(
-  initialChildren, // TODO: Remove `callback` when we delete legacy mode.
-  callback,
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
 ) {
-  var hydrate = true;
-  var root = createFiberRoot(
-    containerInfo,
-    tag,
-    hydrate,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
-  ); // TODO: Move this to FiberRoot constructor
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case "focusin": {
+      var focusEvent = nativeEvent;
+      queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedFocus,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        focusEvent
+      );
+      return true;
+    }
+
+    case "dragenter": {
+      var dragEvent = nativeEvent;
+      queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedDrag,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        dragEvent
+      );
+      return true;
+    }
+
+    case "mouseover": {
+      var mouseEvent = nativeEvent;
+      queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedMouse,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        mouseEvent
+      );
+      return true;
+    }
+
+    case "pointerover": {
+      var pointerEvent = nativeEvent;
+      var pointerId = pointerEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          pointerEvent
+        )
+      );
+      return true;
+    }
+
+    case "gotpointercapture": {
+      var _pointerEvent = nativeEvent;
+      var _pointerId2 = _pointerEvent.pointerId;
+      queuedPointerCaptures.set(
+        _pointerId2,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointerCaptures.get(_pointerId2) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          _pointerEvent
+        )
+      );
+      return true;
+    }
+  }
 
-  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
-  // a regular update because the initial render must match was was rendered
-  // on the server.
-  // NOTE: This update intentionally doesn't have a payload. We're only using
-  // the update to schedule work on the root fiber (and, for legacy roots, to
-  // enqueue the callback if one is provided).
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
 
-  var current = root.current;
-  var lane = requestUpdateLane(current);
-  var update = createUpdate(lane);
-  update.callback =
-    callback !== undefined && callback !== null ? callback : null;
-  var eventTime = requestEventTime();
-  enqueueUpdate(current, update, lane);
-  scheduleInitialHydrationOnRoot(root, lane, eventTime);
-  return root;
-}
-function updateContainer(element, container, parentComponent, callback) {
-  {
-    onScheduleRoot(container, element);
-  }
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
 
-  var current$1 = container.current;
-  var lane = requestUpdateLane(current$1);
+  if (targetInst !== null) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
 
-  if (enableSchedulingProfiler) {
-    markRenderScheduled(lane);
-  }
+    if (nearestMounted !== null) {
+      var tag = nearestMounted.tag;
 
-  var context = getContextForSubtree(parentComponent);
+      if (tag === SuspenseComponent) {
+        var instance = getSuspenseInstanceFromFiber(nearestMounted);
 
-  if (container.context === null) {
-    container.context = context;
-  } else {
-    container.pendingContext = context;
-  }
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, function () {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
+        }
+      } else if (tag === HostRoot) {
+        var root = nearestMounted.stateNode;
 
-  {
-    if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
-      didWarnAboutNestedUpdates = true;
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
 
-      error(
-        "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.",
-        getComponentNameFromFiber(current) || "Unknown"
-      );
+          return;
+        }
+      }
     }
   }
 
-  var update = createUpdate(lane); // Caution: React DevTools currently depends on this property
-  // being called "element".
+  queuedTarget.blockedOn = null;
+}
 
-  update.payload = {
-    element: element
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  var updatePriority = getCurrentUpdatePriority();
+  var queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
   };
-  callback = callback === undefined ? null : callback;
+  var i = 0;
 
-  if (callback !== null) {
-    {
-      if (typeof callback !== "function") {
-        error(
-          "render(...): Expected the last optional `callback` argument to be a " +
-            "function. Instead received: %s.",
-          callback
-        );
-      }
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (
+      !isHigherEventPriority(
+        updatePriority,
+        queuedExplicitHydrationTargets[i].priority
+      )
+    ) {
+      break;
     }
-
-    update.callback = callback;
   }
 
-  var root = enqueueUpdate(current$1, update, lane);
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
 
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, current$1, lane, eventTime);
-    entangleTransitions(root, current$1, lane);
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
   }
-
-  return lane;
 }
-function getPublicRootInstance(container) {
-  var containerFiber = container.current;
 
-  if (!containerFiber.child) {
-    return null;
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
   }
 
-  switch (containerFiber.child.tag) {
-    case HostSingleton:
-    case HostComponent:
-      return getPublicInstance(containerFiber.child.stateNode);
+  var targetContainers = queuedEvent.targetContainers;
 
-    default:
-      return containerFiber.child.stateNode;
+  while (targetContainers.length > 0) {
+    var targetContainer = targetContainers[0];
+    var nextBlockedOn = findInstanceBlockingEvent(
+      queuedEvent.domEventName,
+      queuedEvent.eventSystemFlags,
+      targetContainer,
+      queuedEvent.nativeEvent
+    );
+
+    if (nextBlockedOn === null) {
+      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+        var nativeEvent = queuedEvent.nativeEvent;
+        var nativeEventClone = new nativeEvent.constructor(
+          nativeEvent.type,
+          nativeEvent
+        );
+        setReplayingEvent(nativeEventClone);
+        nativeEvent.target.dispatchEvent(nativeEventClone);
+        resetReplayingEvent();
+      } else {
+        setReplayingEvent(queuedEvent.nativeEvent);
+        dispatchEventForPluginEventSystem(
+          queuedEvent.domEventName,
+          queuedEvent.eventSystemFlags,
+          queuedEvent.nativeEvent,
+          return_targetInst,
+          targetContainer
+        );
+        resetReplayingEvent();
+      }
+    } else {
+      // We're still blocked. Try again later.
+      var fiber = getInstanceFromNode(nextBlockedOn);
+
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
+
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
+
+    targetContainers.shift();
   }
+
+  return true;
 }
-function attemptSynchronousHydration(fiber) {
-  switch (fiber.tag) {
-    case HostRoot: {
-      var root = fiber.stateNode;
 
-      if (isRootDehydrated(root)) {
-        // Flush the first scheduled "update".
-        var lanes = getHighestPriorityPendingLanes(root);
-        flushRoot(root, lanes);
-      }
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
+  }
+}
 
-      break;
-    }
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false;
 
-    case SuspenseComponent: {
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    // First replay discrete events.
+    while (queuedDiscreteEvents.length > 0) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
 
-        if (root !== null) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);
+      if (nextDiscreteEvent.blockedOn !== null) {
+        // We're still blocked.
+        // Increase the priority of this boundary to unblock
+        // the next discrete event.
+        var fiber = getInstanceFromNode(nextDiscreteEvent.blockedOn);
+
+        if (fiber !== null) {
+          attemptDiscreteHydration(fiber);
         }
-      }); // If we're still blocked after this, we need to increase
-      // the priority of any promises resolving within this
-      // boundary so that they next attempt also has higher pri.
 
-      var retryLane = SyncLane;
-      markRetryLaneIfNotHydrated(fiber, retryLane);
-      break;
+        break;
+      }
+
+      var targetContainers = nextDiscreteEvent.targetContainers;
+
+      while (targetContainers.length > 0) {
+        var targetContainer = targetContainers[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          targetContainer,
+          nextDiscreteEvent.nativeEvent
+        );
+
+        if (nextBlockedOn === null) {
+          // This whole function is in !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
+          // so we don't need the new replay behavior code branch.
+          setReplayingEvent(nextDiscreteEvent.nativeEvent);
+          dispatchEventForPluginEventSystem(
+            nextDiscreteEvent.domEventName,
+            nextDiscreteEvent.eventSystemFlags,
+            nextDiscreteEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          );
+          resetReplayingEvent();
+        } else {
+          // We're still blocked. Try again later.
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
+          break;
+        } // This target container was successfully dispatched. Try the next.
+
+        targetContainers.shift();
+      }
+
+      if (nextDiscreteEvent.blockedOn === null) {
+        // We've successfully replayed the first event. Let's try the next one.
+        queuedDiscreteEvents.shift();
+      }
     }
+  } // Next replay any continuous events.
+
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
   }
-}
 
-function markRetryLaneImpl(fiber, retryLane) {
-  var suspenseState = fiber.memoizedState;
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
+  }
 
-  if (suspenseState !== null && suspenseState.dehydrated !== null) {
-    suspenseState.retryLane = higherPriorityLane(
-      suspenseState.retryLane,
-      retryLane
-    );
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
   }
-} // Increases the priority of thenables when they resolve within this boundary.
 
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  var alternate = fiber.alternate;
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
 
-  if (alternate) {
-    markRetryLaneImpl(alternate, retryLane);
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
+
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
+
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      );
+    }
   }
 }
 
-function attemptDiscreteHydration(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority and they should not suspend on I/O,
-    // since you have to wrap anything that might suspend in
-    // Suspense.
-    return;
-  }
+function retryIfBlockedOn(unblocked) {
+  // Mark anything that was blocked on this as no longer blocked
+  // and eligible for a replay.
+  if (queuedDiscreteEvents.length > 0) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
+    // worth it because we expect very few discrete events to queue up and once
+    // we are actually fully unblocked it will be fast to replay them.
 
-  var lane = SyncLane;
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent = queuedDiscreteEvents[i];
 
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      if (queuedEvent.blockedOn === unblocked) {
+        queuedEvent.blockedOn = null;
+      }
+    }
   }
 
-  markRetryLaneIfNotHydrated(fiber, lane);
-}
-function attemptContinuousHydration(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority and they should not suspend on I/O,
-    // since you have to wrap anything that might suspend in
-    // Suspense.
-    return;
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
   }
 
-  var lane = SelectiveHydrationLane;
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
-
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
   }
 
-  markRetryLaneIfNotHydrated(fiber, lane);
-}
-function attemptHydrationAtCurrentPriority(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority other than synchronously flush it.
-    return;
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
   }
 
-  var lane = requestUpdateLane(fiber);
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
+  var unblock = function (queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  };
 
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-  }
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
 
-  markRetryLaneIfNotHydrated(fiber, lane);
-}
-function findHostInstanceWithNoPortals(fiber) {
-  var hostFiber = findCurrentHostFiberWithNoPortals(fiber);
+  for (var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++) {
+    var queuedTarget = queuedExplicitHydrationTargets[_i];
 
-  if (hostFiber === null) {
-    return null;
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
+    }
   }
 
-  return getPublicInstance(hostFiber.stateNode);
-}
+  while (queuedExplicitHydrationTargets.length > 0) {
+    var nextExplicitTarget = queuedExplicitHydrationTargets[0];
 
-var shouldErrorImpl = function (fiber) {
-  return null;
-};
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
 
-function shouldError(fiber) {
-  return shouldErrorImpl(fiber);
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
+      }
+    }
+  }
 }
 
-var shouldSuspendImpl = function (fiber) {
-  return false;
-};
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
 
-function shouldSuspend(fiber) {
-  return shouldSuspendImpl(fiber);
+var _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
+
+function setEnabled(enabled) {
+  _enabled = !!enabled;
 }
-var overrideHookState = null;
-var overrideHookStateDeletePath = null;
-var overrideHookStateRenamePath = null;
-var overrideProps = null;
-var overridePropsDeletePath = null;
-var overridePropsRenamePath = null;
-var scheduleUpdate = null;
-var setErrorHandler = null;
-var setSuspenseHandler = null;
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
+) {
+  var eventPriority = getEventPriority(domEventName);
+  var listenerWrapper;
 
-{
-  var copyWithDeleteImpl = function (obj, path, index) {
-    var key = path[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
 
-    if (index + 1 === path.length) {
-      if (isArray(updated)) {
-        updated.splice(key, 1);
-      } else {
-        delete updated[key];
-      }
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
 
-      return updated;
-    } // $FlowFixMe number or string is fine here
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
 
-    updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
-    return updated;
-  };
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
+  );
+}
 
-  var copyWithDelete = function (obj, path) {
-    return copyWithDeleteImpl(obj, path, 0);
-  };
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
 
-  var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
-    var oldKey = oldPath[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
 
-    if (index + 1 === oldPath.length) {
-      var newKey = newPath[index]; // $FlowFixMe number or string is fine here
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
 
-      updated[newKey] = updated[oldKey];
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (!_enabled) {
+    return;
+  }
+
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+  } else {
+    dispatchEventOriginal(
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+  }
+}
 
-      if (isArray(updated)) {
-        updated.splice(oldKey, 1);
-      } else {
-        delete updated[oldKey];
-      }
-    } else {
-      // $FlowFixMe number or string is fine here
-      updated[oldKey] = copyWithRenameImpl(
-        // $FlowFixMe number or string is fine here
-        obj[oldKey],
-        oldPath,
-        newPath,
-        index + 1
-      );
-    }
+function dispatchEventOriginal(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // TODO: replaying capture phase events is currently broken
+  // because we used to do it during top-level native bubble handlers
+  // but now we use different bubble and capture handlers.
+  // In eager mode, we attach capture listeners early, so we need
+  // to filter them out until we fix the logic to handle them correctly.
+  var allowReplay = (eventSystemFlags & IS_CAPTURE_PHASE) === 0;
 
-    return updated;
-  };
+  if (
+    allowReplay &&
+    hasQueuedDiscreteEvents() &&
+    isDiscreteEventThatRequiresHydration(domEventName)
+  ) {
+    // If we already have a queue of discrete events, and this is another discrete
+    // event, then we can't dispatch it regardless of its target, since they
+    // need to dispatch in order.
+    queueDiscreteEvent(
+      null, // Flags that we're not actually blocked on anything as far as we know.
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+    return;
+  }
 
-  var copyWithRename = function (obj, oldPath, newPath) {
-    if (oldPath.length !== newPath.length) {
-      warn("copyWithRename() expects paths of the same length");
+  var blockedOn = findInstanceBlockingEvent(
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
 
-      return;
-    } else {
-      for (var i = 0; i < newPath.length - 1; i++) {
-        if (oldPath[i] !== newPath[i]) {
-          warn(
-            "copyWithRename() expects paths to be the same except for the deepest key"
-          );
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      return_targetInst,
+      targetContainer
+    );
 
-          return;
-        }
-      }
+    if (allowReplay) {
+      clearIfContinuousEvent(domEventName, nativeEvent);
     }
 
-    return copyWithRenameImpl(obj, oldPath, newPath, 0);
-  };
+    return;
+  }
 
-  var copyWithSetImpl = function (obj, path, index, value) {
-    if (index >= path.length) {
-      return value;
+  if (allowReplay) {
+    if (isDiscreteEventThatRequiresHydration(domEventName)) {
+      // This to be replayed later once the target is available.
+      queueDiscreteEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
+      return;
     }
 
-    var key = path[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj); // $FlowFixMe number or string is fine here
-
-    updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
-    return updated;
-  };
+    if (
+      queueIfContinuousEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )
+    ) {
+      return;
+    } // We need to clear only if we didn't queue because
+    // queueing is accumulative.
 
-  var copyWithSet = function (obj, path, value) {
-    return copyWithSetImpl(obj, path, 0, value);
-  };
+    clearIfContinuousEvent(domEventName, nativeEvent);
+  } // This is not replayable so we'll invoke it but without a target,
+  // in case the event system needs to trace it.
 
-  var findHook = function (fiber, id) {
-    // For now, the "id" of stateful hooks is just the stateful hook index.
-    // This may change in the future with e.g. nested hooks.
-    var currentHook = fiber.memoizedState;
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
 
-    while (currentHook !== null && id > 0) {
-      currentHook = currentHook.next;
-      id--;
-    }
+function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  var blockedOn = findInstanceBlockingEvent(
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
 
-    return currentHook;
-  }; // Support DevTools editable values for useState and useReducer.
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      return_targetInst,
+      targetContainer
+    );
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
 
-  overrideHookState = function (fiber, id, path, value) {
-    var hook = findHook(fiber, id);
+  if (
+    queueIfContinuousEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )
+  ) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
 
-    if (hook !== null) {
-      var newState = copyWithSet(hook.memoizedState, path, value);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+  clearIfContinuousEvent(domEventName, nativeEvent);
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  if (
+    eventSystemFlags & IS_CAPTURE_PHASE &&
+    isDiscreteEventThatRequiresHydration(domEventName)
+  ) {
+    while (blockedOn !== null) {
+      var fiber = getInstanceFromNode(blockedOn);
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
       }
-    }
-  };
-
-  overrideHookStateDeletePath = function (fiber, id, path) {
-    var hook = findHook(fiber, id);
 
-    if (hook !== null) {
-      var newState = copyWithDelete(hook.memoizedState, path);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+      var nextBlockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        );
+      }
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      if (nextBlockedOn === blockedOn) {
+        break;
       }
+
+      blockedOn = nextBlockedOn;
     }
-  };
 
-  overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
-    var hook = findHook(fiber, id);
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
 
-    if (hook !== null) {
-      var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+    return;
+  } // This is not replayable so we'll invoke it but without a target,
+  // in case the event system needs to trace it.
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-      }
-    }
-  }; // Support DevTools props for function components, forwardRef, memo, host components, etc.
+var return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
 
-  overrideProps = function (fiber, path, value) {
-    fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  var nativeEventTarget = getEventTarget(nativeEvent);
+  var targetInst = getClosestInstanceFromNode(nativeEventTarget);
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
-    }
+  if (targetInst !== null) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      var tag = nearestMounted.tag;
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-    }
-  };
+      if (tag === SuspenseComponent) {
+        var instance = getSuspenseInstanceFromFiber(nearestMounted);
 
-  overridePropsDeletePath = function (fiber, path) {
-    fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
-    }
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        var root = nearestMounted.stateNode;
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
+        }
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
+      }
     }
-  };
+  }
 
-  overridePropsRenamePath = function (fiber, oldPath, newPath) {
-    fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
+  return_targetInst = targetInst; // We're not blocked on anything.
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
-    }
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange": // Used by polyfills:
+    // eslint-disable-next-line no-fallthrough
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate": // Only enableCreateEventHandleAPI:
+    // eslint-disable-next-line no-fallthrough
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-    }
-  };
+    case "beforeblur":
+    case "afterblur": // Not used by React but could be by user code:
+    // eslint-disable-next-line no-fallthrough
 
-  scheduleUpdate = function (fiber) {
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return DiscreteEventPriority;
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-    }
-  };
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel": // Not used by React but could be by user code:
+    // eslint-disable-next-line no-fallthrough
 
-  setErrorHandler = function (newShouldErrorImpl) {
-    shouldErrorImpl = newShouldErrorImpl;
-  };
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return ContinuousEventPriority;
 
-  setSuspenseHandler = function (newShouldSuspendImpl) {
-    shouldSuspendImpl = newShouldSuspendImpl;
-  };
-}
+    case "message": {
+      // We might be in the Scheduler callback.
+      // Eventually this mechanism will be replaced by a check
+      // of the current priority on the native scheduler.
+      var schedulerPriority = getCurrentPriorityLevel();
 
-function findHostInstanceByFiber(fiber) {
-  var hostFiber = findCurrentHostFiber(fiber);
+      switch (schedulerPriority) {
+        case ImmediatePriority:
+          return DiscreteEventPriority;
 
-  if (hostFiber === null) {
-    return null;
-  }
+        case UserBlockingPriority:
+          return ContinuousEventPriority;
 
-  return hostFiber.stateNode;
-}
+        case NormalPriority$1:
+        case LowPriority:
+          // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+          return DefaultEventPriority;
 
-function emptyFindFiberByHostInstance(instance) {
-  return null;
-}
+        case IdlePriority:
+          return IdleEventPriority;
 
-function getCurrentFiberForDevTools() {
-  return current;
-}
+        default:
+          return DefaultEventPriority;
+      }
+    }
 
-function injectIntoDevTools(devToolsConfig) {
-  var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
-  var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
-  return injectInternals({
-    bundleType: devToolsConfig.bundleType,
-    version: devToolsConfig.version,
-    rendererPackageName: devToolsConfig.rendererPackageName,
-    rendererConfig: devToolsConfig.rendererConfig,
-    overrideHookState: overrideHookState,
-    overrideHookStateDeletePath: overrideHookStateDeletePath,
-    overrideHookStateRenamePath: overrideHookStateRenamePath,
-    overrideProps: overrideProps,
-    overridePropsDeletePath: overridePropsDeletePath,
-    overridePropsRenamePath: overridePropsRenamePath,
-    setErrorHandler: setErrorHandler,
-    setSuspenseHandler: setSuspenseHandler,
-    scheduleUpdate: scheduleUpdate,
-    currentDispatcherRef: ReactCurrentDispatcher,
-    findHostInstanceByFiber: findHostInstanceByFiber,
-    findFiberByHostInstance:
-      findFiberByHostInstance || emptyFindFiberByHostInstance,
-    // React Refresh
-    findHostInstancesForRefresh: findHostInstancesForRefresh,
-    scheduleRefresh: scheduleRefresh,
-    scheduleRoot: scheduleRoot,
-    setRefreshHandler: setRefreshHandler,
-    // Enables DevTools to append owner stacks to error messages in DEV mode.
-    getCurrentFiber: getCurrentFiberForDevTools,
-    // Enables DevTools to detect reconciler version rather than renderer version
-    // which may not match for third party renderers.
-    reconcilerVersion: ReactVersion
-  });
+    default:
+      return DefaultEventPriority;
+  }
 }
 
 var Dispatcher = Internals.Dispatcher;
@@ -44116,13 +44059,6 @@ function preinit() {
   // so we favor silent bailout over warning or erroring.
 }
 
-setAttemptSynchronousHydration(attemptSynchronousHydration);
-setAttemptDiscreteHydration(attemptDiscreteHydration);
-setAttemptContinuousHydration(attemptContinuousHydration);
-setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority);
-setGetCurrentUpdatePriority(getCurrentUpdatePriority$1);
-setAttemptHydrationAtPriority(runWithPriority);
-
 {
   if (
     typeof Map !== "function" || // $FlowFixMe Flow incorrectly thinks Map has no prototype
@@ -44140,9 +44076,6 @@ setAttemptHydrationAtPriority(runWithPriority);
   }
 }
 
-setRestoreImplementation(restoreControlledState);
-setBatchingImplementation(batchedUpdates, discreteUpdates, flushSync$1);
-
 function createPortal(children, container) {
   var key =
     arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
@@ -44219,7 +44152,7 @@ Internals.Events = [
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
 var foundDevTools = injectIntoDevTools({
   findFiberByHostInstance: getClosestInstanceFromNode,
@@ -44274,7 +44207,7 @@ exports.preinit = preinit;
 exports.preload = preload;
 exports.render = render;
 exports.unmountComponentAtNode = unmountComponentAtNode;
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = createEventHandle;
 exports.unstable_flushControlled = flushControlled;
 exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
diff --git a/compiled/facebook-www/ReactDOM-dev.modern.js b/compiled/facebook-www/ReactDOM-dev.modern.js
index de04fbe9d85b6..8d577f09ce6f5 100644
--- a/compiled/facebook-www/ReactDOM-dev.modern.js
+++ b/compiled/facebook-www/ReactDOM-dev.modern.js
@@ -141,6 +141,7 @@ var dynamicFeatureFlags = require("ReactFeatureFlags");
 
 var disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   replayFailedUnitOfWorkWithInvokeGuardedCallback =
@@ -5109,7 +5110,6 @@ function getEventTarget(nativeEvent) {
   return target.nodeType === TEXT_NODE ? target.parentNode : target;
 }
 
-var restoreImpl = null;
 var restoreTarget = null;
 var restoreQueue = null;
 
@@ -5123,24 +5123,18 @@ function restoreStateOfTarget(target) {
     return;
   }
 
-  if (typeof restoreImpl !== "function") {
-    throw new Error(
-      "setRestoreImplementation() needs to be called to handle a target for controlled " +
-        "events. This error is likely caused by a bug in React. Please file an issue."
-    );
-  }
-
   var stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
 
   if (stateNode) {
     var props = getFiberCurrentPropsFromNode(stateNode);
-    restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+    restoreControlledState(
+      internalInstance.stateNode,
+      internalInstance.type,
+      props
+    );
   }
 }
 
-function setRestoreImplementation(impl) {
-  restoreImpl = impl;
-}
 function enqueueStateRestore(target) {
   if (restoreTarget) {
     if (restoreQueue) {
@@ -5173,256 +5167,6 @@ function restoreStateIfNeeded() {
   }
 }
 
-// the renderer. Such as when we're dispatching events or if third party
-// libraries need to call batchedUpdates. Eventually, this API will go away when
-// everything is batched by default. We'll then have a similar API to opt-out of
-// scheduled work and instead do synchronous work.
-// Defaults
-
-var batchedUpdatesImpl = function (fn, bookkeeping) {
-  return fn(bookkeeping);
-};
-
-var flushSyncImpl = function () {};
-
-var isInsideEventHandler = false;
-
-function finishEventHandler() {
-  // Here we wait until all updates have propagated, which is important
-  // when using controlled components within layers:
-  // https://github.com/facebook/react/issues/1698
-  // Then we restore state of any controlled component.
-  var controlledComponentsHavePendingUpdates = needsStateRestore();
-
-  if (controlledComponentsHavePendingUpdates) {
-    // If a controlled event was fired, we may need to restore the state of
-    // the DOM node back to the controlled value. This is necessary when React
-    // bails out of the update without touching the DOM.
-    // TODO: Restore state in the microtask, after the discrete updates flush,
-    // instead of early flushing them here.
-    flushSyncImpl();
-    restoreStateIfNeeded();
-  }
-}
-
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) {
-    // If we are currently inside another batch, we need to wait until it
-    // fully completes before restoring state.
-    return fn(a, b);
-  }
-
-  isInsideEventHandler = true;
-
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    isInsideEventHandler = false;
-    finishEventHandler();
-  }
-} // TODO: Replace with flushSync
-function setBatchingImplementation(
-  _batchedUpdatesImpl,
-  _discreteUpdatesImpl,
-  _flushSyncImpl
-) {
-  batchedUpdatesImpl = _batchedUpdatesImpl;
-  flushSyncImpl = _flushSyncImpl;
-}
-
-function isInteractive(tag) {
-  return (
-    tag === "button" ||
-    tag === "input" ||
-    tag === "select" ||
-    tag === "textarea"
-  );
-}
-
-function shouldPreventMouseEvent(name, type, props) {
-  switch (name) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      return !!(props.disabled && isInteractive(type));
-
-    default:
-      return false;
-  }
-}
-/**
- * @param {object} inst The instance, which is the source of events.
- * @param {string} registrationName Name of listener (e.g. `onClick`).
- * @return {?function} The stored callback.
- */
-
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-
-  if (stateNode === null) {
-    // Work in progress (ex: onload events in incremental mode).
-    return null;
-  }
-
-  var props = getFiberCurrentPropsFromNode(stateNode);
-
-  if (props === null) {
-    // Work in progress.
-    return null;
-  }
-
-  var listener = props[registrationName];
-
-  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
-    return null;
-  }
-
-  if (listener && typeof listener !== "function") {
-    throw new Error(
-      "Expected `" +
-        registrationName +
-        "` listener to be a function, instead got a value of `" +
-        typeof listener +
-        "` type."
-    );
-  }
-
-  return listener;
-}
-
-var passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
-// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
-
-if (canUseDOM) {
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = true;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = false;
-  }
-}
-
-// Provided by www
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-
-if (typeof ReactFbErrorUtils.invokeGuardedCallback !== "function") {
-  throw new Error(
-    "Expected ReactFbErrorUtils.invokeGuardedCallback to be a function."
-  );
-}
-
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  // This will call `this.onError(err)` if an error was caught.
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
-}
-
-var hasError = false;
-var caughtError = null; // Used by event system to capture/rethrow the first error.
-
-var hasRethrowError = false;
-var rethrowError = null;
-var reporter = {
-  onError: function (error) {
-    hasError = true;
-    caughtError = error;
-  }
-};
-/**
- * Call a function while guarding against errors that happens within it.
- * Returns an error if it throws, otherwise null.
- *
- * In production, this is implemented using a try-catch. The reason we don't
- * use a try-catch directly is so that we can swap out a different
- * implementation in DEV mode.
- *
- * @param {String} name of the guard to use for logging or debugging
- * @param {Function} func The function to invoke
- * @param {*} context The context to use when calling the function
- * @param {...*} args Arguments for function
- */
-
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = false;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
-}
-/**
- * Same as invokeGuardedCallback, but instead of returning an error, it stores
- * it in a global so it can be rethrown by `rethrowCaughtError` later.
- * TODO: See if caughtError and rethrowError can be unified.
- *
- * @param {String} name of the guard to use for logging or debugging
- * @param {Function} func The function to invoke
- * @param {*} context The context to use when calling the function
- * @param {...*} args Arguments for function
- */
-
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
-
-  if (hasError) {
-    var error = clearCaughtError();
-
-    if (!hasRethrowError) {
-      hasRethrowError = true;
-      rethrowError = error;
-    }
-  }
-}
-/**
- * During execution of guarded functions we will capture the first error which
- * we will rethrow to be handled by the top level error handler.
- */
-
-function rethrowCaughtError() {
-  if (hasRethrowError) {
-    var error = rethrowError;
-    hasRethrowError = false;
-    rethrowError = null;
-    throw error;
-  }
-}
-function hasCaughtError() {
-  return hasError;
-}
-function clearCaughtError() {
-  if (hasError) {
-    var error = caughtError;
-    hasError = false;
-    caughtError = null;
-    return error;
-  } else {
-    throw new Error(
-      "clearCaughtError was called but no error was captured. This error " +
-        "is likely caused by a bug in React. Please file an issue."
-    );
-  }
-}
-
 /**
  * `ReactInstanceMap` maintains a mapping from a public facing stateful
  * instance (key) and the internal representation (value). This allows public
@@ -5879,477 +5623,206 @@ function doesFiberContain(parentFiber, childFiber) {
   return false;
 }
 
-// This module only exists as an ESM wrapper around the external CommonJS
-var scheduleCallback$2 = Scheduler.unstable_scheduleCallback;
-var cancelCallback$1 = Scheduler.unstable_cancelCallback;
-var shouldYield = Scheduler.unstable_shouldYield;
-var requestPaint = Scheduler.unstable_requestPaint;
-var now$1 = Scheduler.unstable_now;
-var getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
-var ImmediatePriority = Scheduler.unstable_ImmediatePriority;
-var UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
-var NormalPriority$1 = Scheduler.unstable_NormalPriority;
-var LowPriority = Scheduler.unstable_LowPriority;
-var IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
-// on scheduler/unstable_mock, which we'll need for internal testing
-
-var log$2 = Scheduler.log;
-var unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue;
+var loggedTypeFailures = {};
+var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
 
-var rendererID = null;
-var injectedHook = null;
-var injectedProfilingHooks = null;
-var hasLoggedError = false;
-var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
-function injectInternals(internals) {
-  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
-    // No DevTools
-    return false;
+function setCurrentlyValidatingElement(element) {
+  {
+    if (element) {
+      var owner = element._owner;
+      var stack = describeUnknownElementTypeFrameInDEV(
+        element.type,
+        element._source,
+        owner ? owner.type : null
+      );
+      ReactDebugCurrentFrame.setExtraStackFrame(stack);
+    } else {
+      ReactDebugCurrentFrame.setExtraStackFrame(null);
+    }
   }
+}
 
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+function checkPropTypes(typeSpecs, values, location, componentName, element) {
+  {
+    // $FlowFixMe This is okay but Flow doesn't know it.
+    var has = Function.call.bind(hasOwnProperty);
 
-  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;
-  }
+    for (var typeSpecName in typeSpecs) {
+      if (has(typeSpecs, typeSpecName)) {
+        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
 
-  if (!hook.supportsFiber) {
-    {
-      error(
-        "The installed version of React DevTools is too old and will not work " +
-          "with the current version of React. Please update React DevTools. " +
-          "https://reactjs.org/link/react-devtools"
-      );
-    } // DevTools exists, even though it doesn't support Fiber.
+        try {
+          // This is intentionally an invariant that gets caught. It's the same
+          // behavior as without this statement except with a better message.
+          if (typeof typeSpecs[typeSpecName] !== "function") {
+            // eslint-disable-next-line react-internal/prod-error-codes
+            var err = Error(
+              (componentName || "React class") +
+                ": " +
+                location +
+                " type `" +
+                typeSpecName +
+                "` is invalid; " +
+                "it must be a function, usually from the `prop-types` package, but received `" +
+                typeof typeSpecs[typeSpecName] +
+                "`." +
+                "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+            );
+            err.name = "Invariant Violation";
+            throw err;
+          }
 
-    return true;
-  }
+          error$1 = typeSpecs[typeSpecName](
+            values,
+            typeSpecName,
+            componentName,
+            location,
+            null,
+            "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
+          );
+        } catch (ex) {
+          error$1 = ex;
+        }
 
-  try {
-    if (enableSchedulingProfiler) {
-      // Conditionally inject these hooks only if Timeline profiler is supported by this build.
-      // This gives DevTools a way to feature detect that isn't tied to version number
-      // (since profiling and timeline are controlled by different feature flags).
-      internals = assign({}, internals, {
-        getLaneLabelMap: getLaneLabelMap,
-        injectProfilingHooks: injectProfilingHooks
-      });
-    }
+        if (error$1 && !(error$1 instanceof Error)) {
+          setCurrentlyValidatingElement(element);
 
-    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+          error(
+            "%s: type specification of %s" +
+              " `%s` is invalid; the type checker " +
+              "function must return `null` or an `Error` but returned a %s. " +
+              "You may have forgotten to pass an argument to the type checker " +
+              "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
+              "shape all require an argument).",
+            componentName || "React class",
+            location,
+            typeSpecName,
+            typeof error$1
+          );
 
-    injectedHook = hook;
-  } catch (err) {
-    // Catch all errors because it is unsafe to throw during initialization.
-    {
-      error("React instrumentation encountered an error: %s.", err);
-    }
-  }
+          setCurrentlyValidatingElement(null);
+        }
 
-  if (hook.checkDCE) {
-    // This is the real DevTools.
-    return true;
-  } else {
-    // This is likely a hook installed by Fast Refresh runtime.
-    return false;
-  }
-}
-function onScheduleRoot(root, children) {
-  {
-    if (
-      injectedHook &&
-      typeof injectedHook.onScheduleFiberRoot === "function"
-    ) {
-      try {
-        injectedHook.onScheduleFiberRoot(rendererID, root, children);
-      } catch (err) {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
+        if (
+          error$1 instanceof Error &&
+          !(error$1.message in loggedTypeFailures)
+        ) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error$1.message] = true;
+          setCurrentlyValidatingElement(element);
 
-          error("React instrumentation encountered an error: %s", err);
+          error("Failed %s type: %s", location, error$1.message);
+
+          setCurrentlyValidatingElement(null);
         }
       }
     }
   }
 }
-function onCommitRoot$1(root, eventPriority) {
-  if (injectedHook && typeof injectedHook.onCommitFiberRoot === "function") {
-    try {
-      var didError = (root.current.flags & DidCapture) === DidCapture;
-
-      if (enableProfilerTimer) {
-        var schedulerPriority;
 
-        switch (eventPriority) {
-          case DiscreteEventPriority:
-            schedulerPriority = ImmediatePriority;
-            break;
+var valueStack = [];
+var fiberStack;
 
-          case ContinuousEventPriority:
-            schedulerPriority = UserBlockingPriority;
-            break;
+{
+  fiberStack = [];
+}
 
-          case DefaultEventPriority:
-            schedulerPriority = NormalPriority$1;
-            break;
+var index = -1;
 
-          case IdleEventPriority:
-            schedulerPriority = IdlePriority;
-            break;
+function createCursor(defaultValue) {
+  return {
+    current: defaultValue
+  };
+}
 
-          default:
-            schedulerPriority = NormalPriority$1;
-            break;
-        }
+function pop(cursor, fiber) {
+  if (index < 0) {
+    {
+      error("Unexpected pop.");
+    }
 
-        injectedHook.onCommitFiberRoot(
-          rendererID,
-          root,
-          schedulerPriority,
-          didError
-        );
-      }
-    } catch (err) {
-      {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
+    return;
+  }
 
-          error("React instrumentation encountered an error: %s", err);
-        }
-      }
+  {
+    if (fiber !== fiberStack[index]) {
+      error("Unexpected Fiber popped.");
     }
   }
-}
-function onPostCommitRoot(root) {
-  if (
-    injectedHook &&
-    typeof injectedHook.onPostCommitFiberRoot === "function"
-  ) {
-    try {
-      injectedHook.onPostCommitFiberRoot(rendererID, root);
-    } catch (err) {
-      {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
 
-          error("React instrumentation encountered an error: %s", err);
-        }
-      }
-    }
+  cursor.current = valueStack[index];
+  valueStack[index] = null;
+
+  {
+    fiberStack[index] = null;
   }
+
+  index--;
 }
-function onCommitUnmount(fiber) {
-  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === "function") {
-    try {
-      injectedHook.onCommitFiberUnmount(rendererID, fiber);
-    } catch (err) {
-      {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
 
-          error("React instrumentation encountered an error: %s", err);
-        }
-      }
-    }
+function push(cursor, value, fiber) {
+  index++;
+  valueStack[index] = cursor.current;
+
+  {
+    fiberStack[index] = fiber;
   }
-}
-function setIsStrictModeForDevtools(newIsStrictMode) {
-  {
-    if (typeof log$2 === "function") {
-      // We're in a test because Scheduler.log only exists
-      // in SchedulerMock. To reduce the noise in strict mode tests,
-      // suppress warnings and disable scheduler yielding during the double render
-      unstable_setDisableYieldValue(newIsStrictMode);
-      setSuppressWarning(newIsStrictMode);
-    }
-
-    if (injectedHook && typeof injectedHook.setStrictMode === "function") {
-      try {
-        injectedHook.setStrictMode(rendererID, newIsStrictMode);
-      } catch (err) {
-        {
-          if (!hasLoggedError) {
-            hasLoggedError = true;
-
-            error("React instrumentation encountered an error: %s", err);
-          }
-        }
-      }
-    }
-  }
-} // Profiler API hooks
-
-function injectProfilingHooks(profilingHooks) {
-  injectedProfilingHooks = profilingHooks;
+
+  cursor.current = value;
 }
 
-function getLaneLabelMap() {
-  if (enableSchedulingProfiler) {
-    var map = new Map();
-    var lane = 1;
+var emptyContextObject = {};
 
-    for (var index = 0; index < TotalLanes; index++) {
-      var label = getLabelForLane(lane);
-      map.set(lane, label);
-      lane *= 2;
-    }
+{
+  Object.freeze(emptyContextObject);
+} // A cursor to the current merged context object on the stack.
 
-    return map;
-  } else {
-    return null;
+function hasContextChanged() {
+  {
+    return false;
   }
 }
 
-function markCommitStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markCommitStarted === "function"
-    ) {
-      injectedProfilingHooks.markCommitStarted(lanes);
-    }
-  }
-}
-function markCommitStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markCommitStopped === "function"
-    ) {
-      injectedProfilingHooks.markCommitStopped();
-    }
-  }
-}
-function markComponentRenderStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentRenderStarted === "function"
-    ) {
-      injectedProfilingHooks.markComponentRenderStarted(fiber);
-    }
-  }
-}
-function markComponentRenderStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentRenderStopped === "function"
-    ) {
-      injectedProfilingHooks.markComponentRenderStopped();
-    }
-  }
-}
-function markComponentPassiveEffectMountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
-    }
-  }
-}
-function markComponentPassiveEffectMountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
-    }
-  }
-}
-function markComponentPassiveEffectUnmountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
-    }
-  }
-}
-function markComponentPassiveEffectUnmountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
-    }
-  }
-}
-function markComponentLayoutEffectMountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
-    }
-  }
-}
-function markComponentLayoutEffectMountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
-    }
-  }
-}
-function markComponentLayoutEffectUnmountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
-    }
-  }
-}
-function markComponentLayoutEffectUnmountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
-    }
-  }
-}
-function markComponentErrored(fiber, thrownValue, lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentErrored === "function"
-    ) {
-      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
-    }
-  }
-}
-function markComponentSuspended(fiber, wakeable, lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentSuspended === "function"
-    ) {
-      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
-    }
-  }
-}
-function markLayoutEffectsStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markLayoutEffectsStarted === "function"
-    ) {
-      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
-    }
-  }
-}
-function markLayoutEffectsStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markLayoutEffectsStopped === "function"
-    ) {
-      injectedProfilingHooks.markLayoutEffectsStopped();
-    }
-  }
-}
-function markPassiveEffectsStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markPassiveEffectsStarted === "function"
-    ) {
-      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
-    }
-  }
-}
-function markPassiveEffectsStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markPassiveEffectsStopped === "function"
-    ) {
-      injectedProfilingHooks.markPassiveEffectsStopped();
-    }
-  }
-}
-function markRenderStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderStarted === "function"
-    ) {
-      injectedProfilingHooks.markRenderStarted(lanes);
-    }
-  }
-}
-function markRenderYielded() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderYielded === "function"
-    ) {
-      injectedProfilingHooks.markRenderYielded();
-    }
-  }
-}
-function markRenderStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderStopped === "function"
-    ) {
-      injectedProfilingHooks.markRenderStopped();
-    }
+function isContextProvider(type) {
+  {
+    return false;
   }
 }
-function markRenderScheduled(lane) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderScheduled === "function"
-    ) {
-      injectedProfilingHooks.markRenderScheduled(lane);
-    }
+
+function processChildContext(fiber, type, parentContext) {
+  {
+    return parentContext;
   }
 }
-function markForceUpdateScheduled(fiber, lane) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markForceUpdateScheduled === "function"
-    ) {
-      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
-    }
+
+function findCurrentUnmaskedContext(fiber) {
+  {
+    return emptyContextObject;
   }
 }
-function markStateUpdateScheduled(fiber, lane) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markStateUpdateScheduled === "function"
-    ) {
-      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
-    }
-  }
+
+var LegacyRoot = 0;
+var ConcurrentRoot = 1;
+
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+var OffscreenVisible =
+  /*                     */
+  1;
+var OffscreenDetached =
+  /*                    */
+  2;
+var OffscreenPassiveEffectsConnected =
+  /*     */
+  4;
+function isOffscreenManual(offscreenFiber) {
+  return (
+    offscreenFiber.memoizedProps !== null &&
+    offscreenFiber.memoizedProps.mode === "manual"
+  );
 }
 
 var NoMode =
@@ -6380,7 +5853,7 @@ var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback; // Count leading zeros.
 // Based on:
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
 
-var log$1 = Math.log;
+var log$2 = Math.log;
 var LN2 = Math.LN2;
 
 function clz32Fallback(x) {
@@ -6390,7 +5863,7 @@ function clz32Fallback(x) {
     return 32;
   }
 
-  return (31 - ((log$1(asUint) / LN2) | 0)) | 0;
+  return (31 - ((log$2(asUint) / LN2) | 0)) | 0;
 }
 
 // If those values are changed that package should be rebuilt and redeployed.
@@ -7327,7 +6800,7 @@ var ContinuousEventPriority = InputContinuousLane;
 var DefaultEventPriority = DefaultLane;
 var IdleEventPriority = IdleLane;
 var currentUpdatePriority = NoLane;
-function getCurrentUpdatePriority$1() {
+function getCurrentUpdatePriority() {
   return currentUpdatePriority;
 }
 function setCurrentUpdatePriority(newPriority) {
@@ -7370,35426 +6843,35899 @@ function lanesToEventPriority(lanes) {
   return IdleEventPriority;
 }
 
-// This is imported by the event replaying implementation in React DOM. It's
-// in a separate file to break a circular dependency between the renderer and
-// the reconciler.
-function isRootDehydrated(root) {
-  var currentState = root.current.memoizedState;
-  return currentState.isDehydrated;
-}
+// This module only exists as an ESM wrapper around the external CommonJS
+var scheduleCallback$2 = Scheduler.unstable_scheduleCallback;
+var cancelCallback$1 = Scheduler.unstable_cancelCallback;
+var shouldYield = Scheduler.unstable_shouldYield;
+var requestPaint = Scheduler.unstable_requestPaint;
+var now$1 = Scheduler.unstable_now;
+var getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+var ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+var UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+var NormalPriority$1 = Scheduler.unstable_NormalPriority;
+var LowPriority = Scheduler.unstable_LowPriority;
+var IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+// on scheduler/unstable_mock, which we'll need for internal testing
 
-var _attemptSynchronousHydration;
+var log$1 = Scheduler.log;
+var unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue;
 
-function setAttemptSynchronousHydration(fn) {
-  _attemptSynchronousHydration = fn;
-}
-function attemptSynchronousHydration$1(fiber) {
-  _attemptSynchronousHydration(fiber);
-}
-var attemptDiscreteHydration$1;
-function setAttemptDiscreteHydration(fn) {
-  attemptDiscreteHydration$1 = fn;
-}
-var attemptContinuousHydration$1;
-function setAttemptContinuousHydration(fn) {
-  attemptContinuousHydration$1 = fn;
-}
-var attemptHydrationAtCurrentPriority$1;
-function setAttemptHydrationAtCurrentPriority(fn) {
-  attemptHydrationAtCurrentPriority$1 = fn;
-}
-var getCurrentUpdatePriority;
-function setGetCurrentUpdatePriority(fn) {
-  getCurrentUpdatePriority = fn;
-}
-var attemptHydrationAtPriority;
-function setAttemptHydrationAtPriority(fn) {
-  attemptHydrationAtPriority = fn;
-} // TODO: Upgrade this definition once we're on a newer version of Flow that
-// has this definition built-in.
+var rendererID = null;
+var injectedHook = null;
+var injectedProfilingHooks = null;
+var hasLoggedError = false;
+var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+    // No DevTools
+    return false;
+  }
 
-var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
 
-var queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.
-// if the last target was dehydrated.
+  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;
+  }
 
-var queuedFocus = null;
-var queuedDrag = null;
-var queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+  if (!hook.supportsFiber) {
+    {
+      error(
+        "The installed version of React DevTools is too old and will not work " +
+          "with the current version of React. Please update React DevTools. " +
+          "https://reactjs.org/link/react-devtools"
+      );
+    } // DevTools exists, even though it doesn't support Fiber.
 
-var queuedPointers = new Map();
-var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+    return true;
+  }
 
-var queuedExplicitHydrationTargets = [];
-function hasQueuedDiscreteEvents() {
-  return queuedDiscreteEvents.length > 0;
-}
-var discreteReplayableEvents = [
-  "mousedown",
-  "mouseup",
-  "touchcancel",
-  "touchend",
-  "touchstart",
-  "auxclick",
-  "dblclick",
-  "pointercancel",
-  "pointerdown",
-  "pointerup",
-  "dragend",
-  "dragstart",
-  "drop",
-  "compositionend",
-  "compositionstart",
-  "keydown",
-  "keypress",
-  "keyup",
-  "input",
-  "textInput", // Intentionally camelCase
-  "copy",
-  "cut",
-  "paste",
-  "click",
-  "change",
-  "contextmenu",
-  "reset",
-  "submit"
-];
-function isDiscreteEventThatRequiresHydration(eventType) {
-  return discreteReplayableEvents.indexOf(eventType) > -1;
-}
+  try {
+    if (enableSchedulingProfiler) {
+      // Conditionally inject these hooks only if Timeline profiler is supported by this build.
+      // This gives DevTools a way to feature detect that isn't tied to version number
+      // (since profiling and timeline are controlled by different feature flags).
+      internals = assign({}, internals, {
+        getLaneLabelMap: getLaneLabelMap,
+        injectProfilingHooks: injectProfilingHooks
+      });
+    }
 
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
-}
+    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
 
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    return;
+    injectedHook = hook;
+  } catch (err) {
+    // Catch all errors because it is unsafe to throw during initialization.
+    {
+      error("React instrumentation encountered an error: %s.", err);
+    }
   }
 
-  var queuedEvent = createQueuedReplayableEvent(
-    blockedOn,
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-  queuedDiscreteEvents.push(queuedEvent);
-
-  if (queuedDiscreteEvents.length === 1) {
-    // If this was the first discrete event, we might be able to
-    // synchronously unblock it so that preventDefault still works.
-    while (queuedEvent.blockedOn !== null) {
-      var fiber = getInstanceFromNode$1(queuedEvent.blockedOn);
+  if (hook.checkDCE) {
+    // This is the real DevTools.
+    return true;
+  } else {
+    // This is likely a hook installed by Fast Refresh runtime.
+    return false;
+  }
+}
+function onScheduleRoot(root, children) {
+  {
+    if (
+      injectedHook &&
+      typeof injectedHook.onScheduleFiberRoot === "function"
+    ) {
+      try {
+        injectedHook.onScheduleFiberRoot(rendererID, root, children);
+      } catch (err) {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-      if (fiber === null) {
-        break;
+          error("React instrumentation encountered an error: %s", err);
+        }
       }
+    }
+  }
+}
+function onCommitRoot$1(root, eventPriority) {
+  if (injectedHook && typeof injectedHook.onCommitFiberRoot === "function") {
+    try {
+      var didError = (root.current.flags & DidCapture) === DidCapture;
 
-      attemptSynchronousHydration$1(fiber);
+      if (enableProfilerTimer) {
+        var schedulerPriority;
 
-      if (queuedEvent.blockedOn === null) {
-        // We got unblocked by hydration. Let's try again.
-        replayUnblockedEvents(); // If we're reblocked, on an inner boundary, we might need
-        // to attempt hydrating that one.
+        switch (eventPriority) {
+          case DiscreteEventPriority:
+            schedulerPriority = ImmediatePriority;
+            break;
 
-        continue;
-      } else {
-        // We're still blocked from hydration, we have to give up
-        // and replay later.
-        break;
-      }
-    }
-  }
-} // Resets the replaying for this type of continuous event to no event.
+          case ContinuousEventPriority:
+            schedulerPriority = UserBlockingPriority;
+            break;
 
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
+          case DefaultEventPriority:
+            schedulerPriority = NormalPriority$1;
+            break;
 
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
+          case IdleEventPriority:
+            schedulerPriority = IdlePriority;
+            break;
 
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
+          default:
+            schedulerPriority = NormalPriority$1;
+            break;
+        }
 
-    case "pointerover":
-    case "pointerout": {
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.delete(pointerId);
-      break;
-    }
+        injectedHook.onCommitFiberRoot(
+          rendererID,
+          root,
+          schedulerPriority,
+          didError
+        );
+      }
+    } catch (err) {
+      {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-    case "gotpointercapture":
-    case "lostpointercapture": {
-      var _pointerId = nativeEvent.pointerId;
-      queuedPointerCaptures.delete(_pointerId);
-      break;
+          error("React instrumentation encountered an error: %s", err);
+        }
+      }
     }
   }
 }
-
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
+function onPostCommitRoot(root) {
   if (
-    existingQueuedEvent === null ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
+    injectedHook &&
+    typeof injectedHook.onPostCommitFiberRoot === "function"
   ) {
-    var queuedEvent = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-
-    if (blockedOn !== null) {
-      var fiber = getInstanceFromNode$1(blockedOn);
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {
+      {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-      if (fiber !== null) {
-        // Attempt to increase the priority of this target.
-        attemptContinuousHydration$1(fiber);
+          error("React instrumentation encountered an error: %s", err);
+        }
       }
     }
-
-    return queuedEvent;
-  } // If we have already queued this exact event, then it's because
-  // the different event systems have different DOM event listeners.
-  // We can accumulate the flags, and the targetContainers, and
-  // store a single event to be replayed.
-
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  var targetContainers = existingQueuedEvent.targetContainers;
-
-  if (
-    targetContainer !== null &&
-    targetContainers.indexOf(targetContainer) === -1
-  ) {
-    targetContainers.push(targetContainer);
   }
-
-  return existingQueuedEvent;
 }
+function onCommitUnmount(fiber) {
+  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === "function") {
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, fiber);
+    } catch (err) {
+      {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // These set relatedTarget to null because the replayed event will be treated as if we
-  // moved from outside the window (no target) onto the target once it hydrates.
-  // Instead of mutating we could clone the event.
-  switch (domEventName) {
-    case "focusin": {
-      var focusEvent = nativeEvent;
-      queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedFocus,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        focusEvent
-      );
-      return true;
-    }
-
-    case "dragenter": {
-      var dragEvent = nativeEvent;
-      queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedDrag,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        dragEvent
-      );
-      return true;
+          error("React instrumentation encountered an error: %s", err);
+        }
+      }
     }
-
-    case "mouseover": {
-      var mouseEvent = nativeEvent;
-      queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedMouse,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        mouseEvent
-      );
-      return true;
+  }
+}
+function setIsStrictModeForDevtools(newIsStrictMode) {
+  {
+    if (typeof log$1 === "function") {
+      // We're in a test because Scheduler.log only exists
+      // in SchedulerMock. To reduce the noise in strict mode tests,
+      // suppress warnings and disable scheduler yielding during the double render
+      unstable_setDisableYieldValue(newIsStrictMode);
+      setSuppressWarning(newIsStrictMode);
     }
 
-    case "pointerover": {
-      var pointerEvent = nativeEvent;
-      var pointerId = pointerEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          pointerEvent
-        )
-      );
-      return true;
-    }
+    if (injectedHook && typeof injectedHook.setStrictMode === "function") {
+      try {
+        injectedHook.setStrictMode(rendererID, newIsStrictMode);
+      } catch (err) {
+        {
+          if (!hasLoggedError) {
+            hasLoggedError = true;
 
-    case "gotpointercapture": {
-      var _pointerEvent = nativeEvent;
-      var _pointerId2 = _pointerEvent.pointerId;
-      queuedPointerCaptures.set(
-        _pointerId2,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointerCaptures.get(_pointerId2) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          _pointerEvent
-        )
-      );
-      return true;
+            error("React instrumentation encountered an error: %s", err);
+          }
+        }
+      }
     }
   }
+} // Profiler API hooks
 
-  return false;
-} // Check if this target is unblocked. Returns true if it's unblocked.
-
-function attemptExplicitHydrationTarget(queuedTarget) {
-  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
-  // Try to unify them. It's a bit tricky since it would require two return
-  // values.
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
-
-  if (targetInst !== null) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-
-    if (nearestMounted !== null) {
-      var tag = nearestMounted.tag;
-
-      if (tag === SuspenseComponent) {
-        var instance = getSuspenseInstanceFromFiber(nearestMounted);
-
-        if (instance !== null) {
-          // We're blocked on hydrating this boundary.
-          // Increase its priority.
-          queuedTarget.blockedOn = instance;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (tag === HostRoot) {
-        var root = nearestMounted.stateNode;
+function injectProfilingHooks(profilingHooks) {
+  injectedProfilingHooks = profilingHooks;
+}
 
-        if (isRootDehydrated(root)) {
-          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
-          // a root other than sync.
+function getLaneLabelMap() {
+  if (enableSchedulingProfiler) {
+    var map = new Map();
+    var lane = 1;
 
-          return;
-        }
-      }
+    for (var index = 0; index < TotalLanes; index++) {
+      var label = getLabelForLane(lane);
+      map.set(lane, label);
+      lane *= 2;
     }
-  }
 
-  queuedTarget.blockedOn = null;
+    return map;
+  } else {
+    return null;
+  }
 }
 
-function queueExplicitHydrationTarget(target) {
-  // TODO: This will read the priority if it's dispatched by the React
-  // event system but not native events. Should read window.event.type, like
-  // we do for updates (getCurrentEventPriority).
-  var updatePriority = getCurrentUpdatePriority();
-  var queuedTarget = {
-    blockedOn: null,
-    target: target,
-    priority: updatePriority
-  };
-  var i = 0;
-
-  for (; i < queuedExplicitHydrationTargets.length; i++) {
-    // Stop once we hit the first target with lower priority than
+function markCommitStarted(lanes) {
+  if (enableSchedulingProfiler) {
     if (
-      !isHigherEventPriority(
-        updatePriority,
-        queuedExplicitHydrationTargets[i].priority
-      )
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStarted === "function"
     ) {
-      break;
+      injectedProfilingHooks.markCommitStarted(lanes);
     }
   }
-
-  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
-
-  if (i === 0) {
-    attemptExplicitHydrationTarget(queuedTarget);
-  }
 }
-
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (queuedEvent.blockedOn !== null) {
-    return false;
+function markCommitStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStopped === "function"
+    ) {
+      injectedProfilingHooks.markCommitStopped();
+    }
   }
+}
+function markComponentRenderStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStarted === "function"
+    ) {
+      injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+  }
+}
+function markComponentRenderStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStopped === "function"
+    ) {
+      injectedProfilingHooks.markComponentRenderStopped();
+    }
+  }
+}
+function markComponentPassiveEffectMountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectMountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectMountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectMountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
+    }
+  }
+}
+function markComponentErrored(fiber, thrownValue, lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentErrored === "function"
+    ) {
+      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
+    }
+  }
+}
+function markComponentSuspended(fiber, wakeable, lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentSuspended === "function"
+    ) {
+      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
+    }
+  }
+}
+function markLayoutEffectsStarted(lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStarted === "function"
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    }
+  }
+}
+function markLayoutEffectsStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStopped === "function"
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    }
+  }
+}
+function markPassiveEffectsStarted(lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStarted === "function"
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+    }
+  }
+}
+function markPassiveEffectsStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStopped === "function"
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStopped();
+    }
+  }
+}
+function markRenderStarted(lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStarted === "function"
+    ) {
+      injectedProfilingHooks.markRenderStarted(lanes);
+    }
+  }
+}
+function markRenderYielded() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderYielded === "function"
+    ) {
+      injectedProfilingHooks.markRenderYielded();
+    }
+  }
+}
+function markRenderStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStopped === "function"
+    ) {
+      injectedProfilingHooks.markRenderStopped();
+    }
+  }
+}
+function markRenderScheduled(lane) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderScheduled === "function"
+    ) {
+      injectedProfilingHooks.markRenderScheduled(lane);
+    }
+  }
+}
+function markForceUpdateScheduled(fiber, lane) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markForceUpdateScheduled === "function"
+    ) {
+      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
+    }
+  }
+}
+function markStateUpdateScheduled(fiber, lane) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markStateUpdateScheduled === "function"
+    ) {
+      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+  }
+}
 
-  var targetContainers = queuedEvent.targetContainers;
-
-  while (targetContainers.length > 0) {
-    var targetContainer = targetContainers[0];
-    var nextBlockedOn = findInstanceBlockingEvent(
-      queuedEvent.domEventName,
-      queuedEvent.eventSystemFlags,
-      targetContainer,
-      queuedEvent.nativeEvent
-    );
-
-    if (nextBlockedOn === null) {
-      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-        var nativeEvent = queuedEvent.nativeEvent;
-        var nativeEventClone = new nativeEvent.constructor(
-          nativeEvent.type,
-          nativeEvent
-        );
-        setReplayingEvent(nativeEventClone);
-        nativeEvent.target.dispatchEvent(nativeEventClone);
-        resetReplayingEvent();
-      } else {
-        setReplayingEvent(queuedEvent.nativeEvent);
-        dispatchEventForPluginEventSystem(
-          queuedEvent.domEventName,
-          queuedEvent.eventSystemFlags,
-          queuedEvent.nativeEvent,
-          return_targetInst,
-          targetContainer
-        );
-        resetReplayingEvent();
-      }
-    } else {
-      // We're still blocked. Try again later.
-      var fiber = getInstanceFromNode$1(nextBlockedOn);
-
-      if (fiber !== null) {
-        attemptContinuousHydration$1(fiber);
-      }
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return (
+    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
+  );
+}
 
-      queuedEvent.blockedOn = nextBlockedOn;
-      return false;
-    } // This target container was successfully dispatched. Try the next.
+var objectIs = typeof Object.is === "function" ? Object.is : is; // $FlowFixMe[method-unbinding]
 
-    targetContainers.shift();
+var syncQueue = null;
+var includesLegacySyncCallbacks = false;
+var isFlushingSyncQueue = false;
+function scheduleSyncCallback(callback) {
+  // Push this callback into an internal queue. We'll flush these either in
+  // the next tick, or earlier if something calls `flushSyncCallbackQueue`.
+  if (syncQueue === null) {
+    syncQueue = [callback];
+  } else {
+    // Push onto existing queue. Don't need to schedule a callback because
+    // we already scheduled one when we created the queue.
+    syncQueue.push(callback);
   }
-
-  return true;
 }
-
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
-    map.delete(key);
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = true;
+  scheduleSyncCallback(callback);
+}
+function flushSyncCallbacksOnlyInLegacyMode() {
+  // Only flushes the queue if there's a legacy sync callback scheduled.
+  // TODO: There's only a single type of callback: performSyncOnWorkOnRoot. So
+  // it might make more sense for the queue to be a list of roots instead of a
+  // list of generic callbacks. Then we can have two: one for legacy roots, one
+  // for concurrent roots. And this method would only flush the legacy ones.
+  if (includesLegacySyncCallbacks) {
+    flushSyncCallbacks();
   }
 }
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && syncQueue !== null) {
+    // Prevent re-entrance.
+    isFlushingSyncQueue = true; // Set the event priority to discrete
+    // TODO: Is this necessary anymore? The only user code that runs in this
+    // queue is in the render or commit phases, which already set the
+    // event priority. Should be able to remove.
 
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = false;
+    var previousUpdatePriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    var errors = null;
+    var queue = syncQueue; // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    // First replay discrete events.
-    while (queuedDiscreteEvents.length > 0) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
+    for (var i = 0; i < queue.length; i++) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      var callback = queue[i];
 
-      if (nextDiscreteEvent.blockedOn !== null) {
-        // We're still blocked.
-        // Increase the priority of this boundary to unblock
-        // the next discrete event.
-        var fiber = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
+      try {
+        do {
+          var isSync = true; // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-        if (fiber !== null) {
-          attemptDiscreteHydration$1(fiber);
+          callback = callback(isSync);
+        } while (callback !== null);
+      } catch (error) {
+        // Collect errors so we can rethrow them at the end
+        if (errors === null) {
+          errors = [error];
+        } else {
+          errors.push(error);
         }
-
-        break;
       }
+    }
 
-      var targetContainers = nextDiscreteEvent.targetContainers;
-
-      while (targetContainers.length > 0) {
-        var targetContainer = targetContainers[0];
-        var nextBlockedOn = findInstanceBlockingEvent(
-          nextDiscreteEvent.domEventName,
-          nextDiscreteEvent.eventSystemFlags,
-          targetContainer,
-          nextDiscreteEvent.nativeEvent
-        );
+    syncQueue = null;
+    includesLegacySyncCallbacks = false;
+    setCurrentUpdatePriority(previousUpdatePriority);
+    isFlushingSyncQueue = false;
 
-        if (nextBlockedOn === null) {
-          // This whole function is in !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
-          // so we don't need the new replay behavior code branch.
-          setReplayingEvent(nextDiscreteEvent.nativeEvent);
-          dispatchEventForPluginEventSystem(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            nextDiscreteEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          );
-          resetReplayingEvent();
+    if (errors !== null) {
+      if (errors.length > 1) {
+        if (typeof AggregateError === "function") {
+          // eslint-disable-next-line no-undef
+          throw new AggregateError(errors);
         } else {
-          // We're still blocked. Try again later.
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        } // This target container was successfully dispatched. Try the next.
-
-        targetContainers.shift();
-      }
+          for (var _i = 1; _i < errors.length; _i++) {
+            scheduleCallback$2(
+              ImmediatePriority,
+              throwError.bind(null, errors[_i])
+            );
+          }
 
-      if (nextDiscreteEvent.blockedOn === null) {
-        // We've successfully replayed the first event. Let's try the next one.
-        queuedDiscreteEvents.shift();
+          var firstError = errors[0];
+          throw firstError;
+        }
+      } else {
+        var error = errors[0];
+        throw error;
       }
     }
-  } // Next replay any continuous events.
-
-  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
-    queuedFocus = null;
-  }
-
-  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
-    queuedDrag = null;
   }
 
-  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
-    queuedMouse = null;
-  }
-
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+  return null;
 }
 
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  if (queuedEvent.blockedOn === unblocked) {
-    queuedEvent.blockedOn = null;
+function throwError(error) {
+  throw error;
+}
 
-    if (!hasScheduledReplayAttempt) {
-      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
-      // now unblocked. This first might not actually be unblocked yet.
-      // We could check it early to avoid scheduling an unnecessary callback.
+var nativeConsole = console;
+var nativeConsoleLog = null;
+var pendingGroupArgs = [];
+var printedGroupIndex = -1;
 
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      );
-    }
-  }
+function formatLanes(laneOrLanes) {
+  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
 }
 
-function retryIfBlockedOn(unblocked) {
-  // Mark anything that was blocked on this as no longer blocked
-  // and eligible for a replay.
-  if (queuedDiscreteEvents.length > 0) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
-    // worth it because we expect very few discrete events to queue up and once
-    // we are actually fully unblocked it will be fast to replay them.
+function group() {
+  for (
+    var _len = arguments.length, groupArgs = new Array(_len), _key = 0;
+    _key < _len;
+    _key++
+  ) {
+    groupArgs[_key] = arguments[_key];
+  }
 
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent = queuedDiscreteEvents[i];
+  pendingGroupArgs.push(groupArgs);
 
-      if (queuedEvent.blockedOn === unblocked) {
-        queuedEvent.blockedOn = null;
-      }
-    }
+  if (nativeConsoleLog === null) {
+    nativeConsoleLog = nativeConsole.log;
+    nativeConsole.log = log;
   }
+}
 
-  if (queuedFocus !== null) {
-    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  }
+function groupEnd() {
+  pendingGroupArgs.pop();
 
-  if (queuedDrag !== null) {
-    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  while (printedGroupIndex >= pendingGroupArgs.length) {
+    nativeConsole.groupEnd();
+    printedGroupIndex--;
   }
 
-  if (queuedMouse !== null) {
-    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  if (pendingGroupArgs.length === 0) {
+    nativeConsole.log = nativeConsoleLog;
+    nativeConsoleLog = null;
   }
+}
 
-  var unblock = function (queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
-  };
-
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
-
-  for (var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++) {
-    var queuedTarget = queuedExplicitHydrationTargets[_i];
-
-    if (queuedTarget.blockedOn === unblocked) {
-      queuedTarget.blockedOn = null;
+function log() {
+  if (printedGroupIndex < pendingGroupArgs.length - 1) {
+    for (var i = printedGroupIndex + 1; i < pendingGroupArgs.length; i++) {
+      var groupArgs = pendingGroupArgs[i];
+      nativeConsole.group.apply(nativeConsole, groupArgs);
     }
-  }
 
-  while (queuedExplicitHydrationTargets.length > 0) {
-    var nextExplicitTarget = queuedExplicitHydrationTargets[0];
+    printedGroupIndex = pendingGroupArgs.length - 1;
+  }
 
-    if (nextExplicitTarget.blockedOn !== null) {
-      // We're still blocked.
-      break;
-    } else {
-      attemptExplicitHydrationTarget(nextExplicitTarget);
+  if (typeof nativeConsoleLog === "function") {
+    nativeConsoleLog.apply(void 0, arguments);
+  } else {
+    nativeConsole.log.apply(nativeConsole, arguments);
+  }
+}
 
-      if (nextExplicitTarget.blockedOn === null) {
-        // We're unblocked.
-        queuedExplicitHydrationTargets.shift();
-      }
+var REACT_LOGO_STYLE =
+  "background-color: #20232a; color: #61dafb; padding: 0 2px;";
+function logCommitStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c commit%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
     }
   }
 }
-
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
-
-var _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
-// We'd like to remove this but it's not clear if this is safe.
-
-function setEnabled(enabled) {
-  _enabled = !!enabled;
-}
-function isEnabled() {
-  return _enabled;
+function logCommitStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
+  }
 }
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  var eventPriority = getEventPriority(domEventName);
-  var listenerWrapper;
-
-  switch (eventPriority) {
-    case DiscreteEventPriority:
-      listenerWrapper = dispatchDiscreteEvent;
-      break;
+var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
 
-    case ContinuousEventPriority:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
+var wakeableIDs = new PossiblyWeakMap$1();
+var wakeableID = 0;
 
-    case DefaultEventPriority:
-    default:
-      listenerWrapper = dispatchEvent;
-      break;
+function getWakeableID(wakeable) {
+  if (!wakeableIDs.has(wakeable)) {
+    wakeableIDs.set(wakeable, wakeableID++);
   }
 
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
+  return wakeableIDs.get(wakeable);
 }
 
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-
-  try {
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$3.transition = prevTransition;
+function logComponentSuspended(componentName, wakeable) {
+  {
+    if (enableDebugTracing) {
+      var id = getWakeableID(wakeable);
+      var display = wakeable.displayName || wakeable;
+      log(
+        "%c\u269B\uFE0F%c " + componentName + " suspended",
+        REACT_LOGO_STYLE,
+        "color: #80366d; font-weight: bold;",
+        id,
+        display
+      );
+      wakeable.then(
+        function () {
+          log(
+            "%c\u269B\uFE0F%c " + componentName + " resolved",
+            REACT_LOGO_STYLE,
+            "color: #80366d; font-weight: bold;",
+            id,
+            display
+          );
+        },
+        function () {
+          log(
+            "%c\u269B\uFE0F%c " + componentName + " rejected",
+            REACT_LOGO_STYLE,
+            "color: #80366d; font-weight: bold;",
+            id,
+            display
+          );
+        }
+      );
+    }
   }
 }
-
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-
-  try {
-    setCurrentUpdatePriority(ContinuousEventPriority);
-    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$3.transition = prevTransition;
+function logLayoutEffectsStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c layout effects%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
+    }
   }
 }
-
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (!_enabled) {
-    return;
+function logLayoutEffectsStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
   }
-
-  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-  } else {
-    dispatchEventOriginal(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
+}
+function logPassiveEffectsStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c passive effects%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
+    }
   }
 }
-
-function dispatchEventOriginal(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // TODO: replaying capture phase events is currently broken
-  // because we used to do it during top-level native bubble handlers
-  // but now we use different bubble and capture handlers.
-  // In eager mode, we attach capture listeners early, so we need
-  // to filter them out until we fix the logic to handle them correctly.
-  var allowReplay = (eventSystemFlags & IS_CAPTURE_PHASE) === 0;
-
-  if (
-    allowReplay &&
-    hasQueuedDiscreteEvents() &&
-    isDiscreteEventThatRequiresHydration(domEventName)
-  ) {
-    // If we already have a queue of discrete events, and this is another discrete
-    // event, then we can't dispatch it regardless of its target, since they
-    // need to dispatch in order.
-    queueDiscreteEvent(
-      null, // Flags that we're not actually blocked on anything as far as we know.
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-    return;
+function logPassiveEffectsStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
   }
-
-  var blockedOn = findInstanceBlockingEvent(
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-
-  if (blockedOn === null) {
-    dispatchEventForPluginEventSystem(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      return_targetInst,
-      targetContainer
-    );
-
-    if (allowReplay) {
-      clearIfContinuousEvent(domEventName, nativeEvent);
+}
+function logRenderStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c render%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
     }
-
-    return;
   }
-
-  if (allowReplay) {
-    if (isDiscreteEventThatRequiresHydration(domEventName)) {
-      // This to be replayed later once the target is available.
-      queueDiscreteEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
+}
+function logRenderStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
+  }
+}
+function logForceUpdateScheduled(componentName, lane) {
+  {
+    if (enableDebugTracing) {
+      log(
+        "%c\u269B\uFE0F%c " +
+          componentName +
+          " forced update %c(" +
+          formatLanes(lane) +
+          ")",
+        REACT_LOGO_STYLE,
+        "color: #db2e1f; font-weight: bold;",
+        ""
+      );
+    }
+  }
+}
+function logStateUpdateScheduled(componentName, lane, payloadOrAction) {
+  {
+    if (enableDebugTracing) {
+      log(
+        "%c\u269B\uFE0F%c " +
+          componentName +
+          " updated state %c(" +
+          formatLanes(lane) +
+          ")",
+        REACT_LOGO_STYLE,
+        "color: #01a252; font-weight: bold;",
+        "",
+        payloadOrAction
       );
-      return;
     }
+  }
+}
 
-    if (
-      queueIfContinuousEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )
-    ) {
-      return;
-    } // We need to clear only if we didn't queue because
-    // queueing is accumulative.
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  var currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
 
-    clearIfContinuousEvent(domEventName, nativeEvent);
-  } // This is not replayable so we'll invoke it but without a target,
-  // in case the event system needs to trace it.
+// Intentionally not using it yet to derisk the initial implementation, because
+// the way we push/pop these values is a bit unusual. If there's a mistake, I'd
+// rather the ids be wrong than crash the whole reconciler.
 
-  dispatchEventForPluginEventSystem(
-    domEventName,
-    eventSystemFlags,
-    nativeEvent,
-    null,
-    targetContainer
-  );
+var forkStack = [];
+var forkStackIndex = 0;
+var treeForkProvider = null;
+var treeForkCount = 0;
+var idStack = [];
+var idStackIndex = 0;
+var treeContextProvider = null;
+var treeContextId = 1;
+var treeContextOverflow = "";
+function isForkedChild(workInProgress) {
+  warnIfNotHydrating();
+  return (workInProgress.flags & Forked) !== NoFlags$1;
 }
+function getForksAtLevel(workInProgress) {
+  warnIfNotHydrating();
+  return treeForkCount;
+}
+function getTreeId() {
+  var overflow = treeContextOverflow;
+  var idWithLeadingBit = treeContextId;
+  var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  // This is called right after we reconcile an array (or iterator) of child
+  // fibers, because that's the only place where we know how many children in
+  // the whole set without doing extra work later, or storing addtional
+  // information on the fiber.
+  //
+  // That's why this function is separate from pushTreeId — it's called during
+  // the render phase of the fork parent, not the child, which is where we push
+  // the other context values.
+  //
+  // In the Fizz implementation this is much simpler because the child is
+  // rendered in the same callstack as the parent.
+  //
+  // It might be better to just add a `forks` field to the Fiber type. It would
+  // make this module simpler.
+  warnIfNotHydrating();
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  warnIfNotHydrating();
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  var baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
 
-function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  var blockedOn = findInstanceBlockingEvent(
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-
-  if (blockedOn === null) {
-    dispatchEventForPluginEventSystem(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      return_targetInst,
-      targetContainer
-    );
-    clearIfContinuousEvent(domEventName, nativeEvent);
-    return;
-  }
+  var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  var slot = index + 1;
+  var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
 
-  if (
-    queueIfContinuousEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )
-  ) {
-    nativeEvent.stopPropagation();
-    return;
-  } // We need to clear only if we didn't queue because
-  // queueing is accumulative.
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    var numberOfOverflowBits = baseLength - (baseLength % 5); // Then create a bitmask that selects only those bits.
 
-  clearIfContinuousEvent(domEventName, nativeEvent);
+    var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
 
-  if (
-    eventSystemFlags & IS_CAPTURE_PHASE &&
-    isDiscreteEventThatRequiresHydration(domEventName)
-  ) {
-    while (blockedOn !== null) {
-      var fiber = getInstanceFromNode$1(blockedOn);
+    var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
 
-      if (fiber !== null) {
-        attemptSynchronousHydration$1(fiber);
-      }
+    var restOfBaseId = baseId >> numberOfOverflowBits;
+    var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
 
-      var nextBlockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
+    var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    var restOfNewBits = slot << restOfBaseLength;
+    var id = restOfNewBits | restOfBaseId;
+    var overflow = newOverflow + baseOverflow;
+    treeContextId = (1 << restOfLength) | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    var newBits = slot << baseLength;
 
-      if (nextBlockedOn === null) {
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        );
-      }
+    var _id = newBits | baseId;
 
-      if (nextBlockedOn === blockedOn) {
-        break;
-      }
+    var _overflow = baseOverflow;
+    treeContextId = (1 << length) | _id;
+    treeContextOverflow = _overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  warnIfNotHydrating(); // This component materialized an id. This will affect any ids that appear
+  // in its children.
 
-      blockedOn = nextBlockedOn;
-    }
+  var returnFiber = workInProgress.return;
 
-    if (blockedOn !== null) {
-      nativeEvent.stopPropagation();
-    }
+  if (returnFiber !== null) {
+    var numberOfForks = 1;
+    var slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
 
-    return;
-  } // This is not replayable so we'll invoke it but without a target,
-  // in case the event system needs to trace it.
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
 
-  dispatchEventForPluginEventSystem(
-    domEventName,
-    eventSystemFlags,
-    nativeEvent,
-    null,
-    targetContainer
-  );
+function getLeadingBit(id) {
+  return 1 << (getBitLength(id) - 1);
 }
 
-var return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
-// The return_targetInst field above is conceptually part of the return value.
-
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // TODO: Warn if _enabled is false.
-  return_targetInst = null;
-  var nativeEventTarget = getEventTarget(nativeEvent);
-  var targetInst = getClosestInstanceFromNode(nativeEventTarget);
-
-  if (targetInst !== null) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-
-    if (nearestMounted === null) {
-      // This tree has been unmounted already. Dispatch without a target.
-      targetInst = null;
-    } else {
-      var tag = nearestMounted.tag;
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
 
-      if (tag === SuspenseComponent) {
-        var instance = getSuspenseInstanceFromFiber(nearestMounted);
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+  warnIfNotHydrating();
 
-        if (instance !== null) {
-          // Queue the event to be replayed later. Abort dispatching since we
-          // don't want this event dispatched twice through the event system.
-          // TODO: If this is the first discrete event in the queue. Schedule an increased
-          // priority for this boundary.
-          return instance;
-        } // This shouldn't happen, something went wrong but to avoid blocking
-        // the whole system, dispatch the event without a target.
-        // TODO: Warn.
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
+  }
+}
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  warnIfNotHydrating();
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
 
-        targetInst = null;
-      } else if (tag === HostRoot) {
-        var root = nearestMounted.stateNode;
+function warnIfNotHydrating() {
+  {
+    if (!getIsHydrating()) {
+      error(
+        "Expected to be hydrating. This is a bug in React. Please file " +
+          "an issue."
+      );
+    }
+  }
+}
 
-        if (isRootDehydrated(root)) {
-          // If this happens during a replay something went wrong and it might block
-          // the whole system.
-          return getContainerFromFiber(nearestMounted);
-        }
+var contextStackCursor = createCursor(null);
+var contextFiberStackCursor = createCursor(null);
+var rootInstanceStackCursor = createCursor(null);
 
-        targetInst = null;
-      } else if (nearestMounted !== targetInst) {
-        // If we get an event (ex: img onload) before committing that
-        // component's mount, ignore it for now (that is, treat it as if it was an
-        // event on a non-React tree). We might also consider queueing events and
-        // dispatching them after the mount.
-        targetInst = null;
-      }
+function requiredContext(c) {
+  {
+    if (c === null) {
+      error(
+        "Expected host context to exist. This error is likely caused by a bug " +
+          "in React. Please file an issue."
+      );
     }
   }
 
-  return_targetInst = targetInst; // We're not blocked on anything.
-
-  return null;
+  return c;
 }
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    // Used by SimpleEventPlugin:
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange": // Used by polyfills:
-    // eslint-disable-next-line no-fallthrough
 
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate": // Only enableCreateEventHandleAPI:
-    // eslint-disable-next-line no-fallthrough
+function getCurrentRootHostContainer() {
+  return rootInstanceStackCursor.current;
+}
 
-    case "beforeblur":
-    case "afterblur": // Not used by React but could be by user code:
-    // eslint-disable-next-line no-fallthrough
+function getRootHostContainer() {
+  var rootInstance = requiredContext(rootInstanceStackCursor.current);
+  return rootInstance;
+}
 
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return DiscreteEventPriority;
+function pushHostContainer(fiber, nextRootInstance) {
+  // Push current root instance onto the stack;
+  // This allows us to reset root when portals are popped.
+  push(rootInstanceStackCursor, nextRootInstance, fiber); // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
 
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel": // Not used by React but could be by user code:
-    // eslint-disable-next-line no-fallthrough
+  push(contextFiberStackCursor, fiber, fiber); // Finally, we need to push the host context to the stack.
+  // However, we can't just call getRootHostContext() and push it because
+  // we'd have a different number of entries on the stack depending on
+  // whether getRootHostContext() throws somewhere in renderer code or not.
+  // So we push an empty value first. This lets us safely unwind on errors.
 
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return ContinuousEventPriority;
+  push(contextStackCursor, null, fiber);
+  var nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
 
-    case "message": {
-      // We might be in the Scheduler callback.
-      // Eventually this mechanism will be replaced by a check
-      // of the current priority on the native scheduler.
-      var schedulerPriority = getCurrentPriorityLevel();
+  pop(contextStackCursor, fiber);
+  push(contextStackCursor, nextRootContext, fiber);
+}
 
-      switch (schedulerPriority) {
-        case ImmediatePriority:
-          return DiscreteEventPriority;
+function popHostContainer(fiber) {
+  pop(contextStackCursor, fiber);
+  pop(contextFiberStackCursor, fiber);
+  pop(rootInstanceStackCursor, fiber);
+}
 
-        case UserBlockingPriority:
-          return ContinuousEventPriority;
+function getHostContext() {
+  var context = requiredContext(contextStackCursor.current);
+  return context;
+}
 
-        case NormalPriority$1:
-        case LowPriority:
-          // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
-          return DefaultEventPriority;
+function pushHostContext(fiber) {
+  var context = requiredContext(contextStackCursor.current);
+  var nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
 
-        case IdlePriority:
-          return IdleEventPriority;
+  if (context === nextContext) {
+    return;
+  } // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
 
-        default:
-          return DefaultEventPriority;
-      }
-    }
+  push(contextFiberStackCursor, fiber, fiber);
+  push(contextStackCursor, nextContext, fiber);
+}
 
-    default:
-      return DefaultEventPriority;
+function popHostContext(fiber) {
+  // Do not pop unless this Fiber provided the current context.
+  // pushHostContext() only pushes Fibers that provide unique contexts.
+  if (contextFiberStackCursor.current !== fiber) {
+    return;
   }
-}
 
-function addEventBubbleListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, false);
-  return listener;
-}
-function addEventCaptureListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, true);
-  return listener;
-}
-function addEventCaptureListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, {
-    capture: true,
-    passive: passive
-  });
-  return listener;
-}
-function addEventBubbleListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, {
-    passive: passive
-  });
-  return listener;
-}
-function removeEventListener(target, eventType, listener, capture) {
-  target.removeEventListener(eventType, listener, capture);
+  pop(contextStackCursor, fiber);
+  pop(contextFiberStackCursor, fiber);
 }
 
-/**
- * These variables store information about text content of a target node,
- * allowing comparison of content before and after a given event.
- *
- * Identify the node where selection currently begins, then observe
- * both its text content and its current position in the DOM. Since the
- * browser may natively replace the target node during composition, we can
- * use its position to find its replacement.
- *
- *
- */
-var root = null;
-var startText = null;
-var fallbackText = null;
-function initialize(nativeEventTarget) {
-  root = nativeEventTarget;
-  startText = getText();
-  return true;
-}
-function reset() {
-  root = null;
-  startText = null;
-  fallbackText = null;
-}
-function getData() {
-  if (fallbackText) {
-    return fallbackText;
-  }
+// This may have been an insertion or a hydration.
 
-  var start;
-  var startValue = startText;
-  var startLength = startValue.length;
-  var end;
-  var endValue = getText();
-  var endLength = endValue.length;
+var hydrationParentFiber = null;
+var nextHydratableInstance = null;
+var isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+// due to earlier mismatches or a suspended fiber.
 
-  for (start = 0; start < startLength; start++) {
-    if (startValue[start] !== endValue[start]) {
-      break;
-    }
-  }
+var didSuspendOrErrorDEV = false; // Hydration errors that were thrown inside this boundary
 
-  var minEnd = startLength - start;
+var hydrationErrors = null;
+var rootOrSingletonContext = false;
 
-  for (end = 1; end <= minEnd; end++) {
-    if (startValue[startLength - end] !== endValue[endLength - end]) {
-      break;
+function warnIfHydrating() {
+  {
+    if (isHydrating) {
+      error(
+        "We should not be hydrating here. This is a bug in React. Please file a bug."
+      );
     }
   }
+}
 
-  var sliceTail = end > 1 ? 1 - end : undefined;
-  fallbackText = endValue.slice(start, sliceTail);
-  return fallbackText;
+function markDidThrowWhileHydratingDEV() {
+  {
+    didSuspendOrErrorDEV = true;
+  }
 }
-function getText() {
-  if ("value" in root) {
-    return root.value;
+function didSuspendOrErrorWhileHydratingDEV() {
+  {
+    return didSuspendOrErrorDEV;
   }
-
-  return root.textContent;
 }
 
-/**
- * `charCode` represents the actual "character code" and is safe to use with
- * `String.fromCharCode`. As such, only keys that correspond to printable
- * characters produce a valid `charCode`, the only exception to this is Enter.
- * The Tab-key is considered non-printable and does not have a `charCode`,
- * presumably because it does not produce a tab-character in browsers.
- *
- * @param {object} nativeEvent Native browser event.
- * @return {number} Normalized `charCode` property.
- */
-function getEventCharCode(nativeEvent) {
-  var charCode;
-  var keyCode = nativeEvent.keyCode;
-
-  if ("charCode" in nativeEvent) {
-    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
-
-    if (charCode === 0 && keyCode === 13) {
-      charCode = 13;
-    }
-  } else {
-    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
-    charCode = keyCode;
-  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
-  // report Enter as charCode 10 when ctrl is pressed.
+function enterHydrationState(fiber) {
+  var parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance =
+    getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  didSuspendOrErrorDEV = false;
+  rootOrSingletonContext = true;
+  return true;
+}
 
-  if (charCode === 10) {
-    charCode = 13;
-  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
-  // Must not discard the (non-)printable Enter-key.
+function reenterHydrationStateFromDehydratedSuspenseInstance(
+  fiber,
+  suspenseInstance,
+  treeContext
+) {
+  nextHydratableInstance =
+    getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  didSuspendOrErrorDEV = false;
+  rootOrSingletonContext = false;
 
-  if (charCode >= 32 || charCode === 13) {
-    return charCode;
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
   }
 
-  return 0;
-}
-
-function functionThatReturnsTrue() {
   return true;
 }
 
-function functionThatReturnsFalse() {
-  return false;
-} // This is intentionally a factory so that we have different returned constructors.
-// If we had a single constructor, it would be megamorphic and engines would deopt.
-
-function createSyntheticEvent(Interface) {
-  /**
-   * Synthetic events are dispatched by event plugins, typically in response to a
-   * top-level event delegation handler.
-   *
-   * These systems should generally use pooling to reduce the frequency of garbage
-   * collection. The system should check `isPersistent` to determine whether the
-   * event should be released into the pool after being dispatched. Users that
-   * need a persisted event should invoke `persist`.
-   *
-   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
-   * normalizing browser quirks. Subclasses do not necessarily have to implement a
-   * DOM interface; custom application-specific events can also subclass this.
-   */
-  // $FlowFixMe[missing-this-annot]
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-
-    for (var propName in Interface) {
-      if (!Interface.hasOwnProperty(propName)) {
-        continue;
+function warnUnhydratedInstance(returnFiber, instance) {
+  {
+    switch (returnFiber.tag) {
+      case HostRoot: {
+        didNotHydrateInstanceWithinContainer(
+          returnFiber.stateNode.containerInfo,
+          instance
+        );
+        break;
       }
 
-      var normalize = Interface[propName];
+      case HostSingleton:
+      case HostComponent: {
+        var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+        didNotHydrateInstance(
+          returnFiber.type,
+          returnFiber.memoizedProps,
+          returnFiber.stateNode,
+          instance, // TODO: Delete this argument when we remove the legacy root API.
+          isConcurrentMode
+        );
+        break;
+      }
 
-      if (normalize) {
-        this[propName] = normalize(nativeEvent);
-      } else {
-        this[propName] = nativeEvent[propName];
+      case SuspenseComponent: {
+        var suspenseState = returnFiber.memoizedState;
+        if (suspenseState.dehydrated !== null)
+          didNotHydrateInstanceWithinSuspenseInstance(
+            suspenseState.dehydrated,
+            instance
+          );
+        break;
       }
     }
+  }
+}
 
-    var defaultPrevented =
-      nativeEvent.defaultPrevented != null
-        ? nativeEvent.defaultPrevented
-        : nativeEvent.returnValue === false;
+function deleteHydratableInstance(returnFiber, instance) {
+  warnUnhydratedInstance(returnFiber, instance);
+  var childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  var deletions = returnFiber.deletions;
 
-    if (defaultPrevented) {
-      this.isDefaultPrevented = functionThatReturnsTrue;
-    } else {
-      this.isDefaultPrevented = functionThatReturnsFalse;
-    }
-
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  } // $FlowFixMe[prop-missing] found when upgrading Flow
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
 
-  assign(SyntheticBaseEvent.prototype, {
-    // $FlowFixMe[missing-this-annot]
-    preventDefault: function () {
-      this.defaultPrevented = true;
-      var event = this.nativeEvent;
+function warnNonhydratedInstance(returnFiber, fiber) {
+  {
+    if (didSuspendOrErrorDEV) {
+      // Inside a boundary that already suspended. We're currently rendering the
+      // siblings of a suspended node. The mismatch may be due to the missing
+      // data, so it's probably a false positive.
+      return;
+    }
 
-      if (!event) {
-        return;
-      }
+    switch (returnFiber.tag) {
+      case HostRoot: {
+        var parentContainer = returnFiber.stateNode.containerInfo;
 
-      if (event.preventDefault) {
-        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.returnValue !== "unknown") {
-        event.returnValue = false;
-      }
+        switch (fiber.tag) {
+          case HostSingleton:
+          case HostComponent:
+            var type = fiber.type;
+            didNotFindHydratableInstanceWithinContainer(parentContainer, type);
+            break;
 
-      this.isDefaultPrevented = functionThatReturnsTrue;
-    },
-    // $FlowFixMe[missing-this-annot]
-    stopPropagation: function () {
-      var event = this.nativeEvent;
+          case HostText:
+            var text = fiber.pendingProps;
+            didNotFindHydratableTextInstanceWithinContainer(
+              parentContainer,
+              text
+            );
+            break;
+        }
 
-      if (!event) {
-        return;
+        break;
       }
 
-      if (event.stopPropagation) {
-        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.cancelBubble !== "unknown") {
-        // The ChangeEventPlugin registers a "propertychange" event for
-        // IE. This event does not support bubbling or cancelling, and
-        // any references to cancelBubble throw "Member not found".  A
-        // typeof check of "unknown" circumvents this issue (and is also
-        // IE specific).
-        event.cancelBubble = true;
-      }
+      case HostSingleton:
+      case HostComponent: {
+        var parentType = returnFiber.type;
+        var parentProps = returnFiber.memoizedProps;
+        var parentInstance = returnFiber.stateNode;
 
-      this.isPropagationStopped = functionThatReturnsTrue;
-    },
+        switch (fiber.tag) {
+          case HostSingleton:
+          case HostComponent: {
+            var _type = fiber.type;
+            var _props = fiber.pendingProps;
+            var isConcurrentMode =
+              (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotFindHydratableInstance(
+              parentType,
+              parentProps,
+              parentInstance,
+              _type,
+              _props, // TODO: Delete this argument when we remove the legacy root API.
+              isConcurrentMode
+            );
+            break;
+          }
 
-    /**
-     * We release all dispatched `SyntheticEvent`s after each event loop, adding
-     * them back into the pool. This allows a way to hold onto a reference that
-     * won't be added back into the pool.
-     */
-    persist: function () {
-      // Modern event system doesn't use pooling.
-    },
+          case HostText: {
+            var _text = fiber.pendingProps;
 
-    /**
-     * Checks if this event should be released back into the pool.
-     *
-     * @return {boolean} True if this should not be released, false otherwise.
-     */
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
-}
-/**
- * @interface Event
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+            var _isConcurrentMode =
+              (returnFiber.mode & ConcurrentMode) !== NoMode;
 
-var EventInterface = {
-  eventPhase: 0,
-  bubbles: 0,
-  cancelable: 0,
-  timeStamp: function (event) {
-    return event.timeStamp || Date.now();
-  },
-  defaultPrevented: 0,
-  isTrusted: 0
-};
-var SyntheticEvent = createSyntheticEvent(EventInterface);
+            didNotFindHydratableTextInstance(
+              parentType,
+              parentProps,
+              parentInstance,
+              _text, // TODO: Delete this argument when we remove the legacy root API.
+              _isConcurrentMode
+            );
+            break;
+          }
+        }
 
-var UIEventInterface = assign({}, EventInterface, {
-  view: 0,
-  detail: 0
-});
+        break;
+      }
 
-var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
-var lastMovementX;
-var lastMovementY;
-var lastMouseEvent;
+      case SuspenseComponent: {
+        var suspenseState = returnFiber.memoizedState;
+        var _parentInstance = suspenseState.dehydrated;
+        if (_parentInstance !== null)
+          switch (fiber.tag) {
+            case HostSingleton:
+            case HostComponent:
+              var _type2 = fiber.type;
+              didNotFindHydratableInstanceWithinSuspenseInstance(
+                _parentInstance,
+                _type2
+              );
+              break;
 
-function updateMouseMovementPolyfillState(event) {
-  if (event !== lastMouseEvent) {
-    if (lastMouseEvent && event.type === "mousemove") {
-      // $FlowFixMe assuming this is a number
-      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe assuming this is a number
+            case HostText:
+              var _text2 = fiber.pendingProps;
+              didNotFindHydratableTextInstanceWithinSuspenseInstance(
+                _parentInstance,
+                _text2
+              );
+              break;
+          }
+        break;
+      }
 
-      lastMovementY = event.screenY - lastMouseEvent.screenY;
-    } else {
-      lastMovementX = 0;
-      lastMovementY = 0;
+      default:
+        return;
     }
-
-    lastMouseEvent = event;
   }
 }
-/**
- * @interface MouseEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
 
-var MouseEventInterface = assign({}, UIEventInterface, {
-  screenX: 0,
-  screenY: 0,
-  clientX: 0,
-  clientY: 0,
-  pageX: 0,
-  pageY: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  altKey: 0,
-  metaKey: 0,
-  getModifierState: getEventModifierState,
-  button: 0,
-  buttons: 0,
-  relatedTarget: function (event) {
-    if (event.relatedTarget === undefined)
-      return event.fromElement === event.srcElement
-        ? event.toElement
-        : event.fromElement;
-    return event.relatedTarget;
-  },
-  movementX: function (event) {
-    if ("movementX" in event) {
-      return event.movementX;
-    }
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & ~Hydrating) | Placement;
+  warnNonhydratedInstance(returnFiber, fiber);
+}
 
-    updateMouseMovementPolyfillState(event);
-    return lastMovementX;
-  },
-  movementY: function (event) {
-    if ("movementY" in event) {
-      return event.movementY;
-    } // Don't need to call updateMouseMovementPolyfillState() here
-    // because it's guaranteed to have already run when movementX
-    // was copied.
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  var instance = canHydrateInstance(nextInstance, fiber.type);
 
-    return lastMovementY;
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
   }
-});
-
-var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
-/**
- * @interface DragEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
-
-var DragEventInterface = assign({}, MouseEventInterface, {
-  dataTransfer: 0
-});
-
-var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
-/**
- * @interface FocusEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
 
-var FocusEventInterface = assign({}, UIEventInterface, {
-  relatedTarget: 0
-});
-
-var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
- * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
- */
+  return false;
+}
 
-var AnimationEventInterface = assign({}, EventInterface, {
-  animationName: 0,
-  elapsedTime: 0,
-  pseudoElement: 0
-});
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  var text = fiber.pendingProps;
+  var textInstance = canHydrateTextInstance(nextInstance, text);
 
-var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/clipboard-apis/
- */
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
 
-var ClipboardEventInterface = assign({}, EventInterface, {
-  clipboardData: function (event) {
-    return "clipboardData" in event
-      ? event.clipboardData
-      : window.clipboardData;
+    nextHydratableInstance = null;
+    return true;
   }
-});
 
-var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
- */
+  return false;
+}
 
-var CompositionEventInterface = assign({}, EventInterface, {
-  data: 0
-});
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
 
-var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
- *      /#events-inputevents
- */
-// Happens to share the same list for now.
+  if (suspenseInstance !== null) {
+    var suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
 
-var SyntheticInputEvent = SyntheticCompositionEvent;
-/**
- * Normalization of deprecated HTML5 `key` values
- * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
- */
+    var dehydratedFragment =
+      createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
 
-var normalizeKey = {
-  Esc: "Escape",
-  Spacebar: " ",
-  Left: "ArrowLeft",
-  Up: "ArrowUp",
-  Right: "ArrowRight",
-  Down: "ArrowDown",
-  Del: "Delete",
-  Win: "OS",
-  Menu: "ContextMenu",
-  Apps: "ContextMenu",
-  Scroll: "ScrollLock",
-  MozPrintableKey: "Unidentified"
-};
-/**
- * Translation from legacy `keyCode` to HTML5 `key`
- * Only special keys supported, all others depend on keyboard layout or browser
- * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
- */
+    nextHydratableInstance = null;
+    return true;
+  }
 
-var translateToKey = {
-  "8": "Backspace",
-  "9": "Tab",
-  "12": "Clear",
-  "13": "Enter",
-  "16": "Shift",
-  "17": "Control",
-  "18": "Alt",
-  "19": "Pause",
-  "20": "CapsLock",
-  "27": "Escape",
-  "32": " ",
-  "33": "PageUp",
-  "34": "PageDown",
-  "35": "End",
-  "36": "Home",
-  "37": "ArrowLeft",
-  "38": "ArrowUp",
-  "39": "ArrowRight",
-  "40": "ArrowDown",
-  "45": "Insert",
-  "46": "Delete",
-  "112": "F1",
-  "113": "F2",
-  "114": "F3",
-  "115": "F4",
-  "116": "F5",
-  "117": "F6",
-  "118": "F7",
-  "119": "F8",
-  "120": "F9",
-  "121": "F10",
-  "122": "F11",
-  "123": "F12",
-  "144": "NumLock",
-  "145": "ScrollLock",
-  "224": "Meta"
-};
-/**
- * @param {object} nativeEvent Native browser event.
- * @return {string} Normalized `key` property.
- */
+  return false;
+}
 
-function getEventKey(nativeEvent) {
-  if (nativeEvent.key) {
-    // Normalize inconsistent values reported by browsers due to
-    // implementations of a working draft specification.
-    // FireFox implements `key` but returns `MozPrintableKey` for all
-    // printable characters (normalized to `Unidentified`), ignore it.
-    var key = normalizeKey[nativeEvent.key] || nativeEvent.key; // $FlowFixMe unable to index with a `mixed` value
+function shouldClientRenderOnMismatch(fiber) {
+  return (
+    (fiber.mode & ConcurrentMode) !== NoMode &&
+    (fiber.flags & DidCapture) === NoFlags$1
+  );
+}
 
-    if (key !== "Unidentified") {
-      return key;
-    }
-  } // Browser does not implement `key`, polyfill as much of it as we can.
+function throwOnHydrationMismatch(fiber) {
+  throw new Error(
+    "Hydration failed because the initial UI does not match what was " +
+      "rendered on the server."
+  );
+}
 
-  if (nativeEvent.type === "keypress") {
-    var charCode = getEventCharCode(
-      // $FlowFixMe unable to narrow to `KeyboardEvent`
-      nativeEvent
-    ); // The enter-key is technically both printable and non-printable and can
-    // thus be captured by `keypress`, no other non-printable key should.
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
 
-    return charCode === 13 ? "Enter" : String.fromCharCode(charCode);
+    var currentRootContainer = getRootHostContainer();
+    var currentHostContext = getHostContext();
+    var instance = (fiber.stateNode = resolveSingletonInstance(
+      fiber.type,
+      fiber.pendingProps,
+      currentRootContainer,
+      currentHostContext,
+      false
+    ));
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
   }
+}
 
-  if (nativeEvent.type === "keydown" || nativeEvent.type === "keyup") {
-    // While user keyboard layout determines the actual meaning of each
-    // `keyCode` value, almost all function keys have a universal value.
-    // $FlowFixMe unable to index with a `mixed` value
-    return translateToKey[nativeEvent.keyCode] || "Unidentified";
+function advanceToFirstAttemptableInstance(fiber) {
+  // fiber is HostComponent Fiber
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    )
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
   }
-
-  return "";
 }
-/**
- * Translation from modifier key to the associated property in the event.
- * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
- */
-
-var modifierKeyToProp = {
-  Alt: "altKey",
-  Control: "ctrlKey",
-  Meta: "metaKey",
-  Shift: "shiftKey"
-}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
-// getModifierState. If getModifierState is not supported, we map it to a set of
-// modifier keys exposed by the event. In this case, Lock-keys are not supported.
-// $FlowFixMe[missing-local-annot]
-// $FlowFixMe[missing-this-annot]
-
-function modifierStateGetter(keyArg) {
-  var syntheticEvent = this;
-  var nativeEvent = syntheticEvent.nativeEvent;
 
-  if (nativeEvent.getModifierState) {
-    return nativeEvent.getModifierState(keyArg);
+function advanceToFirstAttemptableTextInstance() {
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForTextInstance(nextHydratableInstance)
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
   }
-
-  var keyProp = modifierKeyToProp[keyArg];
-  return keyProp ? !!nativeEvent[keyProp] : false;
 }
 
-function getEventModifierState(nativeEvent) {
-  return modifierStateGetter;
+function advanceToFirstAttemptableSuspenseInstance() {
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForSuspenseInstance(nextHydratableInstance)
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
+  }
 }
-/**
- * @interface KeyboardEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
-
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-  key: getEventKey,
-  code: 0,
-  location: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  altKey: 0,
-  metaKey: 0,
-  repeat: 0,
-  locale: 0,
-  getModifierState: getEventModifierState,
-  // Legacy Interface
-  charCode: function (event) {
-    // `charCode` is the result of a KeyPress event and represents the value of
-    // the actual printable character.
-    // KeyPress is deprecated, but its replacement is not yet final and not
-    // implemented in any major browser. Only KeyPress has charCode.
-    if (event.type === "keypress") {
-      return getEventCharCode(
-        // $FlowFixMe unable to narrow to `KeyboardEvent`
-        event
-      );
-    }
 
-    return 0;
-  },
-  keyCode: function (event) {
-    // `keyCode` is the result of a KeyDown/Up event and represents the value of
-    // physical keyboard key.
-    // The actual meaning of the value depends on the users' keyboard layout
-    // which cannot be detected. Assuming that it is a US keyboard layout
-    // provides a surprisingly accurate mapping for US and European users.
-    // Due to this, it is left to the user to implement at this time.
-    if (event.type === "keydown" || event.type === "keyup") {
-      return event.keyCode;
-    }
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-    return 0;
-  },
-  which: function (event) {
-    // `which` is an alias for either `keyCode` or `charCode` depending on the
-    // type of the event.
-    if (event.type === "keypress") {
-      return getEventCharCode(
-        // $FlowFixMe unable to narrow to `KeyboardEvent`
-        event
-      );
+  {
+    if (!isHydratableType(fiber.type, fiber.pendingProps)) {
+      // This fiber never hydrates from the DOM and always does an insert
+      fiber.flags = (fiber.flags & ~Hydrating) | Placement;
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      return;
     }
+  }
 
-    if (event.type === "keydown" || event.type === "keyup") {
-      return event.keyCode;
-    }
+  var initialInstance = nextHydratableInstance;
 
-    return 0;
+  if (rootOrSingletonContext) {
+    // We may need to skip past certain nodes in these contexts
+    advanceToFirstAttemptableInstance(fiber);
   }
-});
 
-var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
-/**
- * @interface PointerEvent
- * @see http://www.w3.org/TR/pointerevents/
- */
+  var nextInstance = nextHydratableInstance;
 
-var PointerEventInterface = assign({}, MouseEventInterface, {
-  pointerId: 0,
-  width: 0,
-  height: 0,
-  pressure: 0,
-  tangentialPressure: 0,
-  tiltX: 0,
-  tiltY: 0,
-  twist: 0,
-  pointerType: 0,
-  isPrimary: 0
-});
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
 
-var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
-/**
- * @interface TouchEvent
- * @see http://www.w3.org/TR/touch-events/
- */
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
 
-var TouchEventInterface = assign({}, UIEventInterface, {
-  touches: 0,
-  targetTouches: 0,
-  changedTouches: 0,
-  altKey: 0,
-  metaKey: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  getModifierState: getEventModifierState
-});
+  var firstAttemptedInstance = nextInstance;
 
-var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
- * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
- */
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-var TransitionEventInterface = assign({}, EventInterface, {
-  propertyName: 0,
-  elapsedTime: 0,
-  pseudoElement: 0
-});
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
 
-var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
-/**
- * @interface WheelEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+    if (rootOrSingletonContext) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableInstance(fiber);
+    }
 
-var WheelEventInterface = assign({}, MouseEventInterface, {
-  deltaX: function (event) {
-    return "deltaX" in event
-      ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
-      : "wheelDeltaX" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDeltaX
-      : 0;
-  },
-  deltaY: function (event) {
-    return "deltaY" in event
-      ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
-      : "wheelDeltaY" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
-      : "wheelDelta" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDelta
-      : 0;
-  },
-  deltaZ: 0,
-  // Browsers without "deltaMode" is reporting in raw wheel delta where one
-  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
-  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
-  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
-  deltaMode: 0
-});
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateInstance(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
 
-var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-var START_KEYCODE = 229;
-var canUseCompositionEvent = canUseDOM && "CompositionEvent" in window;
-var documentMode = null;
+  var text = fiber.pendingProps;
+  var isHydratable = isHydratableText(text);
+  var initialInstance = nextHydratableInstance;
 
-if (canUseDOM && "documentMode" in document) {
-  documentMode = document.documentMode;
-} // Webkit offers a very useful `textInput` event that can be used to
-// directly represent `beforeInput`. The IE `textinput` event is not as
-// useful, so we don't use it.
+  if (rootOrSingletonContext && isHydratable) {
+    // We may need to skip past certain nodes in these contexts.
+    // We don't skip if the text is not hydratable because we know no hydratables
+    // exist which could match this Fiber
+    advanceToFirstAttemptableTextInstance();
+  }
 
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
-// by the native compositionend event may be incorrect. Japanese ideographic
-// spaces, for instance (\u3000) are not recorded correctly.
+  var nextInstance = nextHydratableInstance;
 
-var useFallbackCompositionData =
-  canUseDOM &&
-  (!canUseCompositionEvent ||
-    (documentMode && documentMode > 8 && documentMode <= 11));
-var SPACEBAR_CODE = 32;
-var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
 
-function registerEvents$3() {
-  registerTwoPhaseEvent("onBeforeInput", [
-    "compositionend",
-    "keypress",
-    "textInput",
-    "paste"
-  ]);
-  registerTwoPhaseEvent("onCompositionEnd", [
-    "compositionend",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-  registerTwoPhaseEvent("onCompositionStart", [
-    "compositionstart",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-  registerTwoPhaseEvent("onCompositionUpdate", [
-    "compositionupdate",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-} // Track whether we've ever handled a keypress on the space key.
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
 
-var hasSpaceKeypress = false;
-/**
- * Return whether a native keypress event is assumed to be a command.
- * This is required because Firefox fires `keypress` events for key commands
- * (cut, copy, select-all, etc.) even though no character is inserted.
- */
+  var firstAttemptedInstance = nextInstance;
 
-function isKeypressCommand(nativeEvent) {
-  return (
-    (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
-    !(nativeEvent.ctrlKey && nativeEvent.altKey)
-  );
-}
-/**
- * Translate native top level events into event types.
- */
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-function getCompositionEventType(domEventName) {
-  switch (domEventName) {
-    case "compositionstart":
-      return "onCompositionStart";
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
 
-    case "compositionend":
-      return "onCompositionEnd";
+    if (rootOrSingletonContext && isHydratable) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableTextInstance();
+    }
 
-    case "compositionupdate":
-      return "onCompositionUpdate";
-  }
-}
-/**
- * Does our fallback best-guess model think this event signifies that
- * composition has begun?
- */
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateText(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-function isFallbackCompositionStart(domEventName, nativeEvent) {
-  return domEventName === "keydown" && nativeEvent.keyCode === START_KEYCODE;
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
 }
-/**
- * Does our fallback mode think that this event is the end of composition?
- */
-
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      // Command keys insert or clear IME input.
-      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
 
-    case "keydown":
-      // Expect IME keyCode on each keydown. If we get any other
-      // code we must have exited earlier.
-      return nativeEvent.keyCode !== START_KEYCODE;
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      // Events are not possible without cancelling IME.
-      return true;
+  var initialInstance = nextHydratableInstance;
 
-    default:
-      return false;
+  if (rootOrSingletonContext) {
+    // We may need to skip past certain nodes in these contexts
+    advanceToFirstAttemptableSuspenseInstance();
   }
-}
-/**
- * Google Input Tools provides composition data via a CustomEvent,
- * with the `data` property populated in the `detail` object. If this
- * is available on the event object, use it. If not, this is a plain
- * composition event and we have nothing special to extract.
- *
- * @param {object} nativeEvent
- * @return {?string}
- */
 
-function getDataFromCustomEvent(nativeEvent) {
-  var detail = nativeEvent.detail;
+  var nextInstance = nextHydratableInstance;
 
-  if (typeof detail === "object" && "data" in detail) {
-    return detail.data;
-  }
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
 
-  return null;
-}
-/**
- * Check if a composition event was triggered by Korean IME.
- * Our fallback mode does not work well with IE's Korean IME,
- * so just use native composition events when Korean IME is used.
- * Although CompositionEvent.locale property is deprecated,
- * it is available in IE, where our fallback mode is enabled.
- *
- * @param {object} nativeEvent
- * @return {boolean}
- */
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
 
-function isUsingKoreanIME(nativeEvent) {
-  return nativeEvent.locale === "ko";
-} // Track the current IME composition status, if any.
+  var firstAttemptedInstance = nextInstance;
 
-var isComposing = false;
-/**
- * @return {?object} A SyntheticCompositionEvent.
- */
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-function extractCompositionEvent(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget
-) {
-  var eventType;
-  var fallbackData;
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
 
-  if (canUseCompositionEvent) {
-    eventType = getCompositionEventType(domEventName);
-  } else if (!isComposing) {
-    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
-      eventType = "onCompositionStart";
+    if (rootOrSingletonContext) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableSuspenseInstance();
     }
-  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
-    eventType = "onCompositionEnd";
-  }
 
-  if (!eventType) {
-    return null;
-  }
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateSuspense(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
-    // The current composition is stored statically and must not be
-    // overwritten while composition continues.
-    if (!isComposing && eventType === "onCompositionStart") {
-      isComposing = initialize(nativeEventTarget);
-    } else if (eventType === "onCompositionEnd") {
-      if (isComposing) {
-        fallbackData = getData();
-      }
-    }
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
   }
+}
 
-  var listeners = accumulateTwoPhaseListeners(targetInst, eventType);
-
-  if (listeners.length > 0) {
-    var event = new SyntheticCompositionEvent(
-      eventType,
-      domEventName,
-      null,
-      nativeEvent,
-      nativeEventTarget
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
+function prepareToHydrateHostInstance(fiber, hostContext) {
+  var instance = fiber.stateNode;
+  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
+  var updatePayload = hydrateInstance(
+    instance,
+    fiber.type,
+    fiber.memoizedProps,
+    hostContext,
+    fiber,
+    shouldWarnIfMismatchDev
+  ); // TODO: Type this specific to this type of component.
 
-    if (fallbackData) {
-      // Inject data generated from fallback path into the synthetic event.
-      // This matches the property of native CompositionEventInterface.
-      // $FlowFixMe[incompatible-use]
-      event.data = fallbackData;
-    } else {
-      var customData = getDataFromCustomEvent(nativeEvent);
+  fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
+  // is a new ref we mark this as an update.
 
-      if (customData !== null) {
-        // $FlowFixMe[incompatible-use]
-        event.data = customData;
-      }
-    }
+  if (updatePayload !== null) {
+    return true;
   }
+
+  return false;
 }
 
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
+function prepareToHydrateHostTextInstance(fiber) {
+  var textInstance = fiber.stateNode;
+  var textContent = fiber.memoizedProps;
+  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
+  var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
 
-    case "keypress":
-      /**
-       * If native `textInput` events are available, our goal is to make
-       * use of them. However, there is a special case: the spacebar key.
-       * In Webkit, preventing default on a spacebar `textInput` event
-       * cancels character insertion, but it *also* causes the browser
-       * to fall back to its default spacebar behavior of scrolling the
-       * page.
-       *
-       * Tracking at:
-       * https://code.google.com/p/chromium/issues/detail?id=355103
-       *
-       * To avoid this issue, use the keypress event as if no `textInput`
-       * event is available.
-       */
-      var which = nativeEvent.which;
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    var returnFiber = hydrationParentFiber;
 
-      if (which !== SPACEBAR_CODE) {
-        return null;
-      }
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot: {
+          var parentContainer = returnFiber.stateNode.containerInfo;
+          var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+          didNotMatchHydratedContainerTextInstance(
+            parentContainer,
+            textInstance,
+            textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode,
+            shouldWarnIfMismatchDev
+          );
+          break;
+        }
 
-      hasSpaceKeypress = true;
-      return SPACEBAR_CHAR;
+        case HostSingleton:
+        case HostComponent: {
+          var parentType = returnFiber.type;
+          var parentProps = returnFiber.memoizedProps;
+          var parentInstance = returnFiber.stateNode;
 
-    case "textInput":
-      // Record the characters to be added to the DOM.
-      var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
-      // it at the keypress level and bail immediately. Android Chrome
-      // doesn't give us keycodes, so we need to ignore it.
+          var _isConcurrentMode2 =
+            (returnFiber.mode & ConcurrentMode) !== NoMode;
 
-      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
-        return null;
+          didNotMatchHydratedTextInstance(
+            parentType,
+            parentProps,
+            parentInstance,
+            textInstance,
+            textContent, // TODO: Delete this argument when we remove the legacy root API.
+            _isConcurrentMode2,
+            shouldWarnIfMismatchDev
+          );
+          break;
+        }
       }
+    }
+  }
 
-      return chars;
+  return shouldUpdate;
+}
 
-    default:
-      // For other native event types, do nothing.
-      return null;
+function prepareToHydrateHostSuspenseInstance(fiber) {
+  var suspenseState = fiber.memoizedState;
+  var suspenseInstance =
+    suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw new Error(
+      "Expected to have a hydrated suspense instance. " +
+        "This error is likely caused by a bug in React. Please file an issue."
+    );
   }
+
+  hydrateSuspenseInstance(suspenseInstance, fiber);
 }
-/**
- * For browsers that do not provide the `textInput` event, extract the
- * appropriate string to use for SyntheticInputEvent.
- */
 
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  // If we are currently composing (IME) and using a fallback to do so,
-  // try to extract the composed characters from the fallback object.
-  // If composition event is available, we extract a string only at
-  // compositionevent, otherwise extract it at fallback events.
-  if (isComposing) {
-    if (
-      domEventName === "compositionend" ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-    ) {
-      var chars = getData();
-      reset();
-      isComposing = false;
-      return chars;
-    }
+function skipPastDehydratedSuspenseInstance(fiber) {
+  var suspenseState = fiber.memoizedState;
+  var suspenseInstance =
+    suspenseState !== null ? suspenseState.dehydrated : null;
 
-    return null;
+  if (!suspenseInstance) {
+    throw new Error(
+      "Expected to have a hydrated suspense instance. " +
+        "This error is likely caused by a bug in React. Please file an issue."
+    );
   }
 
-  switch (domEventName) {
-    case "paste":
-      // If a paste event occurs after a keypress, throw out the input
-      // chars. Paste events should not lead to BeforeInput events.
-      return null;
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+}
 
-    case "keypress":
-      /**
-       * As of v27, Firefox may fire keypress events even when no character
-       * will be inserted. A few possibilities:
-       *
-       * - `which` is `0`. Arrow keys, Esc key, etc.
-       *
-       * - `which` is the pressed key code, but no char is available.
-       *   Ex: 'AltGr + d` in Polish. There is no modified character for
-       *   this key combination and no character is inserted into the
-       *   document, but FF fires the keypress for char code `100` anyway.
-       *   No `input` event will occur.
-       *
-       * - `which` is the pressed key code, but a command combination is
-       *   being used. Ex: `Cmd+C`. No character is inserted, and no
-       *   `input` event will occur.
-       */
-      if (!isKeypressCommand(nativeEvent)) {
-        // IE fires the `keypress` event when a user types an emoji via
-        // Touch keyboard of Windows.  In such a case, the `char` property
-        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
-        // is 2, the property `which` does not represent an emoji correctly.
-        // In such a case, we directly return the `char` property instead of
-        // using `which`.
-        if (nativeEvent.char && nativeEvent.char.length > 1) {
-          return nativeEvent.char;
-        } else if (nativeEvent.which) {
-          return String.fromCharCode(nativeEvent.which);
-        }
-      }
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
 
-      return null;
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
 
-    case "compositionend":
-      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)
-        ? null
-        : nativeEvent.data;
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
 
-    default:
-      return null;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
   }
 }
-/**
- * Extract a SyntheticInputEvent for `beforeInput`, based on either native
- * `textInput` or fallback behavior.
- *
- * @return {?object} A SyntheticInputEvent.
- */
-
-function extractBeforeInputEvent(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget
-) {
-  var chars;
-
-  if (canUseTextInputEvent) {
-    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
-  } else {
-    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
-  } // If no characters are being inserted, no BeforeInput event should
-  // be fired.
 
-  if (!chars) {
-    return null;
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
+    return false;
   }
 
-  var listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
+    return false;
+  }
 
-  if (listeners.length > 0) {
-    var event = new SyntheticInputEvent(
-      "onBeforeInput",
-      "beforeinput",
-      null,
-      nativeEvent,
-      nativeEventTarget
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    }); // $FlowFixMe[incompatible-use]
+  var shouldClear = false;
 
-    event.data = chars;
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
+    if (
+      fiber.tag !== HostRoot &&
+      fiber.tag !== HostSingleton &&
+      !(
+        fiber.tag === HostComponent &&
+        shouldSetTextContent(fiber.type, fiber.memoizedProps)
+      )
+    ) {
+      shouldClear = true;
+    }
   }
-}
-/**
- * Create an `onBeforeInput` event to match
- * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
- *
- * This event plugin is based on the native `textInput` event
- * available in Chrome, Safari, Opera, and IE. This event fires after
- * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
- *
- * `beforeInput` is spec'd but not implemented in any browsers, and
- * the `input` event does not provide any useful information about what has
- * actually been added, contrary to the spec. Thus, `textInput` is the best
- * available event to identify the characters that have actually been inserted
- * into the target node.
- *
- * This plugin is also responsible for emitting `composition` events, thus
- * allowing us to share composition fallback code for both `beforeInput` and
- * `composition` event types.
- */
 
-function extractEvents$5(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  extractCompositionEvent(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  );
-  extractBeforeInputEvent(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  );
-}
+  if (shouldClear) {
+    var nextInstance = nextHydratableInstance;
 
-/**
- * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
- */
-var supportedInputTypes = {
-  color: true,
-  date: true,
-  datetime: true,
-  "datetime-local": true,
-  email: true,
-  month: true,
-  number: true,
-  password: true,
-  range: true,
-  search: true,
-  tel: true,
-  text: true,
-  time: true,
-  url: true,
-  week: true
-};
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes(fiber);
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
 
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  popToNextHostParent(fiber);
 
-  if (nodeName === "input") {
-    return !!supportedInputTypes[elem.type];
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratableSibling(fiber.stateNode)
+      : null;
   }
 
-  if (nodeName === "textarea") {
-    return true;
-  }
+  return true;
+}
 
-  return false;
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
 }
 
-/**
- * Checks if an event is supported in the current execution environment.
- *
- * NOTE: This will not work correctly for non-generic events such as `change`,
- * `reset`, `load`, `error`, and `select`.
- *
- * Borrows from Modernizr.
- *
- * @param {string} eventNameSuffix Event name, e.g. "click".
- * @return {boolean} True if the event is supported.
- * @internal
- * @license Modernizr 3.0.0pre (Custom Build) | MIT
- */
+function warnIfUnhydratedTailNodes(fiber) {
+  var nextInstance = nextHydratableInstance;
 
-function isEventSupported(eventNameSuffix) {
-  if (!canUseDOM) {
-    return false;
+  while (nextInstance) {
+    warnUnhydratedInstance(fiber, nextInstance);
+    nextInstance = getNextHydratableSibling(nextInstance);
   }
+}
 
-  var eventName = "on" + eventNameSuffix;
-  var isSupported = eventName in document;
+function resetHydrationState() {
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+  didSuspendOrErrorDEV = false;
+}
 
-  if (!isSupported) {
-    var element = document.createElement("div");
-    element.setAttribute(eventName, "return;");
-    isSupported = typeof element[eventName] === "function";
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
   }
-
-  return isSupported;
 }
 
-function registerEvents$2() {
-  registerTwoPhaseEvent("onChange", [
-    "change",
-    "click",
-    "focusin",
-    "focusout",
-    "input",
-    "keydown",
-    "keyup",
-    "selectionchange"
-  ]);
+function getIsHydrating() {
+  return isHydrating;
 }
 
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
-) {
-  // Flag this event loop as needing state restore.
-  enqueueStateRestore(target);
-  var listeners = accumulateTwoPhaseListeners(inst, "onChange");
-
-  if (listeners.length > 0) {
-    var event = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
   }
 }
-/**
- * For IE shims
- */
 
-var activeElement$1 = null;
-var activeElementInst$1 = null;
-/**
- * SECTION: handle `change` event
- */
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
 
-function shouldUseChangeEvent(elem) {
-  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName === "select" || (nodeName === "input" && elem.type === "file")
-  );
-}
+var concurrentQueues = [];
+var concurrentQueuesIndex = 0;
+var concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  var endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  var i = 0;
 
-function manualDispatchChangeEvent(nativeEvent) {
-  var dispatchQueue = [];
-  createAndAccumulateChangeEvent(
-    dispatchQueue,
-    activeElementInst$1,
-    nativeEvent,
-    getEventTarget(nativeEvent)
-  ); // If change and propertychange bubbled, we'd just bind to it like all the
-  // other events and have it go through ReactBrowserEventEmitter. Since it
-  // doesn't, we manually listen for the events and so we have to enqueue and
-  // process the abstract event manually.
-  //
-  // Batching is necessary here in order to ensure that all event handlers run
-  // before the next rerender (including event handlers attached to ancestor
-  // elements instead of directly on the input). Without this, controlled
-  // components don't work properly in conjunction with event bubbling because
-  // the component is rerendered and the value reverted before all the event
-  // handlers can run. See https://github.com/facebook/react/issues/708.
+  while (i < endIndex) {
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
 
-  batchedUpdates$1(runEventInBatch, dispatchQueue);
-}
+    if (queue !== null && update !== null) {
+      var pending = queue.pending;
 
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
-}
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
+      }
 
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
+      queue.pending = update;
+    }
 
-  if (updateValueIfChanged(targetNode)) {
-    return targetInst;
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
   }
 }
-
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if (domEventName === "change") {
-    return targetInst;
-  }
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
 }
-/**
- * SECTION: handle `input` event
- */
 
-var isInputEventSupported = false;
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
 
-if (canUseDOM) {
-  // IE9 claims to support the input event but fails to trigger it when
-  // deleting text, so we ignore its input events.
-  isInputEventSupported =
-    isEventSupported("input") &&
-    (!document.documentMode || document.documentMode > 9);
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  var alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
 }
-/**
- * (For IE <=9) Starts tracking propertychange events on the passed-in element
- * and override the value property so that we can distinguish user events from
- * value changes in JS.
- */
 
-function startWatchingForValueChange(target, targetInst) {
-  activeElement$1 = target;
-  activeElementInst$1 = targetInst;
-  activeElement$1.attachEvent("onpropertychange", handlePropertyChange);
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
 }
-/**
- * (For IE <=9) Removes the event listeners from the currently-tracked element,
- * if any exists.
- */
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  var lane = NoLane;
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
 
-function stopWatchingForValueChange() {
-  if (!activeElement$1) {
-    return;
+  var isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
   }
+}
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
 
-  activeElement$1.detachEvent("onpropertychange", handlePropertyChange);
-  activeElement$1 = null;
-  activeElementInst$1 = null;
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  var root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
 }
-/**
- * (For IE <=9) Handles a propertychange event, sending a `change` event if
- * the value of the active element has changed.
- */
-// $FlowFixMe[missing-local-annot]
 
-function handlePropertyChange(nativeEvent) {
-  if (nativeEvent.propertyName !== "value") {
-    return;
-  }
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  var alternate = sourceFiber.alternate;
 
-  if (getInstIfValueChanged(activeElementInst$1)) {
-    manualDispatchChangeEvent(nativeEvent);
-  }
-}
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
 
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  if (domEventName === "focusin") {
-    // In IE9, propertychange fires for most input events but is buggy and
-    // doesn't fire when text is deleted, but conveniently, selectionchange
-    // appears to fire in all of the remaining cases so we catch those and
-    // forward the event if the value has changed
-    // In either case, we don't want to call the event handler if the value
-    // is changed from JS so we redefine a setter for `.value` that updates
-    // our activeElementValue variable, allowing us to ignore those changes
-    //
-    // stopWatching() should be a noop here but we call it just in case we
-    // missed a blur event somehow.
-    stopWatchingForValueChange();
-    startWatchingForValueChange(target, targetInst);
-  } else if (domEventName === "focusout") {
-    stopWatchingForValueChange();
-  }
-} // For IE8 and IE9.
+  var isHidden = false;
+  var parent = sourceFiber.return;
+  var node = sourceFiber;
 
-function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
-  if (
-    domEventName === "selectionchange" ||
-    domEventName === "keyup" ||
-    domEventName === "keydown"
-  ) {
-    // On the selectionchange event, the target is just document which isn't
-    // helpful for us so just check activeElement instead.
-    //
-    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
-    // propertychange on the first input event after setting `value` from a
-    // script and fires only keydown, keypress, keyup. Catching keyup usually
-    // gets it and catching keydown lets us fire an event for the first
-    // keystroke if user does a key repeat (it'll be a little delayed: right
-    // before the second keystroke). Other input methods (e.g., paste) seem to
-    // fire selectionchange normally.
-    return getInstIfValueChanged(activeElementInst$1);
-  }
-}
-/**
- * SECTION: handle `click` event
- */
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
 
-function shouldUseClickEvent(elem) {
-  // Use the `click` event to detect changes to checkbox and radio inputs.
-  // This approach works across all browsers, whereas `change` does not fire
-  // until `blur` in IE8.
-  var nodeName = elem.nodeName;
-  return (
-    nodeName &&
-    nodeName.toLowerCase() === "input" &&
-    (elem.type === "checkbox" || elem.type === "radio")
-  );
-}
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
 
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if (domEventName === "click") {
-    return getInstIfValueChanged(targetInst);
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      var offscreenInstance = parent.stateNode;
+
+      if (
+        offscreenInstance !== null &&
+        !(offscreenInstance._visibility & OffscreenVisible)
+      ) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
   }
-}
 
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if (domEventName === "input" || domEventName === "change") {
-    return getInstIfValueChanged(targetInst);
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    var root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
   }
 }
 
-function handleControlledInputBlur(node) {
-  var state = node._wrapperState;
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  // update queues do not have a backpointer to the root, the only way to do
+  // this currently is to walk up the return path. This used to not be a big
+  // deal because we would have to walk up the return path to set
+  // the `childLanes`, anyway, but now those two traversals happen at
+  // different times.
+  // TODO: Consider adding a `root` backpointer on the update queue.
 
-  if (!state || !state.controlled || node.type !== "number") {
-    return;
-  }
+  detectUpdateOnUnmountedFiber(sourceFiber, sourceFiber);
+  var node = sourceFiber;
+  var parent = node.return;
 
-  if (!disableInputAttributeSyncing) {
-    // If controlled, assign the value attribute to the current value on blur
-    setDefaultValue(node, "number", node.value);
+  while (parent !== null) {
+    detectUpdateOnUnmountedFiber(sourceFiber, node);
+    node = parent;
+    parent = node.return;
   }
+
+  return node.tag === HostRoot ? node.stateNode : null;
 }
-/**
- * This plugin creates an `onChange` event that normalizes change events
- * across form elements. This event fires at a time when it's possible to
- * change the element's value without seeing a flicker.
- *
- * Supported elements are:
- * - input (see `isTextInputElement`)
- * - textarea
- * - select
- */
 
-function extractEvents$4(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
-  var getTargetInstFunc, handleEventFunc;
+function detectUpdateOnUnmountedFiber(sourceFiber, parent) {
+  {
+    var alternate = parent.alternate;
 
-  if (shouldUseChangeEvent(targetNode)) {
-    getTargetInstFunc = getTargetInstForChangeEvent;
-  } else if (isTextInputElement(targetNode)) {
-    if (isInputEventSupported) {
-      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-    } else {
-      getTargetInstFunc = getTargetInstForInputEventPolyfill;
-      handleEventFunc = handleEventsForInputEventPolyfill;
+    if (
+      alternate === null &&
+      (parent.flags & (Placement | Hydrating)) !== NoFlags$1
+    ) {
+      warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
     }
-  } else if (shouldUseClickEvent(targetNode)) {
-    getTargetInstFunc = getTargetInstForClickEvent;
-  } else if (
-    enableCustomElementPropertySupport &&
-    targetInst &&
-    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
-  ) {
-    getTargetInstFunc = getTargetInstForChangeEvent;
   }
+}
 
-  if (getTargetInstFunc) {
-    var inst = getTargetInstFunc(domEventName, targetInst);
-
-    if (inst) {
-      createAndAccumulateChangeEvent(
-        dispatchQueue,
-        inst,
-        nativeEvent,
-        nativeEventTarget
-      );
-      return;
-    }
-  }
+var UpdateState = 0;
+var ReplaceState = 1;
+var ForceUpdate = 2;
+var CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
 
-  if (handleEventFunc) {
-    handleEventFunc(domEventName, targetNode, targetInst);
-  } // When blurring, set the value attribute for number inputs
+var hasForceUpdate = false;
+var didWarnUpdateInsideUpdate;
+var currentlyProcessingQueue;
 
-  if (domEventName === "focusout") {
-    handleControlledInputBlur(targetNode);
-  }
+{
+  didWarnUpdateInsideUpdate = false;
+  currentlyProcessingQueue = null;
 }
 
-function registerEvents$1() {
-  registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-  registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-  registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-  registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+function initializeUpdateQueue(fiber) {
+  var queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
 }
-/**
- * For almost every interaction we care about, there will be both a top-level
- * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
- * we do not extract duplicate events. However, moving the mouse into the
- * browser from outside will not fire a `mouseout` event. In this case, we use
- * the `mouseover` top-level event.
- */
-
-function extractEvents$3(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var isOverEvent =
-    domEventName === "mouseover" || domEventName === "pointerover";
-  var isOutEvent = domEventName === "mouseout" || domEventName === "pointerout";
-
-  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
-    // If this is an over event with a target, we might have already dispatched
-    // the event in the out event of the other target. If this is replayed,
-    // then it's because we couldn't dispatch against this target previously
-    // so we have to do it now instead.
-    var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  var queue = workInProgress.updateQueue;
+  var currentQueue = current.updateQueue;
 
-    if (related) {
-      // If the related node is managed by React, we can assume that we have
-      // already dispatched the corresponding events during its mouseout.
-      if (
-        getClosestInstanceFromNode(related) ||
-        isContainerMarkedAsRoot(related)
-      ) {
-        return;
-      }
-    }
+  if (queue === currentQueue) {
+    var clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
   }
+}
+function createUpdate(lane) {
+  var update = {
+    lane: lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
 
-  if (!isOutEvent && !isOverEvent) {
-    // Must not be a mouse or pointer in or out - ignoring.
-    return;
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
   }
 
-  var win; // TODO: why is this nullable in the types but we read from it?
+  var sharedQueue = updateQueue.shared;
 
-  if (nativeEventTarget.window === nativeEventTarget) {
-    // `nativeEventTarget` is probably a window object.
-    win = nativeEventTarget;
-  } else {
-    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
-    var doc = nativeEventTarget.ownerDocument;
+  {
+    if (
+      currentlyProcessingQueue === sharedQueue &&
+      !didWarnUpdateInsideUpdate
+    ) {
+      var componentName = getComponentNameFromFiber(fiber);
 
-    if (doc) {
-      win = doc.defaultView || doc.parentWindow;
-    } else {
-      win = window;
+      error(
+        "An update (setState, replaceState, or forceUpdate) was scheduled " +
+          "from inside an update function. Update functions should be pure, " +
+          "with zero side-effects. Consider using componentDidUpdate or a " +
+          "callback.\n\nPlease update the following component: %s",
+        componentName
+      );
+
+      didWarnUpdateInsideUpdate = true;
     }
   }
 
-  var from;
-  var to;
-
-  if (isOutEvent) {
-    var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
+  if (isUnsafeClassRenderPhaseUpdate(fiber)) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    var pending = sharedQueue.pending;
 
-    from = targetInst;
-    to = _related ? getClosestInstanceFromNode(_related) : null;
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
 
-    if (to !== null) {
-      var nearestMounted = getNearestMountedFiber(to);
-      var tag = to.tag;
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
 
-      if (
-        to !== nearestMounted ||
-        (tag !== HostComponent && tag !== HostSingleton && tag !== HostText)
-      ) {
-        to = null;
-      }
-    }
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
   } else {
-    // Moving to a node from outside the window.
-    from = null;
-    to = targetInst;
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
   }
+}
+function entangleTransitions(root, fiber, lane) {
+  var updateQueue = fiber.updateQueue;
 
-  if (from === to) {
-    // Nothing pertains to our managed components.
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
     return;
   }
 
-  var SyntheticEventCtor = SyntheticMouseEvent;
-  var leaveEventType = "onMouseLeave";
-  var enterEventType = "onMouseEnter";
-  var eventTypePrefix = "mouse";
+  var sharedQueue = updateQueue.shared;
 
-  if (domEventName === "pointerout" || domEventName === "pointerover") {
-    SyntheticEventCtor = SyntheticPointerEvent;
-    leaveEventType = "onPointerLeave";
-    enterEventType = "onPointerEnter";
-    eventTypePrefix = "pointer";
-  }
+  if (isTransitionLane(lane)) {
+    var queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
 
-  var fromNode = from == null ? win : getNodeFromInstance(from);
-  var toNode = to == null ? win : getNodeFromInstance(to);
-  var leave = new SyntheticEventCtor(
-    leaveEventType,
-    eventTypePrefix + "leave",
-    from,
-    nativeEvent,
-    nativeEventTarget
-  );
-  leave.target = fromNode;
-  leave.relatedTarget = toNode;
-  var enter = null; // We should only process this nativeEvent if we are processing
-  // the first ancestor. Next time, we will ignore the event.
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
 
-  var nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+    var newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
 
-  if (nativeTargetInst === targetInst) {
-    var enterEvent = new SyntheticEventCtor(
-      enterEventType,
-      eventTypePrefix + "enter",
-      to,
-      nativeEvent,
-      nativeEventTarget
-    );
-    enterEvent.target = toNode;
-    enterEvent.relatedTarget = fromNode;
-    enter = enterEvent;
+    markRootEntangled(root, newQueueLanes);
   }
-
-  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
 }
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  var queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
 
-/**
- * inlined Object.is polyfill to avoid requiring consumers ship their own
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
- */
-function is(x, y) {
-  return (
-    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
-  );
-}
+  var current = workInProgress.alternate;
 
-var objectIs = typeof Object.is === "function" ? Object.is : is; // $FlowFixMe[method-unbinding]
+  if (current !== null) {
+    var currentQueue = current.updateQueue;
 
-/**
- * Performs equality by iterating through keys on an object and returning false
- * when any key has values which are not strictly equal between the arguments.
- * Returns true when the values of all keys are strictly equal.
- */
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      var newFirst = null;
+      var newLast = null;
+      var firstBaseUpdate = queue.firstBaseUpdate;
 
-function shallowEqual(objA, objB) {
-  if (objectIs(objA, objB)) {
-    return true;
-  }
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        var update = firstBaseUpdate;
 
-  if (
-    typeof objA !== "object" ||
-    objA === null ||
-    typeof objB !== "object" ||
-    objB === null
-  ) {
-    return false;
-  }
+        do {
+          var clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
 
-  var keysA = Object.keys(objA);
-  var keysB = Object.keys(objB);
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-  if (keysA.length !== keysB.length) {
-    return false;
-  } // Test for A's keys different from B.
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
 
-  for (var i = 0; i < keysA.length; i++) {
-    var currentKey = keysA[i];
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
 
-    if (
-      !hasOwnProperty.call(objB, currentKey) ||
-      !objectIs(objA[currentKey], objB[currentKey])
-    ) {
-      return false;
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
     }
-  }
-
-  return true;
-}
+  } // Append the update to the end of the list.
 
-/**
- * Given any node return the first leaf node without children.
- *
- * @param {DOMElement|DOMTextNode} node
- * @return {DOMElement|DOMTextNode}
- */
+  var lastBaseUpdate = queue.lastBaseUpdate;
 
-function getLeafNode(node) {
-  while (node && node.firstChild) {
-    node = node.firstChild;
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
   }
 
-  return node;
-}
-/**
- * Get the next sibling within a container. This will walk up the
- * DOM if a node's siblings have been exhausted.
- *
- * @param {DOMElement|DOMTextNode} node
- * @return {?DOMElement|DOMTextNode}
- */
-
-function getSiblingNode(node) {
-  while (node) {
-    if (node.nextSibling) {
-      return node.nextSibling;
-    }
-
-    node = node.parentNode;
-  }
+  queue.lastBaseUpdate = capturedUpdate;
 }
-/**
- * Get object describing the nodes which contain characters at offset.
- *
- * @param {DOMElement|DOMTextNode} root
- * @param {number} offset
- * @return {?object}
- */
-
-function getNodeForCharacterOffset(root, offset) {
-  var node = getLeafNode(root);
-  var nodeStart = 0;
-  var nodeEnd = 0;
 
-  while (node) {
-    if (node.nodeType === TEXT_NODE) {
-      nodeEnd = nodeStart + node.textContent.length;
+function getStateFromUpdate(
+  workInProgress,
+  queue,
+  update,
+  prevState,
+  nextProps,
+  instance
+) {
+  switch (update.tag) {
+    case ReplaceState: {
+      var payload = update.payload;
 
-      if (nodeStart <= offset && nodeEnd >= offset) {
-        return {
-          node: node,
-          offset: offset - nodeStart
-        };
-      }
+      if (typeof payload === "function") {
+        // Updater function
+        {
+          enterDisallowedContextReadInDEV();
+        }
 
-      nodeStart = nodeEnd;
-    }
+        var nextState = payload.call(instance, prevState, nextProps);
 
-    node = getLeafNode(getSiblingNode(node));
-  }
-}
+        {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
 
-/**
- * @param {DOMElement} outerNode
- * @return {?object}
- */
+            try {
+              payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
 
-function getOffsets(outerNode) {
-  var ownerDocument = outerNode.ownerDocument;
-  var win = (ownerDocument && ownerDocument.defaultView) || window;
-  var selection = win.getSelection && win.getSelection();
+          exitDisallowedContextReadInDEV();
+        }
 
-  if (!selection || selection.rangeCount === 0) {
-    return null;
-  }
+        return nextState;
+      } // State object
 
-  var anchorNode = selection.anchorNode,
-    anchorOffset = selection.anchorOffset,
-    focusNode = selection.focusNode,
-    focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
-  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
-  // expose properties, triggering a "Permission denied error" if any of its
-  // properties are accessed. The only seemingly possible way to avoid erroring
-  // is to access a property that typically works for non-anonymous divs and
-  // catch any error that may otherwise arise. See
-  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+      return payload;
+    }
 
-  try {
-    /* eslint-disable ft-flow/no-unused-expressions */
-    anchorNode.nodeType;
-    focusNode.nodeType;
-    /* eslint-enable ft-flow/no-unused-expressions */
-  } catch (e) {
-    return null;
-  }
+    case CaptureUpdate: {
+      workInProgress.flags =
+        (workInProgress.flags & ~ShouldCapture) | DidCapture;
+    }
+    // Intentional fallthrough
 
-  return getModernOffsetsFromPoints(
-    outerNode,
-    anchorNode,
-    anchorOffset,
-    focusNode,
-    focusOffset
-  );
-}
-/**
- * Returns {start, end} where `start` is the character/codepoint index of
- * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
- * `end` is the index of (focusNode, focusOffset).
- *
- * Returns null if you pass in garbage input but we should probably just crash.
- *
- * Exported only for testing.
- */
+    case UpdateState: {
+      var _payload = update.payload;
+      var partialState;
 
-function getModernOffsetsFromPoints(
-  outerNode,
-  anchorNode,
-  anchorOffset,
-  focusNode,
-  focusOffset
-) {
-  var length = 0;
-  var start = -1;
-  var end = -1;
-  var indexWithinAnchor = 0;
-  var indexWithinFocus = 0;
-  var node = outerNode;
-  var parentNode = null;
+      if (typeof _payload === "function") {
+        // Updater function
+        {
+          enterDisallowedContextReadInDEV();
+        }
 
-  outer: while (true) {
-    var next = null;
+        partialState = _payload.call(instance, prevState, nextProps);
 
-    while (true) {
-      if (
-        node === anchorNode &&
-        (anchorOffset === 0 || node.nodeType === TEXT_NODE)
-      ) {
-        start = length + anchorOffset;
-      }
+        {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
 
-      if (
-        node === focusNode &&
-        (focusOffset === 0 || node.nodeType === TEXT_NODE)
-      ) {
-        end = length + focusOffset;
-      }
+            try {
+              _payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
 
-      if (node.nodeType === TEXT_NODE) {
-        length += node.nodeValue.length;
+          exitDisallowedContextReadInDEV();
+        }
+      } else {
+        // Partial state object
+        partialState = _payload;
       }
 
-      if ((next = node.firstChild) === null) {
-        break;
-      } // Moving from `node` to its first child `next`.
+      if (partialState === null || partialState === undefined) {
+        // Null and undefined are treated as no-ops.
+        return prevState;
+      } // Merge the partial state and the previous state.
 
-      parentNode = node;
-      node = next;
+      return assign({}, prevState, partialState);
     }
 
-    while (true) {
-      if (node === outerNode) {
-        // If `outerNode` has children, this is always the second time visiting
-        // it. If it has no children, this is still the first loop, and the only
-        // valid selection is anchorNode and focusNode both equal to this node
-        // and both offsets 0, in which case we will have handled above.
-        break outer;
-      }
-
-      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
-        start = length;
-      }
-
-      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
-        end = length;
-      }
-
-      if ((next = node.nextSibling) !== null) {
-        break;
-      }
-
-      node = parentNode;
-      parentNode = node.parentNode;
-    } // Moving from `node` to its next sibling `next`.
-
-    node = next;
-  }
-
-  if (start === -1 || end === -1) {
-    // This should never happen. (Would happen if the anchor/focus nodes aren't
-    // actually inside the passed-in node.)
-    return null;
+    case ForceUpdate: {
+      hasForceUpdate = true;
+      return prevState;
+    }
   }
 
-  return {
-    start: start,
-    end: end
-  };
+  return prevState;
 }
-/**
- * In modern non-IE browsers, we can support both forward and backward
- * selections.
- *
- * Note: IE10+ supports the Selection object, but it does not support
- * the `extend` method, which means that even in modern IE, it's not possible
- * to programmatically create a backward selection. Thus, for all IE
- * versions, we use the old IE API to create our selections.
- *
- * @param {DOMElement|DOMTextNode} node
- * @param {object} offsets
- */
 
-function setOffsets(node, offsets) {
-  var doc = node.ownerDocument || document;
-  var win = (doc && doc.defaultView) || window; // Edge fails with "Object expected" in some scenarios.
-  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
-  // fails when pasting 100+ items)
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  var queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
 
-  if (!win.getSelection) {
-    return;
+  {
+    currentlyProcessingQueue = queue.shared;
   }
 
-  var selection = win.getSelection();
-  var length = node.textContent.length;
-  var start = Math.min(offsets.start, length);
-  var end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
-  // Flip backward selections, so we can set with a single range.
-
-  if (!selection.extend && start > end) {
-    var temp = end;
-    end = start;
-    start = temp;
-  }
+  var firstBaseUpdate = queue.firstBaseUpdate;
+  var lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
 
-  var startMarker = getNodeForCharacterOffset(node, start);
-  var endMarker = getNodeForCharacterOffset(node, end);
+  var pendingQueue = queue.shared.pending;
 
-  if (startMarker && endMarker) {
-    if (
-      selection.rangeCount === 1 &&
-      selection.anchorNode === startMarker.node &&
-      selection.anchorOffset === startMarker.offset &&
-      selection.focusNode === endMarker.node &&
-      selection.focusOffset === endMarker.offset
-    ) {
-      return;
-    }
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
 
-    var range = doc.createRange();
-    range.setStart(startMarker.node, startMarker.offset);
-    selection.removeAllRanges();
+    var lastPendingUpdate = pendingQueue;
+    var firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
 
-    if (start > end) {
-      selection.addRange(range);
-      selection.extend(endMarker.node, endMarker.offset);
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
     } else {
-      range.setEnd(endMarker.node, endMarker.offset);
-      selection.addRange(range);
+      lastBaseUpdate.next = firstPendingUpdate;
     }
-  }
-}
-
-function isTextNode(node) {
-  return node && node.nodeType === TEXT_NODE;
-}
 
-function containsNode$1(outerNode, innerNode) {
-  if (!outerNode || !innerNode) {
-    return false;
-  } else if (outerNode === innerNode) {
-    return true;
-  } else if (isTextNode(outerNode)) {
-    return false;
-  } else if (isTextNode(innerNode)) {
-    return containsNode$1(outerNode, innerNode.parentNode);
-  } else if ("contains" in outerNode) {
-    return outerNode.contains(innerNode);
-  } else if (outerNode.compareDocumentPosition) {
-    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
-  } else {
-    return false;
-  }
-}
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
 
-function isInDocument(node) {
-  return (
-    node &&
-    node.ownerDocument &&
-    containsNode$1(node.ownerDocument.documentElement, node)
-  );
-}
+    var current = workInProgress.alternate;
 
-function isSameOriginFrame(iframe) {
-  try {
-    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
-    // to throw, e.g. if it has a cross-origin src attribute.
-    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
-    // iframe.contentDocument.defaultView;
-    // A safety way is to access one of the cross origin properties: Window or Location
-    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
-    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
-    return typeof iframe.contentWindow.location.href === "string";
-  } catch (err) {
-    return false;
-  }
-}
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      var currentQueue = current.updateQueue;
+      var currentLastBaseUpdate = currentQueue.lastBaseUpdate;
 
-function getActiveElementDeep() {
-  var win = window;
-  var element = getActiveElement();
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
 
-  while (element instanceof win.HTMLIFrameElement) {
-    if (isSameOriginFrame(element)) {
-      win = element.contentWindow;
-    } else {
-      return element;
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
     }
+  } // These values may change as we process the queue.
 
-    element = getActiveElement(win.document);
-  }
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    var newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
 
-  return element;
-}
-/**
- * @ReactInputSelection: React input selection module. Based on Selection.js,
- * but modified to be suitable for react and has a couple of bug fixes (doesn't
- * assume buttons have range selections allowed).
- * Input selection module for React.
- */
+    var newLanes = NoLanes;
+    var newBaseState = null;
+    var newFirstBaseUpdate = null;
+    var newLastBaseUpdate = null;
+    var update = firstBaseUpdate;
 
-/**
- * @hasSelectionCapabilities: we get the element types that support selection
- * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
- * and `selectionEnd` rows.
- */
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      var updateLane = removeLanes(update.lane, OffscreenLane);
+      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
 
-function hasSelectionCapabilities(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName &&
-    ((nodeName === "input" &&
-      (elem.type === "text" ||
-        elem.type === "search" ||
-        elem.type === "tel" ||
-        elem.type === "url" ||
-        elem.type === "password")) ||
-      nodeName === "textarea" ||
-      elem.contentEditable === "true")
-  );
-}
-function getSelectionInformation() {
-  var focusedElem = getActiveElementDeep();
-  return {
-    focusedElem: focusedElem,
-    selectionRange: hasSelectionCapabilities(focusedElem)
-      ? getSelection$1(focusedElem)
-      : null
-  };
-}
-/**
- * @restoreSelection: If any selection information was potentially lost,
- * restore it. This is useful when performing operations that could remove dom
- * nodes and place them back in, resulting in focus being lost.
- */
+      var shouldSkipUpdate = isHiddenUpdate
+        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
+        : !isSubsetOfLanes(renderLanes, updateLane);
 
-function restoreSelection(priorSelectionInformation) {
-  var curFocusedElem = getActiveElementDeep();
-  var priorFocusedElem = priorSelectionInformation.focusedElem;
-  var priorSelectionRange = priorSelectionInformation.selectionRange;
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        var clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
 
-  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
-    if (
-      priorSelectionRange !== null &&
-      hasSelectionCapabilities(priorFocusedElem)
-    ) {
-      setSelection(priorFocusedElem, priorSelectionRange);
-    } // Focusing a node can change the scroll position, which is undesirable
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
 
-    var ancestors = [];
-    var ancestor = priorFocusedElem;
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          var _clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = _clone;
+        } // Process this update.
 
-    while ((ancestor = ancestor.parentNode)) {
-      if (ancestor.nodeType === ELEMENT_NODE) {
-        ancestors.push({
-          element: ancestor,
-          left: ancestor.scrollLeft,
-          top: ancestor.scrollTop
-        });
+        newState = getStateFromUpdate(
+          workInProgress,
+          queue,
+          update,
+          newState,
+          props,
+          instance
+        );
+        var callback = update.callback;
+
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
+
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
+
+          var callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+      update = update.next;
+
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
+
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          var _lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
+
+          var _firstPendingUpdate = _lastPendingUpdate.next;
+          _lastPendingUpdate.next = null;
+          update = _firstPendingUpdate;
+          queue.lastBaseUpdate = _lastPendingUpdate;
+          queue.shared.pending = null;
+        }
       }
-    }
+    } while (true);
 
-    if (typeof priorFocusedElem.focus === "function") {
-      priorFocusedElem.focus();
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
     }
 
-    for (var i = 0; i < ancestors.length; i++) {
-      var info = ancestors[i];
-      info.element.scrollLeft = info.left;
-      info.element.scrollTop = info.top;
-    }
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
+
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // 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.
+
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
   }
-}
-/**
- * @getSelection: Gets the selection bounds of a focused textarea, input or
- * contentEditable node.
- * -@input: Look up selection bounds of this input
- * -@return {start: selectionStart, end: selectionEnd}
- */
 
-function getSelection$1(input) {
-  var selection;
+  {
+    currentlyProcessingQueue = null;
+  }
+}
 
-  if ("selectionStart" in input) {
-    // Modern browser with input or textarea.
-    selection = {
-      start: input.selectionStart,
-      end: input.selectionEnd
-    };
-  } else {
-    // Content editable or old IE textarea.
-    selection = getOffsets(input);
+function callCallback(callback, context) {
+  if (typeof callback !== "function") {
+    throw new Error(
+      "Invalid argument passed as callback. Expected a function. Instead " +
+        ("received: " + callback)
+    );
   }
 
-  return (
-    selection || {
-      start: 0,
-      end: 0
-    }
-  );
+  callback.call(context);
 }
-/**
- * @setSelection: Sets the selection bounds of a textarea or input and focuses
- * the input.
- * -@input     Set selection bounds of this input or textarea
- * -@offsets   Object of same form that is returned from get*
- */
 
-function setSelection(input, offsets) {
-  var start = offsets.start;
-  var end = offsets.end;
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  var newHiddenCallbacks = updateQueue.callbacks;
 
-  if (end === undefined) {
-    end = start;
-  }
+  if (newHiddenCallbacks !== null) {
+    var existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
 
-  if ("selectionStart" in input) {
-    input.selectionStart = start;
-    input.selectionEnd = Math.min(end, input.value.length);
-  } else {
-    setOffsets(input, offsets);
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks =
+        existingHiddenCallbacks.concat(newHiddenCallbacks);
+    }
   }
 }
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
 
-var skipSelectionChangeEvent =
-  canUseDOM && "documentMode" in document && document.documentMode <= 11;
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
 
-function registerEvents() {
-  registerTwoPhaseEvent("onSelect", [
-    "focusout",
-    "contextmenu",
-    "dragend",
-    "focusin",
-    "keydown",
-    "keyup",
-    "mousedown",
-    "mouseup",
-    "selectionchange"
-  ]);
+    for (var i = 0; i < hiddenCallbacks.length; i++) {
+      var callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
 }
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
 
-var activeElement = null;
-var activeElementInst = null;
-var lastSelection = null;
-var mouseDown = false;
-/**
- * Get an object which is a unique representation of the current selection.
- *
- * The return value will not be consistent across nodes or browsers, but
- * two identical selections on the same node will return identical objects.
- */
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
 
-function getSelection(node) {
-  if ("selectionStart" in node && hasSelectionCapabilities(node)) {
-    return {
-      start: node.selectionStart,
-      end: node.selectionEnd
-    };
-  } else {
-    var win = (node.ownerDocument && node.ownerDocument.defaultView) || window;
-    var selection = win.getSelection();
-    return {
-      anchorNode: selection.anchorNode,
-      anchorOffset: selection.anchorOffset,
-      focusNode: selection.focusNode,
-      focusOffset: selection.focusOffset
-    };
+    for (var i = 0; i < callbacks.length; i++) {
+      var callback = callbacks[i];
+      callCallback(callback, context);
+    }
   }
 }
-/**
- * Get document associated with the event target.
- */
 
-function getEventTargetDocument(eventTarget) {
-  return eventTarget.window === eventTarget
-    ? eventTarget.document
-    : eventTarget.nodeType === DOCUMENT_NODE
-    ? eventTarget
-    : eventTarget.ownerDocument;
-}
 /**
- * Poll selection to see whether it's changed.
- *
- * @param {object} nativeEvent
- * @param {object} nativeEventTarget
- * @return {?SyntheticEvent}
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
  */
 
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  // Ensure we have the right element, and that the user is not dragging a
-  // selection (this matches native `select` event behavior). In HTML5, select
-  // fires only on input and textarea thus if there's no focused element we
-  // won't dispatch.
-  var doc = getEventTargetDocument(nativeEventTarget);
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
 
   if (
-    mouseDown ||
-    activeElement == null ||
-    activeElement !== getActiveElement(doc)
+    typeof objA !== "object" ||
+    objA === null ||
+    typeof objB !== "object" ||
+    objB === null
   ) {
-    return;
-  } // Only fire when selection has actually changed.
+    return false;
+  }
 
-  var currentSelection = getSelection(activeElement);
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
 
-  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
-    lastSelection = currentSelection;
-    var listeners = accumulateTwoPhaseListeners(activeElementInst, "onSelect");
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
 
-    if (listeners.length > 0) {
-      var event = new SyntheticEvent(
-        "onSelect",
-        "select",
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
-      dispatchQueue.push({
-        event: event,
-        listeners: listeners
-      });
-      event.target = activeElement;
+  for (var i = 0; i < keysA.length; i++) {
+    var currentKey = keysA[i];
+
+    if (
+      !hasOwnProperty.call(objB, currentKey) ||
+      !objectIs(objA[currentKey], objB[currentKey])
+    ) {
+      return false;
     }
   }
+
+  return true;
 }
-/**
- * This plugin creates an `onSelect` event that normalizes select events
- * across form elements.
- *
- * Supported elements are:
- * - input (see `isTextInputElement`)
- * - textarea
- * - contentEditable
- *
- * This differs from native browser implementations in the following ways:
- * - Fires on contentEditable fields as well as inputs.
- * - Fires for collapsed selection.
- * - Fires after user input.
- */
 
-function extractEvents$2(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+var ReactStrictModeWarnings = {
+  recordUnsafeLifecycleWarnings: function (fiber, instance) {},
+  flushPendingUnsafeLifecycleWarnings: function () {},
+  recordLegacyContextWarning: function (fiber, instance) {},
+  flushLegacyContextWarning: function () {},
+  discardPendingWarnings: function () {}
+};
 
-  switch (domEventName) {
-    // Track the input node that has focus.
-    case "focusin":
-      if (
-        isTextInputElement(targetNode) ||
-        targetNode.contentEditable === "true"
-      ) {
-        activeElement = targetNode;
-        activeElementInst = targetInst;
-        lastSelection = null;
+{
+  var findStrictRoot = function (fiber) {
+    var maybeStrictRoot = null;
+    var node = fiber;
+
+    while (node !== null) {
+      if (node.mode & StrictLegacyMode) {
+        maybeStrictRoot = node;
       }
 
-      break;
+      node = node.return;
+    }
 
-    case "focusout":
-      activeElement = null;
-      activeElementInst = null;
-      lastSelection = null;
-      break;
-    // Don't fire the event while the user is dragging. This matches the
-    // semantics of the native select event.
+    return maybeStrictRoot;
+  };
 
-    case "mousedown":
-      mouseDown = true;
-      break;
+  var setToSortedString = function (set) {
+    var array = [];
+    set.forEach(function (value) {
+      array.push(value);
+    });
+    return array.sort().join(", ");
+  };
 
-    case "contextmenu":
-    case "mouseup":
-    case "dragend":
-      mouseDown = false;
-      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-      break;
-    // Chrome and IE fire non-standard event when selection is changed (and
-    // sometimes when it hasn't). IE's event fires out of order with respect
-    // to key and input events on deletion, so we discard it.
-    //
-    // Firefox doesn't support selectionchange, so check selection status
-    // after each key entry. The selection changes after keydown and before
-    // keyup, but we check on keydown as well in the case of holding down a
-    // key, when multiple keydown events are fired but only one keyup is.
-    // This is also our approach for IE handling, for the reason above.
+  var pendingComponentWillMountWarnings = [];
+  var pendingUNSAFE_ComponentWillMountWarnings = [];
+  var pendingComponentWillReceivePropsWarnings = [];
+  var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+  var pendingComponentWillUpdateWarnings = [];
+  var pendingUNSAFE_ComponentWillUpdateWarnings = []; // Tracks components we have already warned about.
 
-    case "selectionchange":
-      if (skipSelectionChangeEvent) {
-        break;
-      }
+  var didWarnAboutUnsafeLifecycles = new Set();
 
-    // falls through
+  ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (
+    fiber,
+    instance
+  ) {
+    // Dedupe strategy: Warn once per component.
+    if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
+      return;
+    }
 
-    case "keydown":
-    case "keyup":
-      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-  }
-}
+    if (
+      typeof instance.componentWillMount === "function" && // Don't warn about react-lifecycles-compat polyfilled components.
+      instance.componentWillMount.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillMountWarnings.push(fiber);
+    }
 
-/**
- * Generate a mapping of standard vendor prefixes using the defined style property and event name.
- *
- * @param {string} styleProp
- * @param {string} eventName
- * @returns {object}
- */
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillMount === "function"
+    ) {
+      pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
+    }
 
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
-}
-/**
- * A list of event names to a configurable list of vendor prefixes.
- */
+    if (
+      typeof instance.componentWillReceiveProps === "function" &&
+      instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillReceivePropsWarnings.push(fiber);
+    }
 
-var vendorPrefixes = {
-  animationend: makePrefixMap("Animation", "AnimationEnd"),
-  animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-  animationstart: makePrefixMap("Animation", "AnimationStart"),
-  transitionend: makePrefixMap("Transition", "TransitionEnd")
-};
-/**
- * Event names that have already been detected and prefixed (if applicable).
- */
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillReceiveProps === "function"
+    ) {
+      pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
+    }
 
-var prefixedEventNames = {};
-/**
- * Element to check for prefixes on.
- */
+    if (
+      typeof instance.componentWillUpdate === "function" &&
+      instance.componentWillUpdate.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillUpdateWarnings.push(fiber);
+    }
 
-var style = {};
-/**
- * Bootstrap if a DOM exists.
- */
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillUpdate === "function"
+    ) {
+      pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
+    }
+  };
 
-if (canUseDOM) {
-  style = document.createElement("div").style; // On some platforms, in particular some releases of Android 4.x,
-  // the un-prefixed "animation" and "transition" properties are defined on the
-  // style object but the events that fire will still be prefixed, so we need
-  // to check if the un-prefixed events are usable, and if not remove them from the map.
+  ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
+    // We do an initial pass to gather component names
+    var componentWillMountUniqueNames = new Set();
 
-  if (!("AnimationEvent" in window)) {
-    delete vendorPrefixes.animationend.animation;
-    delete vendorPrefixes.animationiteration.animation;
-    delete vendorPrefixes.animationstart.animation;
-  } // Same as above
+    if (pendingComponentWillMountWarnings.length > 0) {
+      pendingComponentWillMountWarnings.forEach(function (fiber) {
+        componentWillMountUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillMountWarnings = [];
+    }
 
-  if (!("TransitionEvent" in window)) {
-    delete vendorPrefixes.transitionend.transition;
-  }
-}
-/**
- * Attempts to determine the correct vendor prefixed event name.
- *
- * @param {string} eventName
- * @returns {string}
- */
+    var UNSAFE_componentWillMountUniqueNames = new Set();
 
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) {
-    return prefixedEventNames[eventName];
-  } else if (!vendorPrefixes[eventName]) {
-    return eventName;
-  }
+    if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillMountUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillMountWarnings = [];
+    }
 
-  var prefixMap = vendorPrefixes[eventName];
+    var componentWillReceivePropsUniqueNames = new Set();
 
-  for (var styleProp in prefixMap) {
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
+    if (pendingComponentWillReceivePropsWarnings.length > 0) {
+      pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        componentWillReceivePropsUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillReceivePropsWarnings = [];
     }
-  }
 
-  return eventName;
-}
+    var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
 
-var ANIMATION_END = getVendorPrefixedEventName("animationend");
-var ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration");
-var ANIMATION_START = getVendorPrefixedEventName("animationstart");
-var TRANSITION_END = getVendorPrefixedEventName("transitionend");
+    if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillReceivePropsUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+    }
 
-var topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
-//
-// E.g. it needs "pointerDown", not "pointerdown".
-// This is because we derive both React name ("onPointerDown")
-// and DOM name ("pointerdown") from the same list.
-//
-// Exceptions that don't match this convention are listed separately.
-//
-// prettier-ignore
+    var componentWillUpdateUniqueNames = new Set();
 
-var simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'toggle', 'touchMove', 'waiting', 'wheel'];
+    if (pendingComponentWillUpdateWarnings.length > 0) {
+      pendingComponentWillUpdateWarnings.forEach(function (fiber) {
+        componentWillUpdateUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillUpdateWarnings = [];
+    }
 
-{
-  // Special case: these two events don't have on* React handler
-  // and are only accessible via the createEventHandle API.
-  topLevelEventsToReactNames.set("beforeblur", null);
-  topLevelEventsToReactNames.set("afterblur", null);
-}
+    var UNSAFE_componentWillUpdateUniqueNames = new Set();
 
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
-}
+    if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillUpdateUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillUpdateWarnings = [];
+    } // Finally, we flush all the warnings
+    // UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
 
-function registerSimpleEvents() {
-  for (var i = 0; i < simpleEventPluginEvents.length; i++) {
-    var eventName = simpleEventPluginEvents[i];
-    var domEventName = eventName.toLowerCase();
-    var capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
-    registerSimpleEvent(domEventName, "on" + capitalizedEvent);
-  } // Special cases where event names don't match.
+    if (UNSAFE_componentWillMountUniqueNames.size > 0) {
+      var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
 
-  registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-  registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-  registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-  registerSimpleEvent("dblclick", "onDoubleClick");
-  registerSimpleEvent("focusin", "onFocus");
-  registerSimpleEvent("focusout", "onBlur");
-  registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
-}
+      error(
+        "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
+          "\nPlease update the following components: %s",
+        sortedNames
+      );
+    }
 
-function extractEvents$1(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var reactName = topLevelEventsToReactNames.get(domEventName);
+    if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
+      var _sortedNames = setToSortedString(
+        UNSAFE_componentWillReceivePropsUniqueNames
+      );
 
-  if (reactName === undefined) {
-    return;
-  }
+      error(
+        "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " +
+          "and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* If you're updating state whenever props change, " +
+          "refactor your code to use memoization techniques or move it to " +
+          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames
+      );
+    }
 
-  var SyntheticEventCtor = SyntheticEvent;
-  var reactEventType = domEventName;
+    if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
+      var _sortedNames2 = setToSortedString(
+        UNSAFE_componentWillUpdateUniqueNames
+      );
 
-  switch (domEventName) {
-    case "keypress":
-      // Firefox creates a keypress event for function keys too. This removes
-      // the unwanted keypress events. Enter is however both printable and
-      // non-printable. One would expect Tab to be as well (but it isn't).
-      if (getEventCharCode(nativeEvent) === 0) {
-        return;
-      }
+      error(
+        "Using UNSAFE_componentWillUpdate in strict mode is not recommended " +
+          "and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames2
+      );
+    }
 
-    /* falls through */
+    if (componentWillMountUniqueNames.size > 0) {
+      var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);
 
-    case "keydown":
-    case "keyup":
-      SyntheticEventCtor = SyntheticKeyboardEvent;
-      break;
+      warn(
+        "componentWillMount has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
+          "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames3
+      );
+    }
 
-    case "focusin":
-      reactEventType = "focus";
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+    if (componentWillReceivePropsUniqueNames.size > 0) {
+      var _sortedNames4 = setToSortedString(
+        componentWillReceivePropsUniqueNames
+      );
 
-    case "focusout":
-      reactEventType = "blur";
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+      warn(
+        "componentWillReceiveProps has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* If you're updating state whenever props change, refactor your " +
+          "code to use memoization techniques or move it to " +
+          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
+          "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames4
+      );
+    }
 
-    case "beforeblur":
-    case "afterblur":
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+    if (componentWillUpdateUniqueNames.size > 0) {
+      var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);
 
-    case "click":
-      // Firefox creates a click event on right mouse clicks. This removes the
-      // unwanted click events.
-      if (nativeEvent.button === 2) {
-        return;
-      }
+      warn(
+        "componentWillUpdate has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames5
+      );
+    }
+  };
 
-    /* falls through */
+  var pendingLegacyContextWarning = new Map(); // Tracks components we have already warned about.
 
-    case "auxclick":
-    case "dblclick":
-    case "mousedown":
-    case "mousemove":
-    case "mouseup": // TODO: Disabled elements should not respond to mouse events
+  var didWarnAboutLegacyContext = new Set();
 
-    /* falls through */
+  ReactStrictModeWarnings.recordLegacyContextWarning = function (
+    fiber,
+    instance
+  ) {
+    var strictRoot = findStrictRoot(fiber);
 
-    case "mouseout":
-    case "mouseover":
-    case "contextmenu":
-      SyntheticEventCtor = SyntheticMouseEvent;
-      break;
+    if (strictRoot === null) {
+      error(
+        "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."
+      );
 
-    case "drag":
-    case "dragend":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "dragstart":
-    case "drop":
-      SyntheticEventCtor = SyntheticDragEvent;
-      break;
+      return;
+    } // Dedup strategy: Warn once per component.
 
-    case "touchcancel":
-    case "touchend":
-    case "touchmove":
-    case "touchstart":
-      SyntheticEventCtor = SyntheticTouchEvent;
-      break;
+    if (didWarnAboutLegacyContext.has(fiber.type)) {
+      return;
+    }
 
-    case ANIMATION_END:
-    case ANIMATION_ITERATION:
-    case ANIMATION_START:
-      SyntheticEventCtor = SyntheticAnimationEvent;
-      break;
+    var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
 
-    case TRANSITION_END:
-      SyntheticEventCtor = SyntheticTransitionEvent;
-      break;
+    if (
+      fiber.type.contextTypes != null ||
+      fiber.type.childContextTypes != null ||
+      (instance !== null && typeof instance.getChildContext === "function")
+    ) {
+      if (warningsForRoot === undefined) {
+        warningsForRoot = [];
+        pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
+      }
 
-    case "scroll":
-      SyntheticEventCtor = SyntheticUIEvent;
-      break;
+      warningsForRoot.push(fiber);
+    }
+  };
 
-    case "wheel":
-      SyntheticEventCtor = SyntheticWheelEvent;
-      break;
+  ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+    pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
+      if (fiberArray.length === 0) {
+        return;
+      }
 
-    case "copy":
-    case "cut":
-    case "paste":
-      SyntheticEventCtor = SyntheticClipboardEvent;
-      break;
+      var firstFiber = fiberArray[0];
+      var uniqueNames = new Set();
+      fiberArray.forEach(function (fiber) {
+        uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutLegacyContext.add(fiber.type);
+      });
+      var sortedNames = setToSortedString(uniqueNames);
 
-    case "gotpointercapture":
-    case "lostpointercapture":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "pointerup":
-      SyntheticEventCtor = SyntheticPointerEvent;
-      break;
-  }
+      try {
+        setCurrentFiber(firstFiber);
 
-  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+        error(
+          "Legacy context API has been detected within a strict-mode tree." +
+            "\n\nThe old API will be supported in all 16.x releases, but applications " +
+            "using it should migrate to the new version." +
+            "\n\nPlease update the following components: %s" +
+            "\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context",
+          sortedNames
+        );
+      } finally {
+        resetCurrentFiber();
+      }
+    });
+  };
 
-  if (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) {
-    var listeners = accumulateEventHandleNonManagedNodeListeners(
-      // TODO: this cast may not make sense for events like
-      // "focus" where React listens to e.g. "focusin".
-      reactEventType,
-      targetContainer,
-      inCapturePhase
-    );
+  ReactStrictModeWarnings.discardPendingWarnings = function () {
+    pendingComponentWillMountWarnings = [];
+    pendingUNSAFE_ComponentWillMountWarnings = [];
+    pendingComponentWillReceivePropsWarnings = [];
+    pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+    pendingComponentWillUpdateWarnings = [];
+    pendingUNSAFE_ComponentWillUpdateWarnings = [];
+    pendingLegacyContextWarning = new Map();
+  };
+}
 
-    if (listeners.length > 0) {
-      // Intentionally create event lazily.
-      var event = new SyntheticEventCtor(
-        reactName,
-        reactEventType,
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
-      dispatchQueue.push({
-        event: event,
-        listeners: listeners
-      });
-    }
-  } else {
-    // Some events don't bubble in the browser.
-    // In the past, React has always bubbled them, but this can be surprising.
-    // We're going to try aligning closer to the browser behavior by not bubbling
-    // them in React either. We'll start by not bubbling onScroll, and then expand.
-    var accumulateTargetOnly =
-      !inCapturePhase && // TODO: ideally, we'd eventually add all events from
-      // nonDelegatedEvents list in DOMPluginEventSystem.
-      // Then we can remove this special list.
-      // This is a breaking change that can wait until React 18.
-      domEventName === "scroll";
+var ReactCurrentActQueue$2 = ReactSharedInternals.ReactCurrentActQueue; // An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
 
-    var _listeners = accumulateSinglePhaseListeners(
-      targetInst,
-      reactName,
-      nativeEvent.type,
-      inCapturePhase,
-      accumulateTargetOnly,
-      nativeEvent
-    );
+var SuspenseException = new Error(
+  "Suspense Exception: This is not a real error! It's an implementation " +
+    "detail of `use` to interrupt the current render. You must either " +
+    "rethrow it immediately, or move the `use` call outside of the " +
+    "`try/catch` block. Capturing without rethrowing will lead to " +
+    "unexpected behavior.\n\n" +
+    "To handle async errors, wrap your component in an error boundary, or " +
+    "call the promise's `.catch` method and pass the result to `use`"
+);
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+function isThenableResolved(thenable) {
+  var status = thenable.status;
+  return status === "fulfilled" || status === "rejected";
+}
 
-    if (_listeners.length > 0) {
-      // Intentionally create event lazily.
-      var _event = new SyntheticEventCtor(
-        reactName,
-        reactEventType,
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
+function noop$1() {}
 
-      dispatchQueue.push({
-        event: _event,
-        listeners: _listeners
-      });
-    }
+function trackUsedThenable(thenableState, thenable, index) {
+  if (ReactCurrentActQueue$2.current !== null) {
+    ReactCurrentActQueue$2.didUsePromise = true;
   }
-}
 
-registerSimpleEvents();
-registerEvents$1();
-registerEvents$2();
-registerEvents();
-registerEvents$3();
+  var previous = thenableState[index];
 
-function extractEvents(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  // TODO: we should remove the concept of a "SimpleEventPlugin".
-  // This is the basic functionality of the event system. All
-  // the other plugins are essentially polyfills. So the plugin
-  // should probably be inlined somewhere and have its logic
-  // be core the to event system. This would potentially allow
-  // us to ship builds of React without the polyfilled plugins below.
-  extractEvents$1(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget,
-    eventSystemFlags,
-    targetContainer
-  );
-  var shouldProcessPolyfillPlugins =
-    (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
-  // event's native "bubble" phase, which means that we're
-  // not in the capture phase. That's because we emulate
-  // the capture phase here still. This is a trade-off,
-  // because in an ideal world we would not emulate and use
-  // the phases properly, like we do with the SimpleEvent
-  // plugin. However, the plugins below either expect
-  // emulation (EnterLeave) or use state localized to that
-  // plugin (BeforeInput, Change, Select). The state in
-  // these modules complicates things, as you'll essentially
-  // get the case where the capture phase event might change
-  // state, only for the following bubble event to come in
-  // later and not trigger anything as the state now
-  // invalidates the heuristics of the event plugin. We
-  // could alter all these plugins to work in such ways, but
-  // that might cause other unknown side-effects that we
-  // can't foresee right now.
-
-  if (shouldProcessPolyfillPlugins) {
-    extractEvents$3(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$4(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$2(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$5(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-  }
-} // List of events that need to be individually attached to media elements.
-
-var mediaEventTypes = [
-  "abort",
-  "canplay",
-  "canplaythrough",
-  "durationchange",
-  "emptied",
-  "encrypted",
-  "ended",
-  "error",
-  "loadeddata",
-  "loadedmetadata",
-  "loadstart",
-  "pause",
-  "play",
-  "playing",
-  "progress",
-  "ratechange",
-  "resize",
-  "seeked",
-  "seeking",
-  "stalled",
-  "suspend",
-  "timeupdate",
-  "volumechange",
-  "waiting"
-]; // We should not delegate these events to the container, but rather
-// set them on the actual target element itself. This is primarily
-// because these events do not consistently bubble in the DOM.
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$1, noop$1);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
 
-var nonDelegatedEvents = new Set(
-  ["cancel", "close", "invalid", "load", "scroll", "toggle"].concat(
-    mediaEventTypes
-  )
-);
+  switch (thenable.status) {
+    case "fulfilled": {
+      var fulfilledValue = thenable.value;
+      return fulfilledValue;
+    }
 
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
-  event.currentTarget = null;
-}
+    case "rejected": {
+      var rejectedError = thenable.reason;
+      throw rejectedError;
+    }
 
-function processDispatchQueueItemsInOrder(
-  event,
-  dispatchListeners,
-  inCapturePhase
-) {
-  var previousInstance;
+    default: {
+      if (typeof thenable.status === "string") {
+        // Only instrument the thenable if the status if not defined. If
+        // it's defined, but an unknown value, assume it's been instrumented by
+        // some custom userspace implementation. We treat it as "pending".
+        // Attach a dummy listener, to ensure that any lazy initialization can
+        // happen. Flight lazily parses JSON when the value is actually awaited.
+        thenable.then(noop$1, noop$1);
+      } else {
+        var pendingThenable = thenable;
+        pendingThenable.status = "pending";
+        pendingThenable.then(
+          function (fulfilledValue) {
+            if (thenable.status === "pending") {
+              var fulfilledThenable = thenable;
+              fulfilledThenable.status = "fulfilled";
+              fulfilledThenable.value = fulfilledValue;
+            }
+          },
+          function (error) {
+            if (thenable.status === "pending") {
+              var rejectedThenable = thenable;
+              rejectedThenable.status = "rejected";
+              rejectedThenable.reason = error;
+            }
+          }
+        );
+      } // Check one more time in case the thenable resolved synchronously.
 
-  if (inCapturePhase) {
-    for (var i = dispatchListeners.length - 1; i >= 0; i--) {
-      var _dispatchListeners$i = dispatchListeners[i],
-        instance = _dispatchListeners$i.instance,
-        currentTarget = _dispatchListeners$i.currentTarget,
-        listener = _dispatchListeners$i.listener;
+      switch (thenable.status) {
+        case "fulfilled": {
+          var fulfilledThenable = thenable;
+          return fulfilledThenable.value;
+        }
 
-      if (instance !== previousInstance && event.isPropagationStopped()) {
-        return;
-      }
+        case "rejected": {
+          var rejectedThenable = thenable;
+          throw rejectedThenable.reason;
+        }
+      } // Suspend.
+      //
+      // Throwing here is an implementation detail that allows us to unwind the
+      // call stack. But we shouldn't allow it to leak into userspace. Throw an
+      // opaque placeholder value instead of the actual thenable. If it doesn't
+      // get captured by the work loop, log a warning, because that means
+      // something in userspace must have caught it.
 
-      executeDispatch(event, listener, currentTarget);
-      previousInstance = instance;
-    }
-  } else {
-    for (var _i = 0; _i < dispatchListeners.length; _i++) {
-      var _dispatchListeners$_i = dispatchListeners[_i],
-        _instance = _dispatchListeners$_i.instance,
-        _currentTarget = _dispatchListeners$_i.currentTarget,
-        _listener = _dispatchListeners$_i.listener;
+      suspendedThenable = thenable;
 
-      if (_instance !== previousInstance && event.isPropagationStopped()) {
-        return;
+      {
+        needsToResetSuspendedThenableDEV = true;
       }
 
-      executeDispatch(event, _listener, _currentTarget);
-      previousInstance = _instance;
+      throw SuspenseException;
     }
   }
-}
-
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
-
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event,
-      listeners = _dispatchQueue$i.listeners;
-    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
-  } // This would be a good time to rethrow if any of the event handlers threw.
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
 
-  rethrowCaughtError();
-}
+var suspendedThenable = null;
+var needsToResetSuspendedThenableDEV = false;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error(
+      "Expected a suspended thenable. This is a bug in React. Please file " +
+        "an issue."
+    );
+  }
 
-function dispatchEventsForPlugins(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst,
-  targetContainer
-) {
-  var nativeEventTarget = getEventTarget(nativeEvent);
-  var dispatchQueue = [];
-  extractEvents(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget,
-    eventSystemFlags,
-    targetContainer
-  );
-  processDispatchQueue(dispatchQueue, eventSystemFlags);
-}
+  var thenable = suspendedThenable;
+  suspendedThenable = null;
 
-function listenToNonDelegatedEvent(domEventName, targetElement) {
   {
-    if (!nonDelegatedEvents.has(domEventName)) {
-      error(
-        'Did not expect a listenToNonDelegatedEvent() call for "%s". ' +
-          "This is a bug in React. Please file an issue.",
-        domEventName
-      );
-    }
+    needsToResetSuspendedThenableDEV = false;
   }
 
-  var isCapturePhaseListener = false;
-  var listenerSet = getEventListenerSet(targetElement);
-  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
-
-  if (!listenerSet.has(listenerSetKey)) {
-    addTrappedEventListener(
-      targetElement,
-      domEventName,
-      IS_NON_DELEGATED,
-      isCapturePhaseListener
-    );
-    listenerSet.add(listenerSetKey);
-  }
+  return thenable;
 }
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+function checkIfUseWrappedInTryCatch() {
   {
-    if (nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener) {
-      error(
-        'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. ' +
-          "This is a bug in React. Please file an issue.",
-        domEventName
-      );
+    // This was set right before SuspenseException was thrown, and it should
+    // have been cleared when the exception was handled. If it wasn't,
+    // it must have been caught by userspace.
+    if (needsToResetSuspendedThenableDEV) {
+      needsToResetSuspendedThenableDEV = false;
+      return true;
     }
   }
 
-  var eventSystemFlags = 0;
+  return false;
+}
 
-  if (isCapturePhaseListener) {
-    eventSystemFlags |= IS_CAPTURE_PHASE;
-  }
+var thenableState$1 = null;
+var thenableIndexCounter$1 = 0;
+var didWarnAboutMaps;
+var didWarnAboutGenerators;
+var didWarnAboutStringRefs;
+var ownerHasKeyUseWarning;
+var ownerHasFunctionTypeWarning;
 
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
-} // This is only used by createEventHandle when the
-// target is not a DOM element. E.g. window.
+var warnForMissingKey = function (child, returnFiber) {};
 
-function listenToNativeEventForNonManagedEventTarget(
-  domEventName,
-  isCapturePhaseListener,
-  target
-) {
-  var eventSystemFlags = IS_EVENT_HANDLE_NON_MANAGED_NODE;
-  var listenerSet = getEventListenerSet(target);
-  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+{
+  didWarnAboutMaps = false;
+  didWarnAboutGenerators = false;
+  didWarnAboutStringRefs = {};
+  /**
+   * Warn if there's no key explicitly set on dynamic arrays of children or
+   * object keys are not valid. This allows us to keep track of children between
+   * updates.
+   */
 
-  if (!listenerSet.has(listenerSetKey)) {
-    if (isCapturePhaseListener) {
-      eventSystemFlags |= IS_CAPTURE_PHASE;
+  ownerHasKeyUseWarning = {};
+  ownerHasFunctionTypeWarning = {};
+
+  warnForMissingKey = function (child, returnFiber) {
+    if (child === null || typeof child !== "object") {
+      return;
     }
 
-    addTrappedEventListener(
-      target,
-      domEventName,
-      eventSystemFlags,
-      isCapturePhaseListener
-    );
-    listenerSet.add(listenerSetKey);
-  }
-}
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = true;
-    allNativeEvents.forEach(function (domEventName) {
-      // We handle selectionchange separately because it
-      // doesn't bubble and needs to be on the document.
-      if (domEventName !== "selectionchange") {
-        if (!nonDelegatedEvents.has(domEventName)) {
-          listenToNativeEvent(domEventName, false, rootContainerElement);
-        }
+    if (!child._store || child._store.validated || child.key != null) {
+      return;
+    }
 
-        listenToNativeEvent(domEventName, true, rootContainerElement);
-      }
-    });
-    var ownerDocument =
-      rootContainerElement.nodeType === DOCUMENT_NODE
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
+    if (typeof child._store !== "object") {
+      throw new Error(
+        "React Component in warnForMissingKey should have a _store. " +
+          "This error is likely caused by a bug in React. Please file an issue."
+      );
+    } // $FlowFixMe unable to narrow type from mixed to writable object
 
-    if (ownerDocument !== null) {
-      // The selectionchange event also needs deduplication
-      // but it is attached to the document.
-      if (!ownerDocument[listeningMarker]) {
-        ownerDocument[listeningMarker] = true;
-        listenToNativeEvent("selectionchange", false, ownerDocument);
-      }
+    child._store.validated = true;
+    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
+
+    if (ownerHasKeyUseWarning[componentName]) {
+      return;
     }
-  }
+
+    ownerHasKeyUseWarning[componentName] = true;
+
+    error(
+      "Each child in a list should have a unique " +
+        '"key" prop. See https://reactjs.org/link/warning-keys for ' +
+        "more information."
+    );
+  };
 }
 
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  var listener = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  ); // If passive option is not supported, then the event will be
-  // active and not passive.
+function isReactClass(type) {
+  return type.prototype && type.prototype.isReactComponent;
+}
 
-  var isPassiveListener = undefined;
+function unwrapThenable(thenable) {
+  var index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
 
-  if (passiveBrowserEventsSupported) {
-    // Browsers introduced an intervention, making these events
-    // passive by default on document. React doesn't bind them
-    // to document anymore, but changing this now would undo
-    // the performance wins from the change. So we emulate
-    // the existing behavior manually on the roots now.
-    // https://github.com/facebook/react/issues/19651
-    if (
-      domEventName === "touchstart" ||
-      domEventName === "touchmove" ||
-      domEventName === "wheel"
-    ) {
-      isPassiveListener = true;
-    }
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
   }
 
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  var unsubscribeListener; // When legacyFBSupport is enabled, it's for when we
-  // want to add a one time event listener to a container.
-  // This should only be used with enableLegacyFBSupport
-  // due to requirement to provide compatibility with
-  // internal FB www event tooling. This works by removing
-  // the event listener as soon as it is invoked. We could
-  // also attempt to use the {once: true} param on
-  // addEventListener, but that requires support and some
-  // browsers do not support this today, and given this is
-  // to support legacy code patterns, it's likely they'll
-  // need support for such browsers.
-
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = listener; // $FlowFixMe[missing-this-annot]
-    // $FlowFixMe[definition-cycle]
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
 
-    listener = function () {
-      removeEventListener(
-        targetContainer,
-        domEventName,
-        unsubscribeListener,
-        isCapturePhaseListener
-      );
+function coerceRef(returnFiber, current, element) {
+  var mixedRef = element.ref;
 
-      for (
-        var _len = arguments.length, p = new Array(_len), _key = 0;
-        _key < _len;
-        _key++
+  if (
+    mixedRef !== null &&
+    typeof mixedRef !== "function" &&
+    typeof mixedRef !== "object"
+  ) {
+    {
+      if (
+        // We warn in ReactElement.js if owner and self are equal for string refs
+        // because these cannot be automatically converted to an arrow function
+        // using a codemod. Therefore, we don't have to warn about string refs again.
+        !(
+          element._owner &&
+          element._self &&
+          element._owner.stateNode !== element._self
+        ) && // Will already throw with "Function components cannot have string refs"
+        !(element._owner && element._owner.tag !== ClassComponent) && // Will already warn with "Function components cannot be given refs"
+        !(typeof element.type === "function" && !isReactClass(element.type)) && // Will already throw with "Element ref was specified as a string (someStringRef) but no owner was set"
+        element._owner
       ) {
-        p[_key] = arguments[_key];
-      }
+        var componentName =
+          getComponentNameFromFiber(returnFiber) || "Component";
 
-      return originalListener.apply(this, p);
-    };
-  } // TODO: There are too many combinations here. Consolidate them.
+        if (!didWarnAboutStringRefs[componentName]) {
+          error(
+            'Component "%s" contains the string ref "%s". Support for string refs ' +
+              "will be removed in a future major release. We recommend using " +
+              "useRef() or createRef() instead. " +
+              "Learn more about using refs safely here: " +
+              "https://reactjs.org/link/strict-mode-string-ref",
+            componentName,
+            mixedRef
+          );
 
-  if (isCapturePhaseListener) {
-    if (isPassiveListener !== undefined) {
-      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        listener,
-        isPassiveListener
-      );
-    } else {
-      unsubscribeListener = addEventCaptureListener(
-        targetContainer,
-        domEventName,
-        listener
-      );
-    }
-  } else {
-    if (isPassiveListener !== undefined) {
-      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        listener,
-        isPassiveListener
-      );
-    } else {
-      unsubscribeListener = addEventBubbleListener(
-        targetContainer,
-        domEventName,
-        listener
-      );
+          didWarnAboutStringRefs[componentName] = true;
+        }
+      }
     }
-  }
-}
-
-function deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer) {
-  // We defer all click events with legacy FB support mode on.
-  // This means we add a one time event listener to trigger
-  // after the FB delegated listeners fire.
-  var isDeferredListenerForLegacyFBSupport = true;
-  addTrappedEventListener(
-    targetContainer,
-    domEventName,
-    IS_LEGACY_FB_SUPPORT_MODE,
-    false,
-    isDeferredListenerForLegacyFBSupport
-  );
-}
-
-function isMatchingRootContainer(grandContainer, targetContainer) {
-  return (
-    grandContainer === targetContainer ||
-    (grandContainer.nodeType === COMMENT_NODE &&
-      grandContainer.parentNode === targetContainer)
-  );
-}
-
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst,
-  targetContainer
-) {
-  var ancestorInst = targetInst;
-
-  if (
-    (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 &&
-    (eventSystemFlags & IS_NON_DELEGATED) === 0
-  ) {
-    var targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
-    // defer the event to the null with a one
-    // time event listener so we can defer the event.
 
-    if (
-      enableLegacyFBSupport && // If our event flags match the required flags for entering
-      // FB legacy mode and we are processing the "click" event,
-      // then we can defer the event to the "document", to allow
-      // for legacy FB support, where the expected behavior was to
-      // match React < 16 behavior of delegated clicks to the doc.
-      domEventName === "click" &&
-      (eventSystemFlags & SHOULD_NOT_DEFER_CLICK_FOR_FB_SUPPORT_MODE) === 0 &&
-      !isReplayingEvent(nativeEvent)
-    ) {
-      deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer);
-      return;
-    }
+    if (element._owner) {
+      var owner = element._owner;
+      var inst;
 
-    if (targetInst !== null) {
-      // The below logic attempts to work out if we need to change
-      // the target fiber to a different ancestor. We had similar logic
-      // in the legacy event system, except the big difference between
-      // systems is that the modern event system now has an event listener
-      // attached to each React Root and React Portal Root. Together,
-      // the DOM nodes representing these roots are the "rootContainer".
-      // To figure out which ancestor instance we should use, we traverse
-      // up the fiber tree from the target instance and attempt to find
-      // root boundaries that match that of our current "rootContainer".
-      // If we find that "rootContainer", we find the parent fiber
-      // sub-tree for that root and make that our ancestor instance.
-      var node = targetInst;
+      if (owner) {
+        var ownerFiber = owner;
 
-      mainLoop: while (true) {
-        if (node === null) {
-          return;
+        if (ownerFiber.tag !== ClassComponent) {
+          throw new Error(
+            "Function components cannot have string refs. " +
+              "We recommend using useRef() instead. " +
+              "Learn more about using refs safely here: " +
+              "https://reactjs.org/link/strict-mode-string-ref"
+          );
         }
 
-        var nodeTag = node.tag;
-
-        if (nodeTag === HostRoot || nodeTag === HostPortal) {
-          var container = node.stateNode.containerInfo;
-
-          if (isMatchingRootContainer(container, targetContainerNode)) {
-            break;
-          }
-
-          if (nodeTag === HostPortal) {
-            // The target is a portal, but it's not the rootContainer we're looking for.
-            // Normally portals handle their own events all the way down to the root.
-            // So we should be able to stop now. However, we don't know if this portal
-            // was part of *our* root.
-            var grandNode = node.return;
-
-            while (grandNode !== null) {
-              var grandTag = grandNode.tag;
-
-              if (grandTag === HostRoot || grandTag === HostPortal) {
-                var grandContainer = grandNode.stateNode.containerInfo;
+        inst = ownerFiber.stateNode;
+      }
 
-                if (
-                  isMatchingRootContainer(grandContainer, targetContainerNode)
-                ) {
-                  // This is the rootContainer we're looking for and we found it as
-                  // a parent of the Portal. That means we can ignore it because the
-                  // Portal will bubble through to us.
-                  return;
-                }
-              }
+      if (!inst) {
+        throw new Error(
+          "Missing owner for string ref " +
+            mixedRef +
+            ". This error is likely caused by a " +
+            "bug in React. Please file an issue."
+        );
+      } // Assigning this to a const so Flow knows it won't change in the closure
 
-              grandNode = grandNode.return;
-            }
-          } // Now we need to find it's corresponding host fiber in the other
-          // tree. To do this we can use getClosestInstanceFromNode, but we
-          // need to validate that the fiber is a host instance, otherwise
-          // we need to traverse up through the DOM till we find the correct
-          // node that is from the other tree.
+      var resolvedInst = inst;
 
-          while (container !== null) {
-            var parentNode = getClosestInstanceFromNode(container);
+      {
+        checkPropStringCoercion(mixedRef, "ref");
+      }
 
-            if (parentNode === null) {
-              return;
-            }
+      var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
 
-            var parentTag = parentNode.tag;
+      if (
+        current !== null &&
+        current.ref !== null &&
+        typeof current.ref === "function" &&
+        current.ref._stringRef === stringRef
+      ) {
+        return current.ref;
+      }
 
-            if (
-              parentTag === HostComponent ||
-              parentTag === HostText ||
-              parentTag === HostHoistable ||
-              parentTag === HostSingleton
-            ) {
-              node = ancestorInst = parentNode;
-              continue mainLoop;
-            }
+      var ref = function (value) {
+        var refs = resolvedInst.refs;
 
-            container = container.parentNode;
-          }
+        if (value === null) {
+          delete refs[stringRef];
+        } else {
+          refs[stringRef] = value;
         }
+      };
 
-        node = node.return;
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== "string") {
+        throw new Error(
+          "Expected ref to be a function, a string, an object returned by React.createRef(), or null."
+        );
+      }
+
+      if (!element._owner) {
+        throw new Error(
+          "Element ref was specified as a string (" +
+            mixedRef +
+            ") but no owner was set. This could happen for one of" +
+            " the following reasons:\n" +
+            "1. You may be adding a ref to a function component\n" +
+            "2. You may be adding a ref to a component that was not created inside a component's render method\n" +
+            "3. You have multiple copies of React loaded\n" +
+            "See https://reactjs.org/link/refs-must-have-owner for more information."
+        );
       }
     }
   }
 
-  batchedUpdates$1(function () {
-    return dispatchEventsForPlugins(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      ancestorInst,
-      targetContainer
-    );
-  });
+  return mixedRef;
 }
 
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  var childString = Object.prototype.toString.call(newChild);
+  throw new Error(
+    "Objects are not valid as a React child (found: " +
+      (childString === "[object Object]"
+        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
+        : childString) +
+      "). " +
+      "If you meant to render a collection of children, use an array " +
+      "instead."
+  );
 }
 
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  var captureName = reactName !== null ? reactName + "Capture" : null;
-  var reactEventName = inCapturePhase ? captureName : reactName;
-  var listeners = [];
-  var instance = targetFiber;
-  var lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
-
-  while (instance !== null) {
-    var _instance2 = instance,
-      stateNode = _instance2.stateNode,
-      tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+function warnOnFunctionType(returnFiber) {
+  {
+    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
 
-    if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
-    ) {
-      lastHostComponent = stateNode; // createEventHandle listeners
+    if (ownerHasFunctionTypeWarning[componentName]) {
+      return;
+    }
 
-      {
-        var eventHandlerListeners = getEventHandlerListeners(lastHostComponent);
+    ownerHasFunctionTypeWarning[componentName] = true;
 
-        if (eventHandlerListeners !== null) {
-          eventHandlerListeners.forEach(function (entry) {
-            if (
-              entry.type === nativeEventType &&
-              entry.capture === inCapturePhase
-            ) {
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-            }
-          });
-        }
-      } // Standard React on* listeners, i.e. onClick or onClickCapture
+    error(
+      "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."
+    );
+  }
+}
 
-      if (reactEventName !== null) {
-        var listener = getListener(instance, reactEventName);
+function resolveLazy(lazyType) {
+  var payload = lazyType._payload;
+  var init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
 
-        if (listener != null) {
-          listeners.push(
-            createDispatchListener(instance, listener, lastHostComponent)
-          );
-        }
-      }
-    } else if (
-      tag === ScopeComponent &&
-      lastHostComponent !== null &&
-      stateNode !== null
-    ) {
-      // Scopes
-      var reactScopeInstance = stateNode;
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
 
-      var _eventHandlerListeners = getEventHandlerListeners(reactScopeInstance);
+    var deletions = returnFiber.deletions;
 
-      if (_eventHandlerListeners !== null) {
-        _eventHandlerListeners.forEach(function (entry) {
-          if (
-            entry.type === nativeEventType &&
-            entry.capture === inCapturePhase
-          ) {
-            listeners.push(
-              createDispatchListener(
-                instance,
-                entry.callback,
-                lastHostComponent
-              )
-            );
-          }
-        });
-      }
-    } // If we are only accumulating events for the target, then we don't
-    // continue to propagate through the React fiber tree to find other
-    // listeners.
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
+    }
+  }
 
-    if (accumulateTargetOnly) {
-      break;
-    } // If we are processing the onBeforeBlur event, then we need to take
-    // into consideration that part of the React tree might have been hidden
-    // or deleted (as we're invoking this event during commit). We can find
-    // this out by checking if intercept fiber set on the event matches the
-    // current instance fiber. In which case, we should clear all existing
-    // listeners.
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
 
-    if (nativeEvent.type === "beforeblur") {
-      // $FlowFixMe[prop-missing] internal field
-      var detachedInterceptFiber = nativeEvent._detachedInterceptFiber;
+    var childToDelete = currentFirstChild;
 
-      if (
-        detachedInterceptFiber !== null &&
-        (detachedInterceptFiber === instance ||
-          detachedInterceptFiber === instance.alternate)
-      ) {
-        listeners = [];
-      }
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
     }
 
-    instance = instance.return;
+    return null;
   }
 
-  return listeners;
-} // We should only use this function for:
-// - BeforeInputEventPlugin
-// - ChangeEventPlugin
-// - SelectEventPlugin
-// This is because we only process these plugins
-// in the bubble phase, so we need to accumulate two
-// phase event listeners (via emulation).
-
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  var captureName = reactName + "Capture";
-  var listeners = [];
-  var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
-
-  while (instance !== null) {
-    var _instance3 = instance,
-      stateNode = _instance3.stateNode,
-      tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e. <div>)
-
-    if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
-    ) {
-      var currentTarget = stateNode;
-      var captureListener = getListener(instance, captureName);
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    var existingChildren = new Map();
+    var existingChild = currentFirstChild;
 
-      if (captureListener != null) {
-        listeners.unshift(
-          createDispatchListener(instance, captureListener, currentTarget)
-        );
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
       }
 
-      var bubbleListener = getListener(instance, reactName);
-
-      if (bubbleListener != null) {
-        listeners.push(
-          createDispatchListener(instance, bubbleListener, currentTarget)
-        );
-      }
+      existingChild = existingChild.sibling;
     }
 
-    instance = instance.return;
+    return existingChildren;
   }
 
-  return listeners;
-}
-
-function getParent(inst) {
-  if (inst === null) {
-    return null;
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    var clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
   }
 
-  do {
-    // $FlowFixMe[incompatible-use] found when upgrading Flow
-    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
-    // That is depending on if we want nested subtrees (layers) to bubble
-    // events to their parent. We could also go through parentNode on the
-    // host node but that wouldn't work for React Native and doesn't let us
-    // do the portal feature.
-  } while (inst && inst.tag !== HostComponent && inst.tag !== HostSingleton);
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
 
-  if (inst) {
-    return inst;
-  }
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
+    }
 
-  return null;
-}
-/**
- * Return the lowest common ancestor of A and B, or null if they are in
- * different trees.
- */
+    var current = newFiber.alternate;
 
-function getLowestCommonAncestor(instA, instB) {
-  var nodeA = instA;
-  var nodeB = instB;
-  var depthA = 0;
+    if (current !== null) {
+      var oldIndex = current.index;
 
-  for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
-    depthA++;
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
   }
 
-  var depthB = 0;
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
 
-  for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
-    depthB++;
-  } // If A is deeper, crawl up.
-
-  while (depthA - depthB > 0) {
-    nodeA = getParent(nodeA);
-    depthA--;
-  } // If B is deeper, crawl up.
+    return newFiber;
+  }
 
-  while (depthB - depthA > 0) {
-    nodeB = getParent(nodeB);
-    depthB--;
-  } // Walk in lockstep until we find a match.
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      var created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
 
-  var depth = depthA;
+  function updateElement(returnFiber, current, element, lanes) {
+    var elementType = element.type;
 
-  while (depth--) {
-    if (nodeA === nodeB || (nodeB !== null && nodeA === nodeB.alternate)) {
-      return nodeA;
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(
+        returnFiber,
+        current,
+        element.props.children,
+        lanes,
+        element.key
+      );
     }
 
-    nodeA = getParent(nodeA);
-    nodeB = getParent(nodeB);
-  }
+    if (current !== null) {
+      if (
+        current.elementType === elementType || // Keep this check inline so it only runs on the false path:
+        isCompatibleFamilyForHotReloading(current, element) || // Lazy types should reconcile their resolved type.
+        // We need to do this after the Hot Reloading check above,
+        // because hot reloading has different semantics than prod because
+        // it doesn't resuspend. So we can't let the call below suspend.
+        (typeof elementType === "object" &&
+          elementType !== null &&
+          elementType.$$typeof === REACT_LAZY_TYPE &&
+          resolveLazy(elementType) === current.type)
+      ) {
+        // Move based on index
+        var existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
 
-  return null;
-}
+        {
+          existing._debugSource = element._source;
+          existing._debugOwner = element._owner;
+        }
 
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  var registrationName = event._reactName;
-  var listeners = [];
-  var instance = target;
+        return existing;
+      }
+    } // Insert
 
-  while (instance !== null) {
-    if (instance === common) {
-      break;
-    }
+    var created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
+  }
 
-    var _instance4 = instance,
-      alternate = _instance4.alternate,
-      stateNode = _instance4.stateNode,
-      tag = _instance4.tag;
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (
+      current === null ||
+      current.tag !== HostPortal ||
+      current.stateNode.containerInfo !== portal.containerInfo ||
+      current.stateNode.implementation !== portal.implementation
+    ) {
+      // Insert
+      var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
 
-    if (alternate !== null && alternate === common) {
-      break;
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      var created = createFiberFromFragment(
+        fragment,
+        returnFiber.mode,
+        lanes,
+        key
+      );
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
     }
+  }
 
+  function createChild(returnFiber, newChild, lanes) {
     if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
     ) {
-      var currentTarget = stateNode;
-
-      if (inCapturePhase) {
-        var captureListener = getListener(instance, registrationName);
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      var created = createFiberFromText("" + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
 
-        if (captureListener != null) {
-          listeners.unshift(
-            createDispatchListener(instance, captureListener, currentTarget)
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          var _created = createFiberFromElement(
+            newChild,
+            returnFiber.mode,
+            lanes
           );
+
+          _created.ref = coerceRef(returnFiber, null, newChild);
+          _created.return = returnFiber;
+          return _created;
         }
-      } else if (!inCapturePhase) {
-        var bubbleListener = getListener(instance, registrationName);
 
-        if (bubbleListener != null) {
-          listeners.push(
-            createDispatchListener(instance, bubbleListener, currentTarget)
+        case REACT_PORTAL_TYPE: {
+          var _created2 = createFiberFromPortal(
+            newChild,
+            returnFiber.mode,
+            lanes
           );
-        }
-      }
-    }
 
-    instance = instance.return;
-  }
+          _created2.return = returnFiber;
+          return _created2;
+        }
 
-  if (listeners.length !== 0) {
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
-  }
-} // We should only use this function for:
-// - EnterLeaveEventPlugin
-// This is because we only process this plugin
-// in the bubble phase, so we need to accumulate two
-// phase event listeners.
+        case REACT_LAZY_TYPE: {
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return createChild(returnFiber, init(payload), lanes);
+        }
+      }
 
-function accumulateEnterLeaveTwoPhaseListeners(
-  dispatchQueue,
-  leaveEvent,
-  enterEvent,
-  from,
-  to
-) {
-  var common = from && to ? getLowestCommonAncestor(from, to) : null;
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        var _created3 = createFiberFromFragment(
+          newChild,
+          returnFiber.mode,
+          lanes,
+          null
+        );
 
-  if (from !== null) {
-    accumulateEnterLeaveListenersForEvent(
-      dispatchQueue,
-      leaveEvent,
-      from,
-      common,
-      false
-    );
-  }
+        _created3.return = returnFiber;
+        return _created3;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-  if (to !== null && enterEvent !== null) {
-    accumulateEnterLeaveListenersForEvent(
-      dispatchQueue,
-      enterEvent,
-      to,
-      common,
-      true
-    );
-  }
-}
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [];
-  var eventListeners = getEventHandlerListeners(currentTarget);
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
+      }
 
-  if (eventListeners !== null) {
-    eventListeners.forEach(function (entry) {
-      if (entry.type === reactEventType && entry.capture === inCapturePhase) {
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return createChild(
+          returnFiber,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
         );
       }
-    });
-  }
 
-  return listeners;
-}
-function getListenerSetKey(domEventName, capture) {
-  return domEventName + "__" + (capture ? "capture" : "bubble");
-}
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
 
-var didWarnInvalidHydration = false;
-var didWarnScriptTags = false;
-var DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML";
-var SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning";
-var SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
-var AUTOFOCUS = "autoFocus";
-var CHILDREN = "children";
-var STYLE$1 = "style";
-var HTML = "__html";
-var warnedUnknownTags;
-var canDiffStyleForHydrationWarning;
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    }
 
-{
-  warnedUnknownTags = {
-    // There are working polyfills for <dialog>. Let people use it.
-    dialog: true,
-    // Electron ships a custom <webview> tag to display external web content in
-    // an isolated frame and process.
-    // This tag is not present in non Electron environments such as JSDom which
-    // is often used for testing purposes.
-    // @see https://electronjs.org/docs/api/webview-tag
-    webview: true
-  }; // IE 11 parses & normalizes the style attribute as opposed to other
-  // browsers. It adds spaces and sorts the properties in some
-  // non-alphabetical order. Handling that would require sorting CSS
-  // properties in the client & server versions or applying
-  // `expectedStyle` to a temporary DOM node to read its `style` attribute
-  // normalized. Since it only affects IE, we're skipping style warnings
-  // in that browser completely in favor of doing all that work.
-  // See https://github.com/facebook/react/issues/11807
+    return null;
+  }
 
-  canDiffStyleForHydrationWarning = canUseDOM && !document.documentMode;
-}
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    var key = oldFiber !== null ? oldFiber.key : null;
 
-function validatePropertiesInDevelopment(type, props) {
-  {
-    validateProperties$2(type, props);
-    validateProperties$1(type, props);
-    validateProperties(type, props, {
-      registrationNameDependencies: registrationNameDependencies,
-      possibleRegistrationNames: possibleRegistrationNames
-    });
-  }
-}
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
+    ) {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
 
-function warnForPropDifference(propName, serverValue, clientValue) {
-  {
-    if (didWarnInvalidHydration) {
-      return;
+      return updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
     }
 
-    var normalizedClientValue = normalizeMarkupForTextOrAttribute(clientValue);
-    var normalizedServerValue = normalizeMarkupForTextOrAttribute(serverValue);
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          if (newChild.key === key) {
+            return updateElement(returnFiber, oldFiber, newChild, lanes);
+          } else {
+            return null;
+          }
+        }
 
-    if (normalizedServerValue === normalizedClientValue) {
-      return;
-    }
+        case REACT_PORTAL_TYPE: {
+          if (newChild.key === key) {
+            return updatePortal(returnFiber, oldFiber, newChild, lanes);
+          } else {
+            return null;
+          }
+        }
 
-    didWarnInvalidHydration = true;
+        case REACT_LAZY_TYPE: {
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+        }
+      }
 
-    error(
-      "Prop `%s` did not match. Server: %s Client: %s",
-      propName,
-      JSON.stringify(normalizedServerValue),
-      JSON.stringify(normalizedClientValue)
-    );
-  }
-}
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
 
-function warnForExtraAttributes(attributeNames) {
-  {
-    if (didWarnInvalidHydration) {
-      return;
-    }
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-    didWarnInvalidHydration = true;
-    var names = [];
-    attributeNames.forEach(function (name) {
-      names.push(name);
-    });
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          unwrapThenable(thenable),
+          lanes
+        );
+      }
 
-    error("Extra attributes from the server: %s", names);
-  }
-}
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-function warnForInvalidEventListener(registrationName, listener) {
-  {
-    if (listener === false) {
-      error(
-        "Expected `%s` listener to be a function, instead got `false`.\n\n" +
-          "If you used to conditionally omit it with %s={condition && value}, " +
-          "pass %s={condition ? value : undefined} instead.",
-        registrationName,
-        registrationName,
-        registrationName
-      );
-    } else {
-      error(
-        "Expected `%s` listener to be a function, instead got a value of `%s` type.",
-        registrationName,
-        typeof listener
-      );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-  }
-} // Parse the HTML and read it back to normalize the HTML string so that it
-// can be used for comparison.
 
-function normalizeHTML(parent, html) {
-  {
-    // We could have created a separate document here to avoid
-    // re-initializing custom elements if they exist. But this breaks
-    // how <noscript> is being handled. So we use the same document.
-    // See the discussion in https://github.com/facebook/react/pull/11157.
-    var testElement =
-      parent.namespaceURI === HTML_NAMESPACE
-        ? parent.ownerDocument.createElement(parent.tagName)
-        : parent.ownerDocument.createElementNS(
-            parent.namespaceURI,
-            parent.tagName
-          );
-    testElement.innerHTML = html;
-    return testElement.innerHTML;
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    }
+
+    return null;
   }
-} // HTML parsing normalizes CR and CRLF to LF.
-// It also can turn \u0000 into \uFFFD inside attributes.
-// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
-// If we have a mismatch, it might be caused by that.
-// We will still patch up in this case but not fire the warning.
 
-var NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
-var NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+  function updateFromMap(
+    existingChildren,
+    returnFiber,
+    newIdx,
+    newChild,
+    lanes
+  ) {
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
+    ) {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      var matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, "" + newChild, lanes);
+    }
 
-function normalizeMarkupForTextOrAttribute(markup) {
-  {
-    checkHtmlStringCoercion(markup);
-  }
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          var _matchedFiber =
+            existingChildren.get(
+              newChild.key === null ? newIdx : newChild.key
+            ) || null;
 
-  var markupString = typeof markup === "string" ? markup : "" + markup;
-  return markupString
-    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
-    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
-}
+          return updateElement(returnFiber, _matchedFiber, newChild, lanes);
+        }
 
-function checkForUnmatchedText(
-  serverText,
-  clientText,
-  isConcurrentMode,
-  shouldWarnDev
-) {
-  var normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
-  var normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
+        case REACT_PORTAL_TYPE: {
+          var _matchedFiber2 =
+            existingChildren.get(
+              newChild.key === null ? newIdx : newChild.key
+            ) || null;
 
-  if (normalizedServerText === normalizedClientText) {
-    return;
-  }
+          return updatePortal(returnFiber, _matchedFiber2, newChild, lanes);
+        }
 
-  if (shouldWarnDev) {
-    {
-      if (!didWarnInvalidHydration) {
-        didWarnInvalidHydration = true;
-
-        error(
-          'Text content did not match. Server: "%s" Client: "%s"',
-          normalizedServerText,
-          normalizedClientText
-        );
+        case REACT_LAZY_TYPE:
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return updateFromMap(
+            existingChildren,
+            returnFiber,
+            newIdx,
+            init(payload),
+            lanes
+          );
       }
-    }
-  }
-
-  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
-    // In concurrent roots, we throw when there's a text mismatch and revert to
-    // client rendering, up to the nearest Suspense boundary.
-    throw new Error("Text content does not match server-rendered HTML.");
-  }
-}
-function getOwnerDocumentFromRootContainer(rootContainerElement) {
-  return rootContainerElement.nodeType === DOCUMENT_NODE
-    ? rootContainerElement
-    : rootContainerElement.ownerDocument;
-}
-
-function noop$1() {}
 
-function trapClickOnNonInteractiveElement(node) {
-  // Mobile Safari does not fire properly bubble click events on
-  // non-interactive elements, which means delegated click listeners do not
-  // fire. The workaround for this bug involves attaching an empty click
-  // listener on the target node.
-  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
-  // Just set it using the onclick property so that we don't have to manage any
-  // bookkeeping for it. Not sure if we need to clear it when the listener is
-  // removed.
-  // TODO: Only do this for the relevant Safaris maybe?
-  node.onclick = noop$1;
-}
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        var _matchedFiber3 = existingChildren.get(newIdx) || null;
 
-function setInitialDOMProperties(
-  tag,
-  domElement,
-  nextProps,
-  isCustomComponentTag
-) {
-  for (var propKey in nextProps) {
-    if (!nextProps.hasOwnProperty(propKey)) {
-      continue;
-    }
+        return updateFragment(
+          returnFiber,
+          _matchedFiber3,
+          newChild,
+          lanes,
+          null
+        );
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-    var nextProp = nextProps[propKey];
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          unwrapThenable(thenable),
+          lanes
+        );
+      }
 
-    if (propKey === STYLE$1) {
-      {
-        if (nextProp) {
-          // Freeze the next style object so that we can assume it won't be
-          // mutated. We have already warned for this in the past.
-          Object.freeze(nextProp);
-        }
-      } // Relies on `updateStylesByID` not mutating `styleUpdates`.
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-      setValueForStyles(domElement, nextProp);
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      var nextHtml = nextProp ? nextProp[HTML] : undefined;
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
 
-      if (nextHtml != null) {
-        setInnerHTML$1(domElement, nextHtml);
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
       }
-    } else if (propKey === CHILDREN) {
-      if (typeof nextProp === "string") {
-        // Avoid setting initial textContent when the text is empty. In IE11 setting
-        // textContent on a <textarea> will cause the placeholder to not
-        // show within the <textarea> until it has been focused and blurred again.
-        // https://github.com/facebook/react/issues/6731#issuecomment-254874553
-        var canSetTextContent =
-          tag !== "body" && (tag !== "textarea" || nextProp !== "");
+    }
 
-        if (canSetTextContent) {
-          setTextContent(domElement, nextProp);
-        }
-      } else if (typeof nextProp === "number") {
-        var _canSetTextContent = tag !== "body";
+    return null;
+  }
+  /**
+   * Warns if there is a duplicate or missing key
+   */
 
-        if (_canSetTextContent) {
-          setTextContent(domElement, "" + nextProp);
-        }
+  function warnOnInvalidKey(child, knownKeys, returnFiber) {
+    {
+      if (typeof child !== "object" || child === null) {
+        return knownKeys;
       }
-    } else if (
-      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-      propKey === SUPPRESS_HYDRATION_WARNING$1
-    );
-    else if (propKey === AUTOFOCUS);
-    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      if (nextProp != null) {
-        if (typeof nextProp !== "function") {
-          warnForInvalidEventListener(propKey, nextProp);
-        }
 
-        if (propKey === "onScroll") {
-          listenToNonDelegatedEvent("scroll", domElement);
-        }
-      }
-    } else if (nextProp != null) {
-      setValueForProperty(domElement, propKey, nextProp, isCustomComponentTag);
-    }
-  }
-}
+      switch (child.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+        case REACT_PORTAL_TYPE:
+          warnForMissingKey(child, returnFiber);
+          var key = child.key;
 
-function updateDOMProperties(
-  domElement,
-  updatePayload,
-  wasCustomComponentTag,
-  isCustomComponentTag
-) {
-  // TODO: Handle wasCustomComponentTag
-  for (var i = 0; i < updatePayload.length; i += 2) {
-    var propKey = updatePayload[i];
-    var propValue = updatePayload[i + 1];
+          if (typeof key !== "string") {
+            break;
+          }
 
-    if (propKey === STYLE$1) {
-      setValueForStyles(domElement, propValue);
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      setInnerHTML$1(domElement, propValue);
-    } else if (propKey === CHILDREN) {
-      setTextContent(domElement, propValue);
-    } else {
-      setValueForProperty(domElement, propKey, propValue, isCustomComponentTag);
-    }
-  }
-} // creates a script element that won't execute
+          if (knownKeys === null) {
+            knownKeys = new Set();
+            knownKeys.add(key);
+            break;
+          }
 
-function createPotentiallyInlineScriptElement(ownerDocument) {
-  // Create the script via .innerHTML so its "parser-inserted" flag is
-  // set to true and it does not execute
-  var div = ownerDocument.createElement("div");
+          if (!knownKeys.has(key)) {
+            knownKeys.add(key);
+            break;
+          }
 
-  {
-    if (enableTrustedTypesIntegration && !didWarnScriptTags) {
-      error(
-        "Encountered a script tag while rendering React component. " +
-          "Scripts inside React components are never executed when rendering " +
-          "on the client. Consider using template tag instead " +
-          "(https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)."
-      );
+          error(
+            "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.",
+            key
+          );
 
-      didWarnScriptTags = true;
+          break;
+
+        case REACT_LAZY_TYPE:
+          var payload = child._payload;
+          var init = child._init;
+          warnOnInvalidKey(init(payload), knownKeys, returnFiber);
+          break;
+      }
     }
+
+    return knownKeys;
   }
 
-  div.innerHTML = "<script><" + "/script>"; // eslint-disable-line
-  // This is guaranteed to yield a script element.
+  function reconcileChildrenArray(
+    returnFiber,
+    currentFirstChild,
+    newChildren,
+    lanes
+  ) {
+    // This algorithm can't optimize by searching from both ends since we
+    // don't have backpointers on fibers. I'm trying to see how far we can get
+    // with that model. If it ends up not being worth the tradeoffs, we can
+    // add it later.
+    // Even with a two ended optimization, we'd want to optimize for the case
+    // where there are few changes and brute force the comparison instead of
+    // going for the Map. It'd like to explore hitting that path first in
+    // forward-only mode and only go for the Map once we notice that we need
+    // lots of look ahead. This doesn't handle reversal as well as two ended
+    // search but that's unusual. Besides, for the two ended optimization to
+    // work on Iterables, we'd need to copy the whole set.
+    // In this first iteration, we'll just live with hitting the bad case
+    // (adding everything to a Map) in for every insert/move.
+    // If you change this code, also update reconcileChildrenIterator() which
+    // uses the same algorithm.
+    {
+      // First, validate keys.
+      var knownKeys = null;
 
-  var firstChild = div.firstChild;
-  var element = div.removeChild(firstChild);
-  return element;
-}
-function createSelectElement(props, ownerDocument) {
-  var element;
+      for (var i = 0; i < newChildren.length; i++) {
+        var child = newChildren[i];
+        knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+      }
+    }
 
-  if (typeof props.is === "string") {
-    element = ownerDocument.createElement("select", {
-      is: props.is
-    });
-  } else {
-    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
-    // See discussion in https://github.com/facebook/react/pull/6896
-    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
-    element = ownerDocument.createElement("select");
-  }
+    var resultingFirstChild = null;
+    var previousNewFiber = null;
+    var oldFiber = currentFirstChild;
+    var lastPlacedIndex = 0;
+    var newIdx = 0;
+    var nextOldFiber = null;
 
-  if (props.multiple) {
-    element.multiple = true;
-  } else if (props.size) {
-    // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
-    // it is possible that no option is selected.
-    //
-    // This is only necessary when a select in "single selection mode".
-    element.size = props.size;
-  }
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
 
-  return element;
-} // Creates elements in the HTML namesapce
+      var newFiber = updateSlot(
+        returnFiber,
+        oldFiber,
+        newChildren[newIdx],
+        lanes
+      );
 
-function createHTMLElement(type, props, ownerDocument) {
-  {
-    switch (type) {
-      case "script":
-      case "select":
-        error(
-          'createHTMLElement was called with a "%s" type. This type has special creation logic in React and should use the create function implemented specifically for it. This is a bug in React.',
-          type
-        );
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
 
         break;
+      }
 
-      case "svg":
-      case "math":
-        error(
-          'createHTMLElement was called with a "%s" type. This type must be created with Document.createElementNS which this method does not implement. This is a bug in React.',
-          type
-        );
-    }
-  }
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
 
-  var isCustomComponentTag;
-  var element;
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
 
-  {
-    isCustomComponentTag = isCustomComponent(type, props); // Should this check be gated by parent namespace? Not sure we want to
-    // allow <SVG> or <mATH>.
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
 
-    if (!isCustomComponentTag && type !== type.toLowerCase()) {
-      error(
-        "<%s /> is using incorrect casing. " +
-          "Use PascalCase for React components, " +
-          "or lowercase for HTML elements.",
-        type
-      );
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
     }
-  }
 
-  if (typeof props.is === "string") {
-    element = ownerDocument.createElement(type, {
-      is: props.is
-    });
-  } else {
-    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
-    // See discussion in https://github.com/facebook/react/pull/6896
-    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
-    element = ownerDocument.createElement(type);
-  }
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
 
-  {
-    if (
-      !isCustomComponentTag && // $FlowFixMe[method-unbinding]
-      Object.prototype.toString.call(element) ===
-        "[object HTMLUnknownElement]" &&
-      !hasOwnProperty.call(warnedUnknownTags, type)
-    ) {
-      warnedUnknownTags[type] = true;
+      if (getIsHydrating()) {
+        var numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
 
-      error(
-        "The tag <%s> is unrecognized in this browser. " +
-          "If you meant to render a React component, start its name with " +
-          "an uppercase letter.",
-        type
-      );
+      return resultingFirstChild;
     }
-  }
 
-  return element;
-}
-function createTextNode(text, rootContainerElement) {
-  return getOwnerDocumentFromRootContainer(rootContainerElement).createTextNode(
-    text
-  );
-}
-function setInitialProperties(domElement, tag, rawProps) {
-  var isCustomComponentTag = isCustomComponent(tag, rawProps);
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
 
-  {
-    validatePropertiesInDevelopment(tag, rawProps);
-  } // TODO: Make sure that we check isMounted before firing any of these events.
+        if (_newFiber === null) {
+          continue;
+        }
 
-  var props;
+        lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);
 
-  switch (tag) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", domElement);
-      listenToNonDelegatedEvent("close", domElement);
-      props = rawProps;
-      break;
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = _newFiber;
+        } else {
+          previousNewFiber.sibling = _newFiber;
+        }
 
-    case "iframe":
-    case "object":
-    case "embed":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the load event.
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
+        previousNewFiber = _newFiber;
+      }
 
-    case "video":
-    case "audio":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for all the media events.
-      for (var i = 0; i < mediaEventTypes.length; i++) {
-        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      if (getIsHydrating()) {
+        var _numberOfForks = newIdx;
+        pushTreeFork(returnFiber, _numberOfForks);
       }
 
-      props = rawProps;
-      break;
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
 
-    case "source":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the error event.
-      listenToNonDelegatedEvent("error", domElement);
-      props = rawProps;
-      break;
+    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
 
-    case "img":
-    case "image":
-    case "link":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for error and load events.
-      listenToNonDelegatedEvent("error", domElement);
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
+    for (; newIdx < newChildren.length; newIdx++) {
+      var _newFiber2 = updateFromMap(
+        existingChildren,
+        returnFiber,
+        newIdx,
+        newChildren[newIdx],
+        lanes
+      );
 
-    case "details":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the toggle event.
-      listenToNonDelegatedEvent("toggle", domElement);
-      props = rawProps;
-      break;
+      if (_newFiber2 !== null) {
+        if (shouldTrackSideEffects) {
+          if (_newFiber2.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(
+              _newFiber2.key === null ? newIdx : _newFiber2.key
+            );
+          }
+        }
 
-    case "input":
-      initWrapperState$2(domElement, rawProps);
-      props = getHostProps$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+        lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+        if (previousNewFiber === null) {
+          resultingFirstChild = _newFiber2;
+        } else {
+          previousNewFiber.sibling = _newFiber2;
+        }
 
-    case "option":
-      validateProps(domElement, rawProps);
-      props = rawProps;
-      break;
+        previousNewFiber = _newFiber2;
+      }
+    }
 
-    case "select":
-      initWrapperState$1(domElement, rawProps);
-      props = getHostProps$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+    if (getIsHydrating()) {
+      var _numberOfForks2 = newIdx;
+      pushTreeFork(returnFiber, _numberOfForks2);
+    }
 
-    case "textarea":
-      initWrapperState(domElement, rawProps);
-      props = getHostProps(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+    return resultingFirstChild;
+  }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+  function reconcileChildrenIterator(
+    returnFiber,
+    currentFirstChild,
+    newChildrenIterable,
+    lanes
+  ) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    var iteratorFn = getIteratorFn(newChildrenIterable);
 
-    default:
-      props = rawProps;
-  }
+    if (typeof iteratorFn !== "function") {
+      throw new Error(
+        "An object is not an iterable. This error is likely caused by a bug in " +
+          "React. Please file an issue."
+      );
+    }
 
-  assertValidProps(tag, props);
-  setInitialDOMProperties(tag, domElement, props, isCustomComponentTag);
+    {
+      // We don't support rendering Generators because it's a mutation.
+      // See https://github.com/facebook/react/issues/12995
+      if (
+        typeof Symbol === "function" && // $FlowFixMe Flow doesn't know about toStringTag
+        newChildrenIterable[Symbol.toStringTag] === "Generator"
+      ) {
+        if (!didWarnAboutGenerators) {
+          error(
+            "Using Generators as children is unsupported and will likely yield " +
+              "unexpected results because enumerating a generator mutates it. " +
+              "You may convert it to an array with `Array.from()` or the " +
+              "`[...spread]` operator before rendering. Keep in mind " +
+              "you might need to polyfill these features for older browsers."
+          );
+        }
 
-  switch (tag) {
-    case "input":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper$3(domElement, rawProps, false);
-      break;
+        didWarnAboutGenerators = true;
+      } // Warn about using Maps as children
 
-    case "textarea":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper(domElement);
-      break;
+      if (newChildrenIterable.entries === iteratorFn) {
+        if (!didWarnAboutMaps) {
+          error(
+            "Using Maps as children is not supported. " +
+              "Use an array of keyed ReactElements instead."
+          );
+        }
 
-    case "option":
-      postMountWrapper$2(domElement, rawProps);
-      break;
+        didWarnAboutMaps = true;
+      } // First, validate keys.
+      // We'll get a different iterator later for the main pass.
 
-    case "select":
-      postMountWrapper$1(domElement, rawProps);
-      break;
+      var _newChildren = iteratorFn.call(newChildrenIterable);
 
-    default:
-      if (typeof props.onClick === "function") {
-        // TODO: This cast may not be sound for SVG, MathML or custom elements.
-        trapClickOnNonInteractiveElement(domElement);
+      if (_newChildren) {
+        var knownKeys = null;
+
+        var _step = _newChildren.next();
+
+        for (; !_step.done; _step = _newChildren.next()) {
+          var child = _step.value;
+          knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+        }
       }
+    }
 
-      break;
-  }
-} // Calculate the diff between the two objects.
+    var newChildren = iteratorFn.call(newChildrenIterable);
 
-function diffProperties(domElement, tag, lastRawProps, nextRawProps) {
-  {
-    validatePropertiesInDevelopment(tag, nextRawProps);
-  }
+    if (newChildren == null) {
+      throw new Error("An iterable object provided no iterator.");
+    }
 
-  var updatePayload = null;
-  var lastProps;
-  var nextProps;
+    var resultingFirstChild = null;
+    var previousNewFiber = null;
+    var oldFiber = currentFirstChild;
+    var lastPlacedIndex = 0;
+    var newIdx = 0;
+    var nextOldFiber = null;
+    var step = newChildren.next();
 
-  switch (tag) {
-    case "input":
-      lastProps = getHostProps$2(domElement, lastRawProps);
-      nextProps = getHostProps$2(domElement, nextRawProps);
-      updatePayload = [];
-      break;
+    for (
+      ;
+      oldFiber !== null && !step.done;
+      newIdx++, step = newChildren.next()
+    ) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
 
-    case "select":
-      lastProps = getHostProps$1(domElement, lastRawProps);
-      nextProps = getHostProps$1(domElement, nextRawProps);
-      updatePayload = [];
-      break;
+      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
 
-    case "textarea":
-      lastProps = getHostProps(domElement, lastRawProps);
-      nextProps = getHostProps(domElement, nextRawProps);
-      updatePayload = [];
-      break;
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
 
-    default:
-      lastProps = lastRawProps;
-      nextProps = nextRawProps;
+        break;
+      }
 
-      if (
-        typeof lastProps.onClick !== "function" &&
-        typeof nextProps.onClick === "function"
-      ) {
-        // TODO: This cast may not be sound for SVG, MathML or custom elements.
-        trapClickOnNonInteractiveElement(domElement);
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
       }
 
-      break;
-  }
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
 
-  assertValidProps(tag, nextProps);
-  var propKey;
-  var styleName;
-  var styleUpdates = null;
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
 
-  for (propKey in lastProps) {
-    if (
-      nextProps.hasOwnProperty(propKey) ||
-      !lastProps.hasOwnProperty(propKey) ||
-      lastProps[propKey] == null
-    ) {
-      continue;
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
     }
 
-    if (propKey === STYLE$1) {
-      var lastStyle = lastProps[propKey];
-
-      for (styleName in lastStyle) {
-        if (lastStyle.hasOwnProperty(styleName)) {
-          if (!styleUpdates) {
-            styleUpdates = {};
-          }
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
 
-          styleUpdates[styleName] = "";
-        }
-      }
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML || propKey === CHILDREN);
-    else if (
-      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-      propKey === SUPPRESS_HYDRATION_WARNING$1
-    );
-    else if (propKey === AUTOFOCUS);
-    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      // This is a special case. If any listener updates we need to ensure
-      // that the "current" fiber pointer gets updated so we need a commit
-      // to update this element.
-      if (!updatePayload) {
-        updatePayload = [];
+      if (getIsHydrating()) {
+        var numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
       }
-    } else {
-      // For all other deleted properties we add it to the queue. We use
-      // the allowed property list in the commit phase instead.
-      (updatePayload = updatePayload || []).push(propKey, null);
+
+      return resultingFirstChild;
     }
-  }
 
-  for (propKey in nextProps) {
-    var nextProp = nextProps[propKey];
-    var lastProp = lastProps != null ? lastProps[propKey] : undefined;
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        var _newFiber3 = createChild(returnFiber, step.value, lanes);
 
-    if (
-      !nextProps.hasOwnProperty(propKey) ||
-      nextProp === lastProp ||
-      (nextProp == null && lastProp == null)
-    ) {
-      continue;
-    }
+        if (_newFiber3 === null) {
+          continue;
+        }
 
-    if (propKey === STYLE$1) {
-      {
-        if (nextProp) {
-          // Freeze the next style object so that we can assume it won't be
-          // mutated. We have already warned for this in the past.
-          Object.freeze(nextProp);
+        lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = _newFiber3;
+        } else {
+          previousNewFiber.sibling = _newFiber3;
         }
+
+        previousNewFiber = _newFiber3;
       }
 
-      if (lastProp) {
-        // Unset styles on `lastProp` but not on `nextProp`.
-        for (styleName in lastProp) {
-          if (
-            lastProp.hasOwnProperty(styleName) &&
-            (!nextProp || !nextProp.hasOwnProperty(styleName))
-          ) {
-            if (!styleUpdates) {
-              styleUpdates = {};
-            }
+      if (getIsHydrating()) {
+        var _numberOfForks3 = newIdx;
+        pushTreeFork(returnFiber, _numberOfForks3);
+      }
 
-            styleUpdates[styleName] = "";
-          }
-        } // Update styles that changed since `lastProp`.
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
 
-        for (styleName in nextProp) {
-          if (
-            nextProp.hasOwnProperty(styleName) &&
-            lastProp[styleName] !== nextProp[styleName]
-          ) {
-            if (!styleUpdates) {
-              styleUpdates = {};
-            }
+    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
 
-            styleUpdates[styleName] = nextProp[styleName];
-          }
-        }
-      } else {
-        // Relies on `updateStylesByID` not mutating `styleUpdates`.
-        if (!styleUpdates) {
-          if (!updatePayload) {
-            updatePayload = [];
-          }
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      var _newFiber4 = updateFromMap(
+        existingChildren,
+        returnFiber,
+        newIdx,
+        step.value,
+        lanes
+      );
 
-          updatePayload.push(propKey, styleUpdates);
+      if (_newFiber4 !== null) {
+        if (shouldTrackSideEffects) {
+          if (_newFiber4.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(
+              _newFiber4.key === null ? newIdx : _newFiber4.key
+            );
+          }
         }
 
-        styleUpdates = nextProp;
-      }
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      var nextHtml = nextProp ? nextProp[HTML] : undefined;
-      var lastHtml = lastProp ? lastProp[HTML] : undefined;
+        lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);
 
-      if (nextHtml != null) {
-        if (lastHtml !== nextHtml) {
-          (updatePayload = updatePayload || []).push(propKey, nextHtml);
-        }
-      }
-    } else if (propKey === CHILDREN) {
-      if (typeof nextProp === "string" || typeof nextProp === "number") {
-        (updatePayload = updatePayload || []).push(propKey, "" + nextProp);
-      }
-    } else if (
-      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-      propKey === SUPPRESS_HYDRATION_WARNING$1
-    );
-    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      if (nextProp != null) {
-        // We eagerly listen to this even though we haven't committed yet.
-        if (typeof nextProp !== "function") {
-          warnForInvalidEventListener(propKey, nextProp);
+        if (previousNewFiber === null) {
+          resultingFirstChild = _newFiber4;
+        } else {
+          previousNewFiber.sibling = _newFiber4;
         }
 
-        if (propKey === "onScroll") {
-          listenToNonDelegatedEvent("scroll", domElement);
-        }
+        previousNewFiber = _newFiber4;
       }
+    }
 
-      if (!updatePayload && lastProp !== nextProp) {
-        // This is a special case. If any listener updates we need to ensure
-        // that the "current" props pointer gets updated so we need a commit
-        // to update this element.
-        updatePayload = [];
-      }
-    } else {
-      // For any other property we always add it to the queue and then we
-      // filter it out using the allowed property list during the commit.
-      (updatePayload = updatePayload || []).push(propKey, nextProp);
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
     }
-  }
 
-  if (styleUpdates) {
-    {
-      validateShorthandPropertyCollisionInDev(styleUpdates, nextProps[STYLE$1]);
+    if (getIsHydrating()) {
+      var _numberOfForks4 = newIdx;
+      pushTreeFork(returnFiber, _numberOfForks4);
     }
 
-    (updatePayload = updatePayload || []).push(STYLE$1, styleUpdates);
+    return resultingFirstChild;
   }
 
-  return updatePayload;
-} // Apply the diff.
-
-function updateProperties(
-  domElement,
-  updatePayload,
-  tag,
-  lastRawProps,
-  nextRawProps
-) {
-  // Update checked *before* name.
-  // In the middle of an update, it is possible to have multiple checked.
-  // When a checked radio tries to change name, browser makes another radio's checked false.
-  if (
-    tag === "input" &&
-    nextRawProps.type === "radio" &&
-    nextRawProps.name != null
+  function reconcileSingleTextNode(
+    returnFiber,
+    currentFirstChild,
+    textContent,
+    lanes
   ) {
-    updateChecked(domElement, nextRawProps);
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      var existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    var created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
   }
 
-  var wasCustomComponentTag = isCustomComponent(tag, lastRawProps);
-  var isCustomComponentTag = isCustomComponent(tag, nextRawProps); // Apply the diff.
+  function reconcileSingleElement(
+    returnFiber,
+    currentFirstChild,
+    element,
+    lanes
+  ) {
+    var key = element.key;
+    var child = currentFirstChild;
 
-  updateDOMProperties(
-    domElement,
-    updatePayload,
-    wasCustomComponentTag,
-    isCustomComponentTag
-  ); // TODO: Ensure that an update gets scheduled if any of the special props
-  // changed.
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        var elementType = element.type;
 
-  switch (tag) {
-    case "input":
-      // Update the wrapper around inputs *after* updating props. This has to
-      // happen after `updateDOMProperties`. Otherwise HTML5 input validations
-      // raise warnings and prevent the new value from being assigned.
-      updateWrapper$1(domElement, nextRawProps);
-      break;
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            var existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
 
-    case "textarea":
-      updateWrapper(domElement, nextRawProps);
-      break;
+            {
+              existing._debugSource = element._source;
+              existing._debugOwner = element._owner;
+            }
 
-    case "select":
-      // <select> value update needs to occur after <option> children
-      // reconciliation
-      postUpdateWrapper(domElement, nextRawProps);
-      break;
-  }
-}
+            return existing;
+          }
+        } else {
+          if (
+            child.elementType === elementType || // Keep this check inline so it only runs on the false path:
+            isCompatibleFamilyForHotReloading(child, element) || // Lazy types should reconcile their resolved type.
+            // We need to do this after the Hot Reloading check above,
+            // because hot reloading has different semantics than prod because
+            // it doesn't resuspend. So we can't let the call below suspend.
+            (typeof elementType === "object" &&
+              elementType !== null &&
+              elementType.$$typeof === REACT_LAZY_TYPE &&
+              resolveLazy(elementType) === child.type)
+          ) {
+            deleteRemainingChildren(returnFiber, child.sibling);
 
-function getPossibleStandardName(propName) {
-  {
-    var lowerCasedName = propName.toLowerCase();
+            var _existing = useFiber(child, element.props);
 
-    if (!possibleStandardNames.hasOwnProperty(lowerCasedName)) {
-      return null;
-    }
+            _existing.ref = coerceRef(returnFiber, child, element);
+            _existing.return = returnFiber;
 
-    return possibleStandardNames[lowerCasedName] || null;
-  }
-}
+            {
+              _existing._debugSource = element._source;
+              _existing._debugOwner = element._owner;
+            }
 
-function diffHydratedProperties(
-  domElement,
-  tag,
-  rawProps,
-  isConcurrentMode,
-  shouldWarnDev,
-  parentNamespaceDev
-) {
-  var isCustomComponentTag;
-  var extraAttributeNames;
-
-  {
-    isCustomComponentTag = isCustomComponent(tag, rawProps);
-    validatePropertiesInDevelopment(tag, rawProps);
-  } // TODO: Make sure that we check isMounted before firing any of these events.
-
-  switch (tag) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", domElement);
-      listenToNonDelegatedEvent("close", domElement);
-      break;
-
-    case "iframe":
-    case "object":
-    case "embed":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the load event.
-      listenToNonDelegatedEvent("load", domElement);
-      break;
+            return _existing;
+          }
+        } // Didn't match.
 
-    case "video":
-    case "audio":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for all the media events.
-      for (var i = 0; i < mediaEventTypes.length; i++) {
-        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
       }
 
-      break;
-
-    case "source":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the error event.
-      listenToNonDelegatedEvent("error", domElement);
-      break;
-
-    case "img":
-    case "image":
-    case "link":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for error and load events.
-      listenToNonDelegatedEvent("error", domElement);
-      listenToNonDelegatedEvent("load", domElement);
-      break;
+      child = child.sibling;
+    }
 
-    case "details":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the toggle event.
-      listenToNonDelegatedEvent("toggle", domElement);
-      break;
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      var created = createFiberFromFragment(
+        element.props.children,
+        returnFiber.mode,
+        lanes,
+        element.key
+      );
+      created.return = returnFiber;
+      return created;
+    } else {
+      var _created4 = createFiberFromElement(element, returnFiber.mode, lanes);
 
-    case "input":
-      initWrapperState$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+      _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
+      _created4.return = returnFiber;
+      return _created4;
+    }
+  }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+  function reconcileSinglePortal(
+    returnFiber,
+    currentFirstChild,
+    portal,
+    lanes
+  ) {
+    var key = portal.key;
+    var child = currentFirstChild;
 
-    case "option":
-      validateProps(domElement, rawProps);
-      break;
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (
+          child.tag === HostPortal &&
+          child.stateNode.containerInfo === portal.containerInfo &&
+          child.stateNode.implementation === portal.implementation
+        ) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          var existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
+        }
+      } else {
+        deleteChild(returnFiber, child);
+      }
 
-    case "select":
-      initWrapperState$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+      child = child.sibling;
+    }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+    var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
 
-    case "textarea":
-      initWrapperState(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+  function reconcileChildFibersImpl(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    var isUnkeyedTopLevelFragment =
+      typeof newChild === "object" &&
+      newChild !== null &&
+      newChild.type === REACT_FRAGMENT_TYPE &&
+      newChild.key === null;
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-  }
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
 
-  assertValidProps(tag, rawProps);
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(
+            reconcileSingleElement(
+              returnFiber,
+              currentFirstChild,
+              newChild,
+              lanes
+            )
+          );
 
-  {
-    extraAttributeNames = new Set();
-    var attributes = domElement.attributes;
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(
+            reconcileSinglePortal(
+              returnFiber,
+              currentFirstChild,
+              newChild,
+              lanes
+            )
+          );
 
-    for (var _i = 0; _i < attributes.length; _i++) {
-      var name = attributes[_i].name.toLowerCase();
+        case REACT_LAZY_TYPE:
+          var payload = newChild._payload;
+          var init = newChild._init; // TODO: This function is supposed to be non-recursive.
 
-      switch (name) {
-        // Controlled attributes are not validated
-        // TODO: Only ignore them on controlled tags.
-        case "value":
-          break;
+          return reconcileChildFibers(
+            returnFiber,
+            currentFirstChild,
+            init(payload),
+            lanes
+          );
+      }
 
-        case "checked":
-          break;
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      }
 
-        case "selected":
-          break;
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
 
-        default:
-          // Intentionally use the original name.
-          // See discussion in https://github.com/facebook/react/pull/10676.
-          extraAttributeNames.add(attributes[_i].name);
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          unwrapThenable(thenable),
+          lanes
+        );
       }
-    }
-  }
 
-  var updatePayload = null;
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-  for (var propKey in rawProps) {
-    if (!rawProps.hasOwnProperty(propKey)) {
-      continue;
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
 
-    var nextProp = rawProps[propKey];
-
-    if (propKey === CHILDREN) {
-      // For text content children we compare against textContent. This
-      // might match additional HTML that is hidden when we read it using
-      // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
-      // satisfies our requirement. Our requirement is not to produce perfect
-      // HTML and attributes. Ideally we should preserve structure but it's
-      // ok not to if the visible content is still enough to indicate what
-      // even listeners these nodes might be wired up to.
-      // TODO: Warn if there is more than a single textNode as a child.
-      // TODO: Should we use domElement.firstChild.nodeValue to compare?
-      if (typeof nextProp === "string") {
-        if (domElement.textContent !== nextProp) {
-          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
-            checkForUnmatchedText(
-              domElement.textContent,
-              nextProp,
-              isConcurrentMode,
-              shouldWarnDev
-            );
-          }
-
-          updatePayload = [CHILDREN, nextProp];
-        }
-      } else if (typeof nextProp === "number") {
-        if (domElement.textContent !== "" + nextProp) {
-          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
-            checkForUnmatchedText(
-              domElement.textContent,
-              nextProp,
-              isConcurrentMode,
-              shouldWarnDev
-            );
-          }
-
-          updatePayload = [CHILDREN, "" + nextProp];
-        }
-      }
-    } else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      if (nextProp != null) {
-        if (typeof nextProp !== "function") {
-          warnForInvalidEventListener(propKey, nextProp);
-        }
-
-        if (propKey === "onScroll") {
-          listenToNonDelegatedEvent("scroll", domElement);
-        }
-      }
-    } else if (
-      shouldWarnDev &&
-      true && // Convince Flow we've calculated it (it's DEV-only in this method.)
-      typeof isCustomComponentTag === "boolean"
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
     ) {
-      // Validate that the properties correspond to their expected values.
-      var serverValue = void 0;
-      var propertyInfo =
-        isCustomComponentTag && enableCustomElementPropertySupport
-          ? null
-          : getPropertyInfo(propKey);
-
-      if (rawProps[SUPPRESS_HYDRATION_WARNING$1] === true);
-      else if (
-        propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-        propKey === SUPPRESS_HYDRATION_WARNING$1 || // Controlled attributes are not validated
-        // TODO: Only ignore them on controlled tags.
-        propKey === "value" ||
-        propKey === "checked" ||
-        propKey === "selected"
+      return placeSingleChild(
+        reconcileSingleTextNode(
+          returnFiber,
+          currentFirstChild,
+          "" + newChild,
+          lanes
+        )
       );
-      else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-        var serverHTML = domElement.innerHTML;
-        var nextHtml = nextProp ? nextProp[HTML] : undefined;
-
-        if (nextHtml != null) {
-          var expectedHTML = normalizeHTML(domElement, nextHtml);
+    }
 
-          if (expectedHTML !== serverHTML) {
-            warnForPropDifference(propKey, serverHTML, expectedHTML);
-          }
-        }
-      } else if (propKey === STYLE$1) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.delete(propKey);
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    } // Remaining cases are all treated as empty.
 
-        if (canDiffStyleForHydrationWarning) {
-          var expectedStyle = createDangerousStringForStyles(nextProp);
-          serverValue = domElement.getAttribute("style");
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
 
-          if (expectedStyle !== serverValue) {
-            warnForPropDifference(propKey, serverValue, expectedStyle);
-          }
-        }
-      } else if (
-        enableCustomElementPropertySupport &&
-        isCustomComponentTag &&
-        (propKey === "offsetParent" ||
-          propKey === "offsetTop" ||
-          propKey === "offsetLeft" ||
-          propKey === "offsetWidth" ||
-          propKey === "offsetHeight" ||
-          propKey === "isContentEditable" ||
-          propKey === "outerText" ||
-          propKey === "outerHTML")
-      ) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.delete(propKey.toLowerCase());
+  function reconcileChildFibers(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    var firstChildFiber = reconcileChildFibersImpl(
+      returnFiber,
+      currentFirstChild,
+      newChild,
+      lanes
+    );
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
 
-        {
-          error(
-            "Assignment to read-only property will result in a no-op: `%s`",
-            propKey
-          );
-        }
-      } else if (isCustomComponentTag && !enableCustomElementPropertySupport) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.delete(propKey.toLowerCase());
-        serverValue = getValueForAttribute(
-          domElement,
-          propKey,
-          nextProp,
-          isCustomComponentTag
-        );
+    return firstChildFiber;
+  }
 
-        if (nextProp !== serverValue) {
-          warnForPropDifference(propKey, serverValue, nextProp);
-        }
-      } else if (
-        !shouldIgnoreAttribute(propKey, propertyInfo, isCustomComponentTag) &&
-        !shouldRemoveAttribute(
-          propKey,
-          nextProp,
-          propertyInfo,
-          isCustomComponentTag
-        )
-      ) {
-        var isMismatchDueToBadCasing = false;
+  return reconcileChildFibers;
+}
 
-        if (propertyInfo !== null) {
-          // $FlowFixMe - Should be inferred as not undefined.
-          extraAttributeNames.delete(propertyInfo.attributeName);
-          serverValue = getValueForProperty(
-            domElement,
-            propKey,
-            nextProp,
-            propertyInfo
-          );
-        } else {
-          var ownNamespaceDev = parentNamespaceDev;
+var reconcileChildFibers = createChildReconciler(true);
+var mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+}
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw new Error("Resuming work not yet implemented.");
+  }
 
-          if (ownNamespaceDev === HTML_NAMESPACE) {
-            ownNamespaceDev = getIntrinsicNamespace(tag);
-          }
+  if (workInProgress.child === null) {
+    return;
+  }
 
-          if (ownNamespaceDev === HTML_NAMESPACE) {
-            // $FlowFixMe - Should be inferred as not undefined.
-            extraAttributeNames.delete(propKey.toLowerCase());
-          } else {
-            var standardName = getPossibleStandardName(propKey);
+  var currentChild = workInProgress.child;
+  var newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
 
-            if (standardName !== null && standardName !== propKey) {
-              // If an SVG prop is supplied with bad casing, it will
-              // be successfully parsed from HTML, but will produce a mismatch
-              // (and would be incorrectly rendered on the client).
-              // However, we already warn about bad casing elsewhere.
-              // So we'll skip the misleading extra mismatch warning in this case.
-              isMismatchDueToBadCasing = true; // $FlowFixMe - Should be inferred as not undefined.
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(
+      currentChild,
+      currentChild.pendingProps
+    );
+    newChild.return = workInProgress;
+  }
 
-              extraAttributeNames.delete(standardName);
-            } // $FlowFixMe - Should be inferred as not undefined.
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
 
-            extraAttributeNames.delete(propKey);
-          }
+function resetChildFibers(workInProgress, lanes) {
+  var child = workInProgress.child;
 
-          serverValue = getValueForAttribute(
-            domElement,
-            propKey,
-            nextProp,
-            isCustomComponentTag
-          );
-        }
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
+  }
+}
 
-        var dontWarnCustomElement =
-          enableCustomElementPropertySupport &&
-          isCustomComponentTag &&
-          (typeof nextProp === "function" || typeof nextProp === "object");
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
 
-        if (
-          !dontWarnCustomElement &&
-          nextProp !== serverValue &&
-          !isMismatchDueToBadCasing
-        ) {
-          warnForPropDifference(propKey, serverValue, nextProp);
-        }
+var currentTreeHiddenStackCursor = createCursor(null);
+var prevRenderLanesStackCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  var prevRenderLanes = getRenderLanes();
+  push(prevRenderLanesStackCursor, prevRenderLanes, fiber);
+  push(currentTreeHiddenStackCursor, context, fiber); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
+
+  setRenderLanes(mergeLanes(prevRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevRenderLanesStackCursor, getRenderLanes(), fiber);
+  push(
+    currentTreeHiddenStackCursor,
+    currentTreeHiddenStackCursor.current,
+    fiber
+  );
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setRenderLanes(prevRenderLanesStackCursor.current);
+  pop(currentTreeHiddenStackCursor, fiber);
+  pop(prevRenderLanesStackCursor, fiber);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
+
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+var suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+var shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
+}
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  var current = handler.alternate;
+  var props = handler.pendingProps; // Experimental feature: Some Suspense boundaries are marked as having an
+  // undesirable fallback state. These have special behavior where we only
+  // activate the fallback if there's no other boundary on the stack that we can
+  // use instead.
+
+  if (
+    props.unstable_avoidThisFallback === true && // If an avoided boundary is already visible, it behaves identically to
+    // a regular Suspense boundary.
+    (current === null || isCurrentTreeHidden())
+  ) {
+    if (shellBoundary === null) {
+      // We're rendering in the shell. There's no parent Suspense boundary that
+      // can provide a desirable fallback state. We'll use this boundary.
+      push(suspenseHandlerStackCursor, handler, handler); // However, because this is not a desirable fallback, the children are
+      // still considered part of the shell. So we intentionally don't assign
+      // to `shellBoundary`.
+    } else {
+      // There's already a parent Suspense boundary that can provide a desirable
+      // fallback state. Prefer that one.
+      var handlerOnStack = suspenseHandlerStackCursor.current;
+      push(suspenseHandlerStackCursor, handlerOnStack, handler);
+    }
+
+    return;
+  } // TODO: If the parent Suspense handler already suspended, there's no reason
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
+
+  push(suspenseHandlerStackCursor, handler, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      var prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
       }
     }
   }
+}
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    push(suspenseHandlerStackCursor, fiber, fiber);
 
-  {
-    if (shouldWarnDev) {
-      if (
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.size > 0 &&
-        rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true
-      ) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        warnForExtraAttributes(extraAttributeNames);
+    if (shellBoundary !== null);
+    else {
+      var current = fiber.alternate;
+
+      if (current !== null) {
+        var prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
       }
     }
+  } else {
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
   }
+}
+function reuseSuspenseHandlerOnStack(fiber) {
+  push(suspenseHandlerStackCursor, getSuspenseHandler(), fiber);
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor, fiber);
 
-  switch (tag) {
-    case "input":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper$3(domElement, rawProps, true);
-      break;
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
 
-    case "textarea":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper(domElement);
-      break;
+var DefaultSuspenseContext = 0;
+var SubtreeSuspenseContextMask = 1; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
 
-    case "select":
-    case "option":
-      // For input and textarea we current always set the value property at
-      // post mount to force it to diverge from attributes. However, for
-      // option and select we don't quite do the same thing and select
-      // is not resilient to the DOM state changing so we don't do that here.
-      // TODO: Consider not doing this for input and textarea.
-      break;
+var ForceSuspenseFallback = 2;
+var suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return (parentContext & SubtreeSuspenseContextMask) | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext, fiber);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor, fiber);
+}
 
-    default:
-      if (typeof rawProps.onClick === "function") {
-        // TODO: This cast may not be sound for SVG, MathML or custom elements.
-        trapClickOnNonInteractiveElement(domElement);
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
+
+function findFirstSuspended(row) {
+  var node = row;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      var state = node.memoizedState;
+
+      if (state !== null) {
+        var dehydrated = state.dehydrated;
+
+        if (
+          dehydrated === null ||
+          isSuspenseInstancePending(dehydrated) ||
+          isSuspenseInstanceFallback(dehydrated)
+        ) {
+          return node;
+        }
       }
+    } else if (
+      node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+      // keep track of whether it suspended or not.
+      node.memoizedProps.revealOrder !== undefined
+    ) {
+      var didSuspend = (node.flags & DidCapture) !== NoFlags$1;
 
-      break;
+      if (didSuspend) {
+        return node;
+      }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === row) {
+      return null;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
   }
 
-  return updatePayload;
+  return null;
 }
-function diffHydratedText(textNode, text, isConcurrentMode) {
-  var isDifferent = textNode.nodeValue !== text;
-  return isDifferent;
+
+var NoFlags =
+  /*   */
+  0; // Represents whether effect should fire.
+
+var HasEffect =
+  /* */
+  1; // Represents the phase in which the effect (not the clean-up) fires.
+
+var Insertion =
+  /* */
+  2;
+var Layout =
+  /*    */
+  4;
+var Passive =
+  /*   */
+  8;
+
+// and should be reset before starting a new render.
+// This tracks which mutable sources need to be reset after a render.
+
+var workInProgressSources = [];
+var rendererSigil$1;
+
+{
+  // Used to detect multiple renderers using the same mutable source.
+  rendererSigil$1 = {};
 }
-function warnForDeletedHydratableElement(parentNode, child) {
-  {
-    if (didWarnInvalidHydration) {
-      return;
-    }
 
-    didWarnInvalidHydration = true;
+function markSourceAsDirty(mutableSource) {
+  workInProgressSources.push(mutableSource);
+}
+function resetWorkInProgressVersions() {
+  for (var i = 0; i < workInProgressSources.length; i++) {
+    var mutableSource = workInProgressSources[i];
 
-    error(
-      "Did not expect server HTML to contain a <%s> in <%s>.",
-      child.nodeName.toLowerCase(),
-      parentNode.nodeName.toLowerCase()
-    );
+    {
+      mutableSource._workInProgressVersionPrimary = null;
+    }
   }
+
+  workInProgressSources.length = 0;
 }
-function warnForDeletedHydratableText(parentNode, child) {
+function getWorkInProgressVersion(mutableSource) {
   {
-    if (didWarnInvalidHydration) {
-      return;
+    return mutableSource._workInProgressVersionPrimary;
+  }
+}
+function setWorkInProgressVersion(mutableSource, version) {
+  {
+    mutableSource._workInProgressVersionPrimary = version;
+  }
+
+  workInProgressSources.push(mutableSource);
+}
+function warnAboutMultipleRenderersDEV(mutableSource) {
+  {
+    {
+      if (mutableSource._currentPrimaryRenderer == null) {
+        mutableSource._currentPrimaryRenderer = rendererSigil$1;
+      } else if (mutableSource._currentPrimaryRenderer !== rendererSigil$1) {
+        error(
+          "Detected multiple renderers concurrently rendering the " +
+            "same mutable source. This is currently unsupported."
+        );
+      }
     }
+  }
+} // Eager reads the version of a mutable source and stores it on the root.
+// This ensures that the version used for server rendering matches the one
+// that is eventually read during hydration.
+// If they don't match there's a potential tear and a full deopt render is required.
 
-    didWarnInvalidHydration = true;
+function registerMutableSourceForHydration(root, mutableSource) {
+  var getVersion = mutableSource._getVersion;
+  var version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
+  // Retaining it forever may interfere with GC.
 
-    error(
-      'Did not expect server HTML to contain the text node "%s" in <%s>.',
-      child.nodeValue,
-      parentNode.nodeName.toLowerCase()
-    );
+  if (root.mutableSourceEagerHydrationData == null) {
+    root.mutableSourceEagerHydrationData = [mutableSource, version];
+  } else {
+    root.mutableSourceEagerHydrationData.push(mutableSource, version);
   }
 }
-function warnForInsertedHydratedElement(parentNode, tag, props) {
+
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+var didWarnAboutMismatchedHooksForComponent;
+var didWarnUncachedGetSnapshot;
+var didWarnAboutUseWrappedInTryCatch;
+
+{
+  didWarnAboutMismatchedHooksForComponent = new Set();
+  didWarnAboutUseWrappedInTryCatch = new Set();
+} // These are set right before calling the component.
+
+var renderLanes$1 = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
+
+var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
+
+var currentHook = null;
+var workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
+
+var didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+
+var didScheduleRenderPhaseUpdateDuringThisPass = false;
+var shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+
+var localIdCounter = 0; // Counts number of `use`-d thenables
+
+var thenableIndexCounter = 0;
+var thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
+
+var globalClientIdCounter = 0;
+var RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+
+var currentHookNameInDev = null; // In DEV, this list ensures that hooks are called in the same order between renders.
+// The list stores the order of hooks used during the initial render (mount).
+// Subsequent renders (updates) reference this list.
+
+var hookTypesDev = null;
+var hookTypesUpdateIndexDev = -1; // In DEV, this tracks whether currently rendering component needs to ignore
+// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
+// When true, such Hooks will always be "remounted". Only used during hot reload.
+
+var ignorePreviousDependencies = false;
+
+function mountHookTypesDev() {
   {
-    if (didWarnInvalidHydration) {
-      return;
+    var hookName = currentHookNameInDev;
+
+    if (hookTypesDev === null) {
+      hookTypesDev = [hookName];
+    } else {
+      hookTypesDev.push(hookName);
     }
+  }
+}
 
-    didWarnInvalidHydration = true;
+function updateHookTypesDev() {
+  {
+    var hookName = currentHookNameInDev;
 
-    error(
-      "Expected server HTML to contain a matching <%s> in <%s>.",
-      tag,
-      parentNode.nodeName.toLowerCase()
-    );
+    if (hookTypesDev !== null) {
+      hookTypesUpdateIndexDev++;
+
+      if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
+        warnOnHookMismatchInDev(hookName);
+      }
+    }
   }
 }
-function warnForInsertedHydratedText(parentNode, text) {
+
+function checkDepsAreArrayDev(deps) {
   {
-    if (text === "") {
-      // We expect to insert empty text nodes since they're not represented in
-      // the HTML.
-      // TODO: Remove this special case if we can just avoid inserting empty
-      // text nodes.
-      return;
+    if (deps !== undefined && deps !== null && !isArray(deps)) {
+      // Verify deps, but only on mount to avoid extra checks.
+      // It's unlikely their type would change as usually you define them inline.
+      error(
+        "%s received a final argument that is not an array (instead, received `%s`). When " +
+          "specified, the final argument must be an array.",
+        currentHookNameInDev,
+        typeof deps
+      );
     }
+  }
+}
 
-    if (didWarnInvalidHydration) {
-      return;
-    }
+function warnOnHookMismatchInDev(currentHookName) {
+  {
+    var componentName = getComponentNameFromFiber(currentlyRenderingFiber$1);
 
-    didWarnInvalidHydration = true;
+    if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
+      didWarnAboutMismatchedHooksForComponent.add(componentName);
 
-    error(
-      'Expected server HTML to contain a matching text node for "%s" in <%s>.',
-      text,
-      parentNode.nodeName.toLowerCase()
-    );
-  }
-}
-function restoreControlledState(domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      restoreControlledState$3(domElement, props);
-      return;
+      if (hookTypesDev !== null) {
+        var table = "";
+        var secondColumnStart = 30;
 
-    case "textarea":
-      restoreControlledState$1(domElement, props);
-      return;
+        for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
+          var oldHookName = hookTypesDev[i];
+          var newHookName =
+            i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
+          var row = i + 1 + ". " + oldHookName; // Extra space so second column lines up
+          // lol @ IE not supporting String#repeat
 
-    case "select":
-      restoreControlledState$2(domElement, props);
-      return;
+          while (row.length < secondColumnStart) {
+            row += " ";
+          }
+
+          row += newHookName + "\n";
+          table += row;
+        }
+
+        error(
+          "React has detected a change in the order of Hooks called by %s. " +
+            "This will lead to bugs and errors if not fixed. " +
+            "For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n" +
+            "   Previous render            Next render\n" +
+            "   ------------------------------------------------------\n" +
+            "%s" +
+            "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+          componentName,
+          table
+        );
+      }
+    }
   }
 }
 
-// This validation code was written based on the HTML5 parsing spec:
-// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
-//
-// Note: this does not catch all invalid nesting, nor does it try to (as it's
-// not clear what practical benefit doing so provides); instead, we warn only
-// for cases where the parser will give a parse tree differing from what React
-// intended. For example, <b><div></div></b> is invalid but we don't warn
-// because it still parses correctly; we do warn for other cases like nested
-// <p> tags where the beginning of the second element implicitly closes the
-// first, causing a confusing mess.
-// https://html.spec.whatwg.org/multipage/syntax.html#special
-var specialTags = [
-  "address",
-  "applet",
-  "area",
-  "article",
-  "aside",
-  "base",
-  "basefont",
-  "bgsound",
-  "blockquote",
-  "body",
-  "br",
-  "button",
-  "caption",
-  "center",
-  "col",
-  "colgroup",
-  "dd",
-  "details",
-  "dir",
-  "div",
-  "dl",
-  "dt",
-  "embed",
-  "fieldset",
-  "figcaption",
-  "figure",
-  "footer",
-  "form",
-  "frame",
-  "frameset",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "head",
-  "header",
-  "hgroup",
-  "hr",
-  "html",
-  "iframe",
-  "img",
-  "input",
-  "isindex",
-  "li",
-  "link",
-  "listing",
-  "main",
-  "marquee",
-  "menu",
-  "menuitem",
-  "meta",
-  "nav",
-  "noembed",
-  "noframes",
-  "noscript",
-  "object",
-  "ol",
-  "p",
-  "param",
-  "plaintext",
-  "pre",
-  "script",
-  "section",
-  "select",
-  "source",
-  "style",
-  "summary",
-  "table",
-  "tbody",
-  "td",
-  "template",
-  "textarea",
-  "tfoot",
-  "th",
-  "thead",
-  "title",
-  "tr",
-  "track",
-  "ul",
-  "wbr",
-  "xmp"
-]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
+function throwInvalidHookError() {
+  throw new Error(
+    "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for" +
+      " one of the following reasons:\n" +
+      "1. You might have mismatching versions of React and the renderer (such as React DOM)\n" +
+      "2. You might be breaking the Rules of Hooks\n" +
+      "3. You might have more than one copy of React in the same app\n" +
+      "See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."
+  );
+}
 
-var inScopeTags = [
-  "applet",
-  "caption",
-  "html",
-  "table",
-  "td",
-  "th",
-  "marquee",
-  "object",
-  "template", // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
-  // TODO: Distinguish by namespace here -- for <title>, including it here
-  // errs on the side of fewer warnings
-  "foreignObject",
-  "desc",
-  "title"
-]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
+function areHookInputsEqual(nextDeps, prevDeps) {
+  {
+    if (ignorePreviousDependencies) {
+      // Only true when this component is being hot reloaded.
+      return false;
+    }
+  }
 
-var buttonScopeTags = inScopeTags.concat(["button"]); // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
+  if (prevDeps === null) {
+    {
+      error(
+        "%s received a final argument during this render, but not during " +
+          "the previous render. Even though the final argument is optional, " +
+          "its type cannot change between renders.",
+        currentHookNameInDev
+      );
+    }
 
-var impliedEndTags = ["dd", "dt", "li", "option", "optgroup", "p", "rp", "rt"];
-var emptyAncestorInfoDev = {
-  current: null,
-  formTag: null,
-  aTagInScope: null,
-  buttonTagInScope: null,
-  nobrTagInScope: null,
-  pTagInButtonScope: null,
-  listItemTagAutoclosing: null,
-  dlItemTagAutoclosing: null,
-  containerTagInScope: null
-};
+    return false;
+  }
 
-function updatedAncestorInfoDev(oldInfo, tag) {
   {
-    var ancestorInfo = assign({}, oldInfo || emptyAncestorInfoDev);
-
-    var info = {
-      tag: tag
-    };
+    // Don't bother comparing lengths in prod because these arrays should be
+    // passed inline.
+    if (nextDeps.length !== prevDeps.length) {
+      error(
+        "The final argument passed to %s changed size between renders. The " +
+          "order and size of this array must remain constant.\n\n" +
+          "Previous: %s\n" +
+          "Incoming: %s",
+        currentHookNameInDev,
+        "[" + prevDeps.join(", ") + "]",
+        "[" + nextDeps.join(", ") + "]"
+      );
+    }
+  } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-    if (inScopeTags.indexOf(tag) !== -1) {
-      ancestorInfo.aTagInScope = null;
-      ancestorInfo.buttonTagInScope = null;
-      ancestorInfo.nobrTagInScope = null;
+  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
     }
 
-    if (buttonScopeTags.indexOf(tag) !== -1) {
-      ancestorInfo.pTagInButtonScope = null;
-    } // See rules for 'li', 'dd', 'dt' start tags in
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
+    return false;
+  }
 
-    if (
-      specialTags.indexOf(tag) !== -1 &&
-      tag !== "address" &&
-      tag !== "div" &&
-      tag !== "p"
-    ) {
-      ancestorInfo.listItemTagAutoclosing = null;
-      ancestorInfo.dlItemTagAutoclosing = null;
-    }
+  return true;
+}
 
-    ancestorInfo.current = info;
+function renderWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg,
+  nextRenderLanes
+) {
+  renderLanes$1 = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
 
-    if (tag === "form") {
-      ancestorInfo.formTag = info;
-    }
+  {
+    hookTypesDev = current !== null ? current._debugHookTypes : null;
+    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
 
-    if (tag === "a") {
-      ancestorInfo.aTagInScope = info;
-    }
+    ignorePreviousDependencies =
+      current !== null && current.type !== workInProgress.type;
+  }
 
-    if (tag === "button") {
-      ancestorInfo.buttonTagInScope = info;
-    }
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
 
-    if (tag === "nobr") {
-      ancestorInfo.nobrTagInScope = info;
+  {
+    if (current !== null && current.memoizedState !== null) {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
+    } else if (hookTypesDev !== null) {
+      // This dispatcher handles an edge case where a component is updating,
+      // but no stateful hooks have been used.
+      // We want to match the production code behavior (which will use HooksDispatcherOnMount),
+      // but with the extra DEV validation to ensure hooks ordering hasn't changed.
+      // This dispatcher does that.
+      ReactCurrentDispatcher$1.current =
+        HooksDispatcherOnMountWithHookTypesInDEV;
+    } else {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
     }
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
 
-    if (tag === "p") {
-      ancestorInfo.pTagInButtonScope = info;
-    }
+  var shouldDoubleRenderDEV =
+    (workInProgress.mode & StrictLegacyMode) !== NoMode;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  var children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
 
-    if (tag === "li") {
-      ancestorInfo.listItemTagAutoclosing = info;
-    }
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(
+      workInProgress,
+      Component,
+      props,
+      secondArg
+    );
+  }
 
-    if (tag === "dd" || tag === "dt") {
-      ancestorInfo.dlItemTagAutoclosing = info;
-    }
+  if (shouldDoubleRenderDEV) {
+    // In development, components are invoked twice to help detect side effects.
+    setIsStrictModeForDevtools(true);
 
-    if (tag === "#document" || tag === "html") {
-      ancestorInfo.containerTagInScope = null;
-    } else if (!ancestorInfo.containerTagInScope) {
-      ancestorInfo.containerTagInScope = info;
+    try {
+      children = renderWithHooksAgain(
+        workInProgress,
+        Component,
+        props,
+        secondArg
+      );
+    } finally {
+      setIsStrictModeForDevtools(false);
     }
-
-    return ancestorInfo;
   }
+
+  finishRenderingHooks(current, workInProgress);
+  return children;
 }
-/**
- * Returns whether
- */
 
-function isTagValidWithParent(tag, parentTag) {
-  // First, let's check if we're in an unusual parsing mode...
-  switch (parentTag) {
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
-    case "select":
-      return tag === "option" || tag === "optgroup" || tag === "#text";
+function finishRenderingHooks(current, workInProgress) {
+  // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
 
-    case "optgroup":
-      return tag === "option" || tag === "#text";
-    // Strictly speaking, seeing an <option> doesn't mean we're in a <select>
-    // but
+  {
+    workInProgress._debugHookTypes = hookTypesDev;
+  } // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
 
-    case "option":
-      return tag === "#text";
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
-    // No special behavior since these rules fall back to "in body" mode for
-    // all except special table nodes which cause bad parsing behavior anyway.
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
+  var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes$1 = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
 
-    case "tr":
-      return (
-        tag === "th" ||
-        tag === "td" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
-      );
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
+  {
+    currentHookNameInDev = null;
+    hookTypesDev = null;
+    hookTypesUpdateIndexDev = -1; // Confirm that a static flag was not added or removed since the last
+    // render. If this fires, it suggests that we incorrectly reset the static
+    // flags in some other part of the codebase. This has happened before, for
+    // example, in the SuspenseList implementation.
 
-    case "tbody":
-    case "thead":
-    case "tfoot":
-      return (
-        tag === "tr" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
+    if (
+      current !== null &&
+      (current.flags & StaticMask) !== (workInProgress.flags & StaticMask) && // Disable this warning in legacy mode, because legacy Suspense is weird
+      // and creates false positives. To make this work in legacy mode, we'd
+      // need to mark fibers that commit in an incomplete state, somehow. For
+      // now I'll disable the warning that most of the bugs that would trigger
+      // it are either exclusive to concurrent mode or exist in both.
+      (current.mode & ConcurrentMode) !== NoMode
+    ) {
+      error(
+        "Internal React error: Expected static flag was missing. Please " +
+          "notify the React team."
       );
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
-
-    case "colgroup":
-      return tag === "col" || tag === "template";
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
+    }
+  }
 
-    case "table":
-      return (
-        tag === "caption" ||
-        tag === "colgroup" ||
-        tag === "tbody" ||
-        tag === "tfoot" ||
-        tag === "thead" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
-      );
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
 
-    case "head":
-      return (
-        tag === "base" ||
-        tag === "basefont" ||
-        tag === "bgsound" ||
-        tag === "link" ||
-        tag === "meta" ||
-        tag === "title" ||
-        tag === "noscript" ||
-        tag === "noframes" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
-      );
-    // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
+  thenableIndexCounter = 0;
+  thenableState = null;
 
-    case "html":
-      return tag === "head" || tag === "body" || tag === "frameset";
+  if (didRenderTooFewHooks) {
+    throw new Error(
+      "Rendered fewer hooks than expected. This may be caused by an accidental " +
+        "early return statement."
+    );
+  }
 
-    case "frameset":
-      return tag === "frame";
+  if (enableLazyContextPropagation) {
+    if (current !== null) {
+      if (!checkIfWorkInProgressReceivedUpdate()) {
+        // If there were no changes to props or state, we need to check if there
+        // was a context change. We didn't already do this because there's no
+        // 1:1 correspondence between dependencies and hooks. Although, because
+        // there almost always is in the common case (`readContext` is an
+        // internal API), we could compare in there. OTOH, we only hit this case
+        // if everything else bails out, so on the whole it might be better to
+        // keep the comparison out of the common path.
+        var currentDependencies = current.dependencies;
 
-    case "#document":
-      return tag === "html";
-  } // Probably in the "in body" parsing mode, so we outlaw only tag combos
-  // where the parsing rules cause implicit opens or closes to be added.
-  // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
+        if (
+          currentDependencies !== null &&
+          checkIfContextChanged(currentDependencies)
+        ) {
+          markWorkInProgressReceivedUpdate();
+        }
+      }
+    }
+  }
 
-  switch (tag) {
-    case "h1":
-    case "h2":
-    case "h3":
-    case "h4":
-    case "h5":
-    case "h6":
-      return (
-        parentTag !== "h1" &&
-        parentTag !== "h2" &&
-        parentTag !== "h3" &&
-        parentTag !== "h4" &&
-        parentTag !== "h5" &&
-        parentTag !== "h6"
-      );
+  {
+    if (checkIfUseWrappedInTryCatch()) {
+      var componentName =
+        getComponentNameFromFiber(workInProgress) || "Unknown";
 
-    case "rp":
-    case "rt":
-      return impliedEndTags.indexOf(parentTag) === -1;
+      if (!didWarnAboutUseWrappedInTryCatch.has(componentName)) {
+        didWarnAboutUseWrappedInTryCatch.add(componentName);
 
-    case "body":
-    case "caption":
-    case "col":
-    case "colgroup":
-    case "frameset":
-    case "frame":
-    case "head":
-    case "html":
-    case "tbody":
-    case "td":
-    case "tfoot":
-    case "th":
-    case "thead":
-    case "tr":
-      // These tags are only valid with a few parents that have special child
-      // parsing rules -- if we're down here, then none of those matched and
-      // so we allow it only if we don't know what the parent is, as all other
-      // cases are invalid.
-      return parentTag == null;
+        error(
+          "`use` was called from inside a try/catch block. This is not allowed " +
+            "and can lead to unexpected behavior. To handle errors triggered " +
+            "by `use`, wrap your component in a error boundary."
+        );
+      }
+    }
   }
-
-  return true;
 }
-/**
- * Returns whether
- */
-
-function findInvalidAncestorForTag(tag, ancestorInfo) {
-  switch (tag) {
-    case "address":
-    case "article":
-    case "aside":
-    case "blockquote":
-    case "center":
-    case "details":
-    case "dialog":
-    case "dir":
-    case "div":
-    case "dl":
-    case "fieldset":
-    case "figcaption":
-    case "figure":
-    case "footer":
-    case "header":
-    case "hgroup":
-    case "main":
-    case "menu":
-    case "nav":
-    case "ol":
-    case "p":
-    case "section":
-    case "summary":
-    case "ul":
-    case "pre":
-    case "listing":
-    case "table":
-    case "hr":
-    case "xmp":
-    case "h1":
-    case "h2":
-    case "h3":
-    case "h4":
-    case "h5":
-    case "h6":
-      return ancestorInfo.pTagInButtonScope;
-
-    case "form":
-      return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
-
-    case "li":
-      return ancestorInfo.listItemTagAutoclosing;
-
-    case "dd":
-    case "dt":
-      return ancestorInfo.dlItemTagAutoclosing;
-
-    case "button":
-      return ancestorInfo.buttonTagInScope;
 
-    case "a":
-      // Spec says something about storing a list of markers, but it sounds
-      // equivalent to this check.
-      return ancestorInfo.aTagInScope;
+function replaySuspendedComponentWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg
+) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves.
+  //
+  // It's a simplified version of renderWithHooks, but it doesn't need to do
+  // most of the set up work because they weren't reset when we suspended; they
+  // only get reset when the component either completes (finishRenderingHooks)
+  // or unwinds (resetHooksOnUnwind).
+  {
+    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
 
-    case "nobr":
-      return ancestorInfo.nobrTagInScope;
+    ignorePreviousDependencies =
+      current !== null && current.type !== workInProgress.type;
   }
 
-  return null;
+  var children = renderWithHooksAgain(
+    workInProgress,
+    Component,
+    props,
+    secondArg
+  );
+  finishRenderingHooks(current, workInProgress);
+  return children;
 }
 
-var didWarn = {};
-
-function validateDOMNesting(childTag, childText, ancestorInfo) {
-  {
-    ancestorInfo = ancestorInfo || emptyAncestorInfoDev;
-    var parentInfo = ancestorInfo.current;
-    var parentTag = parentInfo && parentInfo.tag;
-
-    if (childText != null) {
-      if (childTag != null) {
-        error(
-          "validateDOMNesting: when childText is passed, childTag should be null"
-        );
-      }
-
-      childTag = "#text";
-    } else if (childTag == null) {
-      error("validateDOMNesting: when childText or childTag must be provided");
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  var numberOfReRenders = 0;
+  var children;
 
-      return;
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
     }
 
-    var invalidParent = isTagValidWithParent(childTag, parentTag)
-      ? null
-      : parentInfo;
-    var invalidAncestor = invalidParent
-      ? null
-      : findInvalidAncestorForTag(childTag, ancestorInfo);
-    var invalidParentOrAncestor = invalidParent || invalidAncestor;
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
 
-    if (!invalidParentOrAncestor) {
-      return;
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw new Error(
+        "Too many re-renders. React limits the number of renders to prevent " +
+          "an infinite loop."
+      );
     }
 
-    var ancestorTag = invalidParentOrAncestor.tag;
-    var warnKey = String(!!invalidParent) + "|" + childTag + "|" + ancestorTag; // eslint-disable-next-line react-internal/safe-string-coercion
+    numberOfReRenders += 1;
 
-    if (didWarn[warnKey]) {
-      return;
-    }
+    {
+      // Even when hot reloading, allow dependencies to stabilize
+      // after first render to prevent infinite render phase updates.
+      ignorePreviousDependencies = false;
+    } // Start over from the beginning of the list
 
-    didWarn[warnKey] = true;
-    var tagDisplayName = childTag;
-    var whitespaceInfo = "";
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
 
-    if (childTag === "#text") {
-      if (childText != null && /\S/.test(childText)) {
-        tagDisplayName = "Text nodes";
-      } else {
-        tagDisplayName = "Whitespace text nodes";
-        whitespaceInfo =
-          " Make sure you don't have any extra whitespace between tags on " +
-          "each line of your source code.";
-      }
-    } else {
-      tagDisplayName = "<" + childTag + ">";
+    {
+      // Also validate hook order for cascading updates.
+      hookTypesUpdateIndexDev = -1;
     }
 
-    if (invalidParent) {
-      var info = "";
-
-      if (ancestorTag === "table" && childTag === "tr") {
-        info +=
-          " Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by " +
-          "the browser.";
-      }
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
 
-      error(
-        "validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s",
-        tagDisplayName,
-        ancestorTag,
-        whitespaceInfo,
-        info
-      );
-    } else {
-      error(
-        "validateDOMNesting(...): %s cannot appear as a descendant of " +
-          "<%s>.",
-        tagDisplayName,
-        ancestorTag
-      );
-    }
-  }
+  return children;
 }
 
-var valueStack = [];
-var fiberStack;
-
-{
-  fiberStack = [];
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  var didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
 }
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
 
-var index = -1;
+  if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+    workInProgress.flags &= ~(
+      MountPassiveDev |
+      MountLayoutDev |
+      Passive$1 |
+      Update
+    );
+  } else {
+    workInProgress.flags &= ~(Passive$1 | Update);
+  }
 
-function createCursor(defaultValue) {
-  return {
-    current: defaultValue
-  };
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
 }
+function resetHooksOnUnwind() {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    var hook = currentlyRenderingFiber$1.memoizedState;
 
-function pop(cursor, fiber) {
-  if (index < 0) {
-    {
-      error("Unexpected pop.");
-    }
+    while (hook !== null) {
+      var queue = hook.queue;
 
-    return;
-  }
+      if (queue !== null) {
+        queue.pending = null;
+      }
 
-  {
-    if (fiber !== fiberStack[index]) {
-      error("Unexpected Fiber popped.");
+      hook = hook.next;
     }
+
+    didScheduleRenderPhaseUpdate = false;
   }
 
-  cursor.current = valueStack[index];
-  valueStack[index] = null;
+  renderLanes$1 = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
 
   {
-    fiberStack[index] = null;
+    hookTypesDev = null;
+    hookTypesUpdateIndexDev = -1;
+    currentHookNameInDev = null;
   }
 
-  index--;
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
 }
 
-function push(cursor, value, fiber) {
-  index++;
-  valueStack[index] = cursor.current;
+function mountWorkInProgressHook() {
+  var hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
 
-  {
-    fiberStack[index] = fiber;
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
   }
 
-  cursor.current = value;
+  return workInProgressHook;
 }
 
-var contextStackCursor = createCursor(null);
-var contextFiberStackCursor = createCursor(null);
-var rootInstanceStackCursor = createCursor(null);
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  var nextCurrentHook;
 
-function requiredContext(c) {
-  {
-    if (c === null) {
-      error(
-        "Expected host context to exist. This error is likely caused by a bug " +
-          "in React. Please file an issue."
-      );
+  if (currentHook === null) {
+    var current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
+    } else {
+      nextCurrentHook = null;
     }
+  } else {
+    nextCurrentHook = currentHook.next;
   }
 
-  return c;
-}
+  var nextWorkInProgressHook;
 
-function getCurrentRootHostContainer() {
-  return rootInstanceStackCursor.current;
-}
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
 
-function getRootHostContainer() {
-  var rootInstance = requiredContext(rootInstanceStackCursor.current);
-  return rootInstance;
-}
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      var currentFiber = currentlyRenderingFiber$1.alternate;
 
-function pushHostContainer(fiber, nextRootInstance) {
-  // Push current root instance onto the stack;
-  // This allows us to reset root when portals are popped.
-  push(rootInstanceStackCursor, nextRootInstance, fiber); // Track the context and the Fiber that provided it.
-  // This enables us to pop only Fibers that provide unique contexts.
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw new Error(
+          "Update hook called on initial render. This is likely a bug in React. Please file an issue."
+        );
+      } else {
+        // This is an update. We should always have a current hook.
+        throw new Error("Rendered more hooks than during the previous render.");
+      }
+    }
 
-  push(contextFiberStackCursor, fiber, fiber); // Finally, we need to push the host context to the stack.
-  // However, we can't just call getRootHostContext() and push it because
-  // we'd have a different number of entries on the stack depending on
-  // whether getRootHostContext() throws somewhere in renderer code or not.
-  // So we push an empty value first. This lets us safely unwind on errors.
+    currentHook = nextCurrentHook;
+    var newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
 
-  push(contextStackCursor, null, fiber);
-  var nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
+  }
 
-  pop(contextStackCursor, fiber);
-  push(contextStackCursor, nextRootContext, fiber);
-}
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
 
-function popHostContainer(fiber) {
-  pop(contextStackCursor, fiber);
-  pop(contextFiberStackCursor, fiber);
-  pop(rootInstanceStackCursor, fiber);
-}
+var createFunctionComponentUpdateQueue;
 
-function getHostContext() {
-  var context = requiredContext(contextStackCursor.current);
-  return context;
+{
+  createFunctionComponentUpdateQueue = function () {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  };
 }
 
-function pushHostContext(fiber) {
-  var context = requiredContext(contextStackCursor.current);
-  var nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
-
-  if (context === nextContext) {
-    return;
-  } // Track the context and the Fiber that provided it.
-  // This enables us to pop only Fibers that provide unique contexts.
-
-  push(contextFiberStackCursor, fiber, fiber);
-  push(contextStackCursor, nextContext, fiber);
-}
+function use(usable) {
+  if (usable !== null && typeof usable === "object") {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === "function") {
+      // This is a thenable.
+      var thenable = usable; // Track the position of the thenable within this fiber.
 
-function popHostContext(fiber) {
-  // Do not pop unless this Fiber provided the current context.
-  // pushHostContext() only pushes Fibers that provide unique contexts.
-  if (contextFiberStackCursor.current !== fiber) {
-    return;
-  }
+      var index = thenableIndexCounter;
+      thenableIndexCounter += 1;
 
-  pop(contextStackCursor, fiber);
-  pop(contextFiberStackCursor, fiber);
-}
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
 
-function validateLinkPropsForStyleResource(props) {
-  {
-    // This should only be called when we know we are opting into Resource semantics (i.e. precedence is not null)
-    var href = props.href,
-      onLoad = props.onLoad,
-      onError = props.onError,
-      disabled = props.disabled;
-    var includedProps = [];
-    if (onLoad) includedProps.push("`onLoad`");
-    if (onError) includedProps.push("`onError`");
-    if (disabled != null) includedProps.push("`disabled`");
-    var includedPropsPhrase = propNamesListJoin(includedProps, "and");
-    includedPropsPhrase += includedProps.length === 1 ? " prop" : " props";
-    var withArticlePhrase =
-      includedProps.length === 1
-        ? "an " + includedPropsPhrase
-        : "the " + includedPropsPhrase;
+      var result = trackUsedThenable(thenableState, thenable, index);
 
-    if (includedProps.length) {
-      error(
-        'React encountered a <link rel="stylesheet" href="%s" ... /> with a `precedence` prop that' +
-          " also included %s. The presence of loading and error handlers indicates an intent to manage" +
-          " the stylesheet loading state from your from your Component code and React will not hoist or" +
-          " deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet" +
-          " using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.",
-        href,
-        withArticlePhrase,
-        includedPropsPhrase
-      );
+      if (
+        currentlyRenderingFiber$1.alternate === null &&
+        (workInProgressHook === null
+          ? currentlyRenderingFiber$1.memoizedState === null
+          : workInProgressHook.next === null)
+      ) {
+        // Initial render, and either this is the first time the component is
+        // called, or there were no Hooks called after this use() the previous
+        // time (perhaps because it threw). Subsequent Hook calls should use the
+        // mount dispatcher.
+        {
+          ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
+        }
+      }
 
-      return true;
+      return result;
+    } else if (
+      usable.$$typeof === REACT_CONTEXT_TYPE ||
+      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    ) {
+      var context = usable;
+      return readContext(context);
     }
-  }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
 
-  return false;
+  throw new Error("An unsupported type was passed to use(): " + String(usable));
 }
 
-function propNamesListJoin(list, combinator) {
-  switch (list.length) {
-    case 0:
-      return "";
+function useMemoCache(size) {
+  var memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
 
-    case 1:
-      return list[0];
-
-    case 2:
-      return list[0] + " " + combinator + " " + list[1];
-
-    default:
-      return (
-        list.slice(0, -1).join(", ") +
-        ", " +
-        combinator +
-        " " +
-        list[list.length - 1]
-      );
-  }
-}
-
-function validatePreloadArguments(href, options) {
-  {
-    if (!href || typeof href !== "string") {
-      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
-
-      error(
-        "ReactDOM.preload() expected the first argument to be a string representing an href but found %s instead.",
-        typeOfArg
-      );
-    } else if (typeof options !== "object" || options === null) {
-      var _typeOfArg = getValueDescriptorExpectingObjectForWarning(options);
-
-      error(
-        'ReactDOM.preload() expected the second argument to be an options argument containing at least an "as" property' +
-          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
-        _typeOfArg,
-        href
-      );
-    } else {
-      var as = options.as;
+  var updateQueue = currentlyRenderingFiber$1.updateQueue;
 
-      switch (as) {
-        // Font specific validation of options
-        case "font": {
-          if (options.crossOrigin === "use-credentials") {
-            error(
-              'ReactDOM.preload() was called with an "as" type of "font" and with a "crossOrigin" option of "use-credentials".' +
-                ' Fonts preloading must use crossOrigin "anonymous" to be functional. Please update your font preload to omit' +
-                ' the crossOrigin option or change it to any other value than "use-credentials" (Browsers default all other values' +
-                ' to anonymous mode). The href for the preload call where this warning originated is "%s"',
-              href
-            );
-          }
+  if (updateQueue !== null) {
+    memoCache = updateQueue.memoCache;
+  } // Otherwise clone from the current fiber
 
-          break;
-        }
+  if (memoCache == null) {
+    var current = currentlyRenderingFiber$1.alternate;
 
-        case "script":
-        case "style": {
-          break;
-        }
-        // We have an invalid as type and need to warn
+    if (current !== null) {
+      var currentUpdateQueue = current.updateQueue;
 
-        default: {
-          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
+      if (currentUpdateQueue !== null) {
+        var currentMemoCache = currentUpdateQueue.memoCache;
 
-          error(
-            'ReactDOM.preload() expected a valid "as" type in the options (second) argument but found %s instead.' +
-              " Please use one of the following valid values instead: %s. The href for the preload call where this" +
-              ' warning originated is "%s".',
-            typeOfAs,
-            '"style", "font", or "script"',
-            href
-          );
+        if (currentMemoCache != null) {
+          memoCache = {
+            data: currentMemoCache.data.map(function (array) {
+              return array.slice();
+            }),
+            index: 0
+          };
         }
       }
     }
-  }
-}
-function validatePreinitArguments(href, options) {
-  {
-    if (!href || typeof href !== "string") {
-      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
+  } // Finally fall back to allocating a fresh instance of the cache
 
-      error(
-        "ReactDOM.preinit() expected the first argument to be a string representing an href but found %s instead.",
-        typeOfArg
-      );
-    } else if (typeof options !== "object" || options === null) {
-      var _typeOfArg2 = getValueDescriptorExpectingObjectForWarning(options);
+  if (memoCache == null) {
+    memoCache = {
+      data: [],
+      index: 0
+    };
+  }
 
-      error(
-        'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
-          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
-        _typeOfArg2,
-        href
-      );
-    } else {
-      var as = options.as;
+  if (updateQueue === null) {
+    updateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = updateQueue;
+  }
 
-      switch (as) {
-        case "style":
-        case "script": {
-          break;
-        }
-        // We have an invalid as type and need to warn
+  updateQueue.memoCache = memoCache;
+  var data = memoCache.data[memoCache.index];
 
-        default: {
-          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
+  if (data === undefined) {
+    data = memoCache.data[memoCache.index] = new Array(size);
 
-          error(
-            'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
-              ' specifying the Resource type. It found %s instead. Currently, valid resource types for for preinit are "style"' +
-              ' and "script". The href for the preinit call where this warning originated is "%s".',
-            typeOfAs,
-            href
-          );
-        }
-      }
+    for (var i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+  } else if (data.length !== size) {
+    // TODO: consider warning or throwing here
+    {
+      error(
+        "Expected a constant size argument for each invocation of useMemoCache. " +
+          "The previous cache was allocated with size %s but size %s was requested.",
+        data.length,
+        size
+      );
     }
   }
-}
-function getValueDescriptorExpectingObjectForWarning(thing) {
-  return thing === null
-    ? "`null`"
-    : thing === undefined
-    ? "`undefined`"
-    : thing === ""
-    ? "an empty string"
-    : 'something with type "' + typeof thing + '"';
-}
-function getValueDescriptorExpectingEnumForWarning(thing) {
-  return thing === null
-    ? "`null`"
-    : thing === undefined
-    ? "`undefined`"
-    : thing === ""
-    ? "an empty string"
-    : typeof thing === "string"
-    ? JSON.stringify(thing)
-    : 'something with type "' + typeof thing + '"';
-}
-
-var Dispatcher$1 = Internals.Dispatcher;
-// In the future this may need to change, especially when modules / scripts are supported
-// It is valid to preload even when we aren't actively rendering. For cases where Float functions are
-// called when there is no rendering we track the last used document. It is not safe to insert
-// arbitrary resources into the lastCurrentDocument b/c it may not actually be the document
-// that the resource is meant to apply too (for example stylesheets or scripts). This is only
-// appropriate for resources that don't really have a strict tie to the document itself for example
-// preloads
 
-var lastCurrentDocument = null;
-var previousDispatcher = null;
-function prepareToRenderResources(rootContainer) {
-  var rootNode = getHoistableRoot(rootContainer);
-  lastCurrentDocument = getDocumentFromRoot(rootNode);
-  previousDispatcher = Dispatcher$1.current;
-  Dispatcher$1.current = ReactDOMClientDispatcher;
-}
-function cleanupAfterRenderResources() {
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
+  memoCache.index++;
+  return data;
 }
-function prepareToCommitHoistables() {
-  tagCaches = null;
-} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
-// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
-// from Internals -> ReactDOM -> FloatClient -> Internals so this doesn't introduce a new one.
-
-var ReactDOMClientDispatcher = {
-  prefetchDNS: prefetchDNS$1,
-  preconnect: preconnect$1,
-  preload: preload$1,
-  preinit: preinit$1
-}; // global collections of Resources
-
-var preloadPropsMap = new Map();
-var preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
 
-function getHoistableRoot(container) {
-  // $FlowFixMe[method-unbinding]
-  return typeof container.getRootNode === "function"
-    ? /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
-       * but it's either a `Document` or `ShadowRoot`. */
-      container.getRootNode()
-    : container.ownerDocument;
+function basicStateReducer(state, action) {
+  // $FlowFixMe: Flow doesn't like mixed types
+  return typeof action === "function" ? action(state) : action;
 }
 
-function getCurrentResourceRoot() {
-  var currentContainer = getCurrentRootHostContainer();
-  return currentContainer ? getHoistableRoot(currentContainer) : null;
-} // Preloads are somewhat special. Even if we don't have the Document
-// used by the root that is rendering a component trying to insert a preload
-// we can still seed the file cache by doing the preload on any document we have
-// access to. We prefer the currentDocument if it exists, we also prefer the
-// lastCurrentDocument if that exists. As a fallback we will use the window.document
-// if available.
-
-function getDocumentForPreloads() {
-  var root = getCurrentResourceRoot();
+function mountReducer(reducer, initialArg, init) {
+  var hook = mountWorkInProgressHook();
+  var initialState;
 
-  if (root) {
-    return root.ownerDocument || root;
+  if (init !== undefined) {
+    initialState = init(initialArg);
   } else {
-    try {
-      return lastCurrentDocument || window.document;
-    } catch (error) {
-      return null;
-    }
+    initialState = initialArg;
   }
-}
 
-function getDocumentFromRoot(root) {
-  return root.ownerDocument || root;
+  hook.memoizedState = hook.baseState = initialState;
+  var queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  var dispatch = (queue.dispatch = dispatchReducerAction.bind(
+    null,
+    currentlyRenderingFiber$1,
+    queue
+  ));
+  return [hook.memoizedState, dispatch];
 }
 
-function preconnectAs(rel, crossOrigin, href) {
-  var ownerDocument = getDocumentForPreloads();
+function updateReducer(reducer, initialArg, init) {
+  var hook = updateWorkInProgressHook();
+  var queue = hook.queue;
 
-  if (typeof href === "string" && href && ownerDocument) {
-    var limitedEscapedHref =
-      escapeSelectorAttributeValueInsideDoubleQuotes(href);
-    var key = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
+  if (queue === null) {
+    throw new Error(
+      "Should have a queue. This is likely a bug in React. Please file an issue."
+    );
+  }
 
-    if (typeof crossOrigin === "string") {
-      key += '[crossorigin="' + crossOrigin + '"]';
-    }
+  queue.lastRenderedReducer = reducer;
+  var current = currentHook; // The last rebase update that is NOT part of the base state.
 
-    if (!preconnectsSet.has(key)) {
-      preconnectsSet.add(key);
-      var preconnectProps = {
-        rel: rel,
-        crossOrigin: crossOrigin,
-        href: href
-      };
+  var baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.
 
-      if (null === ownerDocument.querySelector(key)) {
-        var preloadInstance = ownerDocument.createElement("link");
-        setInitialProperties(preloadInstance, "link", preconnectProps);
-        markNodeAsHoistable(preloadInstance);
-        ownerDocument.head.appendChild(preloadInstance);
-      }
+  var pendingQueue = queue.pending;
+
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      var baseFirst = baseQueue.next;
+      var pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
     }
-  }
-} // --------------------------------------
-//      ReactDOM.prefetchDNS
-// --------------------------------------
 
-function prefetchDNS$1(href, options) {
-  {
-    if (typeof href !== "string" || !href) {
-      error(
-        "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
-        getValueDescriptorExpectingObjectForWarning(href)
-      );
-    } else if (options != null) {
-      if (
-        typeof options === "object" &&
-        hasOwnProperty.call(options, "crossOrigin")
-      ) {
-        error(
-          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
-          getValueDescriptorExpectingEnumForWarning(options)
-        );
-      } else {
+    {
+      if (current.baseQueue !== baseQueue) {
+        // Internal invariant that should never happen, but feasibly could in
+        // the future if we implement resuming, or some form of that.
         error(
-          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
-          getValueDescriptorExpectingEnumForWarning(options)
+          "Internal error: Expected work-in-progress queue to be a clone. " +
+            "This is a bug in React."
         );
       }
     }
-  }
-
-  preconnectAs("dns-prefetch", null, href);
-} // --------------------------------------
-//      ReactDOM.preconnect
-// --------------------------------------
 
-function preconnect$1(href, options) {
-  {
-    if (typeof href !== "string" || !href) {
-      error(
-        "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
-        getValueDescriptorExpectingObjectForWarning(href)
-      );
-    } else if (options != null && typeof options !== "object") {
-      error(
-        "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
-        getValueDescriptorExpectingEnumForWarning(options)
-      );
-    } else if (options != null && typeof options.crossOrigin !== "string") {
-      error(
-        "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
-        getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
-      );
-    }
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
   }
 
-  var crossOrigin =
-    options == null || typeof options.crossOrigin !== "string"
-      ? null
-      : options.crossOrigin === "use-credentials"
-      ? "use-credentials"
-      : "";
-  preconnectAs("preconnect", crossOrigin, href);
-} // --------------------------------------
-//      ReactDOM.preload
-// --------------------------------------
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    var first = baseQueue.next;
+    var newState = current.baseState;
+    var newBaseState = null;
+    var newBaseQueueFirst = null;
+    var newBaseQueueLast = null;
+    var update = first;
 
-function preload$1(href, options) {
-  {
-    validatePreloadArguments(href, options);
-  }
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      var updateLane = removeLanes(update.lane, OffscreenLane);
+      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
 
-  var ownerDocument = getDocumentForPreloads();
+      var shouldSkipUpdate = isHiddenUpdate
+        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
+        : !isSubsetOfLanes(renderLanes$1, updateLane);
 
-  if (
-    typeof href === "string" &&
-    href &&
-    typeof options === "object" &&
-    options !== null &&
-    ownerDocument
-  ) {
-    var as = options.as;
-    var limitedEscapedHref =
-      escapeSelectorAttributeValueInsideDoubleQuotes(href);
-    var preloadKey =
-      'link[rel="preload"][as="' + as + '"][href="' + limitedEscapedHref + '"]';
-    var key = preloadKey;
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        var clone = {
+          lane: updateLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
 
-    switch (as) {
-      case "style":
-        key = getStyleKey(href);
-        break;
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
+          newBaseState = newState;
+        } else {
+          newBaseQueueLast = newBaseQueueLast.next = clone;
+        } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
 
-      case "script":
-        key = getScriptKey(href);
-        break;
-    }
+        currentlyRenderingFiber$1.lanes = mergeLanes(
+          currentlyRenderingFiber$1.lanes,
+          updateLane
+        );
+        markSkippedUpdateLanes(updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newBaseQueueLast !== null) {
+          var _clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          };
+          newBaseQueueLast = newBaseQueueLast.next = _clone;
+        } // Process this update.
 
-    if (!preloadPropsMap.has(key)) {
-      var preloadProps = preloadPropsFromPreloadOptions(href, as, options);
-      preloadPropsMap.set(key, preloadProps);
+        var action = update.action;
 
-      if (null === ownerDocument.querySelector(preloadKey)) {
-        var preloadInstance = ownerDocument.createElement("link");
-        setInitialProperties(preloadInstance, "link", preloadProps);
-        markNodeAsHoistable(preloadInstance);
-        ownerDocument.head.appendChild(preloadInstance);
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
+        }
+
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
+        } else {
+          newState = reducer(newState, action);
+        }
       }
+
+      update = update.next;
+    } while (update !== null && update !== first);
+
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
     }
-  }
-}
 
-function preloadPropsFromPreloadOptions(href, as, options) {
-  return {
-    href: href,
-    rel: "preload",
-    as: as,
-    crossOrigin: as === "font" ? "" : options.crossOrigin,
-    integrity: options.integrity,
-    type: options.type
-  };
-} // --------------------------------------
-//      ReactDOM.preinit
-// --------------------------------------
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
+  }
 
-function preinit$1(href, options) {
-  {
-    validatePreinitArguments(href, options);
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
   }
 
-  if (
-    typeof href === "string" &&
-    href &&
-    typeof options === "object" &&
-    options !== null
-  ) {
-    var resourceRoot = getCurrentResourceRoot();
-    var as = options.as;
+  var dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
+}
 
-    if (!resourceRoot) {
-      if (as === "style" || as === "script") {
-        // We are going to emit a preload as a best effort fallback since this preinit
-        // was called outside of a render. Given the passive nature of this fallback
-        // we do not warn in dev when props disagree if there happens to already be a
-        // matching preload with this href
-        var preloadDocument = getDocumentForPreloads();
+function rerenderReducer(reducer, initialArg, init) {
+  var hook = updateWorkInProgressHook();
+  var queue = hook.queue;
 
-        if (preloadDocument) {
-          var limitedEscapedHref =
-            escapeSelectorAttributeValueInsideDoubleQuotes(href);
-          var preloadKey =
-            'link[rel="preload"][as="' +
-            as +
-            '"][href="' +
-            limitedEscapedHref +
-            '"]';
-          var key = preloadKey;
+  if (queue === null) {
+    throw new Error(
+      "Should have a queue. This is likely a bug in React. Please file an issue."
+    );
+  }
 
-          switch (as) {
-            case "style":
-              key = getStyleKey(href);
-              break;
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
 
-            case "script":
-              key = getScriptKey(href);
-              break;
-          }
+  var dispatch = queue.dispatch;
+  var lastRenderPhaseUpdate = queue.pending;
+  var newState = hook.memoizedState;
 
-          if (!preloadPropsMap.has(key)) {
-            var preloadProps = preloadPropsFromPreinitOptions(
-              href,
-              as,
-              options
-            );
-            preloadPropsMap.set(key, preloadProps);
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    var update = firstRenderPhaseUpdate;
 
-            if (null === preloadDocument.querySelector(preloadKey)) {
-              var preloadInstance = preloadDocument.createElement("link");
-              setInitialProperties(preloadInstance, "link", preloadProps);
-              markNodeAsHoistable(preloadInstance);
-              preloadDocument.head.appendChild(preloadInstance);
-            }
-          }
-        }
-      }
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      var action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
 
-      return;
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
     }
 
-    switch (as) {
-      case "style": {
-        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
-
-        var _key = getStyleKey(href);
-
-        var precedence = options.precedence || "default"; // Check if this resource already exists
-
-        var resource = styles.get(_key);
-
-        if (resource) {
-          // We can early return. The resource exists and there is nothing
-          // more to do
-          return;
-        } // Attempt to hydrate instance from DOM
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
 
-        var instance = resourceRoot.querySelector(
-          getStylesheetSelectorFromKey(_key)
-        );
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
+    }
 
-        if (!instance) {
-          // Construct a new instance and insert it
-          var stylesheetProps = stylesheetPropsFromPreinitOptions(
-            href,
-            precedence,
-            options
-          );
+    queue.lastRenderedState = newState;
+  }
 
-          var _preloadProps = preloadPropsMap.get(_key);
+  return [newState, dispatch];
+}
 
-          if (_preloadProps) {
-            adoptPreloadPropsForStylesheet(stylesheetProps, _preloadProps);
-          }
+function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+  {
+    warnAboutMultipleRenderersDEV(source);
+  }
 
-          var ownerDocument = getDocumentFromRoot(resourceRoot);
-          instance = ownerDocument.createElement("link");
-          markNodeAsHoistable(instance);
-          setInitialProperties(instance, "link", stylesheetProps);
-          insertStylesheet(instance, precedence, resourceRoot);
-        } // Construct a Resource and cache it
+  var getVersion = source._getVersion;
+  var version = getVersion(source._source); // Is it safe for this component to read from this source during the current render?
 
-        resource = {
-          type: "stylesheet",
-          instance: instance,
-          count: 1
-        };
-        styles.set(_key, resource);
-        return;
-      }
+  var isSafeToReadFromSource = false; // Check the version first.
+  // If this render has already been started with a specific version,
+  // we can use it alone to determine if we can safely read from the source.
 
-      case "script": {
-        var src = href;
-        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+  var currentRenderVersion = getWorkInProgressVersion(source);
 
-        var _key2 = getScriptKey(src); // Check if this resource already exists
+  if (currentRenderVersion !== null) {
+    // It's safe to read if the store hasn't been mutated since the last time
+    // we read something.
+    isSafeToReadFromSource = currentRenderVersion === version;
+  } else {
+    // If there's no version, then this is the first time we've read from the
+    // source during the current render pass, so we need to do a bit more work.
+    // What we need to determine is if there are any hooks that already
+    // subscribed to the source, and if so, whether there are any pending
+    // mutations that haven't been synchronized yet.
+    //
+    // If there are no pending mutations, then `root.mutableReadLanes` will be
+    // empty, and we know we can safely read.
+    //
+    // If there *are* pending mutations, we may still be able to safely read
+    // if the currently rendering lanes are inclusive of the pending mutation
+    // lanes, since that guarantees that the value we're about to read from
+    // the source is consistent with the values that we read during the most
+    // recent mutation.
+    isSafeToReadFromSource = isSubsetOfLanes(
+      renderLanes$1,
+      root.mutableReadLanes
+    );
 
-        var _resource = scripts.get(_key2);
+    if (isSafeToReadFromSource) {
+      // If it's safe to read from this source during the current render,
+      // store the version in case other components read from it.
+      // A changed version number will let those components know to throw and restart the render.
+      setWorkInProgressVersion(source, version);
+    }
+  }
 
-        if (_resource) {
-          // We can early return. The resource exists and there is nothing
-          // more to do
-          return;
-        } // Attempt to hydrate instance from DOM
+  if (isSafeToReadFromSource) {
+    var snapshot = getSnapshot(source._source);
 
-        var _instance = resourceRoot.querySelector(
-          getScriptSelectorFromKey(_key2)
+    {
+      if (typeof snapshot === "function") {
+        error(
+          "Mutable source should not return a function as the snapshot value. " +
+            "Functions may close over mutable values and cause tearing."
         );
-
-        if (!_instance) {
-          // Construct a new instance and insert it
-          var scriptProps = scriptPropsFromPreinitOptions(src, options); // Adopt certain preload props
-
-          var _preloadProps2 = preloadPropsMap.get(_key2);
-
-          if (_preloadProps2) {
-            adoptPreloadPropsForScript(scriptProps, _preloadProps2);
-          }
-
-          var _ownerDocument = getDocumentFromRoot(resourceRoot);
-
-          _instance = _ownerDocument.createElement("script");
-          markNodeAsHoistable(_instance);
-          setInitialProperties(_instance, "link", scriptProps);
-
-          _ownerDocument.head.appendChild(_instance);
-        } // Construct a Resource and cache it
-
-        _resource = {
-          type: "script",
-          instance: _instance,
-          count: 1
-        };
-        scripts.set(_key2, _resource);
-        return;
       }
     }
-  }
-}
 
-function preloadPropsFromPreinitOptions(href, as, options) {
-  return {
-    href: href,
-    rel: "preload",
-    as: as,
-    crossOrigin: as === "font" ? "" : options.crossOrigin,
-    integrity: options.integrity
-  };
-}
+    return snapshot;
+  } else {
+    // This handles the special case of a mutable source being shared between renderers.
+    // In that case, if the source is mutated between the first and second renderer,
+    // The second renderer don't know that it needs to reset the WIP version during unwind,
+    // (because the hook only marks sources as dirty if it's written to their WIP version).
+    // That would cause this tear check to throw again and eventually be visible to the user.
+    // We can avoid this infinite loop by explicitly marking the source as dirty.
+    //
+    // This can lead to tearing in the first renderer when it resumes,
+    // but there's nothing we can do about that (short of throwing here and refusing to continue the render).
+    markSourceAsDirty(source); // Intentioally throw an error to force React to retry synchronously. During
+    // the synchronous retry, it will block interleaved mutations, so we should
+    // get a consistent read. Therefore, the following error should never be
+    // visible to the user.
+    // We expect this error not to be thrown during the synchronous retry,
+    // because we blocked interleaved mutations.
 
-function stylesheetPropsFromPreinitOptions(href, precedence, options) {
-  return {
-    rel: "stylesheet",
-    href: href,
-    "data-precedence": precedence,
-    crossOrigin: options.crossOrigin
-  };
+    throw new Error(
+      "Cannot read from mutable source during the current render without tearing. This may be a bug in React. Please file an issue."
+    );
+  }
 }
 
-function scriptPropsFromPreinitOptions(src, options) {
-  return {
-    src: src,
-    async: true,
-    crossOrigin: options.crossOrigin,
-    integrity: options.integrity
-  };
-} // --------------------------------------
-//      Resources from render
-// --------------------------------------
-// This function is called in begin work and we should always have a currentDocument set
-
-function getResource(type, currentProps, pendingProps) {
-  var resourceRoot = getCurrentResourceRoot();
+function useMutableSource(hook, source, getSnapshot, subscribe) {
+  var root = getWorkInProgressRoot();
 
-  if (!resourceRoot) {
+  if (root === null) {
     throw new Error(
-      '"resourceRoot" was expected to exist. This is a bug in React.'
+      "Expected a work-in-progress root. This is a bug in React. Please file an issue."
     );
   }
 
-  switch (type) {
-    case "meta":
-    case "title": {
-      return null;
-    }
-
-    case "style": {
-      if (
-        typeof pendingProps.precedence === "string" &&
-        typeof pendingProps.href === "string"
-      ) {
-        var key = getStyleKey(pendingProps.href);
-        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
-        var resource = styles.get(key);
-
-        if (!resource) {
-          resource = {
-            type: "style",
-            instance: null,
-            count: 0
-          };
-          styles.set(key, resource);
-        }
-
-        return resource;
-      }
+  var getVersion = source._getVersion;
+  var version = getVersion(source._source);
+  var dispatcher = ReactCurrentDispatcher$1.current; // eslint-disable-next-line prefer-const
 
-      return {
-        type: "void",
-        instance: null,
-        count: 0
-      };
-    }
+  var _dispatcher$useState = dispatcher.useState(function () {
+      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    }),
+    currentSnapshot = _dispatcher$useState[0],
+    setSnapshot = _dispatcher$useState[1];
 
-    case "link": {
-      if (
-        pendingProps.rel === "stylesheet" &&
-        typeof pendingProps.href === "string" &&
-        typeof pendingProps.precedence === "string"
-      ) {
-        var qualifiedProps = pendingProps;
+  var snapshot = currentSnapshot; // Grab a handle to the state hook as well.
+  // We use it to clear the pending update queue if we have a new source.
 
-        var _key3 = getStyleKey(qualifiedProps.href);
+  var stateHook = workInProgressHook;
+  var memoizedState = hook.memoizedState;
+  var refs = memoizedState.refs;
+  var prevGetSnapshot = refs.getSnapshot;
+  var prevSource = memoizedState.source;
+  var prevSubscribe = memoizedState.subscribe;
+  var fiber = currentlyRenderingFiber$1;
+  hook.memoizedState = {
+    refs: refs,
+    source: source,
+    subscribe: subscribe
+  }; // Sync the values needed by our subscription handler after each commit.
 
-        var _styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+  dispatcher.useEffect(
+    function () {
+      refs.getSnapshot = getSnapshot; // Normally the dispatch function for a state hook never changes,
+      // but this hook recreates the queue in certain cases  to avoid updates from stale sources.
+      // handleChange() below needs to reference the dispatch function without re-subscribing,
+      // so we use a ref to ensure that it always has the latest version.
 
-        var _resource2 = _styles.get(_key3);
+      refs.setSnapshot = setSnapshot; // Check for a possible change between when we last rendered now.
 
-        if (!_resource2) {
-          // We asserted this above but Flow can't figure out that the type satisfies
-          var ownerDocument = getDocumentFromRoot(resourceRoot);
-          _resource2 = {
-            type: "stylesheet",
-            instance: null,
-            count: 0
-          };
+      var maybeNewVersion = getVersion(source._source);
 
-          _styles.set(_key3, _resource2);
+      if (!objectIs(version, maybeNewVersion)) {
+        var maybeNewSnapshot = getSnapshot(source._source);
 
-          if (!preloadPropsMap.has(_key3)) {
-            preloadStylesheet(
-              ownerDocument,
-              _key3,
-              preloadPropsFromStylesheet(qualifiedProps)
+        {
+          if (typeof maybeNewSnapshot === "function") {
+            error(
+              "Mutable source should not return a function as the snapshot value. " +
+                "Functions may close over mutable values and cause tearing."
             );
           }
         }
 
-        return _resource2;
-      }
+        if (!objectIs(snapshot, maybeNewSnapshot)) {
+          setSnapshot(maybeNewSnapshot);
+          var lane = requestUpdateLane(fiber);
+          markRootMutableRead(root, lane);
+        } // If the source mutated between render and now,
+        // there may be state updates already scheduled from the old source.
+        // Entangle the updates so that they render in the same batch.
 
-      return null;
-    }
+        markRootEntangled(root, root.mutableReadLanes);
+      }
+    },
+    [getSnapshot, source, subscribe]
+  ); // If we got a new source or subscribe function, re-subscribe in a passive effect.
 
-    case "script": {
-      if (typeof pendingProps.src === "string" && pendingProps.async === true) {
-        var scriptProps = pendingProps;
+  dispatcher.useEffect(
+    function () {
+      var handleChange = function () {
+        var latestGetSnapshot = refs.getSnapshot;
+        var latestSetSnapshot = refs.setSnapshot;
 
-        var _key4 = getScriptKey(scriptProps.src);
+        try {
+          latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
 
-        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+          var lane = requestUpdateLane(fiber);
+          markRootMutableRead(root, lane);
+        } catch (error) {
+          // A selector might throw after a source mutation.
+          // e.g. it might try to read from a part of the store that no longer exists.
+          // In this case we should still schedule an update with React.
+          // Worst case the selector will throw again and then an error boundary will handle it.
+          latestSetSnapshot(function () {
+            throw error;
+          });
+        }
+      };
 
-        var _resource3 = scripts.get(_key4);
+      var unsubscribe = subscribe(source._source, handleChange);
 
-        if (!_resource3) {
-          _resource3 = {
-            type: "script",
-            instance: null,
-            count: 0
-          };
-          scripts.set(_key4, _resource3);
+      {
+        if (typeof unsubscribe !== "function") {
+          error(
+            "Mutable source subscribe function must return an unsubscribe function."
+          );
         }
-
-        return _resource3;
       }
 
-      return {
-        type: "void",
-        instance: null,
-        count: 0
-      };
-    }
+      return unsubscribe;
+    },
+    [source, subscribe]
+  ); // If any of the inputs to useMutableSource change, reading is potentially unsafe.
+  //
+  // If either the source or the subscription have changed we can't can't trust the update queue.
+  // Maybe the source changed in a way that the old subscription ignored but the new one depends on.
+  //
+  // If the getSnapshot function changed, we also shouldn't rely on the update queue.
+  // It's possible that the underlying source was mutated between the when the last "change" event fired,
+  // and when the current render (with the new getSnapshot function) is processed.
+  //
+  // In both cases, we need to throw away pending updates (since they are no longer relevant)
+  // and treat reading from the source as we do in the mount case.
 
-    default: {
-      throw new Error(
-        'getResource encountered a type it did not expect: "' +
-          type +
-          '". this is a bug in React.'
-      );
-    }
+  if (
+    !objectIs(prevGetSnapshot, getSnapshot) ||
+    !objectIs(prevSource, source) ||
+    !objectIs(prevSubscribe, subscribe)
+  ) {
+    // Create a new queue and setState method,
+    // So if there are interleaved updates, they get pushed to the older queue.
+    // When this becomes current, the previous queue and dispatch method will be discarded,
+    // including any interleaving updates that occur.
+    var newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: snapshot
+    };
+    newQueue.dispatch = setSnapshot = dispatchSetState.bind(
+      null,
+      currentlyRenderingFiber$1,
+      newQueue
+    );
+    stateHook.queue = newQueue;
+    stateHook.baseQueue = null;
+    snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    stateHook.memoizedState = stateHook.baseState = snapshot;
   }
-}
-
-function styleTagPropsFromRawProps(rawProps) {
-  return assign({}, rawProps, {
-    "data-href": rawProps.href,
-    "data-precedence": rawProps.precedence,
-    href: null,
-    precedence: null
-  });
-}
 
-function getStyleKey(href) {
-  var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
-  return 'href~="' + limitedEscapedHref + '"';
+  return snapshot;
 }
 
-function getStyleTagSelectorFromKey(key) {
-  return "style[data-" + key + "]";
+function mountMutableSource(source, getSnapshot, subscribe) {
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = {
+    refs: {
+      getSnapshot: getSnapshot,
+      setSnapshot: null
+    },
+    source: source,
+    subscribe: subscribe
+  };
+  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
 
-function getStylesheetSelectorFromKey(key) {
-  return 'link[rel="stylesheet"][' + key + "]";
+function updateMutableSource(source, getSnapshot, subscribe) {
+  var hook = updateWorkInProgressHook();
+  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
 
-function getPreloadStylesheetSelectorFromKey(key) {
-  return 'link[rel="preload"][as="style"][' + key + "]";
-}
-
-function stylesheetPropsFromRawProps(rawProps) {
-  return assign({}, rawProps, {
-    "data-precedence": rawProps.precedence,
-    precedence: null
-  });
-}
-
-function preloadStylesheet(ownerDocument, key, preloadProps) {
-  preloadPropsMap.set(key, preloadProps);
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  var fiber = currentlyRenderingFiber$1;
+  var hook = mountWorkInProgressHook();
+  var nextSnapshot;
+  var isHydrating = getIsHydrating();
 
-  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
-    // There is no matching stylesheet instance in the Document.
-    // We will insert a preload now to kick off loading because
-    // we expect this stylesheet to commit
-    if (
-      null ===
-      ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key))
-    ) {
-      var preloadInstance = ownerDocument.createElement("link");
-      setInitialProperties(preloadInstance, "link", preloadProps);
-      markNodeAsHoistable(preloadInstance);
-      ownerDocument.head.appendChild(preloadInstance);
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw new Error(
+        "Missing getServerSnapshot, which is required for " +
+          "server-rendered content. Will revert to client rendering."
+      );
     }
-  }
-}
-
-function preloadPropsFromStylesheet(props) {
-  return {
-    rel: "preload",
-    as: "style",
-    href: props.href,
-    crossOrigin: props.crossOrigin,
-    integrity: props.integrity,
-    media: props.media,
-    hrefLang: props.hrefLang,
-    referrerPolicy: props.referrerPolicy
-  };
-}
 
-function getScriptKey(src) {
-  var limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
-  return '[src="' + limitedEscapedSrc + '"]';
-}
+    nextSnapshot = getServerSnapshot();
 
-function getScriptSelectorFromKey(key) {
-  return "script[async]" + key;
-} // --------------------------------------
-//      Hoistable Resource Reconciliation
-// --------------------------------------
+    {
+      if (!didWarnUncachedGetSnapshot) {
+        if (nextSnapshot !== getServerSnapshot()) {
+          error(
+            "The result of getServerSnapshot should be cached to avoid an infinite loop"
+          );
 
-function acquireResource(hoistableRoot, resource, props) {
-  resource.count++;
+          didWarnUncachedGetSnapshot = true;
+        }
+      }
+    }
+  } else {
+    nextSnapshot = getSnapshot();
 
-  if (resource.instance === null) {
-    switch (resource.type) {
-      case "style": {
-        var qualifiedProps = props;
-        var key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+    {
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedSnapshot = getSnapshot();
 
-        var instance = hoistableRoot.querySelector(
-          getStyleTagSelectorFromKey(key)
-        );
+        if (!objectIs(nextSnapshot, cachedSnapshot)) {
+          error(
+            "The result of getSnapshot should be cached to avoid an infinite loop"
+          );
 
-        if (instance) {
-          resource.instance = instance;
-          markNodeAsHoistable(instance);
-          return instance;
+          didWarnUncachedGetSnapshot = true;
         }
-
-        var styleProps = styleTagPropsFromRawProps(props);
-        var ownerDocument = getDocumentFromRoot(hoistableRoot);
-        instance = ownerDocument.createElement("style");
-        markNodeAsHoistable(instance);
-        setInitialProperties(instance, "style", styleProps);
-        insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
-        resource.instance = instance;
-        return instance;
       }
+    } // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
 
-      case "stylesheet": {
-        // This typing is enforce by `getResource`. If we change the logic
-        // there for what qualifies as a stylesheet resource we need to ensure
-        // this cast still makes sense;
-        var _qualifiedProps = props;
-
-        var _key5 = getStyleKey(_qualifiedProps.href); // Attempt to hydrate instance from DOM
+    var root = getWorkInProgressRoot();
 
-        var _instance2 = hoistableRoot.querySelector(
-          getStylesheetSelectorFromKey(_key5)
-        );
+    if (root === null) {
+      throw new Error(
+        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+      );
+    }
 
-        if (_instance2) {
-          resource.instance = _instance2;
-          markNodeAsHoistable(_instance2);
-          return _instance2;
-        }
+    if (!includesBlockingLane(root, renderLanes$1)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
 
-        var stylesheetProps = stylesheetPropsFromRawProps(props);
-        var preloadProps = preloadPropsMap.get(_key5);
+  hook.memoizedState = nextSnapshot;
+  var inst = {
+    value: nextSnapshot,
+    getSnapshot: getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
 
-        if (preloadProps) {
-          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
-        } // Construct and insert a new instance
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+  // TODO: We can move this to the passive phase once we add a pre-commit
+  // consistency check. See the next comment.
 
-        var _ownerDocument2 = getDocumentFromRoot(hoistableRoot);
+  fiber.flags |= Passive$1;
+  pushEffect(
+    HasEffect | Passive,
+    updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
+    undefined,
+    null
+  );
+  return nextSnapshot;
+}
 
-        _instance2 = _ownerDocument2.createElement("link");
-        markNodeAsHoistable(_instance2);
-        var linkInstance = _instance2;
-        linkInstance._p = new Promise(function (resolve, reject) {
-          linkInstance.onload = resolve;
-          linkInstance.onerror = reject;
-        }).then(
-          function () {
-            return (linkInstance._p.s = "l");
-          },
-          function () {
-            return (linkInstance._p.s = "e");
-          }
-        );
-        setInitialProperties(_instance2, "link", stylesheetProps);
-        insertStylesheet(_instance2, _qualifiedProps.precedence, hoistableRoot);
-        resource.instance = _instance2;
-        return _instance2;
-      }
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  var fiber = currentlyRenderingFiber$1;
+  var hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
 
-      case "script": {
-        // This typing is enforce by `getResource`. If we change the logic
-        // there for what qualifies as a stylesheet resource we need to ensure
-        // this cast still makes sense;
-        var borrowedScriptProps = props;
+  var nextSnapshot = getSnapshot();
 
-        var _key6 = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+  {
+    if (!didWarnUncachedGetSnapshot) {
+      var cachedSnapshot = getSnapshot();
 
-        var _instance3 = hoistableRoot.querySelector(
-          getScriptSelectorFromKey(_key6)
+      if (!objectIs(nextSnapshot, cachedSnapshot)) {
+        error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
         );
 
-        if (_instance3) {
-          resource.instance = _instance3;
-          markNodeAsHoistable(_instance3);
-          return _instance3;
-        }
-
-        var scriptProps = borrowedScriptProps;
-
-        var _preloadProps3 = preloadPropsMap.get(_key6);
+        didWarnUncachedGetSnapshot = true;
+      }
+    }
+  }
 
-        if (_preloadProps3) {
-          scriptProps = assign({}, borrowedScriptProps);
-          adoptPreloadPropsForScript(scriptProps, _preloadProps3);
-        } // Construct and insert a new instance
+  var prevSnapshot = (currentHook || hook).memoizedState;
+  var snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
 
-        var _ownerDocument3 = getDocumentFromRoot(hoistableRoot);
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
+  }
 
-        _instance3 = _ownerDocument3.createElement("script");
-        markNodeAsHoistable(_instance3);
-        setInitialProperties(_instance3, "link", scriptProps);
+  var inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [
+    subscribe
+  ]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
 
-        _ownerDocument3.head.appendChild(_instance3);
+  if (
+    inst.getSnapshot !== getSnapshot ||
+    snapshotChanged || // Check if the susbcribe function changed. We can save some memory by
+    // checking whether we scheduled a subscription effect above.
+    (workInProgressHook !== null &&
+      workInProgressHook.memoizedState.tag & HasEffect)
+  ) {
+    fiber.flags |= Passive$1;
+    pushEffect(
+      HasEffect | Passive,
+      updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
+      undefined,
+      null
+    ); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
 
-        resource.instance = _instance3;
-        return _instance3;
-      }
+    var root = getWorkInProgressRoot();
 
-      case "void": {
-        return null;
-      }
+    if (root === null) {
+      throw new Error(
+        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+      );
+    }
 
-      default: {
-        throw new Error(
-          'acquireResource encountered a resource type it did not expect: "' +
-            resource.type +
-            '". this is a bug in React.'
-        );
-      }
+    if (!includesBlockingLane(root, renderLanes$1)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
     }
   }
 
-  return resource.instance;
-}
-function releaseResource(resource) {
-  resource.count--;
+  return nextSnapshot;
 }
 
-function insertStylesheet(instance, precedence, root) {
-  var nodes = root.querySelectorAll(
-    'link[rel="stylesheet"][data-precedence],style[data-precedence]'
-  );
-  var last = nodes.length ? nodes[nodes.length - 1] : null;
-  var prior = last;
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  var check = {
+    getSnapshot: getSnapshot,
+    value: renderedSnapshot
+  };
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
-    var nodePrecedence = node.dataset.precedence;
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    var stores = componentUpdateQueue.stores;
 
-    if (nodePrecedence === precedence) {
-      prior = node;
-    } else if (prior !== last) {
-      break;
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
     }
   }
+}
 
-  if (prior) {
-    // We get the prior from the document so we know it is in the tree.
-    // We also know that links can't be the topmost Node so the parentNode
-    // must exist.
-    prior.parentNode.insertBefore(instance, prior.nextSibling);
-  } else {
-    var parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
-    parent.insertBefore(instance, parent.firstChild);
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
+
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
   }
 }
 
-function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
-  if (stylesheetProps.crossOrigin == null)
-    stylesheetProps.crossOrigin = preloadProps.crossOrigin;
-  if (stylesheetProps.referrerPolicy == null)
-    stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
-  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+function subscribeToStore(fiber, inst, subscribe) {
+  var handleStoreChange = function () {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
+    }
+  }; // Subscribe to the store and return a clean-up function.
+
+  return subscribe(handleStoreChange);
 }
 
-function adoptPreloadPropsForScript(scriptProps, preloadProps) {
-  if (scriptProps.crossOrigin == null)
-    scriptProps.crossOrigin = preloadProps.crossOrigin;
-  if (scriptProps.referrerPolicy == null)
-    scriptProps.referrerPolicy = preloadProps.referrerPolicy;
-  if (scriptProps.integrity == null)
-    scriptProps.referrerPolicy = preloadProps.integrity;
-} // --------------------------------------
-//      Hoistable Element Reconciliation
-// --------------------------------------
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  var prevValue = inst.value;
 
-var tagCaches = null;
-function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
-  var ownerDocument = getDocumentFromRoot(hoistableRoot);
-  var instance = null;
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
 
-  getInstance: switch (type) {
-    case "title": {
-      instance = ownerDocument.getElementsByTagName("title")[0];
+function forceStoreRerender(fiber) {
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-      if (
-        !instance ||
-        isOwnedInstance(instance) ||
-        instance.namespaceURI === SVG_NAMESPACE ||
-        instance.hasAttribute("itemprop")
-      ) {
-        instance = ownerDocument.createElement(type);
-        ownerDocument.head.insertBefore(
-          instance,
-          ownerDocument.querySelector("head > title")
-        );
-      }
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
+}
 
-      setInitialProperties(instance, type, props);
-      precacheFiberNode(internalInstanceHandle, instance);
-      markNodeAsHoistable(instance);
-      return instance;
-    }
+function mountState(initialState) {
+  var hook = mountWorkInProgressHook();
 
-    case "link": {
-      var cache = getHydratableHoistableCache("link", "href", ownerDocument);
-      var key = type + (props.href || "");
-      var maybeNodes = cache.get(key);
+  if (typeof initialState === "function") {
+    // $FlowFixMe: Flow doesn't like mixed types
+    initialState = initialState();
+  }
 
-      if (maybeNodes) {
-        var nodes = maybeNodes;
+  hook.memoizedState = hook.baseState = initialState;
+  var queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  var dispatch = (queue.dispatch = dispatchSetState.bind(
+    null,
+    currentlyRenderingFiber$1,
+    queue
+  ));
+  return [hook.memoizedState, dispatch];
+}
 
-        for (var i = 0; i < nodes.length; i++) {
-          var node = nodes[i];
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
+}
 
-          if (
-            node.getAttribute("href") !==
-              (props.href == null ? null : props.href) ||
-            node.getAttribute("rel") !==
-              (props.rel == null ? null : props.rel) ||
-            node.getAttribute("title") !==
-              (props.title == null ? null : props.title) ||
-            node.getAttribute("crossorigin") !==
-              (props.crossOrigin == null ? null : props.crossOrigin)
-          ) {
-            // mismatch, try the next node;
-            continue;
-          }
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
+}
 
-          instance = node;
-          nodes.splice(i, 1);
-          break getInstance;
-        }
-      }
+function pushEffect(tag, create, destroy, deps) {
+  var effect = {
+    tag: tag,
+    create: create,
+    destroy: destroy,
+    deps: deps,
+    // Circular
+    next: null
+  };
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-      instance = ownerDocument.createElement(type);
-      setInitialProperties(instance, type, props);
-      ownerDocument.head.appendChild(instance);
-      break;
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    var lastEffect = componentUpdateQueue.lastEffect;
+
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      var firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
     }
+  }
 
-    case "meta": {
-      var _cache = getHydratableHoistableCache(
-        "meta",
-        "content",
-        ownerDocument
-      );
+  return effect;
+}
 
-      var _key7 = type + (props.content || "");
+var stackContainsErrorMessage = null;
 
-      var _maybeNodes = _cache.get(_key7);
+function getCallerStackFrame() {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  var stackFrames = new Error("Error message").stack.split("\n"); // Some browsers (e.g. Chrome) include the error message in the stack
+  // but others (e.g. Firefox) do not.
 
-      if (_maybeNodes) {
-        var _nodes = _maybeNodes;
+  if (stackContainsErrorMessage === null) {
+    stackContainsErrorMessage = stackFrames[0].includes("Error message");
+  }
 
-        for (var _i = 0; _i < _nodes.length; _i++) {
-          var _node = _nodes[_i]; // We coerce content to string because it is the most likely one to
-          // use a `toString` capable value. For the rest we just do identity match
-          // passing non-strings here is not really valid anyway.
+  return stackContainsErrorMessage
+    ? stackFrames.slice(3, 4).join("\n")
+    : stackFrames.slice(2, 3).join("\n");
+}
 
-          {
-            checkAttributeStringCoercion(props.content, "content");
-          }
-
-          if (
-            _node.getAttribute("content") !==
-              (props.content == null ? null : "" + props.content) ||
-            _node.getAttribute("name") !==
-              (props.name == null ? null : props.name) ||
-            _node.getAttribute("property") !==
-              (props.property == null ? null : props.property) ||
-            _node.getAttribute("http-equiv") !==
-              (props.httpEquiv == null ? null : props.httpEquiv) ||
-            _node.getAttribute("charset") !==
-              (props.charSet == null ? null : props.charSet)
-          ) {
-            // mismatch, try the next node;
-            continue;
-          }
-
-          instance = _node;
-
-          _nodes.splice(_i, 1);
-
-          break getInstance;
-        }
-      }
-
-      instance = ownerDocument.createElement(type);
-      setInitialProperties(instance, type, props);
-      ownerDocument.head.appendChild(instance);
-      break;
-    }
-
-    default:
-      throw new Error(
-        'getNodesForType encountered a type it did not expect: "' +
-          type +
-          '". This is a bug in React.'
-      );
-  } // This node is a match
-
-  precacheFiberNode(internalInstanceHandle, instance);
-  markNodeAsHoistable(instance);
-  return instance;
-}
-
-function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
-  var cache;
-  var caches;
+function mountRef(initialValue) {
+  var hook = mountWorkInProgressHook();
 
-  if (tagCaches === null) {
-    cache = new Map();
-    caches = tagCaches = new Map();
-    caches.set(ownerDocument, cache);
-  } else {
-    caches = tagCaches;
-    var maybeCache = caches.get(ownerDocument);
+  if (enableUseRefAccessWarning) {
+    {
+      // Support lazy initialization pattern shown in docs.
+      // We need to store the caller stack frame so that we don't warn on subsequent renders.
+      var hasBeenInitialized = initialValue != null;
+      var lazyInitGetterStack = null;
+      var didCheckForLazyInit = false; // Only warn once per component+hook.
 
-    if (!maybeCache) {
-      cache = new Map();
-      caches.set(ownerDocument, cache);
-    } else {
-      cache = maybeCache;
-    }
-  }
+      var didWarnAboutRead = false;
+      var didWarnAboutWrite = false;
+      var current = initialValue;
+      var ref = {
+        get current() {
+          if (!hasBeenInitialized) {
+            didCheckForLazyInit = true;
+            lazyInitGetterStack = getCallerStackFrame();
+          } else if (currentlyRenderingFiber$1 !== null && !didWarnAboutRead) {
+            if (
+              lazyInitGetterStack === null ||
+              lazyInitGetterStack !== getCallerStackFrame()
+            ) {
+              didWarnAboutRead = true;
 
-  if (cache.has(type)) {
-    // We use type as a special key that signals that this cache has been seeded for this type
-    return cache;
-  } // Mark this cache as seeded for this type
+              warn(
+                "%s: Unsafe read of a mutable value during render.\n\n" +
+                  "Reading from a ref during render is only safe if:\n" +
+                  "1. The ref value has not been updated, or\n" +
+                  "2. The ref holds a lazily-initialized value that is only set once.\n",
+                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
+                  "Unknown"
+              );
+            }
+          }
 
-  cache.set(type, null);
-  var nodes = ownerDocument.getElementsByTagName(type);
+          return current;
+        },
 
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
+        set current(value) {
+          if (currentlyRenderingFiber$1 !== null && !didWarnAboutWrite) {
+            if (hasBeenInitialized || !didCheckForLazyInit) {
+              didWarnAboutWrite = true;
 
-    if (
-      !isOwnedInstance(node) &&
-      (type !== "link" || node.getAttribute("rel") !== "stylesheet") &&
-      node.namespaceURI !== SVG_NAMESPACE
-    ) {
-      var nodeKey = node.getAttribute(keyAttribute) || "";
-      var key = type + nodeKey;
-      var existing = cache.get(key);
+              warn(
+                "%s: Unsafe write of a mutable value during render.\n\n" +
+                  "Writing to a ref during render is only safe if the ref holds " +
+                  "a lazily-initialized value that is only set once.\n",
+                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
+                  "Unknown"
+              );
+            }
+          }
 
-      if (existing) {
-        existing.push(node);
-      } else {
-        cache.set(key, [node]);
-      }
+          hasBeenInitialized = true;
+          current = value;
+        }
+      };
+      Object.seal(ref);
+      hook.memoizedState = ref;
+      return ref;
     }
+  } else {
+    var _ref2 = {
+      current: initialValue
+    };
+    hook.memoizedState = _ref2;
+    return _ref2;
   }
-
-  return cache;
 }
 
-function mountHoistable(hoistableRoot, type, instance) {
-  var ownerDocument = getDocumentFromRoot(hoistableRoot);
-  ownerDocument.head.insertBefore(
-    instance,
-    type === "title" ? ownerDocument.querySelector("head > title") : null
-  );
+function updateRef(initialValue) {
+  var hook = updateWorkInProgressHook();
+  return hook.memoizedState;
 }
-function unmountHoistable(instance) {
-  instance.parentNode.removeChild(instance);
-} // When passing user input into querySelector(All) the embedded string must not alter
-// the semantics of the query. This escape function is safe to use when we know the
-// provided value is going to be wrapped in double quotes as part of an attribute selector
-// Do not use it anywhere else
-// we escape double quotes and backslashes
-
-var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
 
-function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
-  return value.replace(
-    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
-    function (ch) {
-      return "\\" + ch.charCodeAt(0).toString(16);
-    }
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    HasEffect | hookFlags,
+    create,
+    undefined,
+    nextDeps
   );
 }
 
-var SUPPRESS_HYDRATION_WARNING = "suppressHydrationWarning";
-var SUSPENSE_START_DATA = "$";
-var SUSPENSE_END_DATA = "/$";
-var SUSPENSE_PENDING_START_DATA = "$?";
-var SUSPENSE_FALLBACK_START_DATA = "$!";
-var STYLE = "style";
-var eventsEnabled = null;
-var selectionInformation = null;
-function getRootHostContext(rootContainerInstance) {
-  var type;
-  var namespace;
-  var nodeType = rootContainerInstance.nodeType;
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var destroy = undefined; // currentHook is null when rerendering after a render phase state update.
 
-  switch (nodeType) {
-    case DOCUMENT_NODE:
-    case DOCUMENT_FRAGMENT_NODE: {
-      type = nodeType === DOCUMENT_NODE ? "#document" : "#fragment";
-      var root = rootContainerInstance.documentElement;
-      namespace = root ? root.namespaceURI : getChildNamespace(null, "");
-      break;
-    }
+  if (currentHook !== null) {
+    var prevEffect = currentHook.memoizedState;
+    destroy = prevEffect.destroy;
 
-    default: {
-      var container =
-        nodeType === COMMENT_NODE
-          ? rootContainerInstance.parentNode
-          : rootContainerInstance;
-      var ownNamespace = container.namespaceURI || null;
-      type = container.tagName;
-      namespace = getChildNamespace(ownNamespace, type);
-      break;
+    if (nextDeps !== null) {
+      var prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, destroy, nextDeps);
+        return;
+      }
     }
   }
 
-  {
-    var validatedTag = type.toLowerCase();
-    var ancestorInfo = updatedAncestorInfoDev(null, validatedTag);
-    return {
-      namespace: namespace,
-      ancestorInfo: ancestorInfo
-    };
-  }
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    HasEffect | hookFlags,
+    create,
+    destroy,
+    nextDeps
+  );
 }
-function getChildHostContext(parentHostContext, type) {
-  {
-    var parentHostContextDev = parentHostContext;
-    var namespace = getChildNamespace(parentHostContextDev.namespace, type);
-    var ancestorInfo = updatedAncestorInfoDev(
-      parentHostContextDev.ancestorInfo,
-      type
+
+function mountEffect(create, deps) {
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    mountEffectImpl(
+      MountPassiveDev | Passive$1 | PassiveStatic,
+      Passive,
+      create,
+      deps
     );
-    return {
-      namespace: namespace,
-      ancestorInfo: ancestorInfo
-    };
+  } else {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
   }
 }
-function getPublicInstance(instance) {
-  return instance;
+
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
 }
-function prepareForCommit(containerInfo) {
-  eventsEnabled = isEnabled();
-  selectionInformation = getSelectionInformation();
-  var activeInstance = null;
 
-  {
-    var focusedElem = selectionInformation.focusedElem;
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-    if (focusedElem !== null) {
-      activeInstance = getClosestInstanceFromNode(focusedElem);
-    }
-  }
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    var events = componentUpdateQueue.events;
 
-  setEnabled(false);
-  return activeInstance;
-}
-function beforeActiveInstanceBlur(internalInstanceHandle) {
-  {
-    setEnabled(true);
-    dispatchBeforeDetachedBlur(
-      selectionInformation.focusedElem,
-      internalInstanceHandle
-    );
-    setEnabled(false);
-  }
-}
-function afterActiveInstanceBlur() {
-  {
-    setEnabled(true);
-    dispatchAfterDetachedBlur(selectionInformation.focusedElem);
-    setEnabled(false);
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
+    } else {
+      events.push(payload);
+    }
   }
 }
-function resetAfterCommit(containerInfo) {
-  restoreSelection(selectionInformation);
-  setEnabled(eventsEnabled);
-  eventsEnabled = null;
-  selectionInformation = null;
-}
-function createHoistableInstance(
-  type,
-  props,
-  rootContainerInstance,
-  internalInstanceHandle
-) {
-  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
-  var domElement = createHTMLElement(type, props, ownerDocument);
-  precacheFiberNode(internalInstanceHandle, domElement);
-  updateFiberProps(domElement, props);
-  setInitialProperties(domElement, type, props);
-  markNodeAsHoistable(domElement);
-  return domElement;
-}
-function createInstance(
-  type,
-  props,
-  rootContainerInstance,
-  hostContext,
-  internalInstanceHandle
-) {
-  var namespace;
 
-  {
-    // TODO: take namespace into account when validating.
-    var hostContextDev = hostContext;
-    validateDOMNesting(type, null, hostContextDev.ancestorInfo);
+function mountEvent(callback) {
+  var hook = mountWorkInProgressHook();
+  var ref = {
+    impl: callback
+  };
+  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
 
-    if (
-      typeof props.children === "string" ||
-      typeof props.children === "number"
-    ) {
-      var string = "" + props.children;
-      var ownAncestorInfo = updatedAncestorInfoDev(
-        hostContextDev.ancestorInfo,
-        type
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw new Error(
+        "A function wrapped in useEffectEvent can't be called during rendering."
       );
-      validateDOMNesting(null, string, ownAncestorInfo);
     }
 
-    namespace = hostContextDev.namespace;
-  }
+    return ref.impl.apply(undefined, arguments);
+  };
+}
 
-  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
-  var domElement;
+function updateEvent(callback) {
+  var hook = updateWorkInProgressHook();
+  var ref = hook.memoizedState;
+  useEffectEventImpl({
+    ref: ref,
+    nextImpl: callback
+  }); // $FlowIgnore[incompatible-return]
 
-  switch (namespace) {
-    case SVG_NAMESPACE:
-    case MATH_NAMESPACE:
-      domElement = ownerDocument.createElementNS(namespace, type);
-      break;
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw new Error(
+        "A function wrapped in useEffectEvent can't be called during rendering."
+      );
+    }
 
-    default:
-      switch (type) {
-        case "svg":
-          domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
-          break;
+    return ref.impl.apply(undefined, arguments);
+  };
+}
 
-        case "math":
-          domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
-          break;
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
 
-        case "script":
-          domElement = createPotentiallyInlineScriptElement(ownerDocument);
-          break;
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
 
-        case "select":
-          domElement = createSelectElement(props, ownerDocument);
-          break;
+function mountLayoutEffect(create, deps) {
+  var fiberFlags = Update | LayoutStatic;
 
-        default:
-          domElement = createHTMLElement(type, props, ownerDocument);
-      }
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    fiberFlags |= MountLayoutDev;
   }
 
-  precacheFiberNode(internalInstanceHandle, domElement);
-  updateFiberProps(domElement, props);
-  return domElement;
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
 }
-function appendInitialChild(parentInstance, child) {
-  parentInstance.appendChild(child);
+
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
 }
-function finalizeInitialChildren(domElement, type, props, hostContext) {
-  setInitialProperties(domElement, type, props);
 
-  switch (type) {
-    case "button":
-    case "input":
-    case "select":
-    case "textarea":
-      return !!props.autoFocus;
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === "function") {
+    var refCallback = ref;
+    var inst = create();
+    refCallback(inst);
+    return function () {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    var refObject = ref;
 
-    case "img":
-      return true;
+    {
+      if (!refObject.hasOwnProperty("current")) {
+        error(
+          "Expected useImperativeHandle() first argument to either be a " +
+            "ref callback or React.createRef() object. Instead received: %s.",
+          "an object with keys {" + Object.keys(refObject).join(", ") + "}"
+        );
+      }
+    }
 
-    default:
-      return false;
+    var _inst = create();
+
+    refObject.current = _inst;
+    return function () {
+      refObject.current = null;
+    };
   }
 }
-function prepareUpdate(domElement, type, oldProps, newProps, hostContext) {
-  {
-    var hostContextDev = hostContext;
 
-    if (
-      typeof newProps.children !== typeof oldProps.children &&
-      (typeof newProps.children === "string" ||
-        typeof newProps.children === "number")
-    ) {
-      var string = "" + newProps.children;
-      var ownAncestorInfo = updatedAncestorInfoDev(
-        hostContextDev.ancestorInfo,
-        type
+function mountImperativeHandle(ref, create, deps) {
+  {
+    if (typeof create !== "function") {
+      error(
+        "Expected useImperativeHandle() second argument to be a function " +
+          "that creates a handle. Instead received: %s.",
+        create !== null ? typeof create : "null"
       );
-      validateDOMNesting(null, string, ownAncestorInfo);
     }
+  } // TODO: If deps are provided, should we skip comparing the ref itself?
+
+  var effectDeps =
+    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  var fiberFlags = Update | LayoutStatic;
+
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    fiberFlags |= MountLayoutDev;
   }
 
-  return diffProperties(domElement, type, oldProps, newProps);
-}
-function shouldSetTextContent(type, props) {
-  return (
-    type === "textarea" ||
-    type === "noscript" ||
-    typeof props.children === "string" ||
-    typeof props.children === "number" ||
-    (typeof props.dangerouslySetInnerHTML === "object" &&
-      props.dangerouslySetInnerHTML !== null &&
-      props.dangerouslySetInnerHTML.__html != null)
+  mountEffectImpl(
+    fiberFlags,
+    Layout,
+    imperativeHandleEffect.bind(null, create, ref),
+    effectDeps
   );
 }
-function createTextInstance(
-  text,
-  rootContainerInstance,
-  hostContext,
-  internalInstanceHandle
-) {
-  {
-    var hostContextDev = hostContext;
-    validateDOMNesting(null, text, hostContextDev.ancestorInfo);
-  }
 
-  var textNode = createTextNode(text, rootContainerInstance);
-  precacheFiberNode(internalInstanceHandle, textNode);
-  return textNode;
-}
-function getCurrentEventPriority() {
-  var currentEvent = window.event;
-
-  if (currentEvent === undefined) {
-    return DefaultEventPriority;
-  }
+function updateImperativeHandle(ref, create, deps) {
+  {
+    if (typeof create !== "function") {
+      error(
+        "Expected useImperativeHandle() second argument to be a function " +
+          "that creates a handle. Instead received: %s.",
+        create !== null ? typeof create : "null"
+      );
+    }
+  } // TODO: If deps are provided, should we skip comparing the ref itself?
 
-  return getEventPriority(currentEvent.type);
+  var effectDeps =
+    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(
+    Update,
+    Layout,
+    imperativeHandleEffect.bind(null, create, ref),
+    effectDeps
+  );
 }
-// if a component just imports ReactDOM (e.g. for findDOMNode).
-// Some environments might not have setTimeout or clearTimeout.
 
-var scheduleTimeout = typeof setTimeout === "function" ? setTimeout : undefined;
-var cancelTimeout =
-  typeof clearTimeout === "function" ? clearTimeout : undefined;
-var noTimeout = -1;
-var localPromise = typeof Promise === "function" ? Promise : undefined;
-var localRequestAnimationFrame =
-  typeof requestAnimationFrame === "function"
-    ? requestAnimationFrame
-    : scheduleTimeout;
-function getInstanceFromNode(node) {
-  return getClosestInstanceFromNode(node) || null;
-}
-function preparePortalMount(portalInstance) {
-  listenToAllSupportedEvents(portalInstance);
-}
-function prepareScopeUpdate(scopeInstance, internalInstanceHandle) {
-  {
-    precacheFiberNode(internalInstanceHandle, scopeInstance);
-  }
+function mountDebugValue(value, formatterFn) {
+  // This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
 }
-function getInstanceFromScope(scopeInstance) {
-  {
-    return getFiberFromScopeInstance(scopeInstance);
-  }
-} // -------------------
-var scheduleMicrotask =
-  typeof queueMicrotask === "function"
-    ? queueMicrotask
-    : typeof localPromise !== "undefined"
-    ? function (callback) {
-        return localPromise
-          .resolve(null)
-          .then(callback)
-          .catch(handleErrorInNextTick);
-      }
-    : scheduleTimeout; // TODO: Determine the best fallback here.
 
-function handleErrorInNextTick(error) {
-  setTimeout(function () {
-    throw error;
-  });
-} // -------------------
-function commitMount(domElement, type, newProps, internalInstanceHandle) {
-  // Despite the naming that might imply otherwise, this method only
-  // fires if there is an `Update` effect scheduled during mounting.
-  // This happens if `finalizeInitialChildren` returns `true` (which it
-  // does to implement the `autoFocus` attribute on the client). But
-  // there are also other cases when this might happen (such as patching
-  // up text content during hydration mismatch). So we'll check this again.
-  switch (type) {
-    case "button":
-    case "input":
-    case "select":
-    case "textarea":
-      if (newProps.autoFocus) {
-        domElement.focus();
-      }
+var updateDebugValue = mountDebugValue;
 
-      return;
+function mountCallback(callback, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
 
-    case "img": {
-      if (newProps.src) {
-        domElement.src = newProps.src;
-      }
+function updateCallback(callback, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var prevState = hook.memoizedState;
 
-      return;
+  if (nextDeps !== null) {
+    var prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
     }
   }
-}
-function commitUpdate(
-  domElement,
-  updatePayload,
-  type,
-  oldProps,
-  newProps,
-  internalInstanceHandle
-) {
-  // Apply the diff to the DOM node.
-  updateProperties(domElement, updatePayload, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
-  // with current event handlers.
 
-  updateFiberProps(domElement, newProps);
-}
-function resetTextContent(domElement) {
-  setTextContent(domElement, "");
-}
-function commitTextUpdate(textInstance, oldText, newText) {
-  textInstance.nodeValue = newText;
-}
-function appendChild(parentInstance, child) {
-  parentInstance.appendChild(child);
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
 }
-function appendChildToContainer(container, child) {
-  var parentNode;
-
-  if (container.nodeType === COMMENT_NODE) {
-    parentNode = container.parentNode;
-    parentNode.insertBefore(child, container);
-  } else {
-    parentNode = container;
-    parentNode.appendChild(child);
-  } // This container might be used for a portal.
-  // If something inside a portal is clicked, that click should bubble
-  // through the React tree. However, on Mobile Safari the click would
-  // never bubble through the *DOM* tree unless an ancestor with onclick
-  // event exists. So we wouldn't see it and dispatch it.
-  // This is why we ensure that non React root containers have inline onclick
-  // defined.
-  // https://github.com/facebook/react/issues/11918
 
-  var reactRootContainer = container._reactRootContainer;
+function mountMemo(nextCreate, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
 
-  if (
-    (reactRootContainer === null || reactRootContainer === undefined) &&
-    parentNode.onclick === null
-  ) {
-    // TODO: This cast may not be sound for SVG, MathML or custom elements.
-    trapClickOnNonInteractiveElement(parentNode);
-  }
-}
-function insertBefore(parentInstance, child, beforeChild) {
-  parentInstance.insertBefore(child, beforeChild);
-}
-function insertInContainerBefore(container, child, beforeChild) {
-  if (container.nodeType === COMMENT_NODE) {
-    container.parentNode.insertBefore(child, beforeChild);
-  } else {
-    container.insertBefore(child, beforeChild);
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
   }
-}
 
-function createEvent(type, bubbles) {
-  var event = document.createEvent("Event");
-  event.initEvent(type, bubbles, false);
-  return event;
+  var nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
 }
 
-function dispatchBeforeDetachedBlur(target, internalInstanceHandle) {
-  {
-    var event = createEvent("beforeblur", true); // Dispatch "beforeblur" directly on the target,
-    // so it gets picked up by the event system and
-    // can propagate through the React internal tree.
-    // $FlowFixMe: internal field
+function updateMemo(nextCreate, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
 
-    event._detachedInterceptFiber = internalInstanceHandle;
-    target.dispatchEvent(event);
+  if (nextDeps !== null) {
+    var prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
   }
-}
 
-function dispatchAfterDetachedBlur(target) {
-  {
-    var event = createEvent("afterblur", false); // So we know what was detached, make the relatedTarget the
-    // detached target on the "afterblur" event.
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
 
-    event.relatedTarget = target; // Dispatch the event on the document.
+  var nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
 
-    document.dispatchEvent(event);
-  }
+function mountDeferredValue(value) {
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = value;
+  return value;
 }
 
-function removeChild(parentInstance, child) {
-  parentInstance.removeChild(child);
+function updateDeferredValue(value) {
+  var hook = updateWorkInProgressHook();
+  var resolvedCurrentHook = currentHook;
+  var prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value);
 }
-function removeChildFromContainer(container, child) {
-  if (container.nodeType === COMMENT_NODE) {
-    container.parentNode.removeChild(child);
+
+function rerenderDeferredValue(value) {
+  var hook = updateWorkInProgressHook();
+
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    hook.memoizedState = value;
+    return value;
   } else {
-    container.removeChild(child);
+    // This is a rerender during an update.
+    var prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value);
   }
 }
-function clearSuspenseBoundary(parentInstance, suspenseInstance) {
-  var node = suspenseInstance; // Delete all nodes within this suspense boundary.
-  // There might be nested nodes so we need to keep track of how
-  // deep we are and only break out when we're back on top.
-
-  var depth = 0;
-
-  do {
-    var nextNode = node.nextSibling;
-    parentInstance.removeChild(node);
 
-    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
-      var data = nextNode.data;
+function updateDeferredValueImpl(hook, prevValue, value) {
+  var shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes$1);
 
-      if (data === SUSPENSE_END_DATA) {
-        if (depth === 0) {
-          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+  if (shouldDeferValue) {
+    // This is an urgent update. If the value has changed, keep using the
+    // previous value and spawn a deferred render to update it later.
+    if (!objectIs(value, prevValue)) {
+      // Schedule a deferred render
+      var deferredLane = claimNextTransitionLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(
+        currentlyRenderingFiber$1.lanes,
+        deferredLane
+      );
+      markSkippedUpdateLanes(deferredLane); // Set this to true to indicate that the rendered value is inconsistent
+      // from the latest value. The name "baseState" doesn't really match how we
+      // use it because we're reusing a state hook field instead of creating a
+      // new one.
 
-          retryIfBlockedOn(suspenseInstance);
-          return;
-        } else {
-          depth--;
-        }
-      } else if (
-        data === SUSPENSE_START_DATA ||
-        data === SUSPENSE_PENDING_START_DATA ||
-        data === SUSPENSE_FALLBACK_START_DATA
-      ) {
-        depth++;
-      }
-    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      hook.baseState = true;
+    } // Reuse the previous value
 
-    node = nextNode;
-  } while (node); // TODO: Warn, we didn't find the end comment boundary.
-  // Retry if any event replaying was blocked on this.
+    return prevValue;
+  } else {
+    // This is not an urgent update, so we can use the latest value regardless
+    // of what it is. No need to defer it.
+    // However, if we're currently inside a spawned render, then we need to mark
+    // this as an update to prevent the fiber from bailing out.
+    //
+    // `baseState` is true when the current value is different from the rendered
+    // value. The name doesn't really match how we use it because we're reusing
+    // a state hook field instead of creating a new one.
+    if (hook.baseState) {
+      // Flip this back to false.
+      hook.baseState = false;
+      markWorkInProgressReceivedUpdate();
+    }
 
-  retryIfBlockedOn(suspenseInstance);
+    hook.memoizedState = value;
+    return value;
+  }
 }
-function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
-  if (container.nodeType === COMMENT_NODE) {
-    clearSuspenseBoundary(container.parentNode, suspenseInstance);
-  } else if (container.nodeType === ELEMENT_NODE) {
-    clearSuspenseBoundary(container, suspenseInstance);
-  } else; // Retry if any event replaying was blocked on this.
 
-  retryIfBlockedOn(container);
-}
-function hideInstance(instance) {
-  // TODO: Does this work for all element types? What about MathML? Should we
-  // pass host context to this method?
-  instance = instance;
-  var style = instance.style; // $FlowFixMe[method-unbinding]
+function startTransition(setPending, callback, options) {
+  var previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(
+    higherEventPriority(previousPriority, ContinuousEventPriority)
+  );
+  setPending(true);
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+  var currentTransition = ReactCurrentBatchConfig$3.transition;
 
-  if (typeof style.setProperty === "function") {
-    style.setProperty("display", "none", "important");
-  } else {
-    style.display = "none";
+  if (enableTransitionTracing) {
+    if (options !== undefined && options.name !== undefined) {
+      ReactCurrentBatchConfig$3.transition.name = options.name;
+      ReactCurrentBatchConfig$3.transition.startTime = now$1();
+    }
   }
-}
-function hideTextInstance(textInstance) {
-  textInstance.nodeValue = "";
-}
-function unhideInstance(instance, props) {
-  instance = instance;
-  var styleProp = props[STYLE];
-  var display =
-    styleProp !== undefined &&
-    styleProp !== null &&
-    styleProp.hasOwnProperty("display")
-      ? styleProp.display
-      : null;
-  instance.style.display = dangerousStyleValue("display", display);
-}
-function unhideTextInstance(textInstance, text) {
-  textInstance.nodeValue = text;
-}
-function clearContainer(container) {
+
   {
-    var nodeType = container.nodeType;
+    ReactCurrentBatchConfig$3.transition._updatedFibers = new Set();
+  }
 
-    if (nodeType === DOCUMENT_NODE) {
-      clearContainerSparingly(container);
-    } else if (nodeType === ELEMENT_NODE) {
-      switch (container.nodeName) {
-        case "HEAD":
-        case "HTML":
-        case "BODY":
-          clearContainerSparingly(container);
-          return;
+  try {
+    setPending(false);
+    callback();
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
 
-        default: {
-          container.textContent = "";
+    {
+      if (prevTransition === null && currentTransition._updatedFibers) {
+        var updatedFibersCount = currentTransition._updatedFibers.size;
+
+        currentTransition._updatedFibers.clear();
+
+        if (updatedFibersCount > 10) {
+          warn(
+            "Detected a large number of updates inside startTransition. " +
+              "If this is due to a subscription please re-write it to use React provided hooks. " +
+              "Otherwise concurrent mode guarantees are off the table."
+          );
         }
       }
     }
   }
 }
 
-function clearContainerSparingly(container) {
-  var node;
-  var nextNode = container.firstChild;
+function mountTransition() {
+  var _mountState = mountState(false),
+    isPending = _mountState[0],
+    setPending = _mountState[1]; // The `start` method never changes.
 
-  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
-    nextNode = nextNode.nextSibling;
-  }
+  var start = startTransition.bind(null, setPending);
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [isPending, start];
+}
 
-  while (nextNode) {
-    node = nextNode;
-    nextNode = nextNode.nextSibling;
+function updateTransition() {
+  var _updateState = updateState(),
+    isPending = _updateState[0];
 
-    switch (node.nodeName) {
-      case "HTML":
-      case "HEAD":
-      case "BODY": {
-        var element = node;
-        clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
-        // may still hold on to references to the previous fiber tree. We detatch them
-        // prospectively to reset them to a baseline starting state since we cannot create
-        // new instances.
+  var hook = updateWorkInProgressHook();
+  var start = hook.memoizedState;
+  return [isPending, start];
+}
 
-        detachDeletedInstance(element);
-        continue;
-      }
+function rerenderTransition() {
+  var _rerenderState = rerenderState(),
+    isPending = _rerenderState[0];
 
-      case "STYLE": {
-        continue;
-      }
+  var hook = updateWorkInProgressHook();
+  var start = hook.memoizedState;
+  return [isPending, start];
+}
 
-      case "LINK": {
-        if (node.rel.toLowerCase() === "stylesheet") {
-          continue;
-        }
-      }
-    }
+function mountId() {
+  var hook = mountWorkInProgressHook();
+  var root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
 
-    container.removeChild(node);
-  }
+  var identifierPrefix = root.identifierPrefix;
+  var id;
 
-  return;
-} // Making this so we can eventually move all of the instance caching to the commit phase.
-// inserted without breaking hydration
+  if (getIsHydrating()) {
+    var treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
 
-function isHydratableType(type, props) {
-  {
-    if (type === "script") {
-      var async = props.async,
-        onLoad = props.onLoad,
-        onError = props.onError;
-      return !(async && (onLoad || onError));
+    id = ":" + identifierPrefix + "R" + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
+
+    var localId = localIdCounter++;
+
+    if (localId > 0) {
+      id += "H" + localId.toString(32);
     }
 
-    return true;
+    id += ":";
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    var globalClientId = globalClientIdCounter++;
+    id = ":" + identifierPrefix + "r" + globalClientId.toString(32) + ":";
   }
+
+  hook.memoizedState = id;
+  return id;
 }
-function isHydratableText(text) {
-  return text !== "";
+
+function updateId() {
+  var hook = updateWorkInProgressHook();
+  var id = hook.memoizedState;
+  return id;
 }
-function shouldSkipHydratableForInstance(instance, type, props) {
-  if (instance.nodeType !== ELEMENT_NODE) {
-    // This is a suspense boundary or Text node.
-    // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
-    // and this is a hydration error.
-    // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
-    // but it seems reasonable and conservative to reject this as a hydration error as well
-    return false;
-  } else if (
-    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
-    isMarkedHoistable(instance)
-  ) {
-    // We are either about to
-    return true;
-  } else {
-    // We have an Element with the right type.
-    var element = instance;
-    var anyProps = props; // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
-    // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
-    // using high entropy attributes for certain types. This technique will fail for strange insertions like
-    // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
 
-    switch (type) {
-      // case 'title':
-      //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
-      // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
-      case "meta": {
-        // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
-        // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
-        // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
-        // implications are minimal
-        if (!element.hasAttribute("itemprop")) {
-          // This is a Hoistable
-          return true;
-        }
-
-        break;
-      }
+function mountRefresh() {
+  var hook = mountWorkInProgressHook();
+  var refresh = (hook.memoizedState = refreshCache.bind(
+    null,
+    currentlyRenderingFiber$1
+  ));
+  return refresh;
+}
 
-      case "link": {
-        // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
-        // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
-        // matches.
-        var rel = element.getAttribute("rel");
+function updateRefresh() {
+  var hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
 
-        if (rel === "stylesheet" && element.hasAttribute("data-precedence")) {
-          // This is a stylesheet resource
-          return true;
-        } else if (
-          rel !== anyProps.rel ||
-          element.getAttribute("href") !==
-            (anyProps.href == null ? null : anyProps.href) ||
-          element.getAttribute("crossorigin") !==
-            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) ||
-          element.getAttribute("title") !==
-            (anyProps.title == null ? null : anyProps.title)
-        ) {
-          // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
-          // and title could vary for rel alternate
-          return true;
-        }
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
 
-        break;
-      }
+  var provider = fiber.return;
 
-      case "style": {
-        // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
-        // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
-        if (element.hasAttribute("data-precedence")) {
-          // This is a style resource
-          return true;
-        }
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot: {
+        // Schedule an update on the cache boundary to trigger a refresh.
+        var lane = requestUpdateLane(provider);
+        var refreshUpdate = createUpdate(lane);
+        var root = enqueueUpdate(provider, refreshUpdate, lane);
 
-        break;
-      }
+        if (root !== null) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, provider, lane, eventTime);
+          entangleTransitions(root, provider, lane);
+        } // TODO: If a refresh never commits, the new cache created here must be
+        // released. A simple case is start refreshing a cache boundary, but then
+        // unmount that boundary before the refresh completes.
 
-      case "script": {
-        // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
-        // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
-        // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
-        // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
-        // if we learn it is problematic
-        var srcAttr = element.getAttribute("src");
+        var seededCache = createCache();
 
-        if (
-          srcAttr &&
-          element.hasAttribute("async") &&
-          !element.hasAttribute("itemprop")
-        ) {
-          // This is an async script resource
-          return true;
-        } else if (
-          srcAttr !== (anyProps.src == null ? null : anyProps.src) ||
-          element.getAttribute("type") !==
-            (anyProps.type == null ? null : anyProps.type) ||
-          element.getAttribute("crossorigin") !==
-            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)
-        ) {
-          // This script is for a different src
-          return true;
+        if (seedKey !== null && seedKey !== undefined && root !== null) {
+          {
+            // Seed the cache with the value passed by the caller. This could be
+            // from a server mutation, or it could be a streaming response.
+            seededCache.data.set(seedKey, seedValue);
+          }
         }
 
-        break;
+        var payload = {
+          cache: seededCache
+        };
+        refreshUpdate.payload = payload;
+        return;
       }
-    } // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
-    // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
-    // that should work in the vast majority of cases.
+    }
 
-    return false;
-  }
-}
-function shouldSkipHydratableForTextInstance(instance) {
-  return instance.nodeType === ELEMENT_NODE;
-}
-function shouldSkipHydratableForSuspenseInstance(instance) {
-  return instance.nodeType === ELEMENT_NODE;
-}
-function canHydrateInstance(instance, type, props) {
-  if (
-    instance.nodeType !== ELEMENT_NODE ||
-    instance.nodeName.toLowerCase() !== type.toLowerCase()
-  ) {
-    return null;
-  } else {
-    return instance;
-  }
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
 }
-function canHydrateTextInstance(instance, text) {
-  if (text === "") return null;
 
-  if (instance.nodeType !== TEXT_NODE) {
-    // Empty strings are not parsed by HTML so there won't be a correct match here.
-    return null;
-  } // This has now been refined to a text node.
-
-  return instance;
-}
-function canHydrateSuspenseInstance(instance) {
-  if (instance.nodeType !== COMMENT_NODE) {
-    return null;
-  } // This has now been refined to a suspense node.
+function dispatchReducerAction(fiber, queue, action) {
+  {
+    if (typeof arguments[3] === "function") {
+      error(
+        "State updates from the useState() and useReducer() Hooks don't support the " +
+          "second callback argument. To execute a side effect after " +
+          "rendering, declare it in the component body with useEffect()."
+      );
+    }
+  }
 
-  return instance;
-}
-function isSuspenseInstancePending(instance) {
-  return instance.data === SUSPENSE_PENDING_START_DATA;
-}
-function isSuspenseInstanceFallback(instance) {
-  return instance.data === SUSPENSE_FALLBACK_START_DATA;
-}
-function getSuspenseInstanceFallbackErrorDetails(instance) {
-  var dataset = instance.nextSibling && instance.nextSibling.dataset;
-  var digest, message, stack;
+  var lane = requestUpdateLane(fiber);
+  var update = {
+    lane: lane,
+    action: action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
 
-  if (dataset) {
-    digest = dataset.dgst;
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
 
-    {
-      message = dataset.msg;
-      stack = dataset.stck;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitionUpdate(root, queue, lane);
     }
   }
 
+  markUpdateInDevTools(fiber, lane, action);
+}
+
+function dispatchSetState(fiber, queue, action) {
   {
-    return {
-      message: message,
-      digest: digest,
-      stack: stack
-    };
+    if (typeof arguments[3] === "function") {
+      error(
+        "State updates from the useState() and useReducer() Hooks don't support the " +
+          "second callback argument. To execute a side effect after " +
+          "rendering, declare it in the component body with useEffect()."
+      );
+    }
   }
-}
-function registerSuspenseInstanceRetry(instance, callback) {
-  instance._reactRetry = callback;
-}
 
-function getNextHydratable(node) {
-  // Skip non-hydratable nodes.
-  for (; node != null; node = node.nextSibling) {
-    var nodeType = node.nodeType;
+  var lane = requestUpdateLane(fiber);
+  var update = {
+    lane: lane,
+    action: action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
 
-    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
-      break;
-    }
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    var alternate = fiber.alternate;
 
-    if (nodeType === COMMENT_NODE) {
-      var nodeData = node.data;
+    if (
+      fiber.lanes === NoLanes &&
+      (alternate === null || alternate.lanes === NoLanes)
+    ) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      var lastRenderedReducer = queue.lastRenderedReducer;
 
-      if (
-        nodeData === SUSPENSE_START_DATA ||
-        nodeData === SUSPENSE_FALLBACK_START_DATA ||
-        nodeData === SUSPENSE_PENDING_START_DATA
-      ) {
-        break;
-      }
+      if (lastRenderedReducer !== null) {
+        var prevDispatcher;
 
-      if (nodeData === SUSPENSE_END_DATA) {
-        return null;
-      }
-    }
-  }
+        {
+          prevDispatcher = ReactCurrentDispatcher$1.current;
+          ReactCurrentDispatcher$1.current =
+            InvalidNestedHooksDispatcherOnUpdateInDEV;
+        }
 
-  return node;
-}
+        try {
+          var currentState = queue.lastRenderedState;
+          var eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
 
-function getNextHydratableSibling(instance) {
-  return getNextHydratable(instance.nextSibling);
-}
-function getFirstHydratableChild(parentInstance) {
-  return getNextHydratable(parentInstance.firstChild);
-}
-function getFirstHydratableChildWithinContainer(parentContainer) {
-  return getNextHydratable(parentContainer.firstChild);
-}
-function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
-  return getNextHydratable(parentInstance.nextSibling);
-}
-function hydrateInstance(
-  instance,
-  type,
-  props,
-  hostContext,
-  internalInstanceHandle,
-  shouldWarnDev
-) {
-  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
-  // get attached.
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
 
-  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
-  // when the legacy root API is removed.
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {
+          // Suppress the error. It will throw again in the render phase.
+        } finally {
+          {
+            ReactCurrentDispatcher$1.current = prevDispatcher;
+          }
+        }
+      }
+    }
 
-  var isConcurrentMode =
-    (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
-  var parentNamespace;
+    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
 
-  {
-    var hostContextDev = hostContext;
-    parentNamespace = hostContextDev.namespace;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitionUpdate(root, queue, lane);
+    }
   }
 
-  return diffHydratedProperties(
-    instance,
-    type,
-    props,
-    isConcurrentMode,
-    shouldWarnDev,
-    parentNamespace
-  );
-}
-function hydrateTextInstance(
-  textInstance,
-  text,
-  internalInstanceHandle,
-  shouldWarnDev
-) {
-  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
-  return diffHydratedText(textInstance, text);
-}
-function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
-  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+  markUpdateInDevTools(fiber, lane, action);
 }
-function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
-  var node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
-  // There might be nested nodes so we need to keep track of how
-  // deep we are and only break out when we're back on top.
 
-  var depth = 0;
+function isRenderPhaseUpdate(fiber) {
+  var alternate = fiber.alternate;
+  return (
+    fiber === currentlyRenderingFiber$1 ||
+    (alternate !== null && alternate === currentlyRenderingFiber$1)
+  );
+}
 
-  while (node) {
-    if (node.nodeType === COMMENT_NODE) {
-      var data = node.data;
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
+    true;
+  var pending = queue.pending;
 
-      if (data === SUSPENSE_END_DATA) {
-        if (depth === 0) {
-          return getNextHydratableSibling(node);
-        } else {
-          depth--;
-        }
-      } else if (
-        data === SUSPENSE_START_DATA ||
-        data === SUSPENSE_FALLBACK_START_DATA ||
-        data === SUSPENSE_PENDING_START_DATA
-      ) {
-        depth++;
-      }
-    }
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
 
-    node = node.nextSibling;
-  } // TODO: Warn, we didn't find the end comment boundary.
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
 
-  return null;
-} // Returns the SuspenseInstance if this node is a direct child of a
-// SuspenseInstance. I.e. if its previous sibling is a Comment with
-// SUSPENSE_x_START_DATA. Otherwise, null.
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    var queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
 
-function getParentSuspenseInstance(targetInstance) {
-  var node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
-  // There might be nested nodes so we need to keep track of how
-  // deep we are and only break out when we're back on top.
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
 
-  var depth = 0;
+    var newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
 
-  while (node) {
-    if (node.nodeType === COMMENT_NODE) {
-      var data = node.data;
+    markRootEntangled(root, newQueueLanes);
+  }
+}
 
-      if (
-        data === SUSPENSE_START_DATA ||
-        data === SUSPENSE_FALLBACK_START_DATA ||
-        data === SUSPENSE_PENDING_START_DATA
-      ) {
-        if (depth === 0) {
-          return node;
-        } else {
-          depth--;
-        }
-      } else if (data === SUSPENSE_END_DATA) {
-        depth++;
+function markUpdateInDevTools(fiber, lane, action) {
+  {
+    if (enableDebugTracing) {
+      if (fiber.mode & DebugTracingMode) {
+        var name = getComponentNameFromFiber(fiber) || "Unknown";
+        logStateUpdateScheduled(name, lane, action);
       }
     }
+  }
 
-    node = node.previousSibling;
+  if (enableSchedulingProfiler) {
+    markStateUpdateScheduled(fiber, lane);
   }
+}
 
-  return null;
+var ContextOnlyDispatcher = {
+  readContext: readContext,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useMutableSource: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
 }
-function commitHydratedContainer(container) {
-  // Retry if any event replaying was blocked on this.
-  retryIfBlockedOn(container);
+
+{
+  ContextOnlyDispatcher.use = throwInvalidHookError;
 }
-function commitHydratedSuspenseInstance(suspenseInstance) {
-  // Retry if any event replaying was blocked on this.
-  retryIfBlockedOn(suspenseInstance);
-} // @TODO remove this function once float lands and hydrated tail nodes
-function didNotMatchHydratedContainerTextInstance(
-  parentContainer,
-  textInstance,
-  text,
-  isConcurrentMode,
-  shouldWarnDev
-) {
-  checkForUnmatchedText(
-    textInstance.nodeValue,
-    text,
-    isConcurrentMode,
-    shouldWarnDev
-  );
+
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
 }
-function didNotMatchHydratedTextInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  textInstance,
-  text,
-  isConcurrentMode,
-  shouldWarnDev
-) {
-  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-    checkForUnmatchedText(
-      textInstance.nodeValue,
-      text,
-      isConcurrentMode,
-      shouldWarnDev
-    );
-  }
+
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
 }
-function didNotHydrateInstanceWithinContainer(parentContainer, instance) {
-  {
-    if (instance.nodeType === ELEMENT_NODE) {
-      warnForDeletedHydratableElement(parentContainer, instance);
-    } else if (instance.nodeType === COMMENT_NODE);
-    else {
-      warnForDeletedHydratableText(parentContainer, instance);
-    }
-  }
-}
-function didNotHydrateInstanceWithinSuspenseInstance(parentInstance, instance) {
-  {
-    // $FlowFixMe: Only Element or Document can be parent nodes.
-    var parentNode = parentInstance.parentNode;
 
-    if (parentNode !== null) {
-      if (instance.nodeType === ELEMENT_NODE) {
-        warnForDeletedHydratableElement(parentNode, instance);
-      } else if (instance.nodeType === COMMENT_NODE);
-      else {
-        warnForDeletedHydratableText(parentNode, instance);
+var HooksDispatcherOnMountInDEV = null;
+var HooksDispatcherOnMountWithHookTypesInDEV = null;
+var HooksDispatcherOnUpdateInDEV = null;
+var HooksDispatcherOnRerenderInDEV = null;
+var InvalidNestedHooksDispatcherOnMountInDEV = null;
+var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
+var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
+
+{
+  var warnInvalidContextAccess = function () {
+    error(
+      "Context can only be read while React is rendering. " +
+        "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+        "In function components, you can read it directly in the function body, but not " +
+        "inside Hooks like useReducer() or useMemo()."
+    );
+  };
+
+  var warnInvalidHookAccess = function () {
+    error(
+      "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " +
+        "You can only call Hooks at the top level of your React function. " +
+        "For more information, see " +
+        "https://reactjs.org/link/rules-of-hooks"
+    );
+  };
+
+  HooksDispatcherOnMountInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      mountHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
+
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-    }
-  }
-}
-function didNotHydrateInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  instance,
-  isConcurrentMode
-) {
-  {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      if (instance.nodeType === ELEMENT_NODE) {
-        warnForDeletedHydratableElement(parentInstance, instance);
-      } else if (instance.nodeType === COMMENT_NODE);
-      else {
-        warnForDeletedHydratableText(parentInstance, instance);
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
+
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      mountHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
+
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      mountHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      mountHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      mountHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      mountHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      mountHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      mountHookTypesDev();
+      return mountId();
     }
-  }
-}
-function didNotFindHydratableInstanceWithinContainer(
-  parentContainer,
-  type,
-  props
-) {
-  {
-    warnForInsertedHydratedElement(parentContainer, type);
-  }
-}
-function didNotFindHydratableTextInstanceWithinContainer(
-  parentContainer,
-  text
-) {
-  {
-    warnForInsertedHydratedText(parentContainer, text);
-  }
-}
-function didNotFindHydratableInstanceWithinSuspenseInstance(
-  parentInstance,
-  type,
-  props
-) {
-  {
-    // $FlowFixMe: Only Element or Document can be parent nodes.
-    var parentNode = parentInstance.parentNode;
-    if (parentNode !== null) warnForInsertedHydratedElement(parentNode, type);
-  }
-}
-function didNotFindHydratableTextInstanceWithinSuspenseInstance(
-  parentInstance,
-  text
-) {
-  {
-    // $FlowFixMe: Only Element or Document can be parent nodes.
-    var parentNode = parentInstance.parentNode;
-    if (parentNode !== null) warnForInsertedHydratedText(parentNode, text);
-  }
-}
-function didNotFindHydratableInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  type,
-  props,
-  isConcurrentMode
-) {
+  };
+
   {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      warnForInsertedHydratedElement(parentInstance, type);
-    }
+    HooksDispatcherOnMountInDEV.useCacheRefresh = function useCacheRefresh() {
+      currentHookNameInDev = "useCacheRefresh";
+      mountHookTypesDev();
+      return mountRefresh();
+    };
   }
-}
-function didNotFindHydratableTextInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  text,
-  isConcurrentMode
-) {
+
   {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      warnForInsertedHydratedText(parentInstance, text);
-    }
+    HooksDispatcherOnMountInDEV.use = use;
   }
-}
-function errorHydratingContainer(parentContainer) {
+
   {
-    // TODO: This gets logged by onRecoverableError, too, so we should be
-    // able to remove it.
-    error(
-      "An error occurred during hydration. The server HTML was replaced with client content in <%s>.",
-      parentContainer.nodeName.toLowerCase()
-    );
+    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
   }
-} // -------------------
-function requestPostPaintCallback(callback) {
-  localRequestAnimationFrame(function () {
-    localRequestAnimationFrame(function (time) {
-      return callback(time);
-    });
-  });
-} // -------------------
-function isHostHoistableType(type, props, hostContext) {
-  var outsideHostContainerContext;
-  var namespace;
 
   {
-    var hostContextDev = hostContext; // We can only render resources when we are not within the host container context
-
-    outsideHostContainerContext =
-      !hostContextDev.ancestorInfo.containerTagInScope;
-    namespace = hostContextDev.namespace;
-  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
-
-  if (namespace === SVG_NAMESPACE || props.itemProp != null) {
-    {
-      if (
-        outsideHostContainerContext &&
-        props.itemProp != null &&
-        (type === "meta" ||
-          type === "title" ||
-          type === "style" ||
-          type === "link" ||
-          type === "script")
-      ) {
-        error(
-          "Cannot render a <%s> outside the main document if it has an `itemProp` prop. `itemProp` suggests the tag belongs to an" +
-            " `itemScope` which can appear anywhere in the DOM. If you were intending for React to hoist this <%s> remove the `itemProp` prop." +
-            " Otherwise, try moving this tag into the <head> or <body> of the Document.",
-          type,
-          type
-        );
-      }
-    }
-
-    return false;
+    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      mountHookTypesDev();
+      return mountEvent(callback);
+    };
   }
 
-  switch (type) {
-    case "meta":
-    case "title": {
-      return true;
-    }
+  HooksDispatcherOnMountWithHookTypesInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-    case "style": {
-      if (
-        typeof props.precedence !== "string" ||
-        typeof props.href !== "string" ||
-        props.href === ""
-      ) {
-        {
-          if (outsideHostContainerContext) {
-            error(
-              "Cannot render a <style> outside the main document without knowing its precedence and a unique href key." +
-                " React can hoist and deduplicate <style> tags if you provide a `precedence` prop along with an `href` prop that" +
-                ' does not conflic with the `href` values used in any other hoisted <style> or <link rel="stylesheet" ...> tags. ' +
-                " Note that hoisting <style> tags is considered an advanced feature that most will not use directly." +
-                ' Consider moving the <style> tag to the <head> or consider adding a `precedence="default"` and `href="some unique resource identifier"`, or move the <style>' +
-                " to the <style> tag."
-            );
-          }
-        }
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-        return false;
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      return true;
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return mountId();
     }
+  };
 
-    case "link": {
-      if (
-        typeof props.rel !== "string" ||
-        typeof props.href !== "string" ||
-        props.href === "" ||
-        props.onLoad ||
-        props.onError
-      ) {
-        {
-          if (
-            props.rel === "stylesheet" &&
-            typeof props.precedence === "string"
-          ) {
-            validateLinkPropsForStyleResource(props);
-          }
-
-          if (outsideHostContainerContext) {
-            if (
-              typeof props.rel !== "string" ||
-              typeof props.href !== "string" ||
-              props.href === ""
-            ) {
-              error(
-                "Cannot render a <link> outside the main document without a `rel` and `href` prop." +
-                  " Try adding a `rel` and/or `href` prop to this <link> or moving the link into the <head> tag"
-              );
-            } else if (props.onError || props.onLoad) {
-              error(
-                "Cannot render a <link> with onLoad or onError listeners outside the main document." +
-                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
-                  " somewhere in the <body>."
-              );
-            }
-          }
-        }
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return mountRefresh();
+      };
+  }
 
-        return false;
-      }
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.use = use;
+  }
 
-      switch (props.rel) {
-        case "stylesheet": {
-          var precedence = props.precedence,
-            disabled = props.disabled;
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
+  }
 
-          {
-            if (typeof precedence !== "string") {
-              if (outsideHostContainerContext) {
-                error(
-                  'Cannot render a <link rel="stylesheet" /> outside the main document without knowing its precedence.' +
-                    ' Consider adding precedence="default" or moving it into the root <head> tag.'
-                );
-              }
-            }
-          }
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        updateHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
 
-          return typeof precedence === "string" && disabled == null;
-        }
+  HooksDispatcherOnUpdateInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-        default: {
-          return true;
-        }
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-    }
-
-    case "script": {
-      if (
-        props.async !== true ||
-        props.onLoad ||
-        props.onError ||
-        typeof props.src !== "string" ||
-        !props.src
-      ) {
-        {
-          if (outsideHostContainerContext) {
-            if (props.async !== true) {
-              error(
-                "Cannot render a sync or defer <script> outside the main document without knowing its order." +
-                  ' Try adding async="" or moving it into the root <head> tag.'
-              );
-            } else if (props.onLoad || props.onError) {
-              error(
-                "Cannot render a <script> with onLoad or onError listeners outside the main document." +
-                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
-                  " somewhere in the <body>."
-              );
-            } else {
-              error(
-                "Cannot render a <script> outside the main document without `async={true}` and a non-empty `src` prop." +
-                  " Ensure there is a valid `src` and either make the script async or move it into the root <head> tag or" +
-                  " somewhere in the <body>."
-              );
-            }
-          }
-        }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-        return false;
+      try {
+        return updateReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      return true;
-    }
-
-    case "noscript":
-    case "template": {
-      {
-        if (outsideHostContainerContext) {
-          error(
-            "Cannot render <%s> outside the main document. Try moving it into the root <head> tag.",
-            type
-          );
-        }
+      try {
+        return updateState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-
-      return false;
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return updateDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return updateTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return updateId();
     }
-  }
+  };
 
-  return false;
-}
-function prepareRendererToRender(rootContainer) {
   {
-    prepareToRenderResources(rootContainer);
+    HooksDispatcherOnUpdateInDEV.useCacheRefresh = function useCacheRefresh() {
+      currentHookNameInDev = "useCacheRefresh";
+      updateHookTypesDev();
+      return updateRefresh();
+    };
   }
-}
-function resetRendererAfterRender() {
+
   {
-    cleanupAfterRenderResources();
+    HooksDispatcherOnUpdateInDEV.use = use;
   }
-}
-function isHostSingletonType(type) {
-  return type === "html" || type === "head" || type === "body";
-}
-function resolveSingletonInstance(
-  type,
-  props,
-  rootContainerInstance,
-  hostContext,
-  validateDOMNestingDev
-) {
-  {
-    var hostContextDev = hostContext;
 
-    if (validateDOMNestingDev) {
-      validateDOMNesting(type, null, hostContextDev.ancestorInfo);
-    }
+  {
+    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
   }
 
-  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  {
+    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
 
-  switch (type) {
-    case "html": {
-      var documentElement = ownerDocument.documentElement;
+  HooksDispatcherOnRerenderInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      if (!documentElement) {
-        throw new Error(
-          "React expected an <html> element (document.documentElement) to exist in the Document but one was" +
-            " not found. React never removes the documentElement for any Document it renders into so" +
-            " the cause is likely in some other script running on this page."
-        );
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      return documentElement;
-    }
-
-    case "head": {
-      var head = ownerDocument.head;
-
-      if (!head) {
-        throw new Error(
-          "React expected a <head> element (document.head) to exist in the Document but one was" +
-            " not found. React never removes the head for any Document it renders into so" +
-            " the cause is likely in some other script running on this page."
-        );
+      try {
+        return rerenderReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      return head;
+      try {
+        return rerenderState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return rerenderDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return rerenderTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    case "body": {
-      var body = ownerDocument.body;
-
-      if (!body) {
-        throw new Error(
-          "React expected a <body> element (document.body) to exist in the Document but one was" +
-            " not found. React never removes the body for any Document it renders into so" +
-            " the cause is likely in some other script running on this page."
-        );
-      }
+  {
+    HooksDispatcherOnRerenderInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
+  }
 
-      return body;
-    }
+  {
+    HooksDispatcherOnRerenderInDEV.use = use;
+  }
 
-    default: {
-      throw new Error(
-        "resolveSingletonInstance was called with an element type that is not supported. This is a bug in React."
-      );
-    }
+  {
+    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
   }
-}
-function acquireSingletonInstance(
-  type,
-  props,
-  instance,
-  internalInstanceHandle
-) {
+
   {
-    var currentInstanceHandle = getInstanceFromNode$1(instance);
+    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
 
-    if (currentInstanceHandle) {
-      var tagName = instance.tagName.toLowerCase();
+  InvalidNestedHooksDispatcherOnMountInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      error(
-        "You are mounting a new %s component when a previous one has not first unmounted. It is an" +
-          " error to render more than one %s component at a time and attributes and children of these" +
-          " components will likely fail in unpredictable ways. Please only render a single instance of" +
-          " <%s> and if you need to mount a new one, ensure any previous ones have unmounted first.",
-        tagName,
-        tagName,
-        tagName
-      );
-    }
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-    switch (type) {
-      case "html":
-      case "head":
-      case "body": {
-        break;
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      default: {
-        error(
-          "acquireSingletonInstance was called with an element type that is not supported. This is a bug in React."
-        );
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountId();
     }
-  }
+  };
 
-  var attributes = instance.attributes;
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        mountHookTypesDev();
+        return mountRefresh();
+      };
+  }
 
-  while (attributes.length) {
-    instance.removeAttributeNode(attributes[0]);
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
   }
 
-  setInitialProperties(instance, type, props);
-  precacheFiberNode(internalInstanceHandle, instance);
-  updateFiberProps(instance, props);
-}
-function releaseSingletonInstance(instance) {
-  var attributes = instance.attributes;
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
 
-  while (attributes.length) {
-    instance.removeAttributeNode(attributes[0]);
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountEvent(callback);
+      };
   }
 
-  detachDeletedInstance(instance);
-}
-function clearSingleton(instance) {
-  var element = instance;
-  var node = element.firstChild;
+  InvalidNestedHooksDispatcherOnUpdateInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-  while (node) {
-    var nextNode = node.nextSibling;
-    var nodeName = node.nodeName;
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-    if (
-      isMarkedHoistable(node) ||
-      nodeName === "HEAD" ||
-      nodeName === "BODY" ||
-      nodeName === "STYLE" ||
-      (nodeName === "LINK" && node.rel.toLowerCase() === "stylesheet")
-    );
-    else {
-      element.removeChild(node);
+      try {
+        return updateReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+      try {
+        return updateState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    node = nextNode;
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
   }
 
-  return;
-}
-
-var loggedTypeFailures = {};
-var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-
-function setCurrentlyValidatingElement(element) {
   {
-    if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(
-        element.type,
-        element._source,
-        owner ? owner.type : null
-      );
-      ReactDebugCurrentFrame.setExtraStackFrame(stack);
-    } else {
-      ReactDebugCurrentFrame.setExtraStackFrame(null);
-    }
+    InvalidNestedHooksDispatcherOnUpdateInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
   }
-}
 
-function checkPropTypes(typeSpecs, values, location, componentName, element) {
   {
-    // $FlowFixMe This is okay but Flow doesn't know it.
-    var has = Function.call.bind(hasOwnProperty);
-
-    for (var typeSpecName in typeSpecs) {
-      if (has(typeSpecs, typeSpecName)) {
-        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
-        // fail the render phase where it didn't fail before. So we log it.
-        // After these have been cleaned up, we'll let them throw.
-
-        try {
-          // This is intentionally an invariant that gets caught. It's the same
-          // behavior as without this statement except with a better message.
-          if (typeof typeSpecs[typeSpecName] !== "function") {
-            // eslint-disable-next-line react-internal/prod-error-codes
-            var err = Error(
-              (componentName || "React class") +
-                ": " +
-                location +
-                " type `" +
-                typeSpecName +
-                "` is invalid; " +
-                "it must be a function, usually from the `prop-types` package, but received `" +
-                typeof typeSpecs[typeSpecName] +
-                "`." +
-                "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
-            );
-            err.name = "Invariant Violation";
-            throw err;
-          }
-
-          error$1 = typeSpecs[typeSpecName](
-            values,
-            typeSpecName,
-            componentName,
-            location,
-            null,
-            "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
-          );
-        } catch (ex) {
-          error$1 = ex;
-        }
-
-        if (error$1 && !(error$1 instanceof Error)) {
-          setCurrentlyValidatingElement(element);
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
 
-          error(
-            "%s: type specification of %s" +
-              " `%s` is invalid; the type checker " +
-              "function must return `null` or an `Error` but returned a %s. " +
-              "You may have forgotten to pass an argument to the type checker " +
-              "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
-              "shape all require an argument).",
-            componentName || "React class",
-            location,
-            typeSpecName,
-            typeof error$1
-          );
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
+  }
 
-          setCurrentlyValidatingElement(null);
-        }
+  InvalidNestedHooksDispatcherOnRerenderInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-        if (
-          error$1 instanceof Error &&
-          !(error$1.message in loggedTypeFailures)
-        ) {
-          // Only monitor this failure once because there tends to be a lot of the
-          // same error.
-          loggedTypeFailures[error$1.message] = true;
-          setCurrentlyValidatingElement(element);
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-          error("Failed %s type: %s", location, error$1.message);
+      try {
+        return rerenderReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-          setCurrentlyValidatingElement(null);
-        }
+      try {
+        return rerenderState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return rerenderDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return rerenderTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateId();
     }
-  }
-}
-
-var emptyContextObject = {};
-
-{
-  Object.freeze(emptyContextObject);
-} // A cursor to the current merged context object on the stack.
+  };
 
-function hasContextChanged() {
   {
-    return false;
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
   }
-}
 
-function isContextProvider(type) {
   {
-    return false;
+    InvalidNestedHooksDispatcherOnRerenderInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
   }
-}
 
-function processChildContext(fiber, type, parentContext) {
   {
-    return parentContext;
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
   }
-}
 
-function findCurrentUnmaskedContext(fiber) {
   {
-    return emptyContextObject;
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
   }
 }
 
-var LegacyRoot = 0;
-var ConcurrentRoot = 1;
+var now = Scheduler.unstable_now;
+var commitTime = 0;
+var layoutEffectStartTime = -1;
+var profilerStartTime = -1;
+var passiveEffectStartTime = -1;
+/**
+ * Tracks whether the current update was a nested/cascading update (scheduled from a layout effect).
+ *
+ * The overall sequence is:
+ *   1. render
+ *   2. commit (and call `onRender`, `onCommit`)
+ *   3. check for nested updates
+ *   4. flush passive effects (and call `onPostCommit`)
+ *
+ * Nested updates are identified in step 3 above,
+ * but step 4 still applies to the work that was just committed.
+ * We use two flags to track nested updates then:
+ * one tracks whether the upcoming update is a nested update,
+ * and the other tracks whether the current update was a nested update.
+ * The first value gets synced to the second at the start of the render phase.
+ */
 
-// We use the existence of the state object as an indicator that the component
-// is hidden.
-var OffscreenVisible =
-  /*                     */
-  1;
-var OffscreenDetached =
-  /*                    */
-  2;
-var OffscreenPassiveEffectsConnected =
-  /*     */
-  4;
-function isOffscreenManual(offscreenFiber) {
-  return (
-    offscreenFiber.memoizedProps !== null &&
-    offscreenFiber.memoizedProps.mode === "manual"
-  );
-}
+var currentUpdateIsNested = false;
+var nestedUpdateScheduled = false;
 
-var syncQueue = null;
-var includesLegacySyncCallbacks = false;
-var isFlushingSyncQueue = false;
-function scheduleSyncCallback(callback) {
-  // Push this callback into an internal queue. We'll flush these either in
-  // the next tick, or earlier if something calls `flushSyncCallbackQueue`.
-  if (syncQueue === null) {
-    syncQueue = [callback];
-  } else {
-    // Push onto existing queue. Don't need to schedule a callback because
-    // we already scheduled one when we created the queue.
-    syncQueue.push(callback);
-  }
-}
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = true;
-  scheduleSyncCallback(callback);
+function isCurrentUpdateNested() {
+  return currentUpdateIsNested;
 }
-function flushSyncCallbacksOnlyInLegacyMode() {
-  // Only flushes the queue if there's a legacy sync callback scheduled.
-  // TODO: There's only a single type of callback: performSyncOnWorkOnRoot. So
-  // it might make more sense for the queue to be a list of roots instead of a
-  // list of generic callbacks. Then we can have two: one for legacy roots, one
-  // for concurrent roots. And this method would only flush the legacy ones.
-  if (includesLegacySyncCallbacks) {
-    flushSyncCallbacks();
+
+function markNestedUpdateScheduled() {
+  {
+    nestedUpdateScheduled = true;
   }
 }
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && syncQueue !== null) {
-    // Prevent re-entrance.
-    isFlushingSyncQueue = true; // Set the event priority to discrete
-    // TODO: Is this necessary anymore? The only user code that runs in this
-    // queue is in the render or commit phases, which already set the
-    // event priority. Should be able to remove.
-
-    var previousUpdatePriority = getCurrentUpdatePriority$1();
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    var errors = null;
-    var queue = syncQueue; // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-    for (var i = 0; i < queue.length; i++) {
-      // $FlowFixMe[incompatible-use] found when upgrading Flow
-      var callback = queue[i];
-
-      try {
-        do {
-          var isSync = true; // $FlowFixMe[incompatible-type] we bail out when we get a null
-
-          callback = callback(isSync);
-        } while (callback !== null);
-      } catch (error) {
-        // Collect errors so we can rethrow them at the end
-        if (errors === null) {
-          errors = [error];
-        } else {
-          errors.push(error);
-        }
-      }
-    }
-
-    syncQueue = null;
-    includesLegacySyncCallbacks = false;
-    setCurrentUpdatePriority(previousUpdatePriority);
-    isFlushingSyncQueue = false;
-
-    if (errors !== null) {
-      if (errors.length > 1) {
-        if (typeof AggregateError === "function") {
-          // eslint-disable-next-line no-undef
-          throw new AggregateError(errors);
-        } else {
-          for (var _i = 1; _i < errors.length; _i++) {
-            scheduleCallback$2(
-              ImmediatePriority,
-              throwError.bind(null, errors[_i])
-            );
-          }
-
-          var firstError = errors[0];
-          throw firstError;
-        }
-      } else {
-        var error = errors[0];
-        throw error;
-      }
-    }
+function resetNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = false;
+    nestedUpdateScheduled = false;
   }
-
-  return null;
 }
 
-function throwError(error) {
-  throw error;
+function syncNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = nestedUpdateScheduled;
+    nestedUpdateScheduled = false;
+  }
 }
 
-var nativeConsole = console;
-var nativeConsoleLog = null;
-var pendingGroupArgs = [];
-var printedGroupIndex = -1;
-
-function formatLanes(laneOrLanes) {
-  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
+function getCommitTime() {
+  return commitTime;
 }
 
-function group() {
-  for (
-    var _len = arguments.length, groupArgs = new Array(_len), _key = 0;
-    _key < _len;
-    _key++
-  ) {
-    groupArgs[_key] = arguments[_key];
-  }
-
-  pendingGroupArgs.push(groupArgs);
-
-  if (nativeConsoleLog === null) {
-    nativeConsoleLog = nativeConsole.log;
-    nativeConsole.log = log;
-  }
+function recordCommitTime() {
+  commitTime = now();
 }
 
-function groupEnd() {
-  pendingGroupArgs.pop();
-
-  while (printedGroupIndex >= pendingGroupArgs.length) {
-    nativeConsole.groupEnd();
-    printedGroupIndex--;
-  }
+function startProfilerTimer(fiber) {
+  profilerStartTime = now();
 
-  if (pendingGroupArgs.length === 0) {
-    nativeConsole.log = nativeConsoleLog;
-    nativeConsoleLog = null;
+  if (fiber.actualStartTime < 0) {
+    fiber.actualStartTime = now();
   }
 }
 
-function log() {
-  if (printedGroupIndex < pendingGroupArgs.length - 1) {
-    for (var i = printedGroupIndex + 1; i < pendingGroupArgs.length; i++) {
-      var groupArgs = pendingGroupArgs[i];
-      nativeConsole.group.apply(nativeConsole, groupArgs);
-    }
-
-    printedGroupIndex = pendingGroupArgs.length - 1;
-  }
-
-  if (typeof nativeConsoleLog === "function") {
-    nativeConsoleLog.apply(void 0, arguments);
-  } else {
-    nativeConsole.log.apply(nativeConsole, arguments);
-  }
+function stopProfilerTimerIfRunning(fiber) {
+  profilerStartTime = -1;
 }
 
-var REACT_LOGO_STYLE =
-  "background-color: #20232a; color: #61dafb; padding: 0 2px;";
-function logCommitStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c commit%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
+function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+  if (profilerStartTime >= 0) {
+    var elapsedTime = now() - profilerStartTime;
+    fiber.actualDuration += elapsedTime;
+
+    if (overrideBaseTime) {
+      fiber.selfBaseDuration = elapsedTime;
     }
+
+    profilerStartTime = -1;
   }
 }
-function logCommitStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
+
+function recordLayoutEffectDuration(fiber) {
+  if (layoutEffectStartTime >= 0) {
+    var elapsedTime = now() - layoutEffectStartTime;
+    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
+
+    var parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
+          root.effectDuration += elapsedTime;
+          return;
+
+        case Profiler:
+          var parentStateNode = parentFiber.stateNode;
+          parentStateNode.effectDuration += elapsedTime;
+          return;
+      }
+
+      parentFiber = parentFiber.return;
     }
   }
 }
-var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
 
-var wakeableIDs = new PossiblyWeakMap$1();
-var wakeableID = 0;
+function recordPassiveEffectDuration(fiber) {
+  if (passiveEffectStartTime >= 0) {
+    var elapsedTime = now() - passiveEffectStartTime;
+    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
 
-function getWakeableID(wakeable) {
-  if (!wakeableIDs.has(wakeable)) {
-    wakeableIDs.set(wakeable, wakeableID++);
-  }
+    var parentFiber = fiber.return;
 
-  return wakeableIDs.get(wakeable);
-}
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
 
-function logComponentSuspended(componentName, wakeable) {
-  {
-    if (enableDebugTracing) {
-      var id = getWakeableID(wakeable);
-      var display = wakeable.displayName || wakeable;
-      log(
-        "%c\u269B\uFE0F%c " + componentName + " suspended",
-        REACT_LOGO_STYLE,
-        "color: #80366d; font-weight: bold;",
-        id,
-        display
-      );
-      wakeable.then(
-        function () {
-          log(
-            "%c\u269B\uFE0F%c " + componentName + " resolved",
-            REACT_LOGO_STYLE,
-            "color: #80366d; font-weight: bold;",
-            id,
-            display
-          );
-        },
-        function () {
-          log(
-            "%c\u269B\uFE0F%c " + componentName + " rejected",
-            REACT_LOGO_STYLE,
-            "color: #80366d; font-weight: bold;",
-            id,
-            display
-          );
-        }
-      );
+          if (root !== null) {
+            root.passiveEffectDuration += elapsedTime;
+          }
+
+          return;
+
+        case Profiler:
+          var parentStateNode = parentFiber.stateNode;
+
+          if (parentStateNode !== null) {
+            // Detached fibers have their state node cleared out.
+            // In this case, the return pointer is also cleared out,
+            // so we won't be able to report the time spent in this Profiler's subtree.
+            parentStateNode.passiveEffectDuration += elapsedTime;
+          }
+
+          return;
+      }
+
+      parentFiber = parentFiber.return;
     }
   }
 }
-function logLayoutEffectsStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c layout effects%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
-    }
-  }
+
+function startLayoutEffectTimer() {
+  layoutEffectStartTime = now();
 }
-function logLayoutEffectsStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
-    }
-  }
+
+function startPassiveEffectTimer() {
+  passiveEffectStartTime = now();
 }
-function logPassiveEffectsStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c passive effects%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
-    }
+
+function transferActualDuration(fiber) {
+  // Transfer time spent rendering these children so we don't lose it
+  // after we rerender. This is used as a helper in special cases
+  // where we should count the work of multiple passes.
+  var child = fiber.child;
+
+  while (child) {
+    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    fiber.actualDuration += child.actualDuration;
+    child = child.sibling;
   }
 }
-function logPassiveEffectsStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    var props = assign({}, baseProps);
+    var defaultProps = Component.defaultProps;
+
+    for (var propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
     }
+
+    return props;
   }
+
+  return baseProps;
 }
-function logRenderStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c render%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
+
+var fakeInternalInstance = {};
+var didWarnAboutStateAssignmentForComponent;
+var didWarnAboutUninitializedState;
+var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
+var didWarnAboutLegacyLifecyclesAndDerivedState;
+var didWarnAboutUndefinedDerivedState;
+var didWarnAboutDirectlyAssigningPropsToState;
+var didWarnAboutInvalidateContextType;
+var didWarnOnInvalidCallback;
+
+{
+  didWarnAboutStateAssignmentForComponent = new Set();
+  didWarnAboutUninitializedState = new Set();
+  didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+  didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+  didWarnAboutDirectlyAssigningPropsToState = new Set();
+  didWarnAboutUndefinedDerivedState = new Set();
+  didWarnAboutInvalidateContextType = new Set();
+  didWarnOnInvalidCallback = new Set(); // This is so gross but it's at least non-critical and can be removed if
+  // it causes problems. This is meant to give a nicer error message for
+  // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
+  // ...)) which otherwise throws a "_processChildContext is not a function"
+  // exception.
+
+  Object.defineProperty(fakeInternalInstance, "_processChildContext", {
+    enumerable: false,
+    value: function () {
+      throw new Error(
+        "_processChildContext is not available in React 16+. This likely " +
+          "means you have multiple copies of React and are attempting to nest " +
+          "a React 15 tree inside a React 16 tree using " +
+          "unstable_renderSubtreeIntoContainer, which isn't supported. Try " +
+          "to make sure you have only one copy of React (and ideally, switch " +
+          "to ReactDOM.createPortal)."
       );
     }
-  }
+  });
+  Object.freeze(fakeInternalInstance);
 }
-function logRenderStopped() {
+
+function warnOnInvalidCallback(callback, callerName) {
   {
-    if (enableDebugTracing) {
-      groupEnd();
+    if (callback === null || typeof callback === "function") {
+      return;
     }
-  }
-}
-function logForceUpdateScheduled(componentName, lane) {
-  {
-    if (enableDebugTracing) {
-      log(
-        "%c\u269B\uFE0F%c " +
-          componentName +
-          " forced update %c(" +
-          formatLanes(lane) +
-          ")",
-        REACT_LOGO_STYLE,
-        "color: #db2e1f; font-weight: bold;",
-        ""
+
+    var key = callerName + "_" + callback;
+
+    if (!didWarnOnInvalidCallback.has(key)) {
+      didWarnOnInvalidCallback.add(key);
+
+      error(
+        "%s(...): Expected the last optional `callback` argument to be a " +
+          "function. Instead received: %s.",
+        callerName,
+        callback
       );
     }
   }
 }
-function logStateUpdateScheduled(componentName, lane, payloadOrAction) {
+
+function warnOnUndefinedDerivedState(type, partialState) {
   {
-    if (enableDebugTracing) {
-      log(
-        "%c\u269B\uFE0F%c " +
-          componentName +
-          " updated state %c(" +
-          formatLanes(lane) +
-          ")",
-        REACT_LOGO_STYLE,
-        "color: #01a252; font-weight: bold;",
-        "",
-        payloadOrAction
-      );
+    if (partialState === undefined) {
+      var componentName = getComponentNameFromType(type) || "Component";
+
+      if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
+        didWarnAboutUndefinedDerivedState.add(componentName);
+
+        error(
+          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
+            "You have returned undefined.",
+          componentName
+        );
+      }
     }
   }
 }
 
-// Intentionally not using it yet to derisk the initial implementation, because
-// the way we push/pop these values is a bit unusual. If there's a mistake, I'd
-// rather the ids be wrong than crash the whole reconciler.
+function applyDerivedStateFromProps(
+  workInProgress,
+  ctor,
+  getDerivedStateFromProps,
+  nextProps
+) {
+  var prevState = workInProgress.memoizedState;
+  var partialState = getDerivedStateFromProps(nextProps, prevState);
 
-var forkStack = [];
-var forkStackIndex = 0;
-var treeForkProvider = null;
-var treeForkCount = 0;
-var idStack = [];
-var idStackIndex = 0;
-var treeContextProvider = null;
-var treeContextId = 1;
-var treeContextOverflow = "";
-function isForkedChild(workInProgress) {
-  warnIfNotHydrating();
-  return (workInProgress.flags & Forked) !== NoFlags$1;
-}
-function getForksAtLevel(workInProgress) {
-  warnIfNotHydrating();
-  return treeForkCount;
-}
-function getTreeId() {
-  var overflow = treeContextOverflow;
-  var idWithLeadingBit = treeContextId;
-  var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
-  return id.toString(32) + overflow;
-}
-function pushTreeFork(workInProgress, totalChildren) {
-  // This is called right after we reconcile an array (or iterator) of child
-  // fibers, because that's the only place where we know how many children in
-  // the whole set without doing extra work later, or storing addtional
-  // information on the fiber.
-  //
-  // That's why this function is separate from pushTreeId — it's called during
-  // the render phase of the fork parent, not the child, which is where we push
-  // the other context values.
-  //
-  // In the Fizz implementation this is much simpler because the child is
-  // rendered in the same callstack as the parent.
-  //
-  // It might be better to just add a `forks` field to the Fiber type. It would
-  // make this module simpler.
-  warnIfNotHydrating();
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
-}
-function pushTreeId(workInProgress, totalChildren, index) {
-  warnIfNotHydrating();
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  var baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
-  // of the id; we use it to account for leading 0s.
+  {
+    if (workInProgress.mode & StrictLegacyMode) {
+      setIsStrictModeForDevtools(true);
 
-  var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
-  var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
-  var slot = index + 1;
-  var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
-  // consideration the leading 1 we use to mark the end of the sequence.
+      try {
+        // Invoke the function an extra time to help detect side-effects.
+        partialState = getDerivedStateFromProps(nextProps, prevState);
+      } finally {
+        setIsStrictModeForDevtools(false);
+      }
+    }
 
-  if (length > 30) {
-    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
-    // This branch assumes the length of the base id is greater than 5; it won't
-    // work for smaller ids, because you need 5 bits per character.
-    //
-    // We encode the id in multiple steps: first the base id, then the
-    // remaining digits.
-    //
-    // Each 5 bit sequence corresponds to a single base 32 character. So for
-    // example, if the current id is 23 bits long, we can convert 20 of those
-    // bits into a string of 4 characters, with 3 bits left over.
-    //
-    // First calculate how many bits in the base id represent a complete
-    // sequence of characters.
-    var numberOfOverflowBits = baseLength - (baseLength % 5); // Then create a bitmask that selects only those bits.
+    warnOnUndefinedDerivedState(ctor, partialState);
+  } // Merge the partial state and the previous state.
 
-    var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+  var memoizedState =
+    partialState === null || partialState === undefined
+      ? prevState
+      : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
 
-    var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    var updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
+  }
+}
 
-    var restOfBaseId = baseId >> numberOfOverflowBits;
-    var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
-    // we made more room, this time it won't overflow.
+var classComponentUpdater = {
+  isMounted: isMounted,
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState: function (inst, payload, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.payload = payload;
 
-    var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
-    var restOfNewBits = slot << restOfBaseLength;
-    var id = restOfNewBits | restOfBaseId;
-    var overflow = newOverflow + baseOverflow;
-    treeContextId = (1 << restOfLength) | id;
-    treeContextOverflow = overflow;
-  } else {
-    // Normal path
-    var newBits = slot << baseLength;
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback(callback, "setState");
+      }
 
-    var _id = newBits | baseId;
+      update.callback = callback;
+    }
 
-    var _overflow = baseOverflow;
-    treeContextId = (1 << length) | _id;
-    treeContextOverflow = _overflow;
-  }
-}
-function pushMaterializedTreeId(workInProgress) {
-  warnIfNotHydrating(); // This component materialized an id. This will affect any ids that appear
-  // in its children.
+    var root = enqueueUpdate(fiber, update, lane);
 
-  var returnFiber = workInProgress.return;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
+    }
 
-  if (returnFiber !== null) {
-    var numberOfForks = 1;
-    var slotIndex = 0;
-    pushTreeFork(workInProgress, numberOfForks);
-    pushTreeId(workInProgress, numberOfForks, slotIndex);
-  }
-}
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
 
-function getBitLength(number) {
-  return 32 - clz32(number);
-}
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+  enqueueReplaceState: function (inst, payload, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
 
-function getLeadingBit(id) {
-  return 1 << (getBitLength(id) - 1);
-}
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback(callback, "replaceState");
+      }
 
-function popTreeContext(workInProgress) {
-  // Restore the previous values.
-  // This is a bit more complicated than other context-like modules in Fiber
-  // because the same Fiber may appear on the stack multiple times and for
-  // different reasons. We have to keep popping until the work-in-progress is
-  // no longer at the top of the stack.
-  while (workInProgress === treeForkProvider) {
-    treeForkProvider = forkStack[--forkStackIndex];
-    forkStack[forkStackIndex] = null;
-    treeForkCount = forkStack[--forkStackIndex];
-    forkStack[forkStackIndex] = null;
-  }
+      update.callback = callback;
+    }
 
-  while (workInProgress === treeContextProvider) {
-    treeContextProvider = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-    treeContextOverflow = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-    treeContextId = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-  }
-}
-function getSuspendedTreeContext() {
-  warnIfNotHydrating();
+    var root = enqueueUpdate(fiber, update, lane);
 
-  if (treeContextProvider !== null) {
-    return {
-      id: treeContextId,
-      overflow: treeContextOverflow
-    };
-  } else {
-    return null;
-  }
-}
-function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
-  warnIfNotHydrating();
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextId = suspendedContext.id;
-  treeContextOverflow = suspendedContext.overflow;
-  treeContextProvider = workInProgress;
-}
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
+    }
+
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
 
-function warnIfNotHydrating() {
-  {
-    if (!getIsHydrating()) {
-      error(
-        "Expected to be hydrating. This is a bug in React. Please file " +
-          "an issue."
-      );
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
     }
-  }
-}
+  },
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate: function (inst, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.tag = ForceUpdate;
 
-// This may have been an insertion or a hydration.
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback(callback, "forceUpdate");
+      }
 
-var hydrationParentFiber = null;
-var nextHydratableInstance = null;
-var isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
-// due to earlier mismatches or a suspended fiber.
+      update.callback = callback;
+    }
 
-var didSuspendOrErrorDEV = false; // Hydration errors that were thrown inside this boundary
+    var root = enqueueUpdate(fiber, update, lane);
 
-var hydrationErrors = null;
-var rootOrSingletonContext = false;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
+    }
 
-function warnIfHydrating() {
-  {
-    if (isHydrating) {
-      error(
-        "We should not be hydrating here. This is a bug in React. Please file a bug."
-      );
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logForceUpdateScheduled(name, lane);
+        }
+      }
     }
-  }
-}
 
-function markDidThrowWhileHydratingDEV() {
-  {
-    didSuspendOrErrorDEV = true;
-  }
-}
-function didSuspendOrErrorWhileHydratingDEV() {
-  {
-    return didSuspendOrErrorDEV;
+    if (enableSchedulingProfiler) {
+      markForceUpdateScheduled(fiber, lane);
+    }
   }
-}
-
-function enterHydrationState(fiber) {
-  var parentInstance = fiber.stateNode.containerInfo;
-  nextHydratableInstance =
-    getFirstHydratableChildWithinContainer(parentInstance);
-  hydrationParentFiber = fiber;
-  isHydrating = true;
-  hydrationErrors = null;
-  didSuspendOrErrorDEV = false;
-  rootOrSingletonContext = true;
-  return true;
-}
+};
 
-function reenterHydrationStateFromDehydratedSuspenseInstance(
-  fiber,
-  suspenseInstance,
-  treeContext
+function checkShouldComponentUpdate(
+  workInProgress,
+  ctor,
+  oldProps,
+  newProps,
+  oldState,
+  newState,
+  nextContext
 ) {
-  nextHydratableInstance =
-    getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
-  hydrationParentFiber = fiber;
-  isHydrating = true;
-  hydrationErrors = null;
-  didSuspendOrErrorDEV = false;
-  rootOrSingletonContext = false;
+  var instance = workInProgress.stateNode;
 
-  if (treeContext !== null) {
-    restoreSuspendedTreeContext(fiber, treeContext);
-  }
+  if (typeof instance.shouldComponentUpdate === "function") {
+    var shouldUpdate = instance.shouldComponentUpdate(
+      newProps,
+      newState,
+      nextContext
+    );
 
-  return true;
-}
+    {
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
 
-function warnUnhydratedInstance(returnFiber, instance) {
-  {
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        didNotHydrateInstanceWithinContainer(
-          returnFiber.stateNode.containerInfo,
-          instance
-        );
-        break;
+        try {
+          // Invoke the function an extra time to help detect side-effects.
+          shouldUpdate = instance.shouldComponentUpdate(
+            newProps,
+            newState,
+            nextContext
+          );
+        } finally {
+          setIsStrictModeForDevtools(false);
+        }
       }
 
-      case HostSingleton:
-      case HostComponent: {
-        var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
-        didNotHydrateInstance(
-          returnFiber.type,
-          returnFiber.memoizedProps,
-          returnFiber.stateNode,
-          instance, // TODO: Delete this argument when we remove the legacy root API.
-          isConcurrentMode
+      if (shouldUpdate === undefined) {
+        error(
+          "%s.shouldComponentUpdate(): Returned undefined instead of a " +
+            "boolean value. Make sure to return true or false.",
+          getComponentNameFromType(ctor) || "Component"
         );
-        break;
-      }
-
-      case SuspenseComponent: {
-        var suspenseState = returnFiber.memoizedState;
-        if (suspenseState.dehydrated !== null)
-          didNotHydrateInstanceWithinSuspenseInstance(
-            suspenseState.dehydrated,
-            instance
-          );
-        break;
       }
     }
-  }
-}
-
-function deleteHydratableInstance(returnFiber, instance) {
-  warnUnhydratedInstance(returnFiber, instance);
-  var childToDelete = createFiberFromHostInstanceForDeletion();
-  childToDelete.stateNode = instance;
-  childToDelete.return = returnFiber;
-  var deletions = returnFiber.deletions;
 
-  if (deletions === null) {
-    returnFiber.deletions = [childToDelete];
-    returnFiber.flags |= ChildDeletion;
-  } else {
-    deletions.push(childToDelete);
+    return shouldUpdate;
   }
-}
 
-function warnNonhydratedInstance(returnFiber, fiber) {
-  {
-    if (didSuspendOrErrorDEV) {
-      // Inside a boundary that already suspended. We're currently rendering the
-      // siblings of a suspended node. The mismatch may be due to the missing
-      // data, so it's probably a false positive.
-      return;
-    }
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return (
+      !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
+    );
+  }
 
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        var parentContainer = returnFiber.stateNode.containerInfo;
+  return true;
+}
 
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent:
-            var type = fiber.type;
-            didNotFindHydratableInstanceWithinContainer(parentContainer, type);
-            break;
+function checkClassInstance(workInProgress, ctor, newProps) {
+  var instance = workInProgress.stateNode;
 
-          case HostText:
-            var text = fiber.pendingProps;
-            didNotFindHydratableTextInstanceWithinContainer(
-              parentContainer,
-              text
-            );
-            break;
-        }
+  {
+    var name = getComponentNameFromType(ctor) || "Component";
+    var renderPresent = instance.render;
 
-        break;
+    if (!renderPresent) {
+      if (ctor.prototype && typeof ctor.prototype.render === "function") {
+        error(
+          "%s(...): No `render` method found on the returned component " +
+            "instance: did you accidentally return an object from the constructor?",
+          name
+        );
+      } else {
+        error(
+          "%s(...): No `render` method found on the returned component " +
+            "instance: you may have forgotten to define `render`.",
+          name
+        );
       }
+    }
 
-      case HostSingleton:
-      case HostComponent: {
-        var parentType = returnFiber.type;
-        var parentProps = returnFiber.memoizedProps;
-        var parentInstance = returnFiber.stateNode;
-
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent: {
-            var _type = fiber.type;
-            var _props = fiber.pendingProps;
-            var isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
-            didNotFindHydratableInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              _type,
-              _props, // TODO: Delete this argument when we remove the legacy root API.
-              isConcurrentMode
-            );
-            break;
-          }
+    if (
+      instance.getInitialState &&
+      !instance.getInitialState.isReactClassApproved &&
+      !instance.state
+    ) {
+      error(
+        "getInitialState was defined on %s, a plain JavaScript class. " +
+          "This is only supported for classes created using React.createClass. " +
+          "Did you mean to define a state property instead?",
+        name
+      );
+    }
 
-          case HostText: {
-            var _text = fiber.pendingProps;
+    if (
+      instance.getDefaultProps &&
+      !instance.getDefaultProps.isReactClassApproved
+    ) {
+      error(
+        "getDefaultProps was defined on %s, a plain JavaScript class. " +
+          "This is only supported for classes created using React.createClass. " +
+          "Use a static property to define defaultProps instead.",
+        name
+      );
+    }
 
-            var _isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
+    if (instance.propTypes) {
+      error(
+        "propTypes was defined as an instance property on %s. Use a static " +
+          "property to define propTypes instead.",
+        name
+      );
+    }
 
-            didNotFindHydratableTextInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              _text, // TODO: Delete this argument when we remove the legacy root API.
-              _isConcurrentMode
-            );
-            break;
-          }
-        }
+    if (instance.contextType) {
+      error(
+        "contextType was defined as an instance property on %s. Use a static " +
+          "property to define contextType instead.",
+        name
+      );
+    }
 
-        break;
+    {
+      if (ctor.childContextTypes) {
+        error(
+          "%s uses the legacy childContextTypes API which is no longer supported. " +
+            "Use React.createContext() instead.",
+          name
+        );
       }
 
-      case SuspenseComponent: {
-        var suspenseState = returnFiber.memoizedState;
-        var _parentInstance = suspenseState.dehydrated;
-        if (_parentInstance !== null)
-          switch (fiber.tag) {
-            case HostSingleton:
-            case HostComponent:
-              var _type2 = fiber.type;
-              didNotFindHydratableInstanceWithinSuspenseInstance(
-                _parentInstance,
-                _type2
-              );
-              break;
-
-            case HostText:
-              var _text2 = fiber.pendingProps;
-              didNotFindHydratableTextInstanceWithinSuspenseInstance(
-                _parentInstance,
-                _text2
-              );
-              break;
-          }
-        break;
+      if (ctor.contextTypes) {
+        error(
+          "%s uses the legacy contextTypes API which is no longer supported. " +
+            "Use React.createContext() with static contextType instead.",
+          name
+        );
       }
-
-      default:
-        return;
     }
-  }
-}
-
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-  warnNonhydratedInstance(returnFiber, fiber);
-}
 
-function tryHydrateInstance(fiber, nextInstance) {
-  // fiber is a HostComponent Fiber
-  var instance = canHydrateInstance(nextInstance, fiber.type);
+    if (typeof instance.componentShouldUpdate === "function") {
+      error(
+        "%s has a method called " +
+          "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
+          "The name is phrased as a question because the function is " +
+          "expected to return a value.",
+        name
+      );
+    }
 
-  if (instance !== null) {
-    fiber.stateNode = instance;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = getFirstHydratableChild(instance);
-    rootOrSingletonContext = false;
-    return true;
-  }
+    if (
+      ctor.prototype &&
+      ctor.prototype.isPureReactComponent &&
+      typeof instance.shouldComponentUpdate !== "undefined"
+    ) {
+      error(
+        "%s has a method called shouldComponentUpdate(). " +
+          "shouldComponentUpdate should not be used when extending React.PureComponent. " +
+          "Please extend React.Component if shouldComponentUpdate is used.",
+        getComponentNameFromType(ctor) || "A pure component"
+      );
+    }
 
-  return false;
-}
+    if (typeof instance.componentDidUnmount === "function") {
+      error(
+        "%s has a method called " +
+          "componentDidUnmount(). But there is no such lifecycle method. " +
+          "Did you mean componentWillUnmount()?",
+        name
+      );
+    }
 
-function tryHydrateText(fiber, nextInstance) {
-  // fiber is a HostText Fiber
-  var text = fiber.pendingProps;
-  var textInstance = canHydrateTextInstance(nextInstance, text);
+    if (typeof instance.componentDidReceiveProps === "function") {
+      error(
+        "%s has a method called " +
+          "componentDidReceiveProps(). But there is no such lifecycle method. " +
+          "If you meant to update the state in response to changing props, " +
+          "use componentWillReceiveProps(). If you meant to fetch data or " +
+          "run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
+        name
+      );
+    }
 
-  if (textInstance !== null) {
-    fiber.stateNode = textInstance;
-    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+    if (typeof instance.componentWillRecieveProps === "function") {
+      error(
+        "%s has a method called " +
+          "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
+        name
+      );
+    }
 
-    nextHydratableInstance = null;
-    return true;
-  }
+    if (typeof instance.UNSAFE_componentWillRecieveProps === "function") {
+      error(
+        "%s has a method called " +
+          "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
+        name
+      );
+    }
 
-  return false;
-}
+    var hasMutatedProps = instance.props !== newProps;
 
-function tryHydrateSuspense(fiber, nextInstance) {
-  // fiber is a SuspenseComponent Fiber
-  var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
+    if (instance.props !== undefined && hasMutatedProps) {
+      error(
+        "%s(...): When calling super() in `%s`, make sure to pass " +
+          "up the same props that your component's constructor was passed.",
+        name,
+        name
+      );
+    }
 
-  if (suspenseInstance !== null) {
-    var suspenseState = {
-      dehydrated: suspenseInstance,
-      treeContext: getSuspendedTreeContext(),
-      retryLane: OffscreenLane
-    };
-    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
-    // This simplifies the code for getHostSibling and deleting nodes,
-    // since it doesn't have to consider all Suspense boundaries and
-    // check if they're dehydrated ones or not.
+    if (instance.defaultProps) {
+      error(
+        "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
+          " Instead, define defaultProps as a static property on %s.",
+        name,
+        name
+      );
+    }
 
-    var dehydratedFragment =
-      createFiberFromDehydratedFragment(suspenseInstance);
-    dehydratedFragment.return = fiber;
-    fiber.child = dehydratedFragment;
-    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
-    // it during the first pass. Instead, we'll reenter it later.
+    if (
+      typeof instance.getSnapshotBeforeUpdate === "function" &&
+      typeof instance.componentDidUpdate !== "function" &&
+      !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)
+    ) {
+      didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
 
-    nextHydratableInstance = null;
-    return true;
-  }
+      error(
+        "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
+          "This component defines getSnapshotBeforeUpdate() only.",
+        getComponentNameFromType(ctor)
+      );
+    }
 
-  return false;
-}
+    if (typeof instance.getDerivedStateFromProps === "function") {
+      error(
+        "%s: getDerivedStateFromProps() is defined as an instance method " +
+          "and will be ignored. Instead, declare it as a static method.",
+        name
+      );
+    }
 
-function shouldClientRenderOnMismatch(fiber) {
-  return (
-    (fiber.mode & ConcurrentMode) !== NoMode &&
-    (fiber.flags & DidCapture) === NoFlags$1
-  );
-}
+    if (typeof instance.getDerivedStateFromError === "function") {
+      error(
+        "%s: getDerivedStateFromError() is defined as an instance method " +
+          "and will be ignored. Instead, declare it as a static method.",
+        name
+      );
+    }
 
-function throwOnHydrationMismatch(fiber) {
-  throw new Error(
-    "Hydration failed because the initial UI does not match what was " +
-      "rendered on the server."
-  );
-}
+    if (typeof ctor.getSnapshotBeforeUpdate === "function") {
+      error(
+        "%s: getSnapshotBeforeUpdate() is defined as a static method " +
+          "and will be ignored. Instead, declare it as an instance method.",
+        name
+      );
+    }
 
-function claimHydratableSingleton(fiber) {
-  {
-    if (!isHydrating) {
-      return;
+    var state = instance.state;
+
+    if (state && (typeof state !== "object" || isArray(state))) {
+      error("%s.state: must be set to an object or null", name);
     }
 
-    var currentRootContainer = getRootHostContainer();
-    var currentHostContext = getHostContext();
-    var instance = (fiber.stateNode = resolveSingletonInstance(
-      fiber.type,
-      fiber.pendingProps,
-      currentRootContainer,
-      currentHostContext,
-      false
-    ));
-    hydrationParentFiber = fiber;
-    rootOrSingletonContext = true;
-    nextHydratableInstance = getFirstHydratableChild(instance);
+    if (
+      typeof instance.getChildContext === "function" &&
+      typeof ctor.childContextTypes !== "object"
+    ) {
+      error(
+        "%s.getChildContext(): childContextTypes must be defined in order to " +
+          "use getChildContext().",
+        name
+      );
+    }
   }
 }
 
-function advanceToFirstAttemptableInstance(fiber) {
-  // fiber is HostComponent Fiber
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    )
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
-  }
-}
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
 
-function advanceToFirstAttemptableTextInstance() {
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForTextInstance(nextHydratableInstance)
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
-  }
-}
+  set(instance, workInProgress);
 
-function advanceToFirstAttemptableSuspenseInstance() {
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForSuspenseInstance(nextHydratableInstance)
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
+  {
+    instance._reactInternalInstance = fakeInternalInstance;
   }
 }
 
-function tryToClaimNextHydratableInstance(fiber) {
-  if (!isHydrating) {
-    return;
-  }
+function constructClassInstance(workInProgress, ctor, props) {
+  var context = emptyContextObject;
+  var contextType = ctor.contextType;
 
   {
-    if (!isHydratableType(fiber.type, fiber.pendingProps)) {
-      // This fiber never hydrates from the DOM and always does an insert
-      fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      return;
+    if ("contextType" in ctor) {
+      var isValid = // Allow null for conditional declaration
+        contextType === null ||
+        (contextType !== undefined &&
+          contextType.$$typeof === REACT_CONTEXT_TYPE &&
+          contextType._context === undefined); // Not a <Context.Consumer>
+
+      if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
+        didWarnAboutInvalidateContextType.add(ctor);
+        var addendum = "";
+
+        if (contextType === undefined) {
+          addendum =
+            " However, it is set to undefined. " +
+            "This can be caused by a typo or by mixing up named and default imports. " +
+            "This can also happen due to a circular dependency, so " +
+            "try moving the createContext() call to a separate file.";
+        } else if (typeof contextType !== "object") {
+          addendum = " However, it is set to a " + typeof contextType + ".";
+        } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
+          addendum = " Did you accidentally pass the Context.Provider instead?";
+        } else if (contextType._context !== undefined) {
+          // <Context.Consumer>
+          addendum = " Did you accidentally pass the Context.Consumer instead?";
+        } else {
+          addendum =
+            " However, it is set to an object with keys {" +
+            Object.keys(contextType).join(", ") +
+            "}.";
+        }
+
+        error(
+          "%s defines an invalid contextType. " +
+            "contextType should point to the Context object returned by React.createContext().%s",
+          getComponentNameFromType(ctor) || "Component",
+          addendum
+        );
+      }
     }
   }
 
-  var initialInstance = nextHydratableInstance;
-
-  if (rootOrSingletonContext) {
-    // We may need to skip past certain nodes in these contexts
-    advanceToFirstAttemptableInstance(fiber);
+  if (typeof contextType === "object" && contextType !== null) {
+    context = readContext(contextType);
   }
 
-  var nextInstance = nextHydratableInstance;
+  var instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
 
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
+  {
+    if (workInProgress.mode & StrictLegacyMode) {
+      setIsStrictModeForDevtools(true);
 
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
+      try {
+        instance = new ctor(props, context); // eslint-disable-line no-new
+      } finally {
+        setIsStrictModeForDevtools(false);
+      }
+    }
   }
 
-  var firstAttemptedInstance = nextInstance;
+  var state = (workInProgress.memoizedState =
+    instance.state !== null && instance.state !== undefined
+      ? instance.state
+      : null);
+  adoptClassInstance(workInProgress, instance);
 
-  if (!tryHydrateInstance(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+  {
+    if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+      var componentName = getComponentNameFromType(ctor) || "Component";
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+      if (!didWarnAboutUninitializedState.has(componentName)) {
+        didWarnAboutUninitializedState.add(componentName);
 
-    if (rootOrSingletonContext) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableInstance(fiber);
-    }
+        error(
+          "`%s` uses `getDerivedStateFromProps` but its initial state is " +
+            "%s. This is not recommended. Instead, define the initial state by " +
+            "assigning an object to `this.state` in the constructor of `%s`. " +
+            "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
+          componentName,
+          instance.state === null ? "null" : "undefined",
+          componentName
+        );
+      }
+    } // If new component APIs are defined, "unsafe" lifecycles won't be called.
+    // Warn about these lifecycles if they are present.
+    // Don't warn about react-lifecycles-compat polyfilled methods though.
 
     if (
-      !nextHydratableInstance ||
-      !tryHydrateInstance(fiber, nextHydratableInstance)
+      typeof ctor.getDerivedStateFromProps === "function" ||
+      typeof instance.getSnapshotBeforeUpdate === "function"
     ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
-  }
-}
-
-function tryToClaimNextHydratableTextInstance(fiber) {
-  if (!isHydrating) {
-    return;
-  }
-
-  var text = fiber.pendingProps;
-  var isHydratable = isHydratableText(text);
-  var initialInstance = nextHydratableInstance;
-
-  if (rootOrSingletonContext && isHydratable) {
-    // We may need to skip past certain nodes in these contexts.
-    // We don't skip if the text is not hydratable because we know no hydratables
-    // exist which could match this Fiber
-    advanceToFirstAttemptableTextInstance();
-  }
+      var foundWillMountName = null;
+      var foundWillReceivePropsName = null;
+      var foundWillUpdateName = null;
 
-  var nextInstance = nextHydratableInstance;
+      if (
+        typeof instance.componentWillMount === "function" &&
+        instance.componentWillMount.__suppressDeprecationWarning !== true
+      ) {
+        foundWillMountName = "componentWillMount";
+      } else if (typeof instance.UNSAFE_componentWillMount === "function") {
+        foundWillMountName = "UNSAFE_componentWillMount";
+      }
 
-  if (!nextInstance || !isHydratable) {
-    // We exclude non hydrabable text because we know there are no matching hydratables.
-    // We either throw or insert depending on the render mode.
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
+      if (
+        typeof instance.componentWillReceiveProps === "function" &&
+        instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
+      ) {
+        foundWillReceivePropsName = "componentWillReceiveProps";
+      } else if (
+        typeof instance.UNSAFE_componentWillReceiveProps === "function"
+      ) {
+        foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
+      }
 
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
+      if (
+        typeof instance.componentWillUpdate === "function" &&
+        instance.componentWillUpdate.__suppressDeprecationWarning !== true
+      ) {
+        foundWillUpdateName = "componentWillUpdate";
+      } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+        foundWillUpdateName = "UNSAFE_componentWillUpdate";
+      }
 
-  var firstAttemptedInstance = nextInstance;
+      if (
+        foundWillMountName !== null ||
+        foundWillReceivePropsName !== null ||
+        foundWillUpdateName !== null
+      ) {
+        var _componentName = getComponentNameFromType(ctor) || "Component";
 
-  if (!tryHydrateText(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+        var newApiName =
+          typeof ctor.getDerivedStateFromProps === "function"
+            ? "getDerivedStateFromProps()"
+            : "getSnapshotBeforeUpdate()";
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+        if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
+          didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
 
-    if (rootOrSingletonContext && isHydratable) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableTextInstance();
+          error(
+            "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" +
+              "The above lifecycles should be removed. Learn more about this warning here:\n" +
+              "https://reactjs.org/link/unsafe-component-lifecycles",
+            _componentName,
+            newApiName,
+            foundWillMountName !== null ? "\n  " + foundWillMountName : "",
+            foundWillReceivePropsName !== null
+              ? "\n  " + foundWillReceivePropsName
+              : "",
+            foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : ""
+          );
+        }
+      }
     }
+  } // Cache unmasked context so we can avoid recreating masked context unless necessary.
 
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateText(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
+  return instance;
+}
 
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+function callComponentWillMount(workInProgress, instance) {
+  var oldState = instance.state;
+
+  if (typeof instance.componentWillMount === "function") {
+    instance.componentWillMount();
   }
-}
 
-function tryToClaimNextHydratableSuspenseInstance(fiber) {
-  if (!isHydrating) {
-    return;
+  if (typeof instance.UNSAFE_componentWillMount === "function") {
+    instance.UNSAFE_componentWillMount();
   }
 
-  var initialInstance = nextHydratableInstance;
+  if (oldState !== instance.state) {
+    {
+      error(
+        "%s.componentWillMount(): Assigning directly to this.state is " +
+          "deprecated (except inside a component's " +
+          "constructor). Use setState instead.",
+        getComponentNameFromFiber(workInProgress) || "Component"
+      );
+    }
 
-  if (rootOrSingletonContext) {
-    // We may need to skip past certain nodes in these contexts
-    advanceToFirstAttemptableSuspenseInstance();
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
   }
+}
 
-  var nextInstance = nextHydratableInstance;
-
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
+function callComponentWillReceiveProps(
+  workInProgress,
+  instance,
+  newProps,
+  nextContext
+) {
+  var oldState = instance.state;
 
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
+  if (typeof instance.componentWillReceiveProps === "function") {
+    instance.componentWillReceiveProps(newProps, nextContext);
   }
 
-  var firstAttemptedInstance = nextInstance;
+  if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
 
-  if (!tryHydrateSuspense(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+  if (instance.state !== oldState) {
+    {
+      var componentName =
+        getComponentNameFromFiber(workInProgress) || "Component";
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+      if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
+        didWarnAboutStateAssignmentForComponent.add(componentName);
 
-    if (rootOrSingletonContext) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableSuspenseInstance();
+        error(
+          "%s.componentWillReceiveProps(): Assigning directly to " +
+            "this.state is deprecated (except inside a component's " +
+            "constructor). Use setState instead.",
+          componentName
+        );
+      }
     }
 
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateSuspense(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
   }
-}
+} // Invokes the mount life-cycles on a previously never rendered instance.
 
-function prepareToHydrateHostInstance(fiber, hostContext) {
-  var instance = fiber.stateNode;
-  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  var updatePayload = hydrateInstance(
-    instance,
-    fiber.type,
-    fiber.memoizedProps,
-    hostContext,
-    fiber,
-    shouldWarnIfMismatchDev
-  ); // TODO: Type this specific to this type of component.
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  {
+    checkClassInstance(workInProgress, ctor, newProps);
+  }
 
-  fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
-  // is a new ref we mark this as an update.
+  var instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  var contextType = ctor.contextType;
 
-  if (updatePayload !== null) {
-    return true;
+  if (typeof contextType === "object" && contextType !== null) {
+    instance.context = readContext(contextType);
+  } else {
+    instance.context = emptyContextObject;
   }
 
-  return false;
-}
+  {
+    if (instance.state === newProps) {
+      var componentName = getComponentNameFromType(ctor) || "Component";
 
-function prepareToHydrateHostTextInstance(fiber) {
-  var textInstance = fiber.stateNode;
-  var textContent = fiber.memoizedProps;
-  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+      if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
+        didWarnAboutDirectlyAssigningPropsToState.add(componentName);
 
-  if (shouldUpdate) {
-    // We assume that prepareToHydrateHostTextInstance is called in a context where the
-    // hydration parent is the parent host component of this host text.
-    var returnFiber = hydrationParentFiber;
+        error(
+          "%s: It is not recommended to assign props directly to state " +
+            "because updates to props won't be reflected in state. " +
+            "In most cases, it is better to use props directly.",
+          componentName
+        );
+      }
+    }
 
-    if (returnFiber !== null) {
-      switch (returnFiber.tag) {
-        case HostRoot: {
-          var parentContainer = returnFiber.stateNode.containerInfo;
-          var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
-          didNotMatchHydratedContainerTextInstance(
-            parentContainer,
-            textInstance,
-            textContent, // TODO: Delete this argument when we remove the legacy root API.
-            isConcurrentMode,
-            shouldWarnIfMismatchDev
-          );
-          break;
-        }
+    if (workInProgress.mode & StrictLegacyMode) {
+      ReactStrictModeWarnings.recordLegacyContextWarning(
+        workInProgress,
+        instance
+      );
+    }
 
-        case HostSingleton:
-        case HostComponent: {
-          var parentType = returnFiber.type;
-          var parentProps = returnFiber.memoizedProps;
-          var parentInstance = returnFiber.stateNode;
+    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
+      workInProgress,
+      instance
+    );
+  }
+
+  instance.state = workInProgress.memoizedState;
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
 
-          var _isConcurrentMode2 =
-            (returnFiber.mode & ConcurrentMode) !== NoMode;
+  if (
+    typeof ctor.getDerivedStateFromProps !== "function" &&
+    typeof instance.getSnapshotBeforeUpdate !== "function" &&
+    (typeof instance.UNSAFE_componentWillMount === "function" ||
+      typeof instance.componentWillMount === "function")
+  ) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
 
-          didNotMatchHydratedTextInstance(
-            parentType,
-            parentProps,
-            parentInstance,
-            textInstance,
-            textContent, // TODO: Delete this argument when we remove the legacy root API.
-            _isConcurrentMode2,
-            shouldWarnIfMismatchDev
-          );
-          break;
-        }
-      }
-    }
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
   }
 
-  return shouldUpdate;
-}
+  if (typeof instance.componentDidMount === "function") {
+    var fiberFlags = Update | LayoutStatic;
 
-function prepareToHydrateHostSuspenseInstance(fiber) {
-  var suspenseState = fiber.memoizedState;
-  var suspenseInstance =
-    suspenseState !== null ? suspenseState.dehydrated : null;
+    if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+      fiberFlags |= MountLayoutDev;
+    }
 
-  if (!suspenseInstance) {
-    throw new Error(
-      "Expected to have a hydrated suspense instance. " +
-        "This error is likely caused by a bug in React. Please file an issue."
-    );
+    workInProgress.flags |= fiberFlags;
   }
-
-  hydrateSuspenseInstance(suspenseInstance, fiber);
 }
 
-function skipPastDehydratedSuspenseInstance(fiber) {
-  var suspenseState = fiber.memoizedState;
-  var suspenseInstance =
-    suspenseState !== null ? suspenseState.dehydrated : null;
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  var instance = workInProgress.stateNode;
+  var oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  var oldContext = instance.context;
+  var contextType = ctor.contextType;
+  var nextContext = emptyContextObject;
 
-  if (!suspenseInstance) {
-    throw new Error(
-      "Expected to have a hydrated suspense instance. " +
-        "This error is likely caused by a bug in React. Please file an issue."
-    );
+  if (typeof contextType === "object" && contextType !== null) {
+    nextContext = readContext(contextType);
   }
 
-  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
-}
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  var hasNewLifecycles =
+    typeof getDerivedStateFromProps === "function" ||
+    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
 
-function popToNextHostParent(fiber) {
-  hydrationParentFiber = fiber.return;
+  if (
+    !hasNewLifecycles &&
+    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
+      typeof instance.componentWillReceiveProps === "function")
+  ) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(
+        workInProgress,
+        instance,
+        newProps,
+        nextContext
+      );
+    }
+  }
 
-  while (hydrationParentFiber) {
-    switch (hydrationParentFiber.tag) {
-      case HostRoot:
-      case HostSingleton:
-        rootOrSingletonContext = true;
-        return;
+  resetHasForceUpdateBeforeProcessing();
+  var oldState = workInProgress.memoizedState;
+  var newState = (instance.state = oldState);
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
 
-      case HostComponent:
-      case SuspenseComponent:
-        rootOrSingletonContext = false;
-        return;
+  if (
+    oldProps === newProps &&
+    oldState === newState &&
+    !hasContextChanged() &&
+    !checkHasForceUpdateAfterProcessing()
+  ) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === "function") {
+      var fiberFlags = Update | LayoutStatic;
 
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        fiberFlags |= MountLayoutDev;
+      }
+
+      workInProgress.flags |= fiberFlags;
     }
-  }
-}
 
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) {
-    // We're deeper than the current hydration context, inside an inserted
-    // tree.
     return false;
   }
 
-  if (!isHydrating) {
-    // If we're not currently hydrating but we're in a hydration context, then
-    // we were an insertion and now need to pop up reenter hydration of our
-    // siblings.
-    popToNextHostParent(fiber);
-    isHydrating = true;
-    return false;
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    newState = workInProgress.memoizedState;
   }
 
-  var shouldClear = false;
+  var shouldUpdate =
+    checkHasForceUpdateAfterProcessing() ||
+    checkShouldComponentUpdate(
+      workInProgress,
+      ctor,
+      oldProps,
+      newProps,
+      oldState,
+      newState,
+      nextContext
+    );
 
-  {
-    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
-    // that have singleton text content
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
     if (
-      fiber.tag !== HostRoot &&
-      fiber.tag !== HostSingleton &&
-      !(
-        fiber.tag === HostComponent &&
-        shouldSetTextContent(fiber.type, fiber.memoizedProps)
-      )
+      !hasNewLifecycles &&
+      (typeof instance.UNSAFE_componentWillMount === "function" ||
+        typeof instance.componentWillMount === "function")
     ) {
-      shouldClear = true;
-    }
-  }
-
-  if (shouldClear) {
-    var nextInstance = nextHydratableInstance;
+      if (typeof instance.componentWillMount === "function") {
+        instance.componentWillMount();
+      }
 
-    if (nextInstance) {
-      if (shouldClientRenderOnMismatch(fiber)) {
-        warnIfUnhydratedTailNodes(fiber);
-        throwOnHydrationMismatch();
-      } else {
-        while (nextInstance) {
-          deleteHydratableInstance(fiber, nextInstance);
-          nextInstance = getNextHydratableSibling(nextInstance);
-        }
+      if (typeof instance.UNSAFE_componentWillMount === "function") {
+        instance.UNSAFE_componentWillMount();
       }
     }
-  }
 
-  popToNextHostParent(fiber);
+    if (typeof instance.componentDidMount === "function") {
+      var _fiberFlags = Update | LayoutStatic;
 
-  if (fiber.tag === SuspenseComponent) {
-    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        _fiberFlags |= MountLayoutDev;
+      }
+
+      workInProgress.flags |= _fiberFlags;
+    }
   } else {
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratableSibling(fiber.stateNode)
-      : null;
-  }
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === "function") {
+      var _fiberFlags2 = Update | LayoutStatic;
 
-  return true;
-}
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        _fiberFlags2 |= MountLayoutDev;
+      }
 
-function hasUnhydratedTailNodes() {
-  return isHydrating && nextHydratableInstance !== null;
-}
+      workInProgress.flags |= _fiberFlags2;
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized state to indicate that this work can be reused.
 
-function warnIfUnhydratedTailNodes(fiber) {
-  var nextInstance = nextHydratableInstance;
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
 
-  while (nextInstance) {
-    warnUnhydratedInstance(fiber, nextInstance);
-    nextInstance = getNextHydratableSibling(nextInstance);
-  }
-}
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
 
-function resetHydrationState() {
-  hydrationParentFiber = null;
-  nextHydratableInstance = null;
-  isHydrating = false;
-  didSuspendOrErrorDEV = false;
-}
+function updateClassInstance(
+  current,
+  workInProgress,
+  ctor,
+  newProps,
+  renderLanes
+) {
+  var instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  var unresolvedOldProps = workInProgress.memoizedProps;
+  var oldProps =
+    workInProgress.type === workInProgress.elementType
+      ? unresolvedOldProps
+      : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  var unresolvedNewProps = workInProgress.pendingProps;
+  var oldContext = instance.context;
+  var contextType = ctor.contextType;
+  var nextContext = emptyContextObject;
 
-function upgradeHydrationErrorsToRecoverable() {
-  if (hydrationErrors !== null) {
-    // Successfully completed a forced client render. The errors that occurred
-    // during the hydration attempt are now recovered. We will log them in
-    // commit phase, once the entire tree has finished.
-    queueRecoverableErrors(hydrationErrors);
-    hydrationErrors = null;
+  if (typeof contextType === "object" && contextType !== null) {
+    nextContext = readContext(contextType);
   }
-}
 
-function getIsHydrating() {
-  return isHydrating;
-}
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  var hasNewLifecycles =
+    typeof getDerivedStateFromProps === "function" ||
+    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
 
-function queueHydrationError(error) {
-  if (hydrationErrors === null) {
-    hydrationErrors = [error];
-  } else {
-    hydrationErrors.push(error);
+  if (
+    !hasNewLifecycles &&
+    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
+      typeof instance.componentWillReceiveProps === "function")
+  ) {
+    if (
+      unresolvedOldProps !== unresolvedNewProps ||
+      oldContext !== nextContext
+    ) {
+      callComponentWillReceiveProps(
+        workInProgress,
+        instance,
+        newProps,
+        nextContext
+      );
+    }
   }
-}
-
-// we wait until the current render is over (either finished or interrupted)
-// before adding it to the fiber/hook queue. Push to this array so we can
-// access the queue, fiber, update, et al later.
-
-var concurrentQueues = [];
-var concurrentQueuesIndex = 0;
-var concurrentlyUpdatedLanes = NoLanes;
-function finishQueueingConcurrentUpdates() {
-  var endIndex = concurrentQueuesIndex;
-  concurrentQueuesIndex = 0;
-  concurrentlyUpdatedLanes = NoLanes;
-  var i = 0;
-
-  while (i < endIndex) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
 
-    if (queue !== null && update !== null) {
-      var pending = queue.pending;
+  resetHasForceUpdateBeforeProcessing();
+  var oldState = workInProgress.memoizedState;
+  var newState = (instance.state = oldState);
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
 
-      if (pending === null) {
-        // This is the first update. Create a circular list.
-        update.next = update;
-      } else {
-        update.next = pending.next;
-        pending.next = update;
+  if (
+    unresolvedOldProps === unresolvedNewProps &&
+    oldState === newState &&
+    !hasContextChanged() &&
+    !checkHasForceUpdateAfterProcessing() &&
+    !(
+      enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies)
+    )
+  ) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Update;
       }
-
-      queue.pending = update;
     }
 
-    if (lane !== NoLane) {
-      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Snapshot;
+      }
     }
+
+    return false;
   }
-}
-function getConcurrentlyUpdatedLanes() {
-  return concurrentlyUpdatedLanes;
-}
 
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  // Don't update the `childLanes` on the return path yet. If we already in
-  // the middle of rendering, wait until after it has completed.
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
-  // scheduled, to perform an eager bailout, so we need to update it immediately.
-  // TODO: We should probably move this to the "shared" queue instead.
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    newState = workInProgress.memoizedState;
+  }
 
-  fiber.lanes = mergeLanes(fiber.lanes, lane);
-  var alternate = fiber.alternate;
+  var shouldUpdate =
+    checkHasForceUpdateAfterProcessing() ||
+    checkShouldComponentUpdate(
+      workInProgress,
+      ctor,
+      oldProps,
+      newProps,
+      oldState,
+      newState,
+      nextContext
+    ) || // TODO: In some cases, we'll end up checking if context has changed twice,
+    // both before and after `shouldComponentUpdate` has been called. Not ideal,
+    // but I'm loath to refactor this function. This only happens for memoized
+    // components so it's not that common.
+    (enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies));
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, lane);
-  }
-}
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (
+      !hasNewLifecycles &&
+      (typeof instance.UNSAFE_componentWillUpdate === "function" ||
+        typeof instance.componentWillUpdate === "function")
+    ) {
+      if (typeof instance.componentWillUpdate === "function") {
+        instance.componentWillUpdate(newProps, newState, nextContext);
+      }
 
-function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
-  // This function is used to queue an update that doesn't need a rerender. The
-  // only reason we queue it is in case there's a subsequent higher priority
-  // update that causes it to be rebased.
-  var lane = NoLane;
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
-  // queue. However, since this is a bail out, we're not scheduling any work
-  // here. So the update we just queued will leak until something else happens
-  // to schedule work (if ever).
-  //
-  // Check if we're currently in the middle of rendering a tree, and if not,
-  // process the queue immediately to prevent a leak.
+      if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
+    }
 
-  var isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+    if (typeof instance.componentDidUpdate === "function") {
+      workInProgress.flags |= Update;
+    }
 
-  if (!isConcurrentlyRendering) {
-    finishQueueingConcurrentUpdates();
-  }
-}
-function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
-} // Calling this function outside this module should only be done for backwards
-// compatibility and should always be accompanied by a warning.
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Update;
+      }
+    }
 
-function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
-  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
-  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
-  // undefined behavior and we can change it if we need to; it just so happens
-  // that, at the time of this writing, there's an internal product test that
-  // happens to rely on this.
-  var root = getRootForUpdatedFiber(sourceFiber);
-  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
-  return root;
-}
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
+
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
 
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  // Update the source fiber's lanes
-  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
-  var alternate = sourceFiber.alternate;
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+}
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, lane);
-  } // Walk the parent path to the root and update the child lanes.
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value: value,
+    source: source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value: value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
+}
 
-  var isHidden = false;
-  var parent = sourceFiber.return;
-  var node = sourceFiber;
+var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
 
-  while (parent !== null) {
-    parent.childLanes = mergeLanes(parent.childLanes, lane);
-    alternate = parent.alternate;
+if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== "function") {
+  throw new Error(
+    "Expected ReactFiberErrorDialog.showErrorDialog to be a function."
+  );
+}
 
-    if (alternate !== null) {
-      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
-    }
+function showErrorDialog(boundary, errorInfo) {
+  var capturedError = {
+    componentStack: errorInfo.stack !== null ? errorInfo.stack : "",
+    error: errorInfo.value,
+    errorBoundary:
+      boundary !== null && boundary.tag === ClassComponent
+        ? boundary.stateNode
+        : null
+  };
+  return ReactFiberErrorDialogWWW.showErrorDialog(capturedError);
+}
 
-    if (parent.tag === OffscreenComponent) {
-      // Check if this offscreen boundary is currently hidden.
-      //
-      // The instance may be null if the Offscreen parent was unmounted. Usually
-      // the parent wouldn't be reachable in that case because we disconnect
-      // fibers from the tree when they are deleted. However, there's a weird
-      // edge case where setState is called on a fiber that was interrupted
-      // before it ever mounted. Because it never mounts, it also never gets
-      // deleted. Because it never gets deleted, its return pointer never gets
-      // disconnected. Which means it may be attached to a deleted Offscreen
-      // parent node. (This discovery suggests it may be better for memory usage
-      // if we don't attach the `return` pointer until the commit phase, though
-      // in order to do that we'd need some other way to track the return
-      // pointer during the initial render, like on the stack.)
-      //
-      // This case is always accompanied by a warning, but we still need to
-      // account for it. (There may be other cases that we haven't discovered,
-      // too.)
-      var offscreenInstance = parent.stateNode;
+function logCapturedError(boundary, errorInfo) {
+  try {
+    var logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
 
-      if (
-        offscreenInstance !== null &&
-        !(offscreenInstance._visibility & OffscreenVisible)
-      ) {
-        isHidden = true;
-      }
+    if (logError === false) {
+      return;
     }
 
-    node = parent;
-    parent = parent.return;
-  }
+    var error = errorInfo.value;
 
-  if (isHidden && update !== null && node.tag === HostRoot) {
-    var root = node.stateNode;
-    markHiddenUpdate(root, update, lane);
-  }
-}
+    if (true) {
+      var source = errorInfo.source;
+      var stack = errorInfo.stack;
+      var componentStack = stack !== null ? stack : ""; // Browsers support silencing uncaught errors by calling
+      // `preventDefault()` in window `error` handler.
+      // We record this information as an expando on the error.
 
-function getRootForUpdatedFiber(sourceFiber) {
-  // TODO: We will detect and infinite update loop and throw even if this fiber
-  // has already unmounted. This isn't really necessary but it happens to be the
-  // current behavior we've used for several release cycles. Consider not
-  // performing this check if the updated fiber already unmounted, since it's
-  // not possible for that to cause an infinite update loop.
-  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
-  // update queues do not have a backpointer to the root, the only way to do
-  // this currently is to walk up the return path. This used to not be a big
-  // deal because we would have to walk up the return path to set
-  // the `childLanes`, anyway, but now those two traversals happen at
-  // different times.
-  // TODO: Consider adding a `root` backpointer on the update queue.
+      if (error != null && error._suppressLogging) {
+        if (boundary.tag === ClassComponent) {
+          // The error is recoverable and was silenced.
+          // Ignore it and don't print the stack addendum.
+          // This is handy for testing error boundaries without noise.
+          return;
+        } // The error is fatal. Since the silencing might have
+        // been accidental, we'll surface it anyway.
+        // However, the browser would have silenced the original error
+        // so we'll print it first, and then print the stack addendum.
 
-  detectUpdateOnUnmountedFiber(sourceFiber, sourceFiber);
-  var node = sourceFiber;
-  var parent = node.return;
+        console["error"](error); // Don't transform to our wrapper
+        // For a more detailed description of this block, see:
+        // https://github.com/facebook/react/pull/13384
+      }
 
-  while (parent !== null) {
-    detectUpdateOnUnmountedFiber(sourceFiber, node);
-    node = parent;
-    parent = node.return;
-  }
+      var componentName = source ? getComponentNameFromFiber(source) : null;
+      var componentNameMessage = componentName
+        ? "The above error occurred in the <" + componentName + "> component:"
+        : "The above error occurred in one of your React components:";
+      var errorBoundaryMessage;
 
-  return node.tag === HostRoot ? node.stateNode : null;
-}
+      if (boundary.tag === HostRoot) {
+        errorBoundaryMessage =
+          "Consider adding an error boundary to your tree to customize error handling behavior.\n" +
+          "Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.";
+      } else {
+        var errorBoundaryName =
+          getComponentNameFromFiber(boundary) || "Anonymous";
+        errorBoundaryMessage =
+          "React will try to recreate this component tree from scratch " +
+          ("using the error boundary you provided, " + errorBoundaryName + ".");
+      }
 
-function detectUpdateOnUnmountedFiber(sourceFiber, parent) {
-  {
-    var alternate = parent.alternate;
+      var combinedMessage =
+        componentNameMessage +
+        "\n" +
+        componentStack +
+        "\n\n" +
+        ("" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.
+      // We don't include the original error message and JS stack because the browser
+      // has already printed it. Even if the application swallows the error, it is still
+      // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
 
-    if (
-      alternate === null &&
-      (parent.flags & (Placement | Hydrating)) !== NoFlags$1
-    ) {
-      warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
+      console["error"](combinedMessage); // Don't transform to our wrapper
     }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(function () {
+      throw e;
+    });
   }
 }
 
-var UpdateState = 0;
-var ReplaceState = 1;
-var ForceUpdate = 2;
-var CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
-// It should only be read right after calling `processUpdateQueue`, via
-// `checkHasForceUpdateAfterProcessing`.
-
-var hasForceUpdate = false;
-var didWarnUpdateInsideUpdate;
-var currentlyProcessingQueue;
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  var update = createUpdate(lane); // Unmount the root by rendering null.
 
-{
-  didWarnUpdateInsideUpdate = false;
-  currentlyProcessingQueue = null;
-}
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-function initializeUpdateQueue(fiber) {
-  var queue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: {
-      pending: null,
-      lanes: NoLanes,
-      hiddenCallbacks: null
-    },
-    callbacks: null
+  update.payload = {
+    element: null
   };
-  fiber.updateQueue = queue;
-}
-function cloneUpdateQueue(current, workInProgress) {
-  // Clone the update queue from current. Unless it's already a clone.
-  var queue = workInProgress.updateQueue;
-  var currentQueue = current.updateQueue;
+  var error = errorInfo.value;
 
-  if (queue === currentQueue) {
-    var clone = {
-      baseState: currentQueue.baseState,
-      firstBaseUpdate: currentQueue.firstBaseUpdate,
-      lastBaseUpdate: currentQueue.lastBaseUpdate,
-      shared: currentQueue.shared,
-      callbacks: null
-    };
-    workInProgress.updateQueue = clone;
-  }
-}
-function createUpdate(lane) {
-  var update = {
-    lane: lane,
-    tag: UpdateState,
-    payload: null,
-    callback: null,
-    next: null
+  update.callback = function () {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
   };
+
   return update;
 }
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
 
-  if (updateQueue === null) {
-    // Only occurs if the fiber has been unmounted.
-    return null;
-  }
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  var update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
 
-  var sharedQueue = updateQueue.shared;
+  if (typeof getDerivedStateFromError === "function") {
+    var error$1 = errorInfo.value;
 
-  {
-    if (
-      currentlyProcessingQueue === sharedQueue &&
-      !didWarnUpdateInsideUpdate
-    ) {
-      var componentName = getComponentNameFromFiber(fiber);
+    update.payload = function () {
+      return getDerivedStateFromError(error$1);
+    };
 
-      error(
-        "An update (setState, replaceState, or forceUpdate) was scheduled " +
-          "from inside an update function. Update functions should be pure, " +
-          "with zero side-effects. Consider using componentDidUpdate or a " +
-          "callback.\n\nPlease update the following component: %s",
-        componentName
-      );
+    update.callback = function () {
+      {
+        markFailedErrorBoundaryForHotReloading(fiber);
+      }
 
-      didWarnUpdateInsideUpdate = true;
-    }
+      logCapturedError(fiber, errorInfo);
+    };
   }
 
-  if (isUnsafeClassRenderPhaseUpdate(fiber)) {
-    // This is an unsafe render phase update. Add directly to the update
-    // queue so we can process it immediately during the current render.
-    var pending = sharedQueue.pending;
+  var inst = fiber.stateNode;
 
-    if (pending === null) {
-      // This is the first update. Create a circular list.
-      update.next = update;
-    } else {
-      update.next = pending.next;
-      pending.next = update;
-    }
+  if (inst !== null && typeof inst.componentDidCatch === "function") {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+      {
+        markFailedErrorBoundaryForHotReloading(fiber);
+      }
 
-    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
-    // this fiber. This is for backwards compatibility in the case where you
-    // update a different component during render phase than the one that is
-    // currently renderings (a pattern that is accompanied by a warning).
+      logCapturedError(fiber, errorInfo);
 
-    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
-  } else {
-    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
-  }
-}
-function entangleTransitions(root, fiber, lane) {
-  var updateQueue = fiber.updateQueue;
+      if (typeof getDerivedStateFromError !== "function") {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
 
-  if (updateQueue === null) {
-    // Only occurs if the fiber has been unmounted.
-    return;
+      var error$1 = errorInfo.value;
+      var stack = errorInfo.stack;
+      this.componentDidCatch(error$1, {
+        componentStack: stack !== null ? stack : ""
+      });
+
+      {
+        if (typeof getDerivedStateFromError !== "function") {
+          // If componentDidCatch is the only error boundary method defined,
+          // then it needs to call setState to recover from errors.
+          // If no state update is scheduled then the boundary will swallow the error.
+          if (!includesSomeLane(fiber.lanes, SyncLane)) {
+            error(
+              "%s: Error boundaries should implement getDerivedStateFromError(). " +
+                "In that method, return a state update to display an error message or fallback UI.",
+              getComponentNameFromFiber(fiber) || "Unknown"
+            );
+          }
+        }
+      }
+    };
   }
 
-  var sharedQueue = updateQueue.shared;
+  return update;
+}
 
-  if (isTransitionLane(lane)) {
-    var queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
-    // have finished. We can remove them from the shared queue, which represents
-    // a superset of the actually pending lanes. In some cases we may entangle
-    // more than we need to, but that's OK. In fact it's worse if we *don't*
-    // entangle when we should.
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  if (enableLazyContextPropagation) {
+    var currentSourceFiber = sourceFiber.alternate;
 
-    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+    if (currentSourceFiber !== null) {
+      // Since we never visited the children of the suspended component, we
+      // need to propagate the context change now, to ensure that we visit
+      // them during the retry.
+      //
+      // We don't have to do this for errors because we retry errors without
+      // committing in between. So this is specific to Suspense.
+      propagateParentContextChangesToDeferredTree(
+        currentSourceFiber,
+        sourceFiber,
+        rootRenderLanes
+      );
+    }
+  } // Reset the memoizedState to what it was before we attempted to render it.
+  // A legacy mode Suspense quirk, only relevant to hook components.
 
-    var newQueueLanes = mergeLanes(queueLanes, lane);
-    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
-    // the lane finished since the last time we entangled it. So we need to
-    // entangle it again, just to be sure.
+  var tag = sourceFiber.tag;
 
-    markRootEntangled(root, newQueueLanes);
+  if (
+    (sourceFiber.mode & ConcurrentMode) === NoMode &&
+    (tag === FunctionComponent ||
+      tag === ForwardRef ||
+      tag === SimpleMemoComponent)
+  ) {
+    var currentSource = sourceFiber.alternate;
+
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
+    } else {
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
+    }
   }
 }
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  // Captured updates are updates that are thrown by a child during the render
-  // phase. They should be discarded if the render is aborted. Therefore,
-  // we should only put them on the work-in-progress queue, not the current one.
-  var queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
 
-  var current = workInProgress.alternate;
+function markSuspenseBoundaryShouldCapture(
+  suspenseBoundary,
+  returnFiber,
+  sourceFiber,
+  root,
+  rootRenderLanes
+) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // 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.
 
-  if (current !== null) {
-    var currentQueue = current.updateQueue;
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
 
-    if (queue === currentQueue) {
-      // The work-in-progress queue is the same as current. This happens when
-      // we bail out on a parent fiber that then captures an error thrown by
-      // a child. Since we want to append the update only to the work-in
-      // -progress queue, we need to clone the updates. We usually clone during
-      // processUpdateQueue, but that didn't happen in this case because we
-      // skipped over the parent when we bailed out.
-      var newFirst = null;
-      var newLast = null;
-      var firstBaseUpdate = queue.firstBaseUpdate;
+      if (sourceFiber.tag === ClassComponent) {
+        var currentSourceFiber = sourceFiber.alternate;
 
-      if (firstBaseUpdate !== null) {
-        // Loop through the updates and clone them.
-        var update = firstBaseUpdate;
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
+        } else {
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          var update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
+        }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
 
-        do {
-          var clone = {
-            lane: update.lane,
-            tag: update.tag,
-            payload: update.payload,
-            // When this update is rebased, we should not fire its
-            // callback again.
-            callback: null,
-            next: null
-          };
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+    }
+
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
 
-          if (newLast === null) {
-            newFirst = newLast = clone;
-          } else {
-            newLast.next = clone;
-            newLast = clone;
-          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
 
-          update = update.next;
-        } while (update !== null); // Append the captured update the end of the cloned list.
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
+}
 
-        if (newLast === null) {
-          newFirst = newLast = capturedUpdate;
-        } else {
-          newLast.next = capturedUpdate;
-          newLast = capturedUpdate;
-        }
-      } else {
-        // There are no base updates.
-        newFirst = newLast = capturedUpdate;
-      }
+function throwException(
+  root,
+  returnFiber,
+  sourceFiber,
+  value,
+  rootRenderLanes
+) {
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
 
-      queue = {
-        baseState: currentQueue.baseState,
-        firstBaseUpdate: newFirst,
-        lastBaseUpdate: newLast,
-        shared: currentQueue.shared,
-        callbacks: currentQueue.callbacks
-      };
-      workInProgress.updateQueue = queue;
-      return;
+  {
+    if (isDevToolsPresent) {
+      // If we have pending work still, restore the original updaters
+      restorePendingUpdaters(root, rootRenderLanes);
     }
-  } // Append the update to the end of the list.
-
-  var lastBaseUpdate = queue.lastBaseUpdate;
-
-  if (lastBaseUpdate === null) {
-    queue.firstBaseUpdate = capturedUpdate;
-  } else {
-    lastBaseUpdate.next = capturedUpdate;
   }
 
-  queue.lastBaseUpdate = capturedUpdate;
-}
+  if (
+    value !== null &&
+    typeof value === "object" &&
+    typeof value.then === "function"
+  ) {
+    // This is a wakeable. The component suspended.
+    var wakeable = value;
+    resetSuspendedComponent(sourceFiber, rootRenderLanes);
 
-function getStateFromUpdate(
-  workInProgress,
-  queue,
-  update,
-  prevState,
-  nextProps,
-  instance
-) {
-  switch (update.tag) {
-    case ReplaceState: {
-      var payload = update.payload;
+    {
+      if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+        markDidThrowWhileHydratingDEV();
+      }
+    }
 
-      if (typeof payload === "function") {
-        // Updater function
-        {
-          enterDisallowedContextReadInDEV();
+    {
+      if (enableDebugTracing) {
+        if (sourceFiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(sourceFiber) || "Unknown";
+          logComponentSuspended(name, wakeable);
         }
+      }
+    } // Mark the nearest Suspense boundary to switch to rendering a fallback.
 
-        var nextState = payload.call(instance, prevState, nextProps);
+    var suspenseBoundary = getSuspenseHandler();
 
-        {
-          if (workInProgress.mode & StrictLegacyMode) {
-            setIsStrictModeForDevtools(true);
+    if (suspenseBoundary !== null) {
+      switch (suspenseBoundary.tag) {
+        case SuspenseComponent: {
+          // If this suspense boundary is not already showing a fallback, mark
+          // the in-progress render as suspended. We try to perform this logic
+          // as soon as soon as possible during the render phase, so the work
+          // loop can know things like whether it's OK to switch to other tasks,
+          // or whether it can wait for data to resolve before continuing.
+          // TODO: Most of these checks are already performed when entering a
+          // Suspense boundary. We should track the information on the stack so
+          // we don't have to recompute it on demand. This would also allow us
+          // to unify with `use` which needs to perform this logic even sooner,
+          // before `throwException` is called.
+          if (sourceFiber.mode & ConcurrentMode) {
+            if (getShellBoundary() === null) {
+              // Suspended in the "shell" of the app. This is an undesirable
+              // loading state. We should avoid committing this tree.
+              renderDidSuspendDelayIfPossible();
+            } else {
+              // If we suspended deeper than the shell, we don't need to delay
+              // the commmit. However, we still call renderDidSuspend if this is
+              // a new boundary, to tell the work loop that a new fallback has
+              // appeared during this render.
+              // TODO: Theoretically we should be able to delete this branch.
+              // It's currently used for two things: 1) to throttle the
+              // appearance of successive loading states, and 2) in
+              // SuspenseList, to determine whether the children include any
+              // pending fallbacks. For 1, we should apply throttling to all
+              // retries, not just ones that render an additional fallback. For
+              // 2, we should check subtreeFlags instead. Then we can delete
+              // this branch.
+              var current = suspenseBoundary.alternate;
 
-            try {
-              payload.call(instance, prevState, nextProps);
-            } finally {
-              setIsStrictModeForDevtools(false);
+              if (current === null) {
+                renderDidSuspend();
+              }
             }
           }
 
-          exitDisallowedContextReadInDEV();
-        }
-
-        return nextState;
-      } // State object
-
-      return payload;
-    }
+          suspenseBoundary.flags &= ~ForceClientRender;
+          markSuspenseBoundaryShouldCapture(
+            suspenseBoundary,
+            returnFiber,
+            sourceFiber,
+            root,
+            rootRenderLanes
+          ); // Retry listener
+          //
+          // If the fallback does commit, we need to attach a different type of
+          // listener. This one schedules an update on the Suspense boundary to
+          // turn the fallback state off.
+          //
+          // Stash the wakeable on the boundary fiber so we can access it in the
+          // commit phase.
+          //
+          // When the wakeable resolves, we'll attempt to render the boundary
+          // again ("retry").
 
-    case CaptureUpdate: {
-      workInProgress.flags =
-        (workInProgress.flags & ~ShouldCapture) | DidCapture;
-    }
-    // Intentional fallthrough
+          var wakeables = suspenseBoundary.updateQueue;
 
-    case UpdateState: {
-      var _payload = update.payload;
-      var partialState;
+          if (wakeables === null) {
+            suspenseBoundary.updateQueue = new Set([wakeable]);
+          } else {
+            wakeables.add(wakeable);
+          }
 
-      if (typeof _payload === "function") {
-        // Updater function
-        {
-          enterDisallowedContextReadInDEV();
+          break;
         }
 
-        partialState = _payload.call(instance, prevState, nextProps);
+        case OffscreenComponent: {
+          if (suspenseBoundary.mode & ConcurrentMode) {
+            suspenseBoundary.flags |= ShouldCapture;
+            var offscreenQueue = suspenseBoundary.updateQueue;
 
-        {
-          if (workInProgress.mode & StrictLegacyMode) {
-            setIsStrictModeForDevtools(true);
+            if (offscreenQueue === null) {
+              var newOffscreenQueue = {
+                transitions: null,
+                markerInstances: null,
+                wakeables: new Set([wakeable])
+              };
+              suspenseBoundary.updateQueue = newOffscreenQueue;
+            } else {
+              var _wakeables = offscreenQueue.wakeables;
 
-            try {
-              _payload.call(instance, prevState, nextProps);
-            } finally {
-              setIsStrictModeForDevtools(false);
+              if (_wakeables === null) {
+                offscreenQueue.wakeables = new Set([wakeable]);
+              } else {
+                _wakeables.add(wakeable);
+              }
             }
+
+            break;
           }
+        }
+        // eslint-disable-next-line no-fallthrough
 
-          exitDisallowedContextReadInDEV();
+        default: {
+          throw new Error(
+            "Unexpected Suspense handler tag (" +
+              suspenseBoundary.tag +
+              "). This " +
+              "is a bug in React."
+          );
         }
-      } else {
-        // Partial state object
-        partialState = _payload;
-      }
+      } // We only attach ping listeners in concurrent mode. Legacy Suspense always
+      // commits fallbacks synchronously, so there are no pings.
 
-      if (partialState === null || partialState === undefined) {
-        // Null and undefined are treated as no-ops.
-        return prevState;
-      } // Merge the partial state and the previous state.
+      if (suspenseBoundary.mode & ConcurrentMode) {
+        attachPingListener(root, wakeable, rootRenderLanes);
+      }
 
-      return assign({}, prevState, partialState);
+      return;
+    } else {
+      // No boundary was found. Unless this is a sync update, this is OK.
+      // We can suspend and wait for more data to arrive.
+      if (root.tag === ConcurrentRoot) {
+        // In a concurrent root, suspending without a Suspense boundary is
+        // allowed. It will suspend indefinitely without committing.
+        //
+        // TODO: Should we have different behavior for discrete updates? What
+        // about flushSync? Maybe it should put the tree into an inert state,
+        // and potentially log a warning. Revisit this for a future release.
+        attachPingListener(root, wakeable, rootRenderLanes);
+        renderDidSuspendDelayIfPossible();
+        return;
+      } else {
+        // In a legacy root, suspending without a boundary is always an error.
+        var uncaughtSuspenseError = new Error(
+          "A component suspended while responding to synchronous input. This " +
+            "will cause the UI to be replaced with a loading indicator. To " +
+            "fix, updates that suspend should be wrapped " +
+            "with startTransition."
+        );
+        value = uncaughtSuspenseError;
+      }
     }
+  } else {
+    // This is a regular error, not a Suspense wakeable.
+    if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+      markDidThrowWhileHydratingDEV();
 
-    case ForceUpdate: {
-      hasForceUpdate = true;
-      return prevState;
-    }
-  }
+      var _suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+      // discarding the dehydrated content and switching to a client render.
+      // Instead of surfacing the error, find the nearest Suspense boundary
+      // and render it again without hydration.
 
-  return prevState;
-}
+      if (_suspenseBoundary !== null) {
+        if ((_suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+          // Set a flag to indicate that we should try rendering the normal
+          // children again, not the fallback.
+          _suspenseBoundary.flags |= ForceClientRender;
+        }
 
-function processUpdateQueue(workInProgress, props, instance, renderLanes) {
-  // This is always non-null on a ClassComponent or HostRoot
-  var queue = workInProgress.updateQueue;
-  hasForceUpdate = false;
+        markSuspenseBoundaryShouldCapture(
+          _suspenseBoundary,
+          returnFiber,
+          sourceFiber,
+          root,
+          rootRenderLanes
+        ); // Even though the user may not be affected by this error, we should
+        // still log it so it can be fixed.
 
-  {
-    currentlyProcessingQueue = queue.shared;
+        queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+        return;
+      }
+    }
   }
 
-  var firstBaseUpdate = queue.firstBaseUpdate;
-  var lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // 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.
 
-  var pendingQueue = queue.shared.pending;
+  var workInProgress = returnFiber;
 
-  if (pendingQueue !== null) {
-    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
-    // and last so that it's non-circular.
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot: {
+        var _errorInfo = value;
+        workInProgress.flags |= ShouldCapture;
+        var lane = pickArbitraryLane(rootRenderLanes);
+        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+        var update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
+        enqueueCapturedUpdate(workInProgress, update);
+        return;
+      }
 
-    var lastPendingUpdate = pendingQueue;
-    var firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null; // Append pending updates to base queue
+      case ClassComponent:
+        // Capture and retry
+        var errorInfo = value;
+        var ctor = workInProgress.type;
+        var instance = workInProgress.stateNode;
 
-    if (lastBaseUpdate === null) {
-      firstBaseUpdate = firstPendingUpdate;
-    } else {
-      lastBaseUpdate.next = firstPendingUpdate;
-    }
+        if (
+          (workInProgress.flags & DidCapture) === NoFlags$1 &&
+          (typeof ctor.getDerivedStateFromError === "function" ||
+            (instance !== null &&
+              typeof instance.componentDidCatch === "function" &&
+              !isAlreadyFailedLegacyErrorBoundary(instance)))
+        ) {
+          workInProgress.flags |= ShouldCapture;
 
-    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
-    // we need to transfer the updates to that queue, too. Because the base
-    // queue is a singly-linked list with no cycles, we can append to both
-    // lists and take advantage of structural sharing.
-    // TODO: Pass `current` as argument
+          var _lane = pickArbitraryLane(rootRenderLanes);
 
-    var current = workInProgress.alternate;
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, _lane); // Schedule the error boundary to re-render using updated state
 
-    if (current !== null) {
-      // This is always non-null on a ClassComponent or HostRoot
-      var currentQueue = current.updateQueue;
-      var currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+          var _update = createClassErrorUpdate(
+            workInProgress,
+            errorInfo,
+            _lane
+          );
 
-      if (currentLastBaseUpdate !== lastBaseUpdate) {
-        if (currentLastBaseUpdate === null) {
-          currentQueue.firstBaseUpdate = firstPendingUpdate;
-        } else {
-          currentLastBaseUpdate.next = firstPendingUpdate;
+          enqueueCapturedUpdate(workInProgress, _update);
+          return;
         }
 
-        currentQueue.lastBaseUpdate = lastPendingUpdate;
-      }
-    }
-  } // These values may change as we process the queue.
-
-  if (firstBaseUpdate !== null) {
-    // Iterate through the list of updates to compute the result.
-    var newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
-    // from the original lanes.
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-    var newLanes = NoLanes;
-    var newBaseState = null;
-    var newFirstBaseUpdate = null;
-    var newLastBaseUpdate = null;
-    var update = firstBaseUpdate;
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
+}
 
-    do {
-      // An extra OffscreenLane bit is added to updates that were made to
-      // a hidden tree, so that we can distinguish them from updates that were
-      // already there when the tree was hidden.
-      var updateLane = removeLanes(update.lane, OffscreenLane);
-      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
-      // it's not a "base" update and we should disregard the extra base lanes
-      // that were added to renderLanes when we entered the Offscreen tree.
+var TransitionRoot = 0;
+var TransitionTracingMarker = 1;
+function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
+  if (enableTransitionTracing) {
+    if (pendingTransitions !== null) {
+      var transitionStart = pendingTransitions.transitionStart;
+      var onTransitionStart = callbacks.onTransitionStart;
 
-      var shouldSkipUpdate = isHiddenUpdate
-        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
-        : !isSubsetOfLanes(renderLanes, updateLane);
+      if (transitionStart !== null && onTransitionStart != null) {
+        transitionStart.forEach(function (transition) {
+          return onTransitionStart(transition.name, transition.startTime);
+        });
+      }
 
-      if (shouldSkipUpdate) {
-        // Priority is insufficient. Skip this update. If this is the first
-        // skipped update, the previous update/state is the new base
-        // update/state.
-        var clone = {
-          lane: updateLane,
-          tag: update.tag,
-          payload: update.payload,
-          callback: update.callback,
-          next: null
-        };
+      var markerProgress = pendingTransitions.markerProgress;
+      var onMarkerProgress = callbacks.onMarkerProgress;
 
-        if (newLastBaseUpdate === null) {
-          newFirstBaseUpdate = newLastBaseUpdate = clone;
-          newBaseState = newState;
-        } else {
-          newLastBaseUpdate = newLastBaseUpdate.next = clone;
-        } // Update the remaining priority in the queue.
+      if (onMarkerProgress != null && markerProgress !== null) {
+        markerProgress.forEach(function (markerInstance, markerName) {
+          if (markerInstance.transitions !== null) {
+            // TODO: Clone the suspense object so users can't modify it
+            var pending =
+              markerInstance.pendingBoundaries !== null
+                ? Array.from(markerInstance.pendingBoundaries.values())
+                : [];
+            markerInstance.transitions.forEach(function (transition) {
+              onMarkerProgress(
+                transition.name,
+                markerName,
+                transition.startTime,
+                endTime,
+                pending
+              );
+            });
+          }
+        });
+      }
 
-        newLanes = mergeLanes(newLanes, updateLane);
-      } else {
-        // This update does have sufficient priority.
-        if (newLastBaseUpdate !== null) {
-          var _clone = {
-            // This update is going to be committed so we never want uncommit
-            // it. Using NoLane works because 0 is a subset of all bitmasks, so
-            // this will never be skipped by the check above.
-            lane: NoLane,
-            tag: update.tag,
-            payload: update.payload,
-            // When this update is rebased, we should not fire its
-            // callback again.
-            callback: null,
-            next: null
-          };
-          newLastBaseUpdate = newLastBaseUpdate.next = _clone;
-        } // Process this update.
+      var markerComplete = pendingTransitions.markerComplete;
+      var onMarkerComplete = callbacks.onMarkerComplete;
 
-        newState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          newState,
-          props,
-          instance
-        );
-        var callback = update.callback;
+      if (markerComplete !== null && onMarkerComplete != null) {
+        markerComplete.forEach(function (transitions, markerName) {
+          transitions.forEach(function (transition) {
+            onMarkerComplete(
+              transition.name,
+              markerName,
+              transition.startTime,
+              endTime
+            );
+          });
+        });
+      }
 
-        if (callback !== null) {
-          workInProgress.flags |= Callback;
+      var markerIncomplete = pendingTransitions.markerIncomplete;
+      var onMarkerIncomplete = callbacks.onMarkerIncomplete;
 
-          if (isHiddenUpdate) {
-            workInProgress.flags |= Visibility;
-          }
+      if (onMarkerIncomplete != null && markerIncomplete !== null) {
+        markerIncomplete.forEach(function (_ref, markerName) {
+          var transitions = _ref.transitions,
+            aborts = _ref.aborts;
+          transitions.forEach(function (transition) {
+            var filteredAborts = [];
+            aborts.forEach(function (abort) {
+              switch (abort.reason) {
+                case "marker": {
+                  filteredAborts.push({
+                    type: "marker",
+                    name: abort.name,
+                    endTime: endTime
+                  });
+                  break;
+                }
 
-          var callbacks = queue.callbacks;
+                case "suspense": {
+                  filteredAborts.push({
+                    type: "suspense",
+                    name: abort.name,
+                    endTime: endTime
+                  });
+                  break;
+                }
+              }
+            });
 
-          if (callbacks === null) {
-            queue.callbacks = [callback];
-          } else {
-            callbacks.push(callback);
-          }
-        }
-      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+            if (filteredAborts.length > 0) {
+              onMarkerIncomplete(
+                transition.name,
+                markerName,
+                transition.startTime,
+                filteredAborts
+              );
+            }
+          });
+        });
+      }
 
-      update = update.next;
+      var transitionProgress = pendingTransitions.transitionProgress;
+      var onTransitionProgress = callbacks.onTransitionProgress;
 
-      if (update === null) {
-        pendingQueue = queue.shared.pending;
+      if (onTransitionProgress != null && transitionProgress !== null) {
+        transitionProgress.forEach(function (pending, transition) {
+          onTransitionProgress(
+            transition.name,
+            transition.startTime,
+            endTime,
+            Array.from(pending.values())
+          );
+        });
+      }
 
-        if (pendingQueue === null) {
-          break;
-        } else {
-          // An update was scheduled from inside a reducer. Add the new
-          // pending updates to the end of the list and keep processing.
-          var _lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
-          // unravel them when transferring them to the base queue.
+      var transitionComplete = pendingTransitions.transitionComplete;
+      var onTransitionComplete = callbacks.onTransitionComplete;
 
-          var _firstPendingUpdate = _lastPendingUpdate.next;
-          _lastPendingUpdate.next = null;
-          update = _firstPendingUpdate;
-          queue.lastBaseUpdate = _lastPendingUpdate;
-          queue.shared.pending = null;
-        }
+      if (transitionComplete !== null && onTransitionComplete != null) {
+        transitionComplete.forEach(function (transition) {
+          return onTransitionComplete(
+            transition.name,
+            transition.startTime,
+            endTime
+          );
+        });
       }
-    } while (true);
-
-    if (newLastBaseUpdate === null) {
-      newBaseState = newState;
     }
+  }
+} // For every tracing marker, store a pointer to it. We will later access it
+// to get the set of suspense boundaries that need to resolve before the
+// tracing marker can be logged as complete
+// This code lives separate from the ReactFiberTransition code because
+// we push and pop on the tracing marker, not the suspense boundary
 
-    queue.baseState = newBaseState;
-    queue.firstBaseUpdate = newFirstBaseUpdate;
-    queue.lastBaseUpdate = newLastBaseUpdate;
+var markerInstanceStack = createCursor(null);
+function pushRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    // On the root, every transition gets mapped to it's own map of
+    // suspense boundaries. The transition is marked as complete when
+    // the suspense boundaries map is empty. We do this because every
+    // transition completes at different times and depends on different
+    // suspense boundaries to complete. We store all the transitions
+    // along with its map of suspense boundaries in the root incomplete
+    // transitions map. Each entry in this map functions like a tracing
+    // marker does, so we can push it onto the marker instance stack
+    var transitions = getWorkInProgressTransitions();
+    var root = workInProgress.stateNode;
 
-    if (firstBaseUpdate === null) {
-      // `queue.lanes` is used for entangling transitions. We can set it back to
-      // zero once the queue is empty.
-      queue.shared.lanes = NoLanes;
-    } // 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.
+    if (transitions !== null) {
+      transitions.forEach(function (transition) {
+        if (!root.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: TransitionRoot,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root.incompleteTransitions.set(transition, markerInstance);
+        }
+      });
+    }
 
-    markSkippedUpdateLanes(newLanes);
-    workInProgress.lanes = newLanes;
-    workInProgress.memoizedState = newState;
-  }
+    var markerInstances = []; // For ever transition on the suspense boundary, we push the transition
+    // along with its map of pending suspense boundaries onto the marker
+    // instance stack.
 
-  {
-    currentlyProcessingQueue = null;
+    root.incompleteTransitions.forEach(function (markerInstance) {
+      markerInstances.push(markerInstance);
+    });
+    push(markerInstanceStack, markerInstances, workInProgress);
   }
 }
-
-function callCallback(callback, context) {
-  if (typeof callback !== "function") {
-    throw new Error(
-      "Invalid argument passed as callback. Expected a function. Instead " +
-        ("received: " + callback)
-    );
+function popRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
   }
-
-  callback.call(context);
-}
-
-function resetHasForceUpdateBeforeProcessing() {
-  hasForceUpdate = false;
 }
-function checkHasForceUpdateAfterProcessing() {
-  return hasForceUpdate;
-}
-function deferHiddenCallbacks(updateQueue) {
-  // When an update finishes on a hidden component, its callback should not
-  // be fired until/unless the component is made visible again. Stash the
-  // callback on the shared queue object so it can be fired later.
-  var newHiddenCallbacks = updateQueue.callbacks;
-
-  if (newHiddenCallbacks !== null) {
-    var existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
-
-    if (existingHiddenCallbacks === null) {
-      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+function pushMarkerInstance(workInProgress, markerInstance) {
+  if (enableTransitionTracing) {
+    if (markerInstanceStack.current === null) {
+      push(markerInstanceStack, [markerInstance], workInProgress);
     } else {
-      updateQueue.shared.hiddenCallbacks =
-        existingHiddenCallbacks.concat(newHiddenCallbacks);
+      push(
+        markerInstanceStack,
+        markerInstanceStack.current.concat(markerInstance),
+        workInProgress
+      );
     }
   }
 }
-function commitHiddenCallbacks(updateQueue, context) {
-  // This component is switching from hidden -> visible. Commit any callbacks
-  // that were previously deferred.
-  var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
-
-  if (hiddenCallbacks !== null) {
-    updateQueue.shared.hiddenCallbacks = null;
-
-    for (var i = 0; i < hiddenCallbacks.length; i++) {
-      var callback = hiddenCallbacks[i];
-      callCallback(callback, context);
-    }
+function popMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
   }
 }
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
-
-  if (callbacks !== null) {
-    updateQueue.callbacks = null;
-
-    for (var i = 0; i < callbacks.length; i++) {
-      var callback = callbacks[i];
-      callCallback(callback, context);
-    }
+function getMarkerInstances() {
+  if (enableTransitionTracing) {
+    return markerInstanceStack.current;
   }
-}
-
-var ReactStrictModeWarnings = {
-  recordUnsafeLifecycleWarnings: function (fiber, instance) {},
-  flushPendingUnsafeLifecycleWarnings: function () {},
-  recordLegacyContextWarning: function (fiber, instance) {},
-  flushLegacyContextWarning: function () {},
-  discardPendingWarnings: function () {}
-};
-
-{
-  var findStrictRoot = function (fiber) {
-    var maybeStrictRoot = null;
-    var node = fiber;
-
-    while (node !== null) {
-      if (node.mode & StrictLegacyMode) {
-        maybeStrictRoot = node;
-      }
 
-      node = node.return;
-    }
-
-    return maybeStrictRoot;
-  };
-
-  var setToSortedString = function (set) {
-    var array = [];
-    set.forEach(function (value) {
-      array.push(value);
-    });
-    return array.sort().join(", ");
-  };
-
-  var pendingComponentWillMountWarnings = [];
-  var pendingUNSAFE_ComponentWillMountWarnings = [];
-  var pendingComponentWillReceivePropsWarnings = [];
-  var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-  var pendingComponentWillUpdateWarnings = [];
-  var pendingUNSAFE_ComponentWillUpdateWarnings = []; // Tracks components we have already warned about.
-
-  var didWarnAboutUnsafeLifecycles = new Set();
-
-  ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (
-    fiber,
-    instance
-  ) {
-    // Dedupe strategy: Warn once per component.
-    if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
-      return;
-    }
+  return null;
+}
 
-    if (
-      typeof instance.componentWillMount === "function" && // Don't warn about react-lifecycles-compat polyfilled components.
-      instance.componentWillMount.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillMountWarnings.push(fiber);
-    }
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillMount === "function"
-    ) {
-      pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
-    }
+var SelectiveHydrationException = new Error(
+  "This is not a real error. It's an implementation detail of React's " +
+    "selective hydration feature. If this leaks into userspace, it's a bug in " +
+    "React. Please file an issue."
+);
+var didReceiveUpdate = false;
+var didWarnAboutBadClass;
+var didWarnAboutModulePatternComponent;
+var didWarnAboutContextTypeOnFunctionComponent;
+var didWarnAboutGetDerivedStateOnFunctionComponent;
+var didWarnAboutFunctionRefs;
+var didWarnAboutReassigningProps;
+var didWarnAboutRevealOrder;
+var didWarnAboutTailOptions;
+var didWarnAboutDefaultPropsOnFunctionComponent;
 
-    if (
-      typeof instance.componentWillReceiveProps === "function" &&
-      instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillReceivePropsWarnings.push(fiber);
-    }
+{
+  didWarnAboutBadClass = {};
+  didWarnAboutModulePatternComponent = {};
+  didWarnAboutContextTypeOnFunctionComponent = {};
+  didWarnAboutGetDerivedStateOnFunctionComponent = {};
+  didWarnAboutFunctionRefs = {};
+  didWarnAboutReassigningProps = false;
+  didWarnAboutRevealOrder = {};
+  didWarnAboutTailOptions = {};
+  didWarnAboutDefaultPropsOnFunctionComponent = {};
+}
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillReceiveProps === "function"
-    ) {
-      pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
-    }
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === 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
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      current.child,
+      nextChildren,
+      renderLanes
+    );
+  }
+}
 
-    if (
-      typeof instance.componentWillUpdate === "function" &&
-      instance.componentWillUpdate.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillUpdateWarnings.push(fiber);
-    }
+function forceUnmountCurrentAndReconcile(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes
+) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(
+    workInProgress,
+    current.child,
+    null,
+    renderLanes
+  ); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillUpdate === "function"
-    ) {
-      pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
-    }
-  };
+  workInProgress.child = reconcileChildFibers(
+    workInProgress,
+    null,
+    nextChildren,
+    renderLanes
+  );
+}
 
-  ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
-    // We do an initial pass to gather component names
-    var componentWillMountUniqueNames = new Set();
+function updateForwardRef(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  // TODO: current can be non-null here even if the component
+  // hasn't yet mounted. This happens after the first render suspends.
+  // We'll need to figure out if this is fine or can cause issues.
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
 
-    if (pendingComponentWillMountWarnings.length > 0) {
-      pendingComponentWillMountWarnings.forEach(function (fiber) {
-        componentWillMountUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
         );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillMountWarnings = [];
+      }
     }
+  }
 
-    var UNSAFE_componentWillMountUniqueNames = new Set();
+  var render = Component.render;
+  var ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
 
-    if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillMountUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillMountWarnings = [];
-    }
+  var nextChildren;
+  var hasId;
+  prepareToReadContext(workInProgress, renderLanes);
 
-    var componentWillReceivePropsUniqueNames = new Set();
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-    if (pendingComponentWillReceivePropsWarnings.length > 0) {
-      pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
-        componentWillReceivePropsUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillReceivePropsWarnings = [];
-    }
+  {
+    ReactCurrentOwner$1.current = workInProgress;
+    setIsRendering(true);
+    nextChildren = renderWithHooks(
+      current,
+      workInProgress,
+      render,
+      nextProps,
+      ref,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
+  }
 
-    var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
 
-    if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillReceivePropsUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-    }
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
 
-    var componentWillUpdateUniqueNames = new Set();
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
 
-    if (pendingComponentWillUpdateWarnings.length > 0) {
-      pendingComponentWillUpdateWarnings.forEach(function (fiber) {
-        componentWillUpdateUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillUpdateWarnings = [];
-    }
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-    var UNSAFE_componentWillUpdateUniqueNames = new Set();
+function updateMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (current === null) {
+    var type = Component.type;
 
-    if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillUpdateUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillUpdateWarnings = [];
-    } // Finally, we flush all the warnings
-    // UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
+    if (
+      isSimpleFunctionComponent(type) &&
+      Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+      Component.defaultProps === undefined
+    ) {
+      var resolvedType = type;
 
-    if (UNSAFE_componentWillMountUniqueNames.size > 0) {
-      var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
+      {
+        resolvedType = resolveFunctionForHotReloading(type);
+      } // If this is a plain function component without default props,
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
 
-      error(
-        "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
-          "\nPlease update the following components: %s",
-        sortedNames
-      );
-    }
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
 
-    if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
-      var _sortedNames = setToSortedString(
-        UNSAFE_componentWillReceivePropsUniqueNames
-      );
+      {
+        validateFunctionComponentInDev(workInProgress, type);
+      }
 
-      error(
-        "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " +
-          "and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* If you're updating state whenever props change, " +
-          "refactor your code to use memoization techniques or move it to " +
-          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        resolvedType,
+        nextProps,
+        renderLanes
       );
     }
 
-    if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
-      var _sortedNames2 = setToSortedString(
-        UNSAFE_componentWillUpdateUniqueNames
-      );
+    {
+      var innerPropTypes = type.propTypes;
 
-      error(
-        "Using UNSAFE_componentWillUpdate in strict mode is not recommended " +
-          "and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames2
-      );
-    }
+      if (innerPropTypes) {
+        // Inner memo component props aren't currently validated in createElement.
+        // We could move it there, but we'd still need this for lazy code path.
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(type)
+        );
+      }
 
-    if (componentWillMountUniqueNames.size > 0) {
-      var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);
+      if (Component.defaultProps !== undefined) {
+        var componentName = getComponentNameFromType(type) || "Unknown";
 
-      warn(
-        "componentWillMount has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
-          "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames3
-      );
+        if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
+          error(
+            "%s: Support for defaultProps will be removed from memo components " +
+              "in a future major release. Use JavaScript default parameters instead.",
+            componentName
+          );
+
+          didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+        }
+      }
     }
 
-    if (componentWillReceivePropsUniqueNames.size > 0) {
-      var _sortedNames4 = setToSortedString(
-        componentWillReceivePropsUniqueNames
-      );
+    var child = createFiberFromTypeAndProps(
+      Component.type,
+      null,
+      nextProps,
+      workInProgress,
+      workInProgress.mode,
+      renderLanes
+    );
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
 
-      warn(
-        "componentWillReceiveProps has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* If you're updating state whenever props change, refactor your " +
-          "code to use memoization techniques or move it to " +
-          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
-          "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames4
+  {
+    var _type = Component.type;
+    var _innerPropTypes = _type.propTypes;
+
+    if (_innerPropTypes) {
+      // Inner memo component props aren't currently validated in createElement.
+      // We could move it there, but we'd still need this for lazy code path.
+      checkPropTypes(
+        _innerPropTypes,
+        nextProps, // Resolved props
+        "prop",
+        getComponentNameFromType(_type)
       );
     }
+  }
 
-    if (componentWillUpdateUniqueNames.size > 0) {
-      var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);
+  var currentChild = current.child; // This is always exactly one child
 
-      warn(
-        "componentWillUpdate has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames5
-      );
+  var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
+    current,
+    renderLanes
+  );
+
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    var prevProps = currentChild.memoizedProps; // Default to shallow comparison
+
+    var compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
+
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
     }
-  };
+  } // React DevTools reads this flag.
 
-  var pendingLegacyContextWarning = new Map(); // Tracks components we have already warned about.
+  workInProgress.flags |= PerformedWork;
+  var newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
 
-  var didWarnAboutLegacyContext = new Set();
+function updateSimpleMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  // TODO: current can be non-null here even if the component
+  // hasn't yet mounted. This happens when the inner render suspends.
+  // We'll need to figure out if this is fine or can cause issues.
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var outerMemoType = workInProgress.elementType;
 
-  ReactStrictModeWarnings.recordLegacyContextWarning = function (
-    fiber,
-    instance
-  ) {
-    var strictRoot = findStrictRoot(fiber);
+      if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
+        // We warn when you define propTypes on lazy()
+        // so let's just skip over it to find memo() outer wrapper.
+        // Inner props for memo are validated later.
+        var lazyComponent = outerMemoType;
+        var payload = lazyComponent._payload;
+        var init = lazyComponent._init;
 
-    if (strictRoot === null) {
-      error(
-        "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."
-      );
+        try {
+          outerMemoType = init(payload);
+        } catch (x) {
+          outerMemoType = null;
+        } // Inner propTypes will be validated in the function component path.
 
-      return;
-    } // Dedup strategy: Warn once per component.
+        var outerPropTypes = outerMemoType && outerMemoType.propTypes;
 
-    if (didWarnAboutLegacyContext.has(fiber.type)) {
-      return;
+        if (outerPropTypes) {
+          checkPropTypes(
+            outerPropTypes,
+            nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
+            "prop",
+            getComponentNameFromType(outerMemoType)
+          );
+        }
+      }
     }
+  }
 
-    var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
+  if (current !== null) {
+    var prevProps = current.memoizedProps;
 
     if (
-      fiber.type.contextTypes != null ||
-      fiber.type.childContextTypes != null ||
-      (instance !== null && typeof instance.getChildContext === "function")
+      shallowEqual(prevProps, nextProps) &&
+      current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
+      workInProgress.type === current.type
     ) {
-      if (warningsForRoot === undefined) {
-        warningsForRoot = [];
-        pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
-      }
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
 
-      warningsForRoot.push(fiber);
-    }
-  };
+      workInProgress.pendingProps = nextProps = prevProps;
 
-  ReactStrictModeWarnings.flushLegacyContextWarning = function () {
-    pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
-      if (fiberArray.length === 0) {
-        return;
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
       }
+    }
+  }
 
-      var firstFiber = fiberArray[0];
-      var uniqueNames = new Set();
-      fiberArray.forEach(function (fiber) {
-        uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
-        didWarnAboutLegacyContext.add(fiber.type);
-      });
-      var sortedNames = setToSortedString(uniqueNames);
+  return updateFunctionComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    renderLanes
+  );
+}
 
-      try {
-        setCurrentFiber(firstFiber);
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  var nextIsDetached =
+    (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  var prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
 
-        error(
-          "Legacy context API has been detected within a strict-mode tree." +
-            "\n\nThe old API will be supported in all 16.x releases, but applications " +
-            "using it should migrate to the new version." +
-            "\n\nPlease update the following components: %s" +
-            "\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context",
-          sortedNames
+  if (
+    nextProps.mode === "hidden" ||
+    nextProps.mode === "unstable-defer-without-hiding" ||
+    nextIsDetached
+  ) {
+    // Rendering a hidden tree.
+    var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      var nextBaseLanes =
+        prevState !== null
+          ? mergeLanes(prevState.baseLanes, renderLanes)
+          : renderLanes;
+
+      if (current !== null) {
+        // Reset to the current children
+        var currentChild = (workInProgress.child = current.child); // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
+
+        var currentChildLanes = NoLanes;
+
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(
+            mergeLanes(currentChildLanes, currentChild.lanes),
+            currentChild.childLanes
+          );
+          currentChild = currentChild.sibling;
+        }
+
+        var lanesWeJustAttempted = nextBaseLanes;
+        var remainingChildLanes = removeLanes(
+          currentChildLanes,
+          lanesWeJustAttempted
         );
-      } finally {
-        resetCurrentFiber();
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
       }
-    });
-  };
-
-  ReactStrictModeWarnings.discardPendingWarnings = function () {
-    pendingComponentWillMountWarnings = [];
-    pendingUNSAFE_ComponentWillMountWarnings = [];
-    pendingComponentWillReceivePropsWarnings = [];
-    pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-    pendingComponentWillUpdateWarnings = [];
-    pendingUNSAFE_ComponentWillUpdateWarnings = [];
-    pendingLegacyContextWarning = new Map();
-  };
-}
 
-var ReactCurrentActQueue$2 = ReactSharedInternals.ReactCurrentActQueue; // An error that is thrown (e.g. by `use`) to trigger Suspense. If we
-// detect this is caught by userspace, we'll log a warning in development.
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        nextBaseLanes,
+        renderLanes
+      );
+    }
 
-var SuspenseException = new Error(
-  "Suspense Exception: This is not a real error! It's an implementation " +
-    "detail of `use` to interrupt the current render. You must either " +
-    "rethrow it immediately, or move the `use` call outside of the " +
-    "`try/catch` block. Capturing without rethrowing will lead to " +
-    "unexpected behavior.\n\n" +
-    "To handle async errors, wrap your component in an error boundary, or " +
-    "call the promise's `.catch` method and pass the result to `use`"
-);
-function createThenableState() {
-  // The ThenableState is created the first time a component suspends. If it
-  // suspends again, we'll reuse the same state.
-  return [];
-}
-function isThenableResolved(thenable) {
-  var status = thenable.status;
-  return status === "fulfilled" || status === "rejected";
-}
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      var nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
 
-function noop() {}
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null, null);
+        }
+      }
 
-function trackUsedThenable(thenableState, thenable, index) {
-  if (ReactCurrentActQueue$2.current !== null) {
-    ReactCurrentActQueue$2.didUsePromise = true;
-  }
+      reuseHiddenContextOnStack(workInProgress);
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes =
+        laneToLanes(OffscreenLane); // Include the base lanes from the last render
 
-  var previous = thenableState[index];
+      var _nextBaseLanes =
+        prevState !== null
+          ? mergeLanes(prevState.baseLanes, renderLanes)
+          : renderLanes;
 
-  if (previous === undefined) {
-    thenableState.push(thenable);
-  } else {
-    if (previous !== thenable) {
-      // Reuse the previous thenable, and drop the new one. We can assume
-      // they represent the same value, because components are idempotent.
-      // Avoid an unhandled rejection errors for the Promises that we'll
-      // intentionally ignore.
-      thenable.then(noop, noop);
-      thenable = previous;
-    }
-  } // We use an expando to track the status and result of a thenable so that we
-  // can synchronously unwrap the value. Think of this as an extension of the
-  // Promise API, or a custom interface that is a superset of Thenable.
-  //
-  // If the thenable doesn't have a status, set it to "pending" and attach
-  // a listener that will update its status and result when it resolves.
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        _nextBaseLanes,
+        renderLanes
+      );
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      var _nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = _nextState;
 
-  switch (thenable.status) {
-    case "fulfilled": {
-      var fulfilledValue = thenable.value;
-      return fulfilledValue;
-    }
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        var prevCachePool = prevState !== null ? prevState.cachePool : null; // TODO: Consider if and how Offscreen pre-rendering should
+        // be attributed to the transition that spawned it
 
-    case "rejected": {
-      var rejectedError = thenable.reason;
-      throw rejectedError;
-    }
+        pushTransition(workInProgress, prevCachePool, null);
+      } // Push the lanes that were skipped when we bailed out.
 
-    default: {
-      if (typeof thenable.status === "string") {
-        // Only instrument the thenable if the status if not defined. If
-        // it's defined, but an unknown value, assume it's been instrumented by
-        // some custom userspace implementation. We treat it as "pending".
-        // Attach a dummy listener, to ensure that any lazy initialization can
-        // happen. Flight lazily parses JSON when the value is actually awaited.
-        thenable.then(noop, noop);
-      } else {
-        var pendingThenable = thenable;
-        pendingThenable.status = "pending";
-        pendingThenable.then(
-          function (fulfilledValue) {
-            if (thenable.status === "pending") {
-              var fulfilledThenable = thenable;
-              fulfilledThenable.status = "fulfilled";
-              fulfilledThenable.value = fulfilledValue;
-            }
-          },
-          function (error) {
-            if (thenable.status === "pending") {
-              var rejectedThenable = thenable;
-              rejectedThenable.status = "rejected";
-              rejectedThenable.reason = error;
-            }
-          }
-        );
-      } // Check one more time in case the thenable resolved synchronously.
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack(workInProgress);
+      }
 
-      switch (thenable.status) {
-        case "fulfilled": {
-          var fulfilledThenable = thenable;
-          return fulfilledThenable.value;
-        }
+      pushOffscreenSuspenseHandler(workInProgress);
+    }
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      var _prevCachePool = null;
 
-        case "rejected": {
-          var rejectedThenable = thenable;
-          throw rejectedThenable.reason;
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        _prevCachePool = prevState.cachePool;
+      }
+
+      var transitions = null;
+
+      if (enableTransitionTracing) {
+        // We have now gone from hidden to visible, so any transitions should
+        // be added to the stack to get added to any Offscreen/suspense children
+        var instance = workInProgress.stateNode;
+
+        if (instance !== null && instance._transitions != null) {
+          transitions = Array.from(instance._transitions);
         }
-      } // Suspend.
-      //
-      // Throwing here is an implementation detail that allows us to unwind the
-      // call stack. But we shouldn't allow it to leak into userspace. Throw an
-      // opaque placeholder value instead of the actual thenable. If it doesn't
-      // get captured by the work loop, log a warning, because that means
-      // something in userspace must have caught it.
+      }
 
-      suspendedThenable = thenable;
+      pushTransition(workInProgress, _prevCachePool, transitions); // Push the lanes that were skipped when we bailed out.
 
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
       {
-        needsToResetSuspendedThenableDEV = true;
-      }
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
 
-      throw SuspenseException;
+      reuseHiddenContextOnStack(workInProgress);
+      reuseSuspenseHandlerOnStack(workInProgress);
     }
   }
-} // This is used to track the actual thenable that suspended so it can be
-// passed to the rest of the Suspense implementation — which, for historical
-// reasons, expects to receive a thenable.
 
-var suspendedThenable = null;
-var needsToResetSuspendedThenableDEV = false;
-function getSuspendedThenable() {
-  // This is called right after `use` suspends by throwing an exception. `use`
-  // throws an opaque value instead of the thenable itself so that it can't be
-  // caught in userspace. Then the work loop accesses the actual thenable using
-  // this function.
-  if (suspendedThenable === null) {
-    throw new Error(
-      "Expected a suspended thenable. This is a bug in React. Please file " +
-        "an issue."
-    );
-  }
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  var thenable = suspendedThenable;
-  suspendedThenable = null;
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
+  var nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache()
+  };
+  workInProgress.memoizedState = nextState;
 
   {
-    needsToResetSuspendedThenableDEV = false;
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
+
+  reuseHiddenContextOnStack(workInProgress);
+  pushOffscreenSuspenseHandler(workInProgress);
+
+  if (enableLazyContextPropagation && current !== null) {
+    // Since this tree will resume rendering in a separate render, we need
+    // to propagate parent contexts now so we don't lose track of which
+    // ones changed.
+    propagateParentContextChangesToDeferredTree(
+      current,
+      workInProgress,
+      renderLanes
+    );
   }
 
-  return thenable;
-}
-function checkIfUseWrappedInTryCatch() {
-  {
-    // This was set right before SuspenseException was thrown, and it should
-    // have been cleared when the exception was handled. If it wasn't,
-    // it must have been caught by userspace.
-    if (needsToResetSuspendedThenableDEV) {
-      needsToResetSuspendedThenableDEV = false;
-      return true;
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+// ourselves to this constraint, though. If the behavior diverges, we should
+// fork the function.
+
+var updateLegacyHiddenComponent = updateOffscreenComponent;
+
+function updateCacheComponent(current, workInProgress, renderLanes) {
+  prepareToReadContext(workInProgress, renderLanes);
+  var parentCache = readContext(CacheContext);
+
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    var freshCache = requestCacheFromPool(renderLanes);
+    var initialState = {
+      parent: parentCache,
+      cache: freshCache
+    };
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
     }
-  }
 
-  return false;
-}
+    var prevState = current.memoizedState;
+    var nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
 
-var thenableState$1 = null;
-var thenableIndexCounter$1 = 0;
-var didWarnAboutMaps;
-var didWarnAboutGenerators;
-var didWarnAboutStringRefs;
-var ownerHasKeyUseWarning;
-var ownerHasFunctionTypeWarning;
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      var derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
 
-var warnForMissingKey = function (child, returnFiber) {};
+      workInProgress.memoizedState = derivedState;
 
-{
-  didWarnAboutMaps = false;
-  didWarnAboutGenerators = false;
-  didWarnAboutStringRefs = {};
-  /**
-   * Warn if there's no key explicitly set on dynamic arrays of children or
-   * object keys are not valid. This allows us to keep track of children between
-   * updates.
-   */
+      if (workInProgress.lanes === NoLanes) {
+        var updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+      }
 
-  ownerHasKeyUseWarning = {};
-  ownerHasFunctionTypeWarning = {};
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      var nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
 
-  warnForMissingKey = function (child, returnFiber) {
-    if (child === null || typeof child !== "object") {
-      return;
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      }
     }
+  }
 
-    if (!child._store || child._store.validated || child.key != null) {
-      return;
-    }
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
 
-    if (typeof child._store !== "object") {
-      throw new Error(
-        "React Component in warnForMissingKey should have a _store. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
-    } // $FlowFixMe unable to narrow type from mixed to writable object
+function updateTracingMarkerComponent(current, workInProgress, renderLanes) {
+  if (!enableTransitionTracing) {
+    return null;
+  } // TODO: (luna) Only update the tracing marker if it's newly rendered or it's name changed.
+  // A tracing marker is only associated with the transitions that rendered
+  // or updated it, so we can create a new set of transitions each time
 
-    child._store.validated = true;
-    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
+  if (current === null) {
+    var currentTransitions = getPendingTransitions();
 
-    if (ownerHasKeyUseWarning[componentName]) {
-      return;
+    if (currentTransitions !== null) {
+      var markerInstance = {
+        tag: TransitionTracingMarker,
+        transitions: new Set(currentTransitions),
+        pendingBoundaries: null,
+        name: workInProgress.pendingProps.name,
+        aborts: null
+      };
+      workInProgress.stateNode = markerInstance; // We call the marker complete callback when all child suspense boundaries resolve.
+      // We do this in the commit phase on Offscreen. If the marker has no child suspense
+      // boundaries, we need to schedule a passive effect to make sure we call the marker
+      // complete callback.
+
+      workInProgress.flags |= Passive$1;
+    }
+  } else {
+    {
+      if (current.memoizedProps.name !== workInProgress.pendingProps.name) {
+        error(
+          "Changing the name of a tracing marker after mount is not supported. " +
+            "To remount the tracing marker, pass it a new key."
+        );
+      }
     }
+  }
 
-    ownerHasKeyUseWarning[componentName] = true;
+  var instance = workInProgress.stateNode;
 
-    error(
-      "Each child in a list should have a unique " +
-        '"key" prop. See https://reactjs.org/link/warning-keys for ' +
-        "more information."
-    );
-  };
+  if (instance !== null) {
+    pushMarkerInstance(workInProgress, instance);
+  }
+
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function isReactClass(type) {
-  return type.prototype && type.prototype.isReactComponent;
+function updateFragment(current, workInProgress, renderLanes) {
+  var nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function unwrapThenable(thenable) {
-  var index = thenableIndexCounter$1;
-  thenableIndexCounter$1 += 1;
+function updateMode(current, workInProgress, renderLanes) {
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  if (thenableState$1 === null) {
-    thenableState$1 = createThenableState();
+function updateProfiler(current, workInProgress, renderLanes) {
+  {
+    workInProgress.flags |= Update;
+
+    {
+      // Reset effect durations for the next eventual effect phase.
+      // These are reset during render to allow the DevTools commit hook a chance to read them,
+      var stateNode = workInProgress.stateNode;
+      stateNode.effectDuration = 0;
+      stateNode.passiveEffectDuration = 0;
+    }
   }
 
-  return trackUsedThenable(thenableState$1, thenable, index);
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function coerceRef(returnFiber, current, element) {
-  var mixedRef = element.ref;
+function markRef$1(current, workInProgress) {
+  var ref = workInProgress.ref;
 
   if (
-    mixedRef !== null &&
-    typeof mixedRef !== "function" &&
-    typeof mixedRef !== "object"
+    (current === null && ref !== null) ||
+    (current !== null && current.ref !== ref)
   ) {
-    {
-      if (
-        // We warn in ReactElement.js if owner and self are equal for string refs
-        // because these cannot be automatically converted to an arrow function
-        // using a codemod. Therefore, we don't have to warn about string refs again.
-        !(
-          element._owner &&
-          element._self &&
-          element._owner.stateNode !== element._self
-        ) && // Will already throw with "Function components cannot have string refs"
-        !(element._owner && element._owner.tag !== ClassComponent) && // Will already warn with "Function components cannot be given refs"
-        !(typeof element.type === "function" && !isReactClass(element.type)) && // Will already throw with "Element ref was specified as a string (someStringRef) but no owner was set"
-        element._owner
-      ) {
-        var componentName =
-          getComponentNameFromFiber(returnFiber) || "Component";
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
 
-        if (!didWarnAboutStringRefs[componentName]) {
-          error(
-            'Component "%s" contains the string ref "%s". Support for string refs ' +
-              "will be removed in a future major release. We recommend using " +
-              "useRef() or createRef() instead. " +
-              "Learn more about using refs safely here: " +
-              "https://reactjs.org/link/strict-mode-string-ref",
-            componentName,
-            mixedRef
-          );
+function updateFunctionComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
 
-          didWarnAboutStringRefs[componentName] = true;
-        }
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
+        );
       }
     }
+  }
 
-    if (element._owner) {
-      var owner = element._owner;
-      var inst;
-
-      if (owner) {
-        var ownerFiber = owner;
-
-        if (ownerFiber.tag !== ClassComponent) {
-          throw new Error(
-            "Function components cannot have string refs. " +
-              "We recommend using useRef() instead. " +
-              "Learn more about using refs safely here: " +
-              "https://reactjs.org/link/strict-mode-string-ref"
-          );
-        }
+  var context;
 
-        inst = ownerFiber.stateNode;
-      }
+  var nextChildren;
+  var hasId;
+  prepareToReadContext(workInProgress, renderLanes);
 
-      if (!inst) {
-        throw new Error(
-          "Missing owner for string ref " +
-            mixedRef +
-            ". This error is likely caused by a " +
-            "bug in React. Please file an issue."
-        );
-      } // Assigning this to a const so Flow knows it won't change in the closure
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-      var resolvedInst = inst;
+  {
+    ReactCurrentOwner$1.current = workInProgress;
+    setIsRendering(true);
+    nextChildren = renderWithHooks(
+      current,
+      workInProgress,
+      Component,
+      nextProps,
+      context,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
+  }
 
-      {
-        checkPropStringCoercion(mixedRef, "ref");
-      }
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
 
-      var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
 
-      if (
-        current !== null &&
-        current.ref !== null &&
-        typeof current.ref === "function" &&
-        current.ref._stringRef === stringRef
-      ) {
-        return current.ref;
-      }
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
 
-      var ref = function (value) {
-        var refs = resolvedInst.refs;
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-        if (value === null) {
-          delete refs[stringRef];
-        } else {
-          refs[stringRef] = value;
-        }
-      };
+function replayFunctionComponent(
+  current,
+  workInProgress,
+  nextProps,
+  Component,
+  renderLanes
+) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  var context;
 
-      ref._stringRef = stringRef;
-      return ref;
-    } else {
-      if (typeof mixedRef !== "string") {
-        throw new Error(
-          "Expected ref to be a function, a string, an object returned by React.createRef(), or null."
-        );
-      }
+  prepareToReadContext(workInProgress, renderLanes);
 
-      if (!element._owner) {
-        throw new Error(
-          "Element ref was specified as a string (" +
-            mixedRef +
-            ") but no owner was set. This could happen for one of" +
-            " the following reasons:\n" +
-            "1. You may be adding a ref to a function component\n" +
-            "2. You may be adding a ref to a component that was not created inside a component's render method\n" +
-            "3. You have multiple copies of React loaded\n" +
-            "See https://reactjs.org/link/refs-must-have-owner for more information."
-        );
-      }
-    }
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
   }
 
-  return mixedRef;
-}
-
-function throwOnInvalidObjectType(returnFiber, newChild) {
-  // $FlowFixMe[method-unbinding]
-  var childString = Object.prototype.toString.call(newChild);
-  throw new Error(
-    "Objects are not valid as a React child (found: " +
-      (childString === "[object Object]"
-        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
-        : childString) +
-      "). " +
-      "If you meant to render a collection of children, use an array " +
-      "instead."
+  var nextChildren = replaySuspendedComponentWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    context
   );
-}
-
-function warnOnFunctionType(returnFiber) {
-  {
-    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
-
-    if (ownerHasFunctionTypeWarning[componentName]) {
-      return;
-    }
+  var hasId = checkDidRenderIdHook();
 
-    ownerHasFunctionTypeWarning[componentName] = true;
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
 
-    error(
-      "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."
-    );
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function resolveLazy(lazyType) {
-  var payload = lazyType._payload;
-  var init = lazyType._init;
-  return init(payload);
-} // This wrapper function exists because I expect to clone the code in each path
-// to be able to optimize each path individually by branching early. This needs
-// a compiler or we can do it manually. Helpers that don't need this branching
-// live outside of this function.
+function updateClassComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  {
+    // This is used by DevTools to force a boundary to error.
+    switch (shouldError(workInProgress)) {
+      case false: {
+        var _instance = workInProgress.stateNode;
+        var ctor = workInProgress.type; // TODO This way of resetting the error boundary state is a hack.
+        // Is there a better way to do this?
 
-function createChildReconciler(shouldTrackSideEffects) {
-  function deleteChild(returnFiber, childToDelete) {
-    if (!shouldTrackSideEffects) {
-      // Noop.
-      return;
-    }
+        var tempInstance = new ctor(
+          workInProgress.memoizedProps,
+          _instance.context
+        );
+        var state = tempInstance.state;
 
-    var deletions = returnFiber.deletions;
+        _instance.updater.enqueueSetState(_instance, state, null);
 
-    if (deletions === null) {
-      returnFiber.deletions = [childToDelete];
-      returnFiber.flags |= ChildDeletion;
-    } else {
-      deletions.push(childToDelete);
-    }
-  }
+        break;
+      }
 
-  function deleteRemainingChildren(returnFiber, currentFirstChild) {
-    if (!shouldTrackSideEffects) {
-      // Noop.
-      return null;
-    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
-    // assuming that after the first child we've already added everything.
+      case true: {
+        workInProgress.flags |= DidCapture;
+        workInProgress.flags |= ShouldCapture; // eslint-disable-next-line react-internal/prod-error-codes
 
-    var childToDelete = currentFirstChild;
+        var error$1 = new Error("Simulated error coming from DevTools");
+        var lane = pickArbitraryLane(renderLanes);
+        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
 
-    while (childToDelete !== null) {
-      deleteChild(returnFiber, childToDelete);
-      childToDelete = childToDelete.sibling;
+        var update = createClassErrorUpdate(
+          workInProgress,
+          createCapturedValueAtFiber(error$1, workInProgress),
+          lane
+        );
+        enqueueCapturedUpdate(workInProgress, update);
+        break;
+      }
     }
 
-    return null;
-  }
-
-  function mapRemainingChildren(returnFiber, currentFirstChild) {
-    // Add the remaining children to a temporary map so that we can find them by
-    // keys quickly. Implicit (null) keys get added to this set with their index
-    // instead.
-    var existingChildren = new Map();
-    var existingChild = currentFirstChild;
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
 
-    while (existingChild !== null) {
-      if (existingChild.key !== null) {
-        existingChildren.set(existingChild.key, existingChild);
-      } else {
-        existingChildren.set(existingChild.index, existingChild);
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
+        );
       }
-
-      existingChild = existingChild.sibling;
     }
+  } // 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.
 
-    return existingChildren;
-  }
+  var hasContext;
 
-  function useFiber(fiber, pendingProps) {
-    // We currently set sibling to null and index to 0 here because it is easy
-    // to forget to do before returning it. E.g. for the single child case.
-    var clone = createWorkInProgress(fiber, pendingProps);
-    clone.index = 0;
-    clone.sibling = null;
-    return clone;
+  if (isContextProvider()) {
+    hasContext = true;
+  } else {
+    hasContext = false;
   }
 
-  function placeChild(newFiber, lastPlacedIndex, newIndex) {
-    newFiber.index = newIndex;
+  prepareToReadContext(workInProgress, renderLanes);
+  var instance = workInProgress.stateNode;
+  var shouldUpdate;
 
-    if (!shouldTrackSideEffects) {
-      // During hydration, the useId algorithm needs to know which fibers are
-      // part of a list of children (arrays, iterators).
-      newFiber.flags |= Forked;
-      return lastPlacedIndex;
-    }
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
 
-    var current = newFiber.alternate;
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(
+      workInProgress,
+      Component,
+      nextProps,
+      renderLanes
+    );
+  } else {
+    shouldUpdate = updateClassInstance(
+      current,
+      workInProgress,
+      Component,
+      nextProps,
+      renderLanes
+    );
+  }
 
-    if (current !== null) {
-      var oldIndex = current.index;
+  var nextUnitOfWork = finishClassComponent(
+    current,
+    workInProgress,
+    Component,
+    shouldUpdate,
+    hasContext,
+    renderLanes
+  );
 
-      if (oldIndex < lastPlacedIndex) {
-        // This is a move.
-        newFiber.flags |= Placement | PlacementDEV;
-        return lastPlacedIndex;
-      } else {
-        // This item can stay in place.
-        return oldIndex;
+  {
+    var inst = workInProgress.stateNode;
+
+    if (shouldUpdate && inst.props !== nextProps) {
+      if (!didWarnAboutReassigningProps) {
+        error(
+          "It looks like %s is reassigning its own `this.props` while rendering. " +
+            "This is not supported and can lead to confusing bugs.",
+          getComponentNameFromFiber(workInProgress) || "a component"
+        );
       }
-    } else {
-      // This is an insertion.
-      newFiber.flags |= Placement | PlacementDEV;
-      return lastPlacedIndex;
+
+      didWarnAboutReassigningProps = true;
     }
   }
 
-  function placeSingleChild(newFiber) {
-    // This is simpler for the single child case. We only need to do a
-    // placement for inserting new children.
-    if (shouldTrackSideEffects && newFiber.alternate === null) {
-      newFiber.flags |= Placement | PlacementDEV;
-    }
+  return nextUnitOfWork;
+}
 
-    return newFiber;
-  }
+function finishClassComponent(
+  current,
+  workInProgress,
+  Component,
+  shouldUpdate,
+  hasContext,
+  renderLanes
+) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  var didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-  function updateTextNode(returnFiber, current, textContent, lanes) {
-    if (current === null || current.tag !== HostText) {
-      // Insert
-      var created = createFiberFromText(textContent, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, textContent);
-      existing.return = returnFiber;
-      return existing;
-    }
+  if (!shouldUpdate && !didCaptureError) {
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
 
-  function updateElement(returnFiber, current, element, lanes) {
-    var elementType = element.type;
+  var instance = workInProgress.stateNode; // Rerender
 
-    if (elementType === REACT_FRAGMENT_TYPE) {
-      return updateFragment(
-        returnFiber,
-        current,
-        element.props.children,
-        lanes,
-        element.key
-      );
+  ReactCurrentOwner$1.current = workInProgress;
+  var nextChildren;
+
+  if (
+    didCaptureError &&
+    typeof Component.getDerivedStateFromError !== "function"
+  ) {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
+
+    {
+      stopProfilerTimerIfRunning();
+    }
+  } else {
+    if (enableSchedulingProfiler) {
+      markComponentRenderStarted(workInProgress);
     }
 
-    if (current !== null) {
-      if (
-        current.elementType === elementType || // Keep this check inline so it only runs on the false path:
-        isCompatibleFamilyForHotReloading(current, element) || // Lazy types should reconcile their resolved type.
-        // We need to do this after the Hot Reloading check above,
-        // because hot reloading has different semantics than prod because
-        // it doesn't resuspend. So we can't let the call below suspend.
-        (typeof elementType === "object" &&
-          elementType !== null &&
-          elementType.$$typeof === REACT_LAZY_TYPE &&
-          resolveLazy(elementType) === current.type)
-      ) {
-        // Move based on index
-        var existing = useFiber(current, element.props);
-        existing.ref = coerceRef(returnFiber, current, element);
-        existing.return = returnFiber;
+    {
+      setIsRendering(true);
+      nextChildren = instance.render();
 
-        {
-          existing._debugSource = element._source;
-          existing._debugOwner = element._owner;
-        }
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
 
-        return existing;
+        try {
+          instance.render();
+        } finally {
+          setIsStrictModeForDevtools(false);
+        }
       }
-    } // Insert
-
-    var created = createFiberFromElement(element, returnFiber.mode, lanes);
-    created.ref = coerceRef(returnFiber, current, element);
-    created.return = returnFiber;
-    return created;
-  }
 
-  function updatePortal(returnFiber, current, portal, lanes) {
-    if (
-      current === null ||
-      current.tag !== HostPortal ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
-    ) {
-      // Insert
-      var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, portal.children || []);
-      existing.return = returnFiber;
-      return existing;
+      setIsRendering(false);
     }
-  }
 
-  function updateFragment(returnFiber, current, fragment, lanes, key) {
-    if (current === null || current.tag !== Fragment) {
-      // Insert
-      var created = createFiberFromFragment(
-        fragment,
-        returnFiber.mode,
-        lanes,
-        key
-      );
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, fragment);
-      existing.return = returnFiber;
-      return existing;
+    if (enableSchedulingProfiler) {
+      markComponentRenderStopped();
     }
-  }
+  } // React DevTools reads this flag.
 
-  function createChild(returnFiber, newChild, lanes) {
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys. If the previous node is implicitly keyed
-      // we can continue to replace it without aborting even if it is not a text
-      // node.
-      var created = createFiberFromText("" + newChild, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    }
+  workInProgress.flags |= PerformedWork;
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          var _created = createFiberFromElement(
-            newChild,
-            returnFiber.mode,
-            lanes
-          );
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(
+      current,
+      workInProgress,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
 
-          _created.ref = coerceRef(returnFiber, null, newChild);
-          _created.return = returnFiber;
-          return _created;
-        }
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
 
-        case REACT_PORTAL_TYPE: {
-          var _created2 = createFiberFromPortal(
-            newChild,
-            returnFiber.mode,
-            lanes
-          );
+  return workInProgress.child;
+}
 
-          _created2.return = returnFiber;
-          return _created2;
-        }
+function pushHostRootContext(workInProgress) {
+  var root = workInProgress.stateNode;
 
-        case REACT_LAZY_TYPE: {
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return createChild(returnFiber, init(payload), lanes);
-        }
-      }
+  pushHostContainer(workInProgress, root.containerInfo);
+}
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        var _created3 = createFiberFromFragment(
-          newChild,
-          returnFiber.mode,
-          lanes,
-          null
-        );
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
 
-        _created3.return = returnFiber;
-        return _created3;
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
+  if (current === null) {
+    throw new Error("Should have a current fiber. This is a bug in React.");
+  }
 
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return createChild(returnFiber, unwrapThenable(thenable), lanes);
-      }
+  var nextProps = workInProgress.pendingProps;
+  var prevState = workInProgress.memoizedState;
+  var prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  var nextState = workInProgress.memoizedState;
+  var root = workInProgress.stateNode;
+  pushRootTransition(workInProgress);
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return createChild(
-          returnFiber,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+  if (enableTransitionTracing) {
+    pushRootMarkerInstance(workInProgress);
+  }
 
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
+  {
+    var nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
     }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-    return null;
-  }
+  var nextChildren = nextState.element;
 
-  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
-    // Update the fiber if the keys match, otherwise return null.
-    var key = oldFiber !== null ? oldFiber.key : null;
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    var overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    var updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
 
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys. If the previous node is implicitly keyed
-      // we can continue to replace it without aborting even if it is not a text
-      // node.
-      if (key !== null) {
-        return null;
-      }
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
+
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      var recoverableError = createCapturedValueAtFiber(
+        new Error(
+          "There was an error while hydrating. Because the error happened outside " +
+            "of a Suspense boundary, the entire root will switch to " +
+            "client rendering."
+        ),
+        workInProgress
+      );
+      return mountHostRootWithoutHydrating(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes,
+        recoverableError
+      );
+    } else if (nextChildren !== prevChildren) {
+      var _recoverableError = createCapturedValueAtFiber(
+        new Error(
+          "This root received an early update, before anything was able " +
+            "hydrate. Switched the entire root to client rendering."
+        ),
+        workInProgress
+      );
 
-      return updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
-    }
+      return mountHostRootWithoutHydrating(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes,
+        _recoverableError
+      );
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          if (newChild.key === key) {
-            return updateElement(returnFiber, oldFiber, newChild, lanes);
-          } else {
-            return null;
-          }
-        }
+      {
+        var mutableSourceEagerHydrationData =
+          root.mutableSourceEagerHydrationData;
 
-        case REACT_PORTAL_TYPE: {
-          if (newChild.key === key) {
-            return updatePortal(returnFiber, oldFiber, newChild, lanes);
-          } else {
-            return null;
+        if (mutableSourceEagerHydrationData != null) {
+          for (var i = 0; i < mutableSourceEagerHydrationData.length; i += 2) {
+            var mutableSource = mutableSourceEagerHydrationData[i];
+            var version = mutableSourceEagerHydrationData[i + 1];
+            setWorkInProgressVersion(mutableSource, version);
           }
         }
-
-        case REACT_LAZY_TYPE: {
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return updateSlot(returnFiber, oldFiber, init(payload), lanes);
-        }
       }
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        if (key !== null) {
-          return null;
-        }
-
-        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
-
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+      var child = mountChildFibers(
+        workInProgress,
+        null,
+        nextChildren,
+        renderLanes
+      );
+      workInProgress.child = child;
+      var node = child;
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = (node.flags & ~Placement) | Hydrating;
+        node = node.sibling;
       }
-
-      throwOnInvalidObjectType(returnFiber, newChild);
     }
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
     }
 
-    return null;
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
   }
 
-  function updateFromMap(
-    existingChildren,
-    returnFiber,
-    newIdx,
-    newChild,
-    lanes
-  ) {
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys, so we neither have to check the old nor
-      // new node for the key. If both are text nodes, they match.
-      var matchedFiber = existingChildren.get(newIdx) || null;
-      return updateTextNode(returnFiber, matchedFiber, "" + newChild, lanes);
-    }
-
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          var _matchedFiber =
-            existingChildren.get(
-              newChild.key === null ? newIdx : newChild.key
-            ) || null;
-
-          return updateElement(returnFiber, _matchedFiber, newChild, lanes);
-        }
+  return workInProgress.child;
+}
 
-        case REACT_PORTAL_TYPE: {
-          var _matchedFiber2 =
-            existingChildren.get(
-              newChild.key === null ? newIdx : newChild.key
-            ) || null;
+function mountHostRootWithoutHydrating(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes,
+  recoverableError
+) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-          return updatePortal(returnFiber, _matchedFiber2, newChild, lanes);
-        }
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
 
-        case REACT_LAZY_TYPE:
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return updateFromMap(
-            existingChildren,
-            returnFiber,
-            newIdx,
-            init(payload),
-            lanes
-          );
-      }
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        var _matchedFiber3 = existingChildren.get(newIdx) || null;
+  var type = workInProgress.type;
+  var nextProps = workInProgress.pendingProps;
+  var prevProps = current !== null ? current.memoizedProps : null;
+  var nextChildren = nextProps.children;
+  var isDirectTextChild = shouldSetTextContent(type, nextProps);
 
-        return updateFragment(
-          returnFiber,
-          _matchedFiber3,
-          newChild,
-          lanes,
-          null
-        );
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } 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.flags |= ContentReset;
+  }
 
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  var currentProps = current === null ? null : current.memoizedProps;
+  var resource = (workInProgress.memoizedState = getResource(
+    workInProgress.type,
+    currentProps,
+    workInProgress.pendingProps
+  ));
 
-      throwOnInvalidObjectType(returnFiber, newChild);
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(
+        workInProgress.type,
+        workInProgress.pendingProps,
+        getRootHostContainer(),
+        workInProgress
+      );
     }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
-    }
+  return null;
+}
 
-    return null;
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
   }
-  /**
-   * Warns if there is a duplicate or missing key
-   */
 
-  function warnOnInvalidKey(child, knownKeys, returnFiber) {
-    {
-      if (typeof child !== "object" || child === null) {
-        return knownKeys;
-      }
+  var nextChildren = workInProgress.pendingProps.children;
 
-      switch (child.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-        case REACT_PORTAL_TYPE:
-          warnForMissingKey(child, returnFiber);
-          var key = child.key;
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
 
-          if (typeof key !== "string") {
-            break;
-          }
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
 
-          if (knownKeys === null) {
-            knownKeys = new Set();
-            knownKeys.add(key);
-            break;
-          }
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
 
-          if (!knownKeys.has(key)) {
-            knownKeys.add(key);
-            break;
-          }
+  return null;
+}
 
-          error(
-            "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.",
-            key
-          );
+function mountLazyComponent(
+  _current,
+  workInProgress,
+  elementType,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  var props = workInProgress.pendingProps;
+  var lazyComponent = elementType;
+  var payload = lazyComponent._payload;
+  var init = lazyComponent._init;
+  var Component = init(payload); // Store the unwrapped component in the type.
 
-          break;
+  workInProgress.type = Component;
+  var resolvedTag = (workInProgress.tag = resolveLazyComponentTag(Component));
+  var resolvedProps = resolveDefaultProps(Component, props);
+  var child;
 
-        case REACT_LAZY_TYPE:
-          var payload = child._payload;
-          var init = child._init;
-          warnOnInvalidKey(init(payload), knownKeys, returnFiber);
-          break;
+  switch (resolvedTag) {
+    case FunctionComponent: {
+      {
+        validateFunctionComponentInDev(workInProgress, Component);
+        workInProgress.type = Component =
+          resolveFunctionForHotReloading(Component);
       }
-    }
 
-    return knownKeys;
-  }
-
-  function reconcileChildrenArray(
-    returnFiber,
-    currentFirstChild,
-    newChildren,
-    lanes
-  ) {
-    // This algorithm can't optimize by searching from both ends since we
-    // don't have backpointers on fibers. I'm trying to see how far we can get
-    // with that model. If it ends up not being worth the tradeoffs, we can
-    // add it later.
-    // Even with a two ended optimization, we'd want to optimize for the case
-    // where there are few changes and brute force the comparison instead of
-    // going for the Map. It'd like to explore hitting that path first in
-    // forward-only mode and only go for the Map once we notice that we need
-    // lots of look ahead. This doesn't handle reversal as well as two ended
-    // search but that's unusual. Besides, for the two ended optimization to
-    // work on Iterables, we'd need to copy the whole set.
-    // In this first iteration, we'll just live with hitting the bad case
-    // (adding everything to a Map) in for every insert/move.
-    // If you change this code, also update reconcileChildrenIterator() which
-    // uses the same algorithm.
-    {
-      // First, validate keys.
-      var knownKeys = null;
+      child = updateFunctionComponent(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
+    }
 
-      for (var i = 0; i < newChildren.length; i++) {
-        var child = newChildren[i];
-        knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+    case ClassComponent: {
+      {
+        workInProgress.type = Component =
+          resolveClassForHotReloading(Component);
       }
-    }
 
-    var resultingFirstChild = null;
-    var previousNewFiber = null;
-    var oldFiber = currentFirstChild;
-    var lastPlacedIndex = 0;
-    var newIdx = 0;
-    var nextOldFiber = null;
+      child = updateClassComponent(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
+    }
 
-    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
-      if (oldFiber.index > newIdx) {
-        nextOldFiber = oldFiber;
-        oldFiber = null;
-      } else {
-        nextOldFiber = oldFiber.sibling;
+    case ForwardRef: {
+      {
+        workInProgress.type = Component =
+          resolveForwardRefForHotReloading(Component);
       }
 
-      var newFiber = updateSlot(
-        returnFiber,
-        oldFiber,
-        newChildren[newIdx],
-        lanes
+      child = updateForwardRef(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
       );
+      return child;
+    }
 
-      if (newFiber === null) {
-        // TODO: This breaks on empty slots like null children. That's
-        // unfortunate because it triggers the slow path all the time. We need
-        // a better way to communicate whether this was a miss or null,
-        // boolean, undefined, etc.
-        if (oldFiber === null) {
-          oldFiber = nextOldFiber;
-        }
-
-        break;
-      }
+    case MemoComponent: {
+      {
+        if (workInProgress.type !== workInProgress.elementType) {
+          var outerPropTypes = Component.propTypes;
 
-      if (shouldTrackSideEffects) {
-        if (oldFiber && newFiber.alternate === null) {
-          // We matched the slot, but we didn't reuse the existing fiber, so we
-          // need to delete the existing child.
-          deleteChild(returnFiber, oldFiber);
+          if (outerPropTypes) {
+            checkPropTypes(
+              outerPropTypes,
+              resolvedProps, // Resolved for outer only
+              "prop",
+              getComponentNameFromType(Component)
+            );
+          }
         }
       }
 
-      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+      child = updateMemoComponent(
+        null,
+        workInProgress,
+        Component,
+        resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes
+      );
+      return child;
+    }
+  }
 
-      if (previousNewFiber === null) {
-        // TODO: Move out of the loop. This only happens for the first run.
-        resultingFirstChild = newFiber;
-      } else {
-        // TODO: Defer siblings if we're not at the right index for this slot.
-        // I.e. if we had null values before, then we want to defer this
-        // for each null value. However, we also don't want to call updateSlot
-        // with the previous one.
-        previousNewFiber.sibling = newFiber;
-      }
+  var hint = "";
 
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
+  {
+    if (
+      Component !== null &&
+      typeof Component === "object" &&
+      Component.$$typeof === REACT_LAZY_TYPE
+    ) {
+      hint = " Did you wrap a component in React.lazy() more than once?";
     }
+  } // This message intentionally doesn't mention ForwardRef or MemoComponent
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
+
+  throw new Error(
+    "Element type is invalid. Received a promise that resolves to: " +
+      Component +
+      ". " +
+      ("Lazy element type must resolve to a class or function." + hint)
+  );
+}
+
+function mountIncompleteClassComponent(
+  _current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // 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.
 
-    if (newIdx === newChildren.length) {
-      // We've reached the end of the new children. We can delete the rest.
-      deleteRemainingChildren(returnFiber, oldFiber);
+  var hasContext;
 
-      if (getIsHydrating()) {
-        var numberOfForks = newIdx;
-        pushTreeFork(returnFiber, numberOfForks);
-      }
+  if (isContextProvider()) {
+    hasContext = true;
+  } else {
+    hasContext = false;
+  }
 
-      return resultingFirstChild;
-    }
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(
+    null,
+    workInProgress,
+    Component,
+    true,
+    hasContext,
+    renderLanes
+  );
+}
 
-    if (oldFiber === null) {
-      // If we don't have any more existing children we can choose a fast path
-      // since the rest will all be insertions.
-      for (; newIdx < newChildren.length; newIdx++) {
-        var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+function mountIndeterminateComponent(
+  _current,
+  workInProgress,
+  Component,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  var props = workInProgress.pendingProps;
+  var context;
 
-        if (_newFiber === null) {
-          continue;
-        }
+  prepareToReadContext(workInProgress, renderLanes);
+  var value;
+  var hasId;
 
-        lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-        if (previousNewFiber === null) {
-          // TODO: Move out of the loop. This only happens for the first run.
-          resultingFirstChild = _newFiber;
-        } else {
-          previousNewFiber.sibling = _newFiber;
-        }
+  {
+    if (
+      Component.prototype &&
+      typeof Component.prototype.render === "function"
+    ) {
+      var componentName = getComponentNameFromType(Component) || "Unknown";
 
-        previousNewFiber = _newFiber;
-      }
+      if (!didWarnAboutBadClass[componentName]) {
+        error(
+          "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
+            "This is likely to cause errors. Change %s to extend React.Component instead.",
+          componentName,
+          componentName
+        );
 
-      if (getIsHydrating()) {
-        var _numberOfForks = newIdx;
-        pushTreeFork(returnFiber, _numberOfForks);
+        didWarnAboutBadClass[componentName] = true;
       }
+    }
 
-      return resultingFirstChild;
-    } // Add all children to a key map for quick lookups.
+    if (workInProgress.mode & StrictLegacyMode) {
+      ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+    }
 
-    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+    setIsRendering(true);
+    ReactCurrentOwner$1.current = workInProgress;
+    value = renderWithHooks(
+      null,
+      workInProgress,
+      Component,
+      props,
+      context,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
+  }
 
-    for (; newIdx < newChildren.length; newIdx++) {
-      var _newFiber2 = updateFromMap(
-        existingChildren,
-        returnFiber,
-        newIdx,
-        newChildren[newIdx],
-        lanes
-      );
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
 
-      if (_newFiber2 !== null) {
-        if (shouldTrackSideEffects) {
-          if (_newFiber2.alternate !== null) {
-            // The new fiber is a work in progress, but if there exists a
-            // current, that means that we reused the fiber. We need to delete
-            // it from the child list so that we don't add it to the deletion
-            // list.
-            existingChildren.delete(
-              _newFiber2.key === null ? newIdx : _newFiber2.key
-            );
-          }
-        }
+  workInProgress.flags |= PerformedWork;
 
-        lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);
+  {
+    // Support for module components is deprecated and is removed behind a flag.
+    // Whether or not it would crash later, we want to show a good message in DEV first.
+    if (
+      typeof value === "object" &&
+      value !== null &&
+      typeof value.render === "function" &&
+      value.$$typeof === undefined
+    ) {
+      var _componentName = getComponentNameFromType(Component) || "Unknown";
 
-        if (previousNewFiber === null) {
-          resultingFirstChild = _newFiber2;
-        } else {
-          previousNewFiber.sibling = _newFiber2;
-        }
+      if (!didWarnAboutModulePatternComponent[_componentName]) {
+        error(
+          "The <%s /> component appears to be a function component that returns a class instance. " +
+            "Change %s to a class that extends React.Component instead. " +
+            "If you can't use a class try assigning the prototype on the function as a workaround. " +
+            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
+            "cannot be called with `new` by React.",
+          _componentName,
+          _componentName,
+          _componentName
+        );
 
-        previousNewFiber = _newFiber2;
+        didWarnAboutModulePatternComponent[_componentName] = true;
       }
     }
+  }
 
-    if (shouldTrackSideEffects) {
-      // Any existing children that weren't consumed above were deleted. We need
-      // to add them to the deletion list.
-      existingChildren.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    }
+  {
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
 
-    if (getIsHydrating()) {
-      var _numberOfForks2 = newIdx;
-      pushTreeFork(returnFiber, _numberOfForks2);
+    {
+      if (Component.contextTypes) {
+        error(
+          "%s uses the legacy contextTypes API which is no longer supported. " +
+            "Use React.createContext() with React.useContext() instead.",
+          getComponentNameFromType(Component) || "Unknown"
+        );
+      }
     }
 
-    return resultingFirstChild;
-  }
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
+    }
 
-  function reconcileChildrenIterator(
-    returnFiber,
-    currentFirstChild,
-    newChildrenIterable,
-    lanes
-  ) {
-    // This is the same implementation as reconcileChildrenArray(),
-    // but using the iterator instead.
-    var iteratorFn = getIteratorFn(newChildrenIterable);
+    reconcileChildren(null, workInProgress, value, renderLanes);
 
-    if (typeof iteratorFn !== "function") {
-      throw new Error(
-        "An object is not an iterable. This error is likely caused by a bug in " +
-          "React. Please file an issue."
-      );
+    {
+      validateFunctionComponentInDev(workInProgress, Component);
     }
 
-    {
-      // We don't support rendering Generators because it's a mutation.
-      // See https://github.com/facebook/react/issues/12995
-      if (
-        typeof Symbol === "function" && // $FlowFixMe Flow doesn't know about toStringTag
-        newChildrenIterable[Symbol.toStringTag] === "Generator"
-      ) {
-        if (!didWarnAboutGenerators) {
-          error(
-            "Using Generators as children is unsupported and will likely yield " +
-              "unexpected results because enumerating a generator mutates it. " +
-              "You may convert it to an array with `Array.from()` or the " +
-              "`[...spread]` operator before rendering. Keep in mind " +
-              "you might need to polyfill these features for older browsers."
-          );
-        }
+    return workInProgress.child;
+  }
+}
 
-        didWarnAboutGenerators = true;
-      } // Warn about using Maps as children
+function validateFunctionComponentInDev(workInProgress, Component) {
+  {
+    if (Component) {
+      if (Component.childContextTypes) {
+        error(
+          "%s(...): childContextTypes cannot be defined on a function component.",
+          Component.displayName || Component.name || "Component"
+        );
+      }
+    }
 
-      if (newChildrenIterable.entries === iteratorFn) {
-        if (!didWarnAboutMaps) {
-          error(
-            "Using Maps as children is not supported. " +
-              "Use an array of keyed ReactElements instead."
-          );
-        }
+    if (workInProgress.ref !== null) {
+      var info = "";
+      var ownerName = getCurrentFiberOwnerNameInDevOrNull();
 
-        didWarnAboutMaps = true;
-      } // First, validate keys.
-      // We'll get a different iterator later for the main pass.
+      if (ownerName) {
+        info += "\n\nCheck the render method of `" + ownerName + "`.";
+      }
 
-      var _newChildren = iteratorFn.call(newChildrenIterable);
+      var warningKey = ownerName || "";
+      var debugSource = workInProgress._debugSource;
 
-      if (_newChildren) {
-        var knownKeys = null;
+      if (debugSource) {
+        warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
+      }
 
-        var _step = _newChildren.next();
+      if (!didWarnAboutFunctionRefs[warningKey]) {
+        didWarnAboutFunctionRefs[warningKey] = true;
 
-        for (; !_step.done; _step = _newChildren.next()) {
-          var child = _step.value;
-          knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
-        }
+        error(
+          "Function components cannot be given refs. " +
+            "Attempts to access this ref will fail. " +
+            "Did you mean to use React.forwardRef()?%s",
+          info
+        );
       }
     }
 
-    var newChildren = iteratorFn.call(newChildrenIterable);
-
-    if (newChildren == null) {
-      throw new Error("An iterable object provided no iterator.");
-    }
+    if (Component.defaultProps !== undefined) {
+      var componentName = getComponentNameFromType(Component) || "Unknown";
 
-    var resultingFirstChild = null;
-    var previousNewFiber = null;
-    var oldFiber = currentFirstChild;
-    var lastPlacedIndex = 0;
-    var newIdx = 0;
-    var nextOldFiber = null;
-    var step = newChildren.next();
+      if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
+        error(
+          "%s: Support for defaultProps will be removed from function components " +
+            "in a future major release. Use JavaScript default parameters instead.",
+          componentName
+        );
 
-    for (
-      ;
-      oldFiber !== null && !step.done;
-      newIdx++, step = newChildren.next()
-    ) {
-      if (oldFiber.index > newIdx) {
-        nextOldFiber = oldFiber;
-        oldFiber = null;
-      } else {
-        nextOldFiber = oldFiber.sibling;
+        didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
       }
+    }
 
-      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+    if (typeof Component.getDerivedStateFromProps === "function") {
+      var _componentName3 = getComponentNameFromType(Component) || "Unknown";
 
-      if (newFiber === null) {
-        // TODO: This breaks on empty slots like null children. That's
-        // unfortunate because it triggers the slow path all the time. We need
-        // a better way to communicate whether this was a miss or null,
-        // boolean, undefined, etc.
-        if (oldFiber === null) {
-          oldFiber = nextOldFiber;
-        }
+      if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
+        error(
+          "%s: Function components do not support getDerivedStateFromProps.",
+          _componentName3
+        );
 
-        break;
+        didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
       }
+    }
 
-      if (shouldTrackSideEffects) {
-        if (oldFiber && newFiber.alternate === null) {
-          // We matched the slot, but we didn't reuse the existing fiber, so we
-          // need to delete the existing child.
-          deleteChild(returnFiber, oldFiber);
-        }
-      }
+    if (
+      typeof Component.contextType === "object" &&
+      Component.contextType !== null
+    ) {
+      var _componentName4 = getComponentNameFromType(Component) || "Unknown";
 
-      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+      if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
+        error(
+          "%s: Function components do not support contextType.",
+          _componentName4
+        );
 
-      if (previousNewFiber === null) {
-        // TODO: Move out of the loop. This only happens for the first run.
-        resultingFirstChild = newFiber;
-      } else {
-        // TODO: Defer siblings if we're not at the right index for this slot.
-        // I.e. if we had null values before, then we want to defer this
-        // for each null value. However, we also don't want to call updateSlot
-        // with the previous one.
-        previousNewFiber.sibling = newFiber;
+        didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
       }
-
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
     }
+  }
+}
 
-    if (step.done) {
-      // We've reached the end of the new children. We can delete the rest.
-      deleteRemainingChildren(returnFiber, oldFiber);
+var SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
 
-      if (getIsHydrating()) {
-        var numberOfForks = newIdx;
-        pushTreeFork(returnFiber, numberOfForks);
-      }
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
 
-      return resultingFirstChild;
-    }
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  var cachePool = null;
 
-    if (oldFiber === null) {
-      // If we don't have any more existing children we can choose a fast path
-      // since the rest will all be insertions.
-      for (; !step.done; newIdx++, step = newChildren.next()) {
-        var _newFiber3 = createChild(returnFiber, step.value, lanes);
+  {
+    var prevCachePool = prevOffscreenState.cachePool;
 
-        if (_newFiber3 === null) {
-          continue;
-        }
+    if (prevCachePool !== null) {
+      var parentCache = CacheContext._currentValue;
 
-        lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
+      }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
+    }
+  }
 
-        if (previousNewFiber === null) {
-          // TODO: Move out of the loop. This only happens for the first run.
-          resultingFirstChild = _newFiber3;
-        } else {
-          previousNewFiber.sibling = _newFiber3;
-        }
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool: cachePool
+  };
+} // TODO: Probably should inline this back
 
-        previousNewFiber = _newFiber3;
-      }
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  if (current !== null) {
+    var suspenseState = current.memoizedState;
 
-      if (getIsHydrating()) {
-        var _numberOfForks3 = newIdx;
-        pushTreeFork(returnFiber, _numberOfForks3);
-      }
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
+    }
+  } // Not currently showing content. Consult the Suspense context.
 
-      return resultingFirstChild;
-    } // Add all children to a key map for quick lookups.
+  var suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+}
 
-    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
+}
 
-    for (; !step.done; newIdx++, step = newChildren.next()) {
-      var _newFiber4 = updateFromMap(
-        existingChildren,
-        returnFiber,
-        newIdx,
-        step.value,
-        lanes
-      );
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
 
-      if (_newFiber4 !== null) {
-        if (shouldTrackSideEffects) {
-          if (_newFiber4.alternate !== null) {
-            // The new fiber is a work in progress, but if there exists a
-            // current, that means that we reused the fiber. We need to delete
-            // it from the child list so that we don't add it to the deletion
-            // list.
-            existingChildren.delete(
-              _newFiber4.key === null ? newIdx : _newFiber4.key
-            );
-          }
-        }
+  {
+    if (shouldSuspend(workInProgress)) {
+      workInProgress.flags |= DidCapture;
+    }
+  }
 
-        lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);
+  var showFallback = false;
+  var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-        if (previousNewFiber === null) {
-          resultingFirstChild = _newFiber4;
-        } else {
-          previousNewFiber.sibling = _newFiber4;
-        }
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
 
-        previousNewFiber = _newFiber4;
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
       }
-    }
 
-    if (shouldTrackSideEffects) {
-      // Any existing children that weren't consumed above were deleted. We need
-      // to add them to the deletion list.
-      existingChildren.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    }
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
 
-    if (getIsHydrating()) {
-      var _numberOfForks4 = newIdx;
-      pushTreeFork(returnFiber, _numberOfForks4);
-    }
+      var suspenseState = workInProgress.memoizedState;
 
-    return resultingFirstChild;
-  }
+      if (suspenseState !== null) {
+        var dehydrated = suspenseState.dehydrated;
 
-  function reconcileSingleTextNode(
-    returnFiber,
-    currentFirstChild,
-    textContent,
-    lanes
-  ) {
-    // There's no need to check for keys on text nodes since we don't have a
-    // way to define them.
-    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
-      // We already have an existing node so let's just update it and delete
-      // the rest.
-      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
-      var existing = useFiber(currentFirstChild, textContent);
-      existing.return = returnFiber;
-      return existing;
-    } // The existing first child is not a text node so we need to create one
-    // and delete the existing ones.
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
 
-    deleteRemainingChildren(returnFiber, currentFirstChild);
-    var created = createFiberFromText(textContent, returnFiber.mode, lanes);
-    created.return = returnFiber;
-    return created;
-  }
+      popSuspenseHandler(workInProgress);
+    }
 
-  function reconcileSingleElement(
-    returnFiber,
-    currentFirstChild,
-    element,
-    lanes
-  ) {
-    var key = element.key;
-    var child = currentFirstChild;
+    var nextPrimaryChildren = nextProps.children;
+    var nextFallbackChildren = nextProps.fallback;
 
-    while (child !== null) {
-      // TODO: If key === null and child.key === null, then this only applies to
-      // the first item in the list.
-      if (child.key === key) {
-        var elementType = element.type;
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var fallbackFragment = mountSuspenseFallbackChildren(
+        workInProgress,
+        nextPrimaryChildren,
+        nextFallbackChildren,
+        renderLanes
+      );
+      var primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
 
-        if (elementType === REACT_FRAGMENT_TYPE) {
-          if (child.tag === Fragment) {
-            deleteRemainingChildren(returnFiber, child.sibling);
-            var existing = useFiber(child, element.props.children);
-            existing.return = returnFiber;
+      if (enableTransitionTracing) {
+        var currentTransitions = getPendingTransitions();
 
-            {
-              existing._debugSource = element._source;
-              existing._debugOwner = element._owner;
-            }
+        if (currentTransitions !== null) {
+          var parentMarkerInstances = getMarkerInstances();
+          var offscreenQueue = primaryChildFragment.updateQueue;
 
-            return existing;
+          if (offscreenQueue === null) {
+            var newOffscreenQueue = {
+              transitions: currentTransitions,
+              markerInstances: parentMarkerInstances,
+              wakeables: null
+            };
+            primaryChildFragment.updateQueue = newOffscreenQueue;
+          } else {
+            offscreenQueue.transitions = currentTransitions;
+            offscreenQueue.markerInstances = parentMarkerInstances;
           }
-        } else {
-          if (
-            child.elementType === elementType || // Keep this check inline so it only runs on the false path:
-            isCompatibleFamilyForHotReloading(child, element) || // Lazy types should reconcile their resolved type.
-            // We need to do this after the Hot Reloading check above,
-            // because hot reloading has different semantics than prod because
-            // it doesn't resuspend. So we can't let the call below suspend.
-            (typeof elementType === "object" &&
-              elementType !== null &&
-              elementType.$$typeof === REACT_LAZY_TYPE &&
-              resolveLazy(elementType) === child.type)
-          ) {
-            deleteRemainingChildren(returnFiber, child.sibling);
+        }
+      }
 
-            var _existing = useFiber(child, element.props);
+      return fallbackFragment;
+    } else if (typeof nextProps.unstable_expectedLoadTime === "number") {
+      // This is a CPU-bound tree. Skip this tree and show a placeholder to
+      // unblock the surrounding content. Then immediately retry after the
+      // initial commit.
+      pushFallbackTreeSuspenseHandler(workInProgress);
 
-            _existing.ref = coerceRef(returnFiber, child, element);
-            _existing.return = returnFiber;
+      var _fallbackFragment = mountSuspenseFallbackChildren(
+        workInProgress,
+        nextPrimaryChildren,
+        nextFallbackChildren,
+        renderLanes
+      );
 
-            {
-              _existing._debugSource = element._source;
-              _existing._debugOwner = element._owner;
-            }
+      var _primaryChildFragment = workInProgress.child;
+      _primaryChildFragment.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
+      // Since nothing actually suspended, there will nothing to ping this to
+      // get it started back up to attempt the next item. While in terms of
+      // priority this work has the same priority as this current render, it's
+      // not part of the same transition once the transition has committed. If
+      // it's sync, we still want to yield so that it can be painted.
+      // Conceptually, this is really the same as pinging. We can use any
+      // RetryLane even if it's the one currently rendering since we're leaving
+      // it behind on this node.
 
-            return _existing;
-          }
-        } // Didn't match.
+      workInProgress.lanes = SomeRetryLane;
+      return _fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    var prevState = current.memoizedState;
 
-        deleteRemainingChildren(returnFiber, child);
-        break;
-      } else {
-        deleteChild(returnFiber, child);
-      }
+    if (prevState !== null) {
+      var _dehydrated = prevState.dehydrated;
 
-      child = child.sibling;
+      if (_dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(
+          current,
+          workInProgress,
+          didSuspend,
+          nextProps,
+          _dehydrated,
+          prevState,
+          renderLanes
+        );
+      }
     }
 
-    if (element.type === REACT_FRAGMENT_TYPE) {
-      var created = createFiberFromFragment(
-        element.props.children,
-        returnFiber.mode,
-        lanes,
-        element.key
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var _nextFallbackChildren = nextProps.fallback;
+      var _nextPrimaryChildren = nextProps.children;
+      var fallbackChildFragment = updateSuspenseFallbackChildren(
+        current,
+        workInProgress,
+        _nextPrimaryChildren,
+        _nextFallbackChildren,
+        renderLanes
       );
-      created.return = returnFiber;
-      return created;
-    } else {
-      var _created4 = createFiberFromElement(element, returnFiber.mode, lanes);
+      var _primaryChildFragment2 = workInProgress.child;
+      var prevOffscreenState = current.child.memoizedState;
+      _primaryChildFragment2.memoizedState =
+        prevOffscreenState === null
+          ? mountSuspenseOffscreenState(renderLanes)
+          : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
 
-      _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
-      _created4.return = returnFiber;
-      return _created4;
-    }
-  }
+      if (enableTransitionTracing) {
+        var _currentTransitions = getPendingTransitions();
 
-  function reconcileSinglePortal(
-    returnFiber,
-    currentFirstChild,
-    portal,
-    lanes
-  ) {
-    var key = portal.key;
-    var child = currentFirstChild;
+        if (_currentTransitions !== null) {
+          var _parentMarkerInstances = getMarkerInstances();
 
-    while (child !== null) {
-      // TODO: If key === null and child.key === null, then this only applies to
-      // the first item in the list.
-      if (child.key === key) {
-        if (
-          child.tag === HostPortal &&
-          child.stateNode.containerInfo === portal.containerInfo &&
-          child.stateNode.implementation === portal.implementation
-        ) {
-          deleteRemainingChildren(returnFiber, child.sibling);
-          var existing = useFiber(child, portal.children || []);
-          existing.return = returnFiber;
-          return existing;
-        } else {
-          deleteRemainingChildren(returnFiber, child);
-          break;
+          var _offscreenQueue = _primaryChildFragment2.updateQueue;
+          var currentOffscreenQueue = current.updateQueue;
+
+          if (_offscreenQueue === null) {
+            var _newOffscreenQueue = {
+              transitions: _currentTransitions,
+              markerInstances: _parentMarkerInstances,
+              wakeables: null
+            };
+            _primaryChildFragment2.updateQueue = _newOffscreenQueue;
+          } else if (_offscreenQueue === currentOffscreenQueue) {
+            // If the work-in-progress queue is the same object as current, we
+            // can't modify it without cloning it first.
+            var _newOffscreenQueue2 = {
+              transitions: _currentTransitions,
+              markerInstances: _parentMarkerInstances,
+              wakeables:
+                currentOffscreenQueue !== null
+                  ? currentOffscreenQueue.wakeables
+                  : null
+            };
+            _primaryChildFragment2.updateQueue = _newOffscreenQueue2;
+          } else {
+            _offscreenQueue.transitions = _currentTransitions;
+            _offscreenQueue.markerInstances = _parentMarkerInstances;
+          }
         }
-      } else {
-        deleteChild(returnFiber, child);
       }
 
-      child = child.sibling;
+      _primaryChildFragment2.childLanes = getRemainingWorkInPrimaryTree(
+        current,
+        renderLanes
+      );
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      var _nextPrimaryChildren2 = nextProps.children;
+
+      var _primaryChildFragment3 = updateSuspensePrimaryChildren(
+        current,
+        workInProgress,
+        _nextPrimaryChildren2,
+        renderLanes
+      );
+
+      workInProgress.memoizedState = null;
+      return _primaryChildFragment3;
     }
+  }
+}
 
-    var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
-    created.return = returnFiber;
-    return created;
-  } // This API will tag the children with the side-effect of the reconciliation
-  // itself. They will be added to the side-effect list as we pass through the
-  // children and the parent.
+function mountSuspensePrimaryChildren(
+  workInProgress,
+  primaryChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var primaryChildProps = {
+    mode: "visible",
+    children: primaryChildren
+  };
+  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
+    primaryChildProps,
+    mode
+  );
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
 
-  function reconcileChildFibersImpl(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
+function mountSuspenseFallbackChildren(
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var progressedPrimaryFragment = workInProgress.child;
+  var primaryChildProps = {
+    mode: "hidden",
+    children: primaryChildren
+  };
+  var primaryChildFragment;
+  var fallbackChildFragment;
+
+  if (
+    (mode & ConcurrentMode) === NoMode &&
+    progressedPrimaryFragment !== null
   ) {
-    // This function is not recursive.
-    // If the top level item is an array, we treat it as a set of children,
-    // not as a fragment. Nested arrays on the other hand will be treated as
-    // fragment nodes. Recursion happens at the normal flow.
-    // Handle top level unkeyed fragments as if they were arrays.
-    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
-    // We treat the ambiguous cases above the same.
-    // TODO: Let's use recursion like we do for Usable nodes?
-    var isUnkeyedTopLevelFragment =
-      typeof newChild === "object" &&
-      newChild !== null &&
-      newChild.type === REACT_FRAGMENT_TYPE &&
-      newChild.key === null;
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
 
-    if (isUnkeyedTopLevelFragment) {
-      newChild = newChild.props.children;
-    } // Handle object types
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration = 0;
+      primaryChildFragment.treeBaseDuration = 0;
+    }
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return placeSingleChild(
-            reconcileSingleElement(
-              returnFiber,
-              currentFirstChild,
-              newChild,
-              lanes
-            )
-          );
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    );
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(
+      primaryChildProps,
+      mode
+    );
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    );
+  }
 
-        case REACT_PORTAL_TYPE:
-          return placeSingleChild(
-            reconcileSinglePortal(
-              returnFiber,
-              currentFirstChild,
-              newChild,
-              lanes
-            )
-          );
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
+}
 
-        case REACT_LAZY_TYPE:
-          var payload = newChild._payload;
-          var init = newChild._init; // TODO: This function is supposed to be non-recursive.
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
+}
 
-          return reconcileChildFibers(
-            returnFiber,
-            currentFirstChild,
-            init(payload),
-            lanes
-          );
-      }
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
+}
 
-      if (isArray(newChild)) {
-        return reconcileChildrenArray(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      }
+function updateSuspensePrimaryChildren(
+  current,
+  workInProgress,
+  primaryChildren,
+  renderLanes
+) {
+  var currentPrimaryChildFragment = current.child;
+  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  var primaryChildFragment = updateWorkInProgressOffscreenFiber(
+    currentPrimaryChildFragment,
+    {
+      mode: "visible",
+      children: primaryChildren
+    }
+  );
 
-      if (getIteratorFn(newChild)) {
-        return reconcileChildrenIterator(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      } // Usables are a valid React node type. When React encounters a Usable in
-      // a child position, it unwraps it using the same algorithm as `use`. For
-      // example, for promises, React will throw an exception to unwind the
-      // stack, then replay the component once the promise resolves.
-      //
-      // A difference from `use` is that React will keep unwrapping the value
-      // until it reaches a non-Usable type.
-      //
-      // e.g. Usable<Usable<Usable<T>>> should resolve to T
-      //
-      // The structure is a bit unfortunate. Ideally, we shouldn't need to
-      // replay the entire begin phase of the parent fiber in order to reconcile
-      // the children again. This would require a somewhat significant refactor,
-      // because reconcilation happens deep within the begin phase, and
-      // depending on the type of work, not always at the end. We should
-      // consider as an future improvement.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
 
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    var deletions = workInProgress.deletions;
 
-      throwOnInvalidObjectType(returnFiber, newChild);
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
     }
+  }
 
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      return placeSingleChild(
-        reconcileSingleTextNode(
-          returnFiber,
-          currentFirstChild,
-          "" + newChild,
-          lanes
-        )
-      );
-    }
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
+}
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
-    } // Remaining cases are all treated as empty.
+function updateSuspenseFallbackChildren(
+  current,
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var currentPrimaryChildFragment = current.child;
+  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  var primaryChildProps = {
+    mode: "hidden",
+    children: primaryChildren
+  };
+  var primaryChildFragment;
 
-    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  if (
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+    // already cloned. In legacy mode, the only case where this isn't true is
+    // when DevTools forces us to display a fallback; we skip the first render
+    // pass entirely and go straight to rendering the fallback. (In Concurrent
+    // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+    // only codepath.)
+    workInProgress.child !== currentPrimaryChildFragment
+  ) {
+    var progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
+
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration =
+        currentPrimaryChildFragment.selfBaseDuration;
+      primaryChildFragment.treeBaseDuration =
+        currentPrimaryChildFragment.treeBaseDuration;
+    } // The fallback fiber was added as a deletion during the first pass.
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
+
+    workInProgress.deletions = null;
+  } else {
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(
+      currentPrimaryChildFragment,
+      primaryChildProps
+    ); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
+
+    primaryChildFragment.subtreeFlags =
+      currentPrimaryChildFragment.subtreeFlags & StaticMask;
   }
 
-  function reconcileChildFibers(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    // This indirection only exists so we can reset `thenableState` at the end.
-    // It should get inlined by Closure.
-    thenableIndexCounter$1 = 0;
-    var firstChildFiber = reconcileChildFibersImpl(
-      returnFiber,
-      currentFirstChild,
-      newChild,
-      lanes
+  var fallbackChildFragment;
+
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(
+      currentFallbackChildFragment,
+      fallbackChildren
     );
-    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
-    // set at the beginning.
+  } else {
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    ); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
 
-    return firstChildFiber;
+    fallbackChildFragment.flags |= Placement;
   }
 
-  return reconcileChildFibers;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
 }
 
-var reconcileChildFibers = createChildReconciler(true);
-var mountChildFibers = createChildReconciler(false);
-function resetChildReconcilerOnUnwind() {
-  // On unwind, clear any pending thenables that were used.
-  thenableState$1 = null;
-  thenableIndexCounter$1 = 0;
+function retrySuspenseComponentWithoutHydrating(
+  current,
+  workInProgress,
+  renderLanes,
+  recoverableError
+) {
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
+
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+
+  var nextProps = workInProgress.pendingProps;
+  var primaryChildren = nextProps.children;
+  var primaryChildFragment = mountSuspensePrimaryChildren(
+    workInProgress,
+    primaryChildren
+  ); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
+
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
 }
-function cloneChildFibers(current, workInProgress) {
-  if (current !== null && workInProgress.child !== current.child) {
-    throw new Error("Resuming work not yet implemented.");
-  }
 
-  if (workInProgress.child === null) {
-    return;
-  }
+function mountSuspenseFallbackAfterRetryWithoutHydrating(
+  current,
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var fiberMode = workInProgress.mode;
+  var primaryChildProps = {
+    mode: "visible",
+    children: primaryChildren
+  };
+  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
+    primaryChildProps,
+    fiberMode
+  );
+  var fallbackChildFragment = createFiberFromFragment(
+    fallbackChildren,
+    fiberMode,
+    renderLanes,
+    null
+  ); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
 
-  var currentChild = workInProgress.child;
-  var newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
-  workInProgress.child = newChild;
-  newChild.return = workInProgress;
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
 
-  while (currentChild.sibling !== null) {
-    currentChild = currentChild.sibling;
-    newChild = newChild.sibling = createWorkInProgress(
-      currentChild,
-      currentChild.pendingProps
-    );
-    newChild.return = workInProgress;
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
   }
 
-  newChild.sibling = null;
-} // Reset a workInProgress child set to prepare it for a second pass.
+  return fallbackChildFragment;
+}
 
-function resetChildFibers(workInProgress, lanes) {
-  var child = workInProgress.child;
+function mountDehydratedSuspenseComponent(
+  workInProgress,
+  suspenseInstance,
+  renderLanes
+) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    {
+      error(
+        "Cannot hydrate Suspense in legacy mode. Switch from " +
+          "ReactDOM.hydrate(element, container) to " +
+          "ReactDOMClient.hydrateRoot(container, <App />)" +
+          ".render(element) or remove the Suspense components from " +
+          "the server rendered components."
+      );
+    }
 
-  while (child !== null) {
-    resetWorkInProgress(child, lanes);
-    child = child.sibling;
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
   }
+
+  return null;
 }
 
-// TODO: This isn't being used yet, but it's intended to replace the
-// InvisibleParentContext that is currently managed by SuspenseContext.
+function updateDehydratedSuspenseComponent(
+  current,
+  workInProgress,
+  didSuspend,
+  nextProps,
+  suspenseInstance,
+  suspenseState,
+  renderLanes
+) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+    // but after we've already committed once.
 
-var currentTreeHiddenStackCursor = createCursor(null);
-var prevRenderLanesStackCursor = createCursor(NoLanes);
-function pushHiddenContext(fiber, context) {
-  var prevRenderLanes = getRenderLanes();
-  push(prevRenderLanesStackCursor, prevRenderLanes, fiber);
-  push(currentTreeHiddenStackCursor, context, fiber); // When rendering a subtree that's currently hidden, we must include all
-  // lanes that would have rendered if the hidden subtree hadn't been deferred.
-  // That is, in order to reveal content from hidden -> visible, we must commit
-  // all the updates that we skipped when we originally hid the tree.
+    warnIfHydrating();
 
-  setRenderLanes(mergeLanes(prevRenderLanes, context.baseLanes));
-}
-function reuseHiddenContextOnStack(fiber) {
-  // This subtree is not currently hidden, so we don't need to add any lanes
-  // to the render lanes. But we still need to push something to avoid a
-  // context mismatch. Reuse the existing context on the stack.
-  push(prevRenderLanesStackCursor, getRenderLanes(), fiber);
-  push(
-    currentTreeHiddenStackCursor,
-    currentTreeHiddenStackCursor.current,
-    fiber
-  );
-}
-function popHiddenContext(fiber) {
-  // Restore the previous render lanes from the stack
-  setRenderLanes(prevRenderLanesStackCursor.current);
-  pop(currentTreeHiddenStackCursor, fiber);
-  pop(prevRenderLanesStackCursor, fiber);
-}
-function isCurrentTreeHidden() {
-  return currentTreeHiddenStackCursor.current !== null;
-}
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        null
+      );
+    }
 
-// suspends, i.e. it's the nearest `catch` block on the stack.
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      var digest, message, stack;
 
-var suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
-// Everything above this is the "shell". When this is null, it means we're
-// rendering in the shell of the app. If it's non-null, it means we're rendering
-// deeper than the shell, inside a new tree that wasn't already visible.
-//
-// The main way we use this concept is to determine whether showing a fallback
-// would result in a desirable or undesirable loading state. Activing a fallback
-// in the shell is considered an undersirable loading state, because it would
-// mean hiding visible (albeit stale) content in the current tree — we prefer to
-// show the stale content, rather than switch to a fallback. But showing a
-// fallback in a new tree is fine, because there's no stale content to
-// prefer instead.
+      {
+        var _getSuspenseInstanceF =
+          getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
 
-var shellBoundary = null;
-function getShellBoundary() {
-  return shellBoundary;
-}
-function pushPrimaryTreeSuspenseHandler(handler) {
-  // TODO: Pass as argument
-  var current = handler.alternate;
-  var props = handler.pendingProps; // Experimental feature: Some Suspense boundaries are marked as having an
-  // undesirable fallback state. These have special behavior where we only
-  // activate the fallback if there's no other boundary on the stack that we can
-  // use instead.
+        digest = _getSuspenseInstanceF.digest;
+        message = _getSuspenseInstanceF.message;
+        stack = _getSuspenseInstanceF.stack;
+      }
 
-  if (
-    props.unstable_avoidThisFallback === true && // If an avoided boundary is already visible, it behaves identically to
-    // a regular Suspense boundary.
-    (current === null || isCurrentTreeHidden())
-  ) {
-    if (shellBoundary === null) {
-      // We're rendering in the shell. There's no parent Suspense boundary that
-      // can provide a desirable fallback state. We'll use this boundary.
-      push(suspenseHandlerStackCursor, handler, handler); // However, because this is not a desirable fallback, the children are
-      // still considered part of the shell. So we intentionally don't assign
-      // to `shellBoundary`.
-    } else {
-      // There's already a parent Suspense boundary that can provide a desirable
-      // fallback state. Prefer that one.
-      var handlerOnStack = suspenseHandlerStackCursor.current;
-      push(suspenseHandlerStackCursor, handlerOnStack, handler);
+      var error;
+
+      if (message) {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        error = new Error(message);
+      } else {
+        error = new Error(
+          "The server could not finish this Suspense boundary, likely " +
+            "due to an error during server rendering. Switched to " +
+            "client rendering."
+        );
+      }
+
+      error.digest = digest;
+      var capturedValue = createCapturedValue(error, digest, stack);
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        capturedValue
+      );
     }
 
-    return;
-  } // TODO: If the parent Suspense handler already suspended, there's no reason
-  // to push a nested Suspense handler, because it will get replaced by the
-  // outer fallback, anyway. Consider this as a future optimization.
+    if (
+      enableLazyContextPropagation && // TODO: Factoring is a little weird, since we check this right below, too.
+      // But don't want to re-arrange the if-else chain until/unless this
+      // feature lands.
+      !didReceiveUpdate
+    ) {
+      // We need to check if any children have context before we decide to bail
+      // out, so propagate the changes now.
+      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
+    } // We use lanes to indicate that a child might depend on context, so if
+    // any context has changed, we need to treat is as if the input might have changed.
 
-  push(suspenseHandlerStackCursor, handler, handler);
+    var hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
 
-  if (shellBoundary === null) {
-    if (current === null || isCurrentTreeHidden()) {
-      // This boundary is not visible in the current UI.
-      shellBoundary = handler;
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      var root = getWorkInProgressRoot();
+
+      if (root !== null) {
+        var attemptHydrationAtLane = getBumpedLaneForHydration(
+          root,
+          renderLanes
+        );
+
+        if (
+          attemptHydrationAtLane !== NoLane &&
+          attemptHydrationAtLane !== suspenseState.retryLane
+        ) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane; // TODO: Ideally this would inherit the event time of the current render
+
+          var eventTime = NoTimestamp;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(
+            root,
+            current,
+            attemptHydrationAtLane,
+            eventTime
+          ); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
+
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
+
+      renderDidSuspendDelayIfPossible();
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        null
+      );
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+
+      var retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
     } else {
-      var prevState = current.memoizedState;
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(
+        workInProgress,
+        suspenseInstance,
+        suspenseState.treeContext
+      );
+      var primaryChildren = nextProps.children;
+      var primaryChildFragment = mountSuspensePrimaryChildren(
+        workInProgress,
+        primaryChildren
+      ); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
 
-      if (prevState !== null) {
-        // This boundary is showing a fallback in the current UI.
-        shellBoundary = handler;
-      }
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
     }
-  }
-}
-function pushFallbackTreeSuspenseHandler(fiber) {
-  // We're about to render the fallback. If something in the fallback suspends,
-  // it's akin to throwing inside of a `catch` block. This boundary should not
-  // capture. Reuse the existing handler on the stack.
-  reuseSuspenseHandlerOnStack(fiber);
-}
-function pushOffscreenSuspenseHandler(fiber) {
-  if (fiber.tag === OffscreenComponent) {
-    push(suspenseHandlerStackCursor, fiber, fiber);
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
 
-    if (shellBoundary !== null);
-    else {
-      var current = fiber.alternate;
+      var _capturedValue = createCapturedValue(
+        new Error(
+          "There was an error while hydrating this Suspense boundary. " +
+            "Switched to client rendering."
+        )
+      );
 
-      if (current !== null) {
-        var prevState = current.memoizedState;
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        _capturedValue
+      );
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
 
-        if (prevState !== null) {
-          // This is the first boundary in the stack that's already showing
-          // a fallback. So everything outside is considered the shell.
-          shellBoundary = fiber;
-        }
-      }
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var nextPrimaryChildren = nextProps.children;
+      var nextFallbackChildren = nextProps.fallback;
+      var fallbackChildFragment =
+        mountSuspenseFallbackAfterRetryWithoutHydrating(
+          current,
+          workInProgress,
+          nextPrimaryChildren,
+          nextFallbackChildren,
+          renderLanes
+        );
+      var _primaryChildFragment4 = workInProgress.child;
+      _primaryChildFragment4.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
     }
-  } else {
-    // This is a LegacyHidden component.
-    reuseSuspenseHandlerOnStack(fiber);
   }
 }
-function reuseSuspenseHandlerOnStack(fiber) {
-  push(suspenseHandlerStackCursor, getSuspenseHandler(), fiber);
-}
-function getSuspenseHandler() {
-  return suspenseHandlerStackCursor.current;
-}
-function popSuspenseHandler(fiber) {
-  pop(suspenseHandlerStackCursor, fiber);
 
-  if (shellBoundary === fiber) {
-    // Popping back into the shell.
-    shellBoundary = null;
-  }
-} // SuspenseList context
-// TODO: Move to a separate module? We may change the SuspenseList
-// implementation to hide/show in the commit phase, anyway.
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  var alternate = fiber.alternate;
 
-var DefaultSuspenseContext = 0;
-var SubtreeSuspenseContextMask = 1; // ForceSuspenseFallback can be used by SuspenseList to force newly added
-// items into their fallback state during one of the render passes.
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  }
 
-var ForceSuspenseFallback = 2;
-var suspenseStackCursor = createCursor(DefaultSuspenseContext);
-function hasSuspenseListContext(parentContext, flag) {
-  return (parentContext & flag) !== 0;
-}
-function setDefaultShallowSuspenseListContext(parentContext) {
-  return parentContext & SubtreeSuspenseContextMask;
-}
-function setShallowSuspenseListContext(parentContext, shallowContext) {
-  return (parentContext & SubtreeSuspenseContextMask) | shallowContext;
-}
-function pushSuspenseListContext(fiber, newContext) {
-  push(suspenseStackCursor, newContext, fiber);
-}
-function popSuspenseListContext(fiber) {
-  pop(suspenseStackCursor, fiber);
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
 }
 
-// A non-null SuspenseState means that it is blocked for one reason or another.
-// - A non-null dehydrated field means it's blocked pending hydration.
-//   - A non-null dehydrated field can use isSuspenseInstancePending or
-//     isSuspenseInstanceFallback to query the reason for being dehydrated.
-// - A null dehydrated field means it's blocked by something suspending and
-//   we're currently showing a fallback instead.
-
-function findFirstSuspended(row) {
-  var node = row;
+function propagateSuspenseContextChange(
+  workInProgress,
+  firstChild,
+  renderLanes
+) {
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  var node = firstChild;
 
   while (node !== null) {
     if (node.tag === SuspenseComponent) {
       var state = node.memoizedState;
 
       if (state !== null) {
-        var dehydrated = state.dehydrated;
-
-        if (
-          dehydrated === null ||
-          isSuspenseInstancePending(dehydrated) ||
-          isSuspenseInstanceFallback(dehydrated)
-        ) {
-          return node;
-        }
-      }
-    } else if (
-      node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
-      // keep track of whether it suspended or not.
-      node.memoizedProps.revealOrder !== undefined
-    ) {
-      var didSuspend = (node.flags & DidCapture) !== NoFlags$1;
-
-      if (didSuspend) {
-        return node;
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
       }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
     } else if (node.child !== null) {
       node.child.return = node;
       node = node.child;
       continue;
     }
 
-    if (node === row) {
-      return null;
-    }
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
     while (node.sibling === null) {
-      if (node.return === null || node.return === row) {
-        return null;
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
       }
 
       node = node.return;
-    }
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
     node.sibling.return = node.return;
     node = node.sibling;
   }
+}
 
-  return null;
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  var row = firstChild;
+  var lastContentRow = null;
+
+  while (row !== null) {
+    var currentRow = row.alternate; // New rows can't be content rows.
+
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
+    }
+
+    row = row.sibling;
+  }
+
+  return lastContentRow;
 }
 
-var NoFlags =
-  /*   */
-  0; // Represents whether effect should fire.
+function validateRevealOrder(revealOrder) {
+  {
+    if (
+      revealOrder !== undefined &&
+      revealOrder !== "forwards" &&
+      revealOrder !== "backwards" &&
+      revealOrder !== "together" &&
+      !didWarnAboutRevealOrder[revealOrder]
+    ) {
+      didWarnAboutRevealOrder[revealOrder] = true;
 
-var HasEffect =
-  /* */
-  1; // Represents the phase in which the effect (not the clean-up) fires.
+      if (typeof revealOrder === "string") {
+        switch (revealOrder.toLowerCase()) {
+          case "together":
+          case "forwards":
+          case "backwards": {
+            error(
+              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
+                'Use lowercase "%s" instead.',
+              revealOrder,
+              revealOrder.toLowerCase()
+            );
 
-var Insertion =
-  /* */
-  2;
-var Layout =
-  /*    */
-  4;
-var Passive =
-  /*   */
-  8;
+            break;
+          }
 
-// and should be reset before starting a new render.
-// This tracks which mutable sources need to be reset after a render.
+          case "forward":
+          case "backward": {
+            error(
+              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
+                'React uses the -s suffix in the spelling. Use "%ss" instead.',
+              revealOrder,
+              revealOrder.toLowerCase()
+            );
 
-var workInProgressSources = [];
-var rendererSigil$1;
+            break;
+          }
 
-{
-  // Used to detect multiple renderers using the same mutable source.
-  rendererSigil$1 = {};
+          default:
+            error(
+              '"%s" is not a supported revealOrder on <SuspenseList />. ' +
+                'Did you mean "together", "forwards" or "backwards"?',
+              revealOrder
+            );
+
+            break;
+        }
+      } else {
+        error(
+          "%s is not a supported value for revealOrder on <SuspenseList />. " +
+            'Did you mean "together", "forwards" or "backwards"?',
+          revealOrder
+        );
+      }
+    }
+  }
 }
 
-function markSourceAsDirty(mutableSource) {
-  workInProgressSources.push(mutableSource);
+function validateTailOptions(tailMode, revealOrder) {
+  {
+    if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
+      if (tailMode !== "collapsed" && tailMode !== "hidden") {
+        didWarnAboutTailOptions[tailMode] = true;
+
+        error(
+          '"%s" is not a supported value for tail on <SuspenseList />. ' +
+            'Did you mean "collapsed" or "hidden"?',
+          tailMode
+        );
+      } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
+        didWarnAboutTailOptions[tailMode] = true;
+
+        error(
+          '<SuspenseList tail="%s" /> is only valid if revealOrder is ' +
+            '"forwards" or "backwards". ' +
+            'Did you mean to specify revealOrder="forwards"?',
+          tailMode
+        );
+      }
+    }
+  }
 }
-function resetWorkInProgressVersions() {
-  for (var i = 0; i < workInProgressSources.length; i++) {
-    var mutableSource = workInProgressSources[i];
 
-    {
-      mutableSource._workInProgressVersionPrimary = null;
+function validateSuspenseListNestedChild(childSlot, index) {
+  {
+    var isAnArray = isArray(childSlot);
+    var isIterable =
+      !isAnArray && typeof getIteratorFn(childSlot) === "function";
+
+    if (isAnArray || isIterable) {
+      var type = isAnArray ? "array" : "iterable";
+
+      error(
+        "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " +
+          "an additional SuspenseList to configure its revealOrder: " +
+          "<SuspenseList revealOrder=...> ... " +
+          "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " +
+          "</SuspenseList>",
+        type,
+        index,
+        type
+      );
+
+      return false;
     }
   }
 
-  workInProgressSources.length = 0;
+  return true;
 }
-function getWorkInProgressVersion(mutableSource) {
+
+function validateSuspenseListChildren(children, revealOrder) {
   {
-    return mutableSource._workInProgressVersionPrimary;
+    if (
+      (revealOrder === "forwards" || revealOrder === "backwards") &&
+      children !== undefined &&
+      children !== null &&
+      children !== false
+    ) {
+      if (isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+          if (!validateSuspenseListNestedChild(children[i], i)) {
+            return;
+          }
+        }
+      } else {
+        var iteratorFn = getIteratorFn(children);
+
+        if (typeof iteratorFn === "function") {
+          var childrenIterator = iteratorFn.call(children);
+
+          if (childrenIterator) {
+            var step = childrenIterator.next();
+            var _i = 0;
+
+            for (; !step.done; step = childrenIterator.next()) {
+              if (!validateSuspenseListNestedChild(step.value, _i)) {
+                return;
+              }
+
+              _i++;
+            }
+          }
+        } else {
+          error(
+            'A single row was passed to a <SuspenseList revealOrder="%s" />. ' +
+              "This is not useful since it needs multiple rows. " +
+              "Did you mean to pass multiple children or an array?",
+            revealOrder
+          );
+        }
+      }
+    }
   }
 }
-function setWorkInProgressVersion(mutableSource, version) {
-  {
-    mutableSource._workInProgressVersionPrimary = version;
+
+function initSuspenseListRenderState(
+  workInProgress,
+  isBackwards,
+  tail,
+  lastContentRow,
+  tailMode
+) {
+  var renderState = workInProgress.memoizedState;
+
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
+  } else {
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
+  }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
+
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var revealOrder = nextProps.revealOrder;
+  var tailMode = nextProps.tail;
+  var newChildren = nextProps.children;
+  validateRevealOrder(revealOrder);
+  validateTailOptions(tailMode, revealOrder);
+  validateSuspenseListChildren(newChildren, revealOrder);
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  var suspenseContext = suspenseStackCursor.current;
+  var shouldForceFallback = hasSuspenseListContext(
+    suspenseContext,
+    ForceSuspenseFallback
+  );
+
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(
+      suspenseContext,
+      ForceSuspenseFallback
+    );
+    workInProgress.flags |= DidCapture;
+  } else {
+    var didSuspendBefore =
+      current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(
+        workInProgress,
+        workInProgress.child,
+        renderLanes
+      );
+    }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
   }
 
-  workInProgressSources.push(mutableSource);
-}
-function warnAboutMultipleRenderersDEV(mutableSource) {
-  {
-    {
-      if (mutableSource._currentPrimaryRenderer == null) {
-        mutableSource._currentPrimaryRenderer = rendererSigil$1;
-      } else if (mutableSource._currentPrimaryRenderer !== rendererSigil$1) {
-        error(
-          "Detected multiple renderers concurrently rendering the " +
-            "same mutable source. This is currently unsupported."
+  pushSuspenseListContext(workInProgress, suspenseContext);
+
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case "forwards": {
+        var lastContentRow = findLastContentRow(workInProgress.child);
+        var tail;
+
+        if (lastContentRow === null) {
+          // The whole list is part of the tail.
+          // TODO: We could fast path by just rendering the tail now.
+          tail = workInProgress.child;
+          workInProgress.child = null;
+        } else {
+          // Disconnect the tail rows after the content row.
+          // We're going to render them separately later.
+          tail = lastContentRow.sibling;
+          lastContentRow.sibling = null;
+        }
+
+        initSuspenseListRenderState(
+          workInProgress,
+          false, // isBackwards
+          tail,
+          lastContentRow,
+          tailMode
+        );
+        break;
+      }
+
+      case "backwards": {
+        // We're going to find the first row that has existing content.
+        // At the same time we're going to reverse the list of everything
+        // we pass in the meantime. That's going to be our tail in reverse
+        // order.
+        var _tail = null;
+        var row = workInProgress.child;
+        workInProgress.child = null;
+
+        while (row !== null) {
+          var currentRow = row.alternate; // New rows can't be content rows.
+
+          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+            // This is the beginning of the main content.
+            workInProgress.child = row;
+            break;
+          }
+
+          var nextRow = row.sibling;
+          row.sibling = _tail;
+          _tail = row;
+          row = nextRow;
+        } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+
+        initSuspenseListRenderState(
+          workInProgress,
+          true, // isBackwards
+          _tail,
+          null, // last
+          tailMode
+        );
+        break;
+      }
+
+      case "together": {
+        initSuspenseListRenderState(
+          workInProgress,
+          false, // isBackwards
+          null, // tail
+          null, // last
+          undefined
         );
+        break;
+      }
+
+      default: {
+        // The default reveal order is the same as not having
+        // a boundary.
+        workInProgress.memoizedState = null;
       }
     }
   }
-} // Eager reads the version of a mutable source and stores it on the root.
-// This ensures that the version used for server rendering matches the one
-// that is eventually read during hydration.
-// If they don't match there's a potential tear and a full deopt render is required.
-
-function registerMutableSourceForHydration(root, mutableSource) {
-  var getVersion = mutableSource._getVersion;
-  var version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
-  // Retaining it forever may interfere with GC.
 
-  if (root.mutableSourceEagerHydrationData == null) {
-    root.mutableSourceEagerHydrationData = [mutableSource, version];
-  } else {
-    root.mutableSourceEagerHydrationData.push(mutableSource, version);
-  }
+  return workInProgress.child;
 }
 
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
-var didWarnAboutMismatchedHooksForComponent;
-var didWarnUncachedGetSnapshot;
-var didWarnAboutUseWrappedInTryCatch;
-
-{
-  didWarnAboutMismatchedHooksForComponent = new Set();
-  didWarnAboutUseWrappedInTryCatch = new Set();
-} // These are set right before calling the component.
-
-var renderLanes$1 = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
-// the work-in-progress hook.
-
-var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
-// current hook list is the list that belongs to the current fiber. The
-// work-in-progress hook list is a new list that will be added to the
-// work-in-progress fiber.
-
-var currentHook = null;
-var workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
-// does not get reset if we do another render pass; only when we're completely
-// finished evaluating this component. This is an optimization so we know
-// whether we need to clear render phase updates after a throw.
-
-var didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
-// gets reset after each attempt.
-// TODO: Maybe there's some way to consolidate this with
-// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
-
-var didScheduleRenderPhaseUpdateDuringThisPass = false;
-var shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  var nextChildren = workInProgress.pendingProps;
 
-var localIdCounter = 0; // Counts number of `use`-d thenables
+  if (current === 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
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
 
-var thenableIndexCounter = 0;
-var thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
-// hydration). This counter is global, so client ids are not stable across
-// render attempts.
+  return workInProgress.child;
+}
 
-var globalClientIdCounter = 0;
-var RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+var hasWarnedAboutUsingNoValuePropOnContextProvider = false;
 
-var currentHookNameInDev = null; // In DEV, this list ensures that hooks are called in the same order between renders.
-// The list stores the order of hooks used during the initial render (mount).
-// Subsequent renders (updates) reference this list.
+function updateContextProvider(current, workInProgress, renderLanes) {
+  var providerType = workInProgress.type;
+  var context = providerType._context;
+  var newProps = workInProgress.pendingProps;
+  var oldProps = workInProgress.memoizedProps;
+  var newValue = newProps.value;
 
-var hookTypesDev = null;
-var hookTypesUpdateIndexDev = -1; // In DEV, this tracks whether currently rendering component needs to ignore
-// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
-// When true, such Hooks will always be "remounted". Only used during hot reload.
+  {
+    if (!("value" in newProps)) {
+      if (!hasWarnedAboutUsingNoValuePropOnContextProvider) {
+        hasWarnedAboutUsingNoValuePropOnContextProvider = true;
 
-var ignorePreviousDependencies = false;
+        error(
+          "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
+        );
+      }
+    }
 
-function mountHookTypesDev() {
-  {
-    var hookName = currentHookNameInDev;
+    var providerPropTypes = workInProgress.type.propTypes;
 
-    if (hookTypesDev === null) {
-      hookTypesDev = [hookName];
-    } else {
-      hookTypesDev.push(hookName);
+    if (providerPropTypes) {
+      checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider");
     }
   }
-}
 
-function updateHookTypesDev() {
-  {
-    var hookName = currentHookNameInDev;
+  pushProvider(workInProgress, context, newValue);
 
-    if (hookTypesDev !== null) {
-      hookTypesUpdateIndexDev++;
+  if (enableLazyContextPropagation);
+  else {
+    if (oldProps !== null) {
+      var oldValue = oldProps.value;
 
-      if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
-        warnOnHookMismatchInDev(hookName);
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(
+            current,
+            workInProgress,
+            renderLanes
+          );
+        }
+      } else {
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
       }
     }
   }
-}
 
-function checkDepsAreArrayDev(deps) {
-  {
-    if (deps !== undefined && deps !== null && !isArray(deps)) {
-      // Verify deps, but only on mount to avoid extra checks.
-      // It's unlikely their type would change as usually you define them inline.
-      error(
-        "%s received a final argument that is not an array (instead, received `%s`). When " +
-          "specified, the final argument must be an array.",
-        currentHookNameInDev,
-        typeof deps
-      );
-    }
-  }
+  var newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function warnOnHookMismatchInDev(currentHookName) {
-  {
-    var componentName = getComponentNameFromFiber(currentlyRenderingFiber$1);
-
-    if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
-      didWarnAboutMismatchedHooksForComponent.add(componentName);
-
-      if (hookTypesDev !== null) {
-        var table = "";
-        var secondColumnStart = 30;
+var hasWarnedAboutUsingContextAsConsumer = false;
 
-        for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
-          var oldHookName = hookTypesDev[i];
-          var newHookName =
-            i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
-          var row = i + 1 + ". " + oldHookName; // Extra space so second column lines up
-          // lol @ IE not supporting String#repeat
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  var context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+  // DEV mode, we create a separate object for Context.Consumer that acts
+  // like a proxy to Context. This proxy object adds unnecessary code in PROD
+  // so we use the old behaviour (Context.Consumer references Context) to
+  // reduce size and overhead. The separate object references context via
+  // a property called "_context", which also gives us the ability to check
+  // in DEV mode if this property exists or not and warn if it does not.
 
-          while (row.length < secondColumnStart) {
-            row += " ";
-          }
+  {
+    if (context._context === undefined) {
+      // This may be because it's a Context (rather than a Consumer).
+      // Or it may be because it's older React where they're the same thing.
+      // We only want to warn if we're sure it's a new React.
+      if (context !== context.Consumer) {
+        if (!hasWarnedAboutUsingContextAsConsumer) {
+          hasWarnedAboutUsingContextAsConsumer = true;
 
-          row += newHookName + "\n";
-          table += row;
+          error(
+            "Rendering <Context> directly is not supported and will be removed in " +
+              "a future major release. Did you mean to render <Context.Consumer> instead?"
+          );
         }
-
-        error(
-          "React has detected a change in the order of Hooks called by %s. " +
-            "This will lead to bugs and errors if not fixed. " +
-            "For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n" +
-            "   Previous render            Next render\n" +
-            "   ------------------------------------------------------\n" +
-            "%s" +
-            "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-          componentName,
-          table
-        );
       }
+    } else {
+      context = context._context;
     }
   }
-}
 
-function throwInvalidHookError() {
-  throw new Error(
-    "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for" +
-      " one of the following reasons:\n" +
-      "1. You might have mismatching versions of React and the renderer (such as React DOM)\n" +
-      "2. You might be breaking the Rules of Hooks\n" +
-      "3. You might have more than one copy of React in the same app\n" +
-      "See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."
-  );
-}
+  var newProps = workInProgress.pendingProps;
+  var render = newProps.children;
 
-function areHookInputsEqual(nextDeps, prevDeps) {
   {
-    if (ignorePreviousDependencies) {
-      // Only true when this component is being hot reloaded.
-      return false;
-    }
-  }
-
-  if (prevDeps === null) {
-    {
+    if (typeof render !== "function") {
       error(
-        "%s received a final argument during this render, but not during " +
-          "the previous render. Even though the final argument is optional, " +
-          "its type cannot change between renders.",
-        currentHookNameInDev
+        "A context consumer was rendered with multiple children, or a child " +
+          "that isn't a function. A context consumer expects a single child " +
+          "that is a function. If you did pass a function, make sure there " +
+          "is no trailing or leading whitespace around it."
       );
     }
-
-    return false;
   }
 
-  {
-    // Don't bother comparing lengths in prod because these arrays should be
-    // passed inline.
-    if (nextDeps.length !== prevDeps.length) {
-      error(
-        "The final argument passed to %s changed size between renders. The " +
-          "order and size of this array must remain constant.\n\n" +
-          "Previous: %s\n" +
-          "Incoming: %s",
-        currentHookNameInDev,
-        "[" + prevDeps.join(", ") + "]",
-        "[" + nextDeps.join(", ") + "]"
-      );
-    }
-  } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
-    // $FlowFixMe[incompatible-use] found when upgrading Flow
-    if (objectIs(nextDeps[i], prevDeps[i])) {
-      continue;
-    }
+  prepareToReadContext(workInProgress, renderLanes);
+  var newValue = readContext(context);
 
-    return false;
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
   }
 
-  return true;
-}
-
-function renderWithHooks(
-  current,
-  workInProgress,
-  Component,
-  props,
-  secondArg,
-  nextRenderLanes
-) {
-  renderLanes$1 = nextRenderLanes;
-  currentlyRenderingFiber$1 = workInProgress;
+  var newChildren;
 
   {
-    hookTypesDev = current !== null ? current._debugHookTypes : null;
-    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
-
-    ignorePreviousDependencies =
-      current !== null && current.type !== workInProgress.type;
+    ReactCurrentOwner$1.current = workInProgress;
+    setIsRendering(true);
+    newChildren = render(newValue);
+    setIsRendering(false);
   }
 
-  workInProgress.memoizedState = null;
-  workInProgress.updateQueue = null;
-  workInProgress.lanes = NoLanes; // The following should have already been reset
-  // currentHook = null;
-  // workInProgressHook = null;
-  // didScheduleRenderPhaseUpdate = false;
-  // localIdCounter = 0;
-  // thenableIndexCounter = 0;
-  // thenableState = null;
-  // TODO Warn if no hooks are used at all during mount, then some are used during update.
-  // Currently we will identify the update render as a mount because memoizedState === null.
-  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
-  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
-  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
-  // so memoizedState would be null during updates and mounts.
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
 
-  {
-    if (current !== null && current.memoizedState !== null) {
-      ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
-    } else if (hookTypesDev !== null) {
-      // This dispatcher handles an edge case where a component is updating,
-      // but no stateful hooks have been used.
-      // We want to match the production code behavior (which will use HooksDispatcherOnMount),
-      // but with the extra DEV validation to ensure hooks ordering hasn't changed.
-      // This dispatcher does that.
-      ReactCurrentDispatcher$1.current =
-        HooksDispatcherOnMountWithHookTypesInDEV;
-    } else {
-      ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
-    }
-  } // In Strict Mode, during development, user functions are double invoked to
-  // help detect side effects. The logic for how this is implemented for in
-  // hook components is a bit complex so let's break it down.
-  //
-  // We will invoke the entire component function twice. However, during the
-  // second invocation of the component, the hook state from the first
-  // invocation will be reused. That means things like `useMemo` functions won't
-  // run again, because the deps will match and the memoized result will
-  // be reused.
-  //
-  // We want memoized functions to run twice, too, so account for this, user
-  // functions are double invoked during the *first* invocation of the component
-  // function, and are *not* double invoked during the second incovation:
-  //
-  // - First execution of component function: user functions are double invoked
-  // - Second execution of component function (in Strict Mode, during
-  //   development): user functions are not double invoked.
-  //
-  // This is intentional for a few reasons; most importantly, it's because of
-  // how `use` works when something suspends: it reuses the promise that was
-  // passed during the first attempt. This is itself a form of memoization.
-  // We need to be able to memoize the reactive inputs to the `use` call using
-  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
-  // come from the same component invocation as the output.
-  //
-  // There are plenty of tests to ensure this behavior is correct.
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  var shouldDoubleRenderDEV =
-    (workInProgress.mode & StrictLegacyMode) !== NoMode;
-  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
-  var children = Component(props, secondArg);
-  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+function updateScopeComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  if (didScheduleRenderPhaseUpdateDuringThisPass) {
-    // Keep rendering until the component stabilizes (there are no more render
-    // phase updates).
-    children = renderWithHooksAgain(
-      workInProgress,
-      Component,
-      props,
-      secondArg
-    );
-  }
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+function checkIfWorkInProgressReceivedUpdate() {
+  return didReceiveUpdate;
+}
 
-  if (shouldDoubleRenderDEV) {
-    // In development, components are invoked twice to help detect side effects.
-    setIsStrictModeForDevtools(true);
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
 
-    try {
-      children = renderWithHooksAgain(
-        workInProgress,
-        Component,
-        props,
-        secondArg
-      );
-    } finally {
-      setIsStrictModeForDevtools(false);
+      workInProgress.flags |= Placement;
     }
   }
-
-  finishRenderingHooks(current, workInProgress);
-  return children;
 }
 
-function finishRenderingHooks(current, workInProgress) {
-  // We can assume the previous dispatcher is always this one, since we set it
-  // at the beginning of the render phase and there's no re-entrance.
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    workInProgress.dependencies = current.dependencies;
+  }
 
   {
-    workInProgress._debugHookTypes = hookTypesDev;
-  } // This check uses currentHook so that it works the same in DEV and prod bundles.
-  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
+    // Don't update "base" render times for bailouts.
+    stopProfilerTimerIfRunning();
+  }
 
-  var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
-  renderLanes$1 = NoLanes;
-  currentlyRenderingFiber$1 = null;
-  currentHook = null;
-  workInProgressHook = null;
+  markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.
 
-  {
-    currentHookNameInDev = null;
-    hookTypesDev = null;
-    hookTypesUpdateIndexDev = -1; // Confirm that a static flag was not added or removed since the last
-    // render. If this fires, it suggests that we incorrectly reset the static
-    // flags in some other part of the codebase. This has happened before, for
-    // example, in the SuspenseList implementation.
+  if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+    // 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.
+    if (enableLazyContextPropagation && current !== null) {
+      // Before bailing out, check if there are any context changes in
+      // the children.
+      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
 
-    if (
-      current !== null &&
-      (current.flags & StaticMask) !== (workInProgress.flags & StaticMask) && // Disable this warning in legacy mode, because legacy Suspense is weird
-      // and creates false positives. To make this work in legacy mode, we'd
-      // need to mark fibers that commit in an incomplete state, somehow. For
-      // now I'll disable the warning that most of the bugs that would trigger
-      // it are either exclusive to concurrent mode or exist in both.
-      (current.mode & ConcurrentMode) !== NoMode
-    ) {
-      error(
-        "Internal React error: Expected static flag was missing. Please " +
-          "notify the React team."
-      );
+      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+        return null;
+      }
+    } else {
+      return null;
     }
-  }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
 
-  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
-  // localIdCounter = 0;
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
 
-  thenableIndexCounter = 0;
-  thenableState = null;
+function remountFiber(current, oldWorkInProgress, newWorkInProgress) {
+  {
+    var returnFiber = oldWorkInProgress.return;
 
-  if (didRenderTooFewHooks) {
-    throw new Error(
-      "Rendered fewer hooks than expected. This may be caused by an accidental " +
-        "early return statement."
-    );
-  }
+    if (returnFiber === null) {
+      // eslint-disable-next-line react-internal/prod-error-codes
+      throw new Error("Cannot swap the root fiber.");
+    } // Disconnect from the old current.
+    // It will get deleted.
 
-  if (enableLazyContextPropagation) {
-    if (current !== null) {
-      if (!checkIfWorkInProgressReceivedUpdate()) {
-        // If there were no changes to props or state, we need to check if there
-        // was a context change. We didn't already do this because there's no
-        // 1:1 correspondence between dependencies and hooks. Although, because
-        // there almost always is in the common case (`readContext` is an
-        // internal API), we could compare in there. OTOH, we only hit this case
-        // if everything else bails out, so on the whole it might be better to
-        // keep the comparison out of the common path.
-        var currentDependencies = current.dependencies;
+    current.alternate = null;
+    oldWorkInProgress.alternate = null; // Connect to the new tree.
+
+    newWorkInProgress.index = oldWorkInProgress.index;
+    newWorkInProgress.sibling = oldWorkInProgress.sibling;
+    newWorkInProgress.return = oldWorkInProgress.return;
+    newWorkInProgress.ref = oldWorkInProgress.ref; // Replace the child/sibling pointers above it.
+
+    if (oldWorkInProgress === returnFiber.child) {
+      returnFiber.child = newWorkInProgress;
+    } else {
+      var prevSibling = returnFiber.child;
+
+      if (prevSibling === null) {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error("Expected parent to have a child.");
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-        if (
-          currentDependencies !== null &&
-          checkIfContextChanged(currentDependencies)
-        ) {
-          markWorkInProgressReceivedUpdate();
+      while (prevSibling.sibling !== oldWorkInProgress) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        prevSibling = prevSibling.sibling;
+
+        if (prevSibling === null) {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error("Expected to find the previous sibling.");
         }
-      }
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      prevSibling.sibling = newWorkInProgress;
+    } // Delete the old fiber and place the new one.
+    // Since the old fiber is disconnected, we have to schedule it manually.
+
+    var deletions = returnFiber.deletions;
+
+    if (deletions === null) {
+      returnFiber.deletions = [current];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(current);
     }
+
+    newWorkInProgress.flags |= Placement; // Restart work from the new fiber.
+
+    return newWorkInProgress;
   }
+}
 
-  {
-    if (checkIfUseWrappedInTryCatch()) {
-      var componentName =
-        getComponentNameFromFiber(workInProgress) || "Unknown";
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  var updateLanes = current.lanes;
 
-      if (!didWarnAboutUseWrappedInTryCatch.has(componentName)) {
-        didWarnAboutUseWrappedInTryCatch.add(componentName);
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+  // to check for a context change before we bail out.
 
-        error(
-          "`use` was called from inside a try/catch block. This is not allowed " +
-            "and can lead to unexpected behavior. To handle errors triggered " +
-            "by `use`, wrap your component in a error boundary."
-        );
-      }
+  if (enableLazyContextPropagation) {
+    var dependencies = current.dependencies;
+
+    if (dependencies !== null && checkIfContextChanged(dependencies)) {
+      return true;
     }
   }
+
+  return false;
 }
 
-function replaySuspendedComponentWithHooks(
+function attemptEarlyBailoutIfNoScheduledUpdate(
   current,
   workInProgress,
-  Component,
-  props,
-  secondArg
+  renderLanes
 ) {
-  // This function is used to replay a component that previously suspended,
-  // after its data resolves.
-  //
-  // It's a simplified version of renderWithHooks, but it doesn't need to do
-  // most of the set up work because they weren't reset when we suspended; they
-  // only get reset when the component either completes (finishRenderingHooks)
-  // or unwinds (resetHooksOnUnwind).
-  {
-    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
+  // 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);
+      pushRootTransition(workInProgress);
 
-    ignorePreviousDependencies =
-      current !== null && current.type !== workInProgress.type;
-  }
+      if (enableTransitionTracing) {
+        pushRootMarkerInstance(workInProgress);
+      }
 
-  var children = renderWithHooksAgain(
-    workInProgress,
-    Component,
-    props,
-    secondArg
-  );
-  finishRenderingHooks(current, workInProgress);
-  return children;
-}
+      {
+        var cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
+      }
 
-function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
-  // This is used to perform another render pass. It's used when setState is
-  // called during render, and for double invoking components in Strict Mode
-  // during development.
-  //
-  // The state from the previous pass is reused whenever possible. So, state
-  // updates that were already processed are not processed again, and memoized
-  // functions (`useMemo`) are not invoked again.
-  //
-  // Keep rendering in a loop for as long as render phase updates continue to
-  // be scheduled. Use a counter to prevent infinite loops.
-  var numberOfReRenders = 0;
-  var children;
+      resetHydrationState();
+      break;
 
-  do {
-    if (didScheduleRenderPhaseUpdateDuringThisPass) {
-      // It's possible that a use() value depended on a state that was updated in
-      // this rerender, so we need to watch for different thenables this time.
-      thenableState = null;
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
+
+    case ClassComponent: {
+      break;
     }
 
-    thenableIndexCounter = 0;
-    didScheduleRenderPhaseUpdateDuringThisPass = false;
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
 
-    if (numberOfReRenders >= RE_RENDER_LIMIT) {
-      throw new Error(
-        "Too many re-renders. React limits the number of renders to prevent " +
-          "an infinite loop."
-      );
+    case ContextProvider: {
+      var newValue = workInProgress.memoizedProps.value;
+      var context = workInProgress.type._context;
+      pushProvider(workInProgress, context, newValue);
+      break;
     }
 
-    numberOfReRenders += 1;
+    case Profiler:
+      {
+        // Profiler should only call onRender when one of its descendants actually rendered.
+        var hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
 
-    {
-      // Even when hot reloading, allow dependencies to stabilize
-      // after first render to prevent infinite render phase updates.
-      ignorePreviousDependencies = false;
-    } // Start over from the beginning of the list
+        if (hasChildWork) {
+          workInProgress.flags |= Update;
+        }
 
-    currentHook = null;
-    workInProgressHook = null;
-    workInProgress.updateQueue = null;
+        {
+          // Reset effect durations for the next eventual effect phase.
+          // These are reset during render to allow the DevTools commit hook a chance to read them,
+          var stateNode = workInProgress.stateNode;
+          stateNode.effectDuration = 0;
+          stateNode.passiveEffectDuration = 0;
+        }
+      }
 
-    {
-      // Also validate hook order for cascading updates.
-      hookTypesUpdateIndexDev = -1;
-    }
+      break;
 
-    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV;
-    children = Component(props, secondArg);
-  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+    case SuspenseComponent: {
+      var state = workInProgress.memoizedState;
 
-  return children;
-}
+      if (state !== null) {
+        if (state.dehydrated !== null) {
+          // We're not going to render the children, so this is just to maintain
+          // push/pop symmetry
+          pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+          // been unsuspended it has committed as a resolved Suspense component.
+          // If it needs to be retried, it should have work scheduled on it.
 
-function checkDidRenderIdHook() {
-  // This should be called immediately after every renderWithHooks call.
-  // Conceptually, it's part of the return value of renderWithHooks; it's only a
-  // separate function to avoid using an array tuple.
-  var didRenderIdHook = localIdCounter !== 0;
-  localIdCounter = 0;
-  return didRenderIdHook;
-}
-function bailoutHooks(current, workInProgress, lanes) {
-  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
-  // complete phase (bubbleProperties).
+          workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+          // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
 
-  if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-    workInProgress.flags &= ~(
-      MountPassiveDev |
-      MountLayoutDev |
-      Passive$1 |
-      Update
-    );
-  } else {
-    workInProgress.flags &= ~(Passive$1 | Update);
-  }
+          return null;
+        } // If this boundary is currently timed out, we need to decide
+        // whether to retry the primary children, or to skip over it and
+        // go straight to the fallback. Check the priority of the primary
+        // child fragment.
 
-  current.lanes = removeLanes(current.lanes, lanes);
-}
-function resetHooksAfterThrow() {
-  // This is called immediaetly after a throw. It shouldn't reset the entire
-  // module state, because the work loop might decide to replay the component
-  // again without rewinding.
-  //
-  // It should only reset things like the current dispatcher, to prevent hooks
-  // from being called outside of a component.
-  // We can assume the previous dispatcher is always this one, since we set it
-  // at the beginning of the render phase and there's no re-entrance.
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-}
-function resetHooksOnUnwind() {
-  if (didScheduleRenderPhaseUpdate) {
-    // There were render phase updates. These are only valid for this render
-    // phase, which we are now aborting. Remove the updates from the queues so
-    // they do not persist to the next render. Do not remove updates from hooks
-    // that weren't processed.
-    //
-    // Only reset the updates from the queue if it has a clone. If it does
-    // not have a clone, that means it wasn't processed, and the updates were
-    // scheduled before we entered the render phase.
-    var hook = currentlyRenderingFiber$1.memoizedState;
+        var primaryChildFragment = workInProgress.child;
+        var primaryChildLanes = primaryChildFragment.childLanes;
 
-    while (hook !== null) {
-      var queue = hook.queue;
+        if (includesSomeLane(renderLanes, primaryChildLanes)) {
+          // The primary children have pending work. Use the normal path
+          // to attempt to render the primary children again.
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        } else {
+          // The primary child fragment does not have pending work marked
+          // on it
+          pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+          // priority. Bailout.
 
-      if (queue !== null) {
-        queue.pending = null;
+          var child = bailoutOnAlreadyFinishedWork(
+            current,
+            workInProgress,
+            renderLanes
+          );
+
+          if (child !== null) {
+            // The fallback children have pending work. Skip over the
+            // primary children and work on the fallback.
+            return child.sibling;
+          } else {
+            // Note: We can return `null` here because we already checked
+            // whether there were nested context consumers, via the call to
+            // `bailoutOnAlreadyFinishedWork` above.
+            return null;
+          }
+        }
+      } else {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
       }
 
-      hook = hook.next;
+      break;
     }
 
-    didScheduleRenderPhaseUpdate = false;
-  }
+    case SuspenseListComponent: {
+      var didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
 
-  renderLanes$1 = NoLanes;
-  currentlyRenderingFiber$1 = null;
-  currentHook = null;
-  workInProgressHook = null;
+      var _hasChildWork = includesSomeLane(
+        renderLanes,
+        workInProgress.childLanes
+      );
 
-  {
-    hookTypesDev = null;
-    hookTypesUpdateIndexDev = -1;
-    currentHookNameInDev = null;
-  }
+      if (enableLazyContextPropagation && !_hasChildWork) {
+        // Context changes may not have been propagated yet. We need to do
+        // that now, before we can decide whether to bail out.
+        // TODO: We use `childLanes` as a heuristic for whether there is
+        // remaining work in a few places, including
+        // `bailoutOnAlreadyFinishedWork` and
+        // `updateDehydratedSuspenseComponent`. We should maybe extract this
+        // into a dedicated function.
+        lazilyPropagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes
+        );
+        _hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
+      }
 
-  didScheduleRenderPhaseUpdateDuringThisPass = false;
-  localIdCounter = 0;
-  thenableIndexCounter = 0;
-  thenableState = null;
-}
+      if (didSuspendBefore) {
+        if (_hasChildWork) {
+          // If something was in fallback state last time, and we have all the
+          // same children then we're still in progressive loading state.
+          // Something might get unblocked by state updates or retries in the
+          // tree which will affect the tail. So we need to use the normal
+          // path to compute the correct tail.
+          return updateSuspenseListComponent(
+            current,
+            workInProgress,
+            renderLanes
+          );
+        } // If none of the children had any work, that means that none of
+        // them got retried so they'll still be blocked in the same way
+        // as before. We can fast bail out.
 
-function mountWorkInProgressHook() {
-  var hook = {
-    memoizedState: null,
-    baseState: null,
-    baseQueue: null,
-    queue: null,
-    next: null
-  };
+        workInProgress.flags |= DidCapture;
+      } // If nothing suspended before and we're rendering the same children,
+      // then the tail doesn't matter. Anything new that suspends will work
+      // in the "together" mode, so we can continue from the state we had.
 
-  if (workInProgressHook === null) {
-    // This is the first hook in the list
-    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
-  } else {
-    // Append to the end of the list
-    workInProgressHook = workInProgressHook.next = hook;
-  }
+      var renderState = workInProgress.memoizedState;
 
-  return workInProgressHook;
-}
+      if (renderState !== null) {
+        // Reset to the "together" mode in case we've started a different
+        // update in the past but didn't complete it.
+        renderState.rendering = null;
+        renderState.tail = null;
+        renderState.lastEffect = null;
+      }
 
-function updateWorkInProgressHook() {
-  // This function is used both for updates and for re-renders triggered by a
-  // render phase update. It assumes there is either a current hook we can
-  // clone, or a work-in-progress hook from a previous render pass that we can
-  // use as a base.
-  var nextCurrentHook;
+      pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
 
-  if (currentHook === null) {
-    var current = currentlyRenderingFiber$1.alternate;
+      if (_hasChildWork) {
+        break;
+      } else {
+        // If none of the children had any work, that means that none of
+        // them got retried so they'll still be blocked in the same way
+        // as before. We can fast bail out.
+        return null;
+      }
+    }
 
-    if (current !== null) {
-      nextCurrentHook = current.memoizedState;
-    } else {
-      nextCurrentHook = null;
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      // Need to check if the tree still needs to be deferred. This is
+      // almost identical to the logic used in the normal update path,
+      // so we'll just enter that. The only difference is we'll bail out
+      // at the next level instead of this one, because the child props
+      // have not changed. Which is fine.
+      // TODO: Probably should refactor `beginWork` to split the bailout
+      // path from the normal path. I'm tempted to do a labeled break here
+      // but I won't :)
+      workInProgress.lanes = NoLanes;
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
     }
-  } else {
-    nextCurrentHook = currentHook.next;
-  }
 
-  var nextWorkInProgressHook;
+    case CacheComponent: {
+      {
+        var _cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, _cache);
+      }
 
-  if (workInProgressHook === null) {
-    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
-  } else {
-    nextWorkInProgressHook = workInProgressHook.next;
-  }
+      break;
+    }
 
-  if (nextWorkInProgressHook !== null) {
-    // There's already a work-in-progress. Reuse it.
-    workInProgressHook = nextWorkInProgressHook;
-    nextWorkInProgressHook = workInProgressHook.next;
-    currentHook = nextCurrentHook;
-  } else {
-    // Clone from the current hook.
-    if (nextCurrentHook === null) {
-      var currentFiber = currentlyRenderingFiber$1.alternate;
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var instance = workInProgress.stateNode;
 
-      if (currentFiber === null) {
-        // This is the initial render. This branch is reached when the component
-        // suspends, resumes, then renders an additional hook.
-        // Should never be reached because we should switch to the mount dispatcher first.
-        throw new Error(
-          "Update hook called on initial render. This is likely a bug in React. Please file an issue."
-        );
-      } else {
-        // This is an update. We should always have a current hook.
-        throw new Error("Rendered more hooks than during the previous render.");
+        if (instance !== null) {
+          pushMarkerInstance(workInProgress, instance);
+        }
       }
     }
+  }
 
-    currentHook = nextCurrentHook;
-    var newHook = {
-      memoizedState: currentHook.memoizedState,
-      baseState: currentHook.baseState,
-      baseQueue: currentHook.baseQueue,
-      queue: currentHook.queue,
-      next: null
-    };
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+}
 
-    if (workInProgressHook === null) {
-      // This is the first hook in the list.
-      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+function beginWork$1(current, workInProgress, renderLanes) {
+  {
+    if (workInProgress._debugNeedsRemount && current !== null) {
+      // This will restart the begin phase with a new fiber.
+      return remountFiber(
+        current,
+        workInProgress,
+        createFiberFromTypeAndProps(
+          workInProgress.type,
+          workInProgress.key,
+          workInProgress.pendingProps,
+          workInProgress._debugOwner || null,
+          workInProgress.mode,
+          workInProgress.lanes
+        )
+      );
+    }
+  }
+
+  if (current !== null) {
+    var oldProps = current.memoizedProps;
+    var newProps = workInProgress.pendingProps;
+
+    if (
+      oldProps !== newProps ||
+      hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
+      workInProgress.type !== current.type
+    ) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
     } else {
-      // Append to the end of the list.
-      workInProgressHook = workInProgressHook.next = newHook;
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
+        current,
+        renderLanes
+      );
+
+      if (
+        !hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+        // may not be work scheduled on `current`, so we check for this flag.
+        (workInProgress.flags & DidCapture) === NoFlags$1
+      ) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
+
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
+      }
     }
-  }
-
-  return workInProgressHook;
-} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
-// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
+  } else {
+    didReceiveUpdate = false;
 
-var createFunctionComponentUpdateQueue;
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      var slotIndex = workInProgress.index;
+      var numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
 
-{
-  createFunctionComponentUpdateQueue = function () {
-    return {
-      lastEffect: null,
-      events: null,
-      stores: null,
-      memoCache: null
-    };
-  };
-}
+  workInProgress.lanes = NoLanes;
 
-function use(usable) {
-  if (usable !== null && typeof usable === "object") {
-    // $FlowFixMe[method-unbinding]
-    if (typeof usable.then === "function") {
-      // This is a thenable.
-      var thenable = usable; // Track the position of the thenable within this fiber.
+  switch (workInProgress.tag) {
+    case IndeterminateComponent: {
+      return mountIndeterminateComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        renderLanes
+      );
+    }
 
-      var index = thenableIndexCounter;
-      thenableIndexCounter += 1;
+    case LazyComponent: {
+      var elementType = workInProgress.elementType;
+      return mountLazyComponent(
+        current,
+        workInProgress,
+        elementType,
+        renderLanes
+      );
+    }
 
-      if (thenableState === null) {
-        thenableState = createThenableState();
-      }
+    case FunctionComponent: {
+      var Component = workInProgress.type;
+      var unresolvedProps = workInProgress.pendingProps;
+      var resolvedProps =
+        workInProgress.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      return updateFunctionComponent(
+        current,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+    }
 
-      var result = trackUsedThenable(thenableState, thenable, index);
+    case ClassComponent: {
+      var _Component = workInProgress.type;
+      var _unresolvedProps = workInProgress.pendingProps;
 
-      if (
-        currentlyRenderingFiber$1.alternate === null &&
-        (workInProgressHook === null
-          ? currentlyRenderingFiber$1.memoizedState === null
-          : workInProgressHook.next === null)
-      ) {
-        // Initial render, and either this is the first time the component is
-        // called, or there were no Hooks called after this use() the previous
-        // time (perhaps because it threw). Subsequent Hook calls should use the
-        // mount dispatcher.
-        {
-          ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
-        }
-      }
+      var _resolvedProps =
+        workInProgress.elementType === _Component
+          ? _unresolvedProps
+          : resolveDefaultProps(_Component, _unresolvedProps);
 
-      return result;
-    } else if (
-      usable.$$typeof === REACT_CONTEXT_TYPE ||
-      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
-    ) {
-      var context = usable;
-      return readContext(context);
+      return updateClassComponent(
+        current,
+        workInProgress,
+        _Component,
+        _resolvedProps,
+        renderLanes
+      );
     }
-  } // eslint-disable-next-line react-internal/safe-string-coercion
-
-  throw new Error("An unsupported type was passed to use(): " + String(usable));
-}
 
-function useMemoCache(size) {
-  var memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
 
-  var updateQueue = currentlyRenderingFiber$1.updateQueue;
+    case HostHoistable: {
+      return updateHostHoistable(current, workInProgress);
+    }
 
-  if (updateQueue !== null) {
-    memoCache = updateQueue.memoCache;
-  } // Otherwise clone from the current fiber
+    // eslint-disable-next-line no-fallthrough
 
-  if (memoCache == null) {
-    var current = currentlyRenderingFiber$1.alternate;
+    case HostSingleton: {
+      return updateHostSingleton(current, workInProgress, renderLanes);
+    }
 
-    if (current !== null) {
-      var currentUpdateQueue = current.updateQueue;
+    // eslint-disable-next-line no-fallthrough
 
-      if (currentUpdateQueue !== null) {
-        var currentMemoCache = currentUpdateQueue.memoCache;
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
 
-        if (currentMemoCache != null) {
-          memoCache = {
-            data: currentMemoCache.data.map(function (array) {
-              return array.slice();
-            }),
-            index: 0
-          };
-        }
-      }
-    }
-  } // Finally fall back to allocating a fresh instance of the cache
+    case HostText:
+      return updateHostText$1(current, workInProgress);
 
-  if (memoCache == null) {
-    memoCache = {
-      data: [],
-      index: 0
-    };
-  }
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
 
-  if (updateQueue === null) {
-    updateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = updateQueue;
-  }
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
 
-  updateQueue.memoCache = memoCache;
-  var data = memoCache.data[memoCache.index];
+    case ForwardRef: {
+      var type = workInProgress.type;
+      var _unresolvedProps2 = workInProgress.pendingProps;
 
-  if (data === undefined) {
-    data = memoCache.data[memoCache.index] = new Array(size);
+      var _resolvedProps2 =
+        workInProgress.elementType === type
+          ? _unresolvedProps2
+          : resolveDefaultProps(type, _unresolvedProps2);
 
-    for (var i = 0; i < size; i++) {
-      data[i] = REACT_MEMO_CACHE_SENTINEL;
-    }
-  } else if (data.length !== size) {
-    // TODO: consider warning or throwing here
-    {
-      error(
-        "Expected a constant size argument for each invocation of useMemoCache. " +
-          "The previous cache was allocated with size %s but size %s was requested.",
-        data.length,
-        size
+      return updateForwardRef(
+        current,
+        workInProgress,
+        type,
+        _resolvedProps2,
+        renderLanes
       );
     }
-  }
-
-  memoCache.index++;
-  return data;
-}
 
-function basicStateReducer(state, action) {
-  // $FlowFixMe: Flow doesn't like mixed types
-  return typeof action === "function" ? action(state) : action;
-}
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
 
-function mountReducer(reducer, initialArg, init) {
-  var hook = mountWorkInProgressHook();
-  var initialState;
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
 
-  if (init !== undefined) {
-    initialState = init(initialArg);
-  } else {
-    initialState = initialArg;
-  }
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
 
-  hook.memoizedState = hook.baseState = initialState;
-  var queue = {
-    pending: null,
-    lanes: NoLanes,
-    dispatch: null,
-    lastRenderedReducer: reducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = queue;
-  var dispatch = (queue.dispatch = dispatchReducerAction.bind(
-    null,
-    currentlyRenderingFiber$1,
-    queue
-  ));
-  return [hook.memoizedState, dispatch];
-}
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
 
-function updateReducer(reducer, initialArg, init) {
-  var hook = updateWorkInProgressHook();
-  var queue = hook.queue;
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
 
-  if (queue === null) {
-    throw new Error(
-      "Should have a queue. This is likely a bug in React. Please file an issue."
-    );
-  }
+    case MemoComponent: {
+      var _type2 = workInProgress.type;
+      var _unresolvedProps3 = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
 
-  queue.lastRenderedReducer = reducer;
-  var current = currentHook; // The last rebase update that is NOT part of the base state.
+      var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
 
-  var baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.
+      {
+        if (workInProgress.type !== workInProgress.elementType) {
+          var outerPropTypes = _type2.propTypes;
 
-  var pendingQueue = queue.pending;
+          if (outerPropTypes) {
+            checkPropTypes(
+              outerPropTypes,
+              _resolvedProps3, // Resolved for outer only
+              "prop",
+              getComponentNameFromType(_type2)
+            );
+          }
+        }
+      }
 
-  if (pendingQueue !== null) {
-    // We have new updates that haven't been processed yet.
-    // We'll add them to the base queue.
-    if (baseQueue !== null) {
-      // Merge the pending queue and the base queue.
-      var baseFirst = baseQueue.next;
-      var pendingFirst = pendingQueue.next;
-      baseQueue.next = pendingFirst;
-      pendingQueue.next = baseFirst;
+      _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
+      return updateMemoComponent(
+        current,
+        workInProgress,
+        _type2,
+        _resolvedProps3,
+        renderLanes
+      );
     }
 
-    {
-      if (current.baseQueue !== baseQueue) {
-        // Internal invariant that should never happen, but feasibly could in
-        // the future if we implement resuming, or some form of that.
-        error(
-          "Internal error: Expected work-in-progress queue to be a clone. " +
-            "This is a bug in React."
-        );
-      }
+    case SimpleMemoComponent: {
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        workInProgress.pendingProps,
+        renderLanes
+      );
     }
 
-    current.baseQueue = baseQueue = pendingQueue;
-    queue.pending = null;
-  }
+    case IncompleteClassComponent: {
+      var _Component2 = workInProgress.type;
+      var _unresolvedProps4 = workInProgress.pendingProps;
 
-  if (baseQueue !== null) {
-    // We have a queue to process.
-    var first = baseQueue.next;
-    var newState = current.baseState;
-    var newBaseState = null;
-    var newBaseQueueFirst = null;
-    var newBaseQueueLast = null;
-    var update = first;
+      var _resolvedProps4 =
+        workInProgress.elementType === _Component2
+          ? _unresolvedProps4
+          : resolveDefaultProps(_Component2, _unresolvedProps4);
 
-    do {
-      // An extra OffscreenLane bit is added to updates that were made to
-      // a hidden tree, so that we can distinguish them from updates that were
-      // already there when the tree was hidden.
-      var updateLane = removeLanes(update.lane, OffscreenLane);
-      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
-      // it's not a "base" update and we should disregard the extra base lanes
-      // that were added to renderLanes when we entered the Offscreen tree.
+      return mountIncompleteClassComponent(
+        current,
+        workInProgress,
+        _Component2,
+        _resolvedProps4,
+        renderLanes
+      );
+    }
 
-      var shouldSkipUpdate = isHiddenUpdate
-        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
-        : !isSubsetOfLanes(renderLanes$1, updateLane);
+    case SuspenseListComponent: {
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    }
 
-      if (shouldSkipUpdate) {
-        // Priority is insufficient. Skip this update. If this is the first
-        // skipped update, the previous update/state is the new base
-        // update/state.
-        var clone = {
-          lane: updateLane,
-          action: update.action,
-          hasEagerState: update.hasEagerState,
-          eagerState: update.eagerState,
-          next: null
-        };
+    case ScopeComponent: {
+      {
+        return updateScopeComponent(current, workInProgress, renderLanes);
+      }
+    }
 
-        if (newBaseQueueLast === null) {
-          newBaseQueueFirst = newBaseQueueLast = clone;
-          newBaseState = newState;
-        } else {
-          newBaseQueueLast = newBaseQueueLast.next = clone;
-        } // Update the remaining priority in the queue.
-        // TODO: Don't need to accumulate this. Instead, we can remove
-        // renderLanes from the original lanes.
+    case OffscreenComponent: {
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    }
 
-        currentlyRenderingFiber$1.lanes = mergeLanes(
-          currentlyRenderingFiber$1.lanes,
-          updateLane
+    case LegacyHiddenComponent: {
+      {
+        return updateLegacyHiddenComponent(
+          current,
+          workInProgress,
+          renderLanes
         );
-        markSkippedUpdateLanes(updateLane);
-      } else {
-        // This update does have sufficient priority.
-        if (newBaseQueueLast !== null) {
-          var _clone = {
-            // This update is going to be committed so we never want uncommit
-            // it. Using NoLane works because 0 is a subset of all bitmasks, so
-            // this will never be skipped by the check above.
-            lane: NoLane,
-            action: update.action,
-            hasEagerState: update.hasEagerState,
-            eagerState: update.eagerState,
-            next: null
-          };
-          newBaseQueueLast = newBaseQueueLast.next = _clone;
-        } // Process this update.
-
-        var action = update.action;
-
-        if (shouldDoubleInvokeUserFnsInHooksDEV) {
-          reducer(newState, action);
-        }
-
-        if (update.hasEagerState) {
-          // If this update is a state update (not a reducer) and was processed eagerly,
-          // we can use the eagerly computed state
-          newState = update.eagerState;
-        } else {
-          newState = reducer(newState, action);
-        }
       }
+    }
 
-      update = update.next;
-    } while (update !== null && update !== first);
-
-    if (newBaseQueueLast === null) {
-      newBaseState = newState;
-    } else {
-      newBaseQueueLast.next = newBaseQueueFirst;
-    } // Mark that the fiber performed work, but only if the new state is
-    // different from the current state.
-
-    if (!objectIs(newState, hook.memoizedState)) {
-      markWorkInProgressReceivedUpdate();
+    case CacheComponent: {
+      {
+        return updateCacheComponent(current, workInProgress, renderLanes);
+      }
     }
 
-    hook.memoizedState = newState;
-    hook.baseState = newBaseState;
-    hook.baseQueue = newBaseQueueLast;
-    queue.lastRenderedState = newState;
-  }
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        return updateTracingMarkerComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
 
-  if (baseQueue === null) {
-    // `queue.lanes` is used for entangling transitions. We can set it back to
-    // zero once the queue is empty.
-    queue.lanes = NoLanes;
+      break;
+    }
   }
 
-  var dispatch = queue.dispatch;
-  return [hook.memoizedState, dispatch];
+  throw new Error(
+    "Unknown unit of work tag (" +
+      workInProgress.tag +
+      "). This error is likely caused by a bug in " +
+      "React. Please file an issue."
+  );
 }
 
-function rerenderReducer(reducer, initialArg, init) {
-  var hook = updateWorkInProgressHook();
-  var queue = hook.queue;
-
-  if (queue === null) {
-    throw new Error(
-      "Should have a queue. This is likely a bug in React. Please file an issue."
-    );
-  }
-
-  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
-  // work-in-progress hook.
-
-  var dispatch = queue.dispatch;
-  var lastRenderPhaseUpdate = queue.pending;
-  var newState = hook.memoizedState;
-
-  if (lastRenderPhaseUpdate !== null) {
-    // The queue doesn't persist past this render pass.
-    queue.pending = null;
-    var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
-    var update = firstRenderPhaseUpdate;
+var valueCursor = createCursor(null);
+var rendererCursorDEV;
 
-    do {
-      // Process this render phase update. We don't have to check the
-      // priority because it will always be the same as the current
-      // render's.
-      var action = update.action;
-      newState = reducer(newState, action);
-      update = update.next;
-    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
-    // different from the current state.
+{
+  rendererCursorDEV = createCursor(null);
+}
 
-    if (!objectIs(newState, hook.memoizedState)) {
-      markWorkInProgressReceivedUpdate();
-    }
+var rendererSigil;
 
-    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
-    // the base state unless the queue is empty.
-    // TODO: Not sure if this is the desired semantics, but it's what we
-    // do for gDSFP. I can't remember why.
+{
+  // Use this to detect multiple renderers using the same context
+  rendererSigil = {};
+}
 
-    if (hook.baseQueue === null) {
-      hook.baseState = newState;
-    }
+var currentlyRenderingFiber = null;
+var lastContextDependency = null;
+var lastFullyObservedContext = null;
+var isDisallowedContextReadInDEV = false;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
 
-    queue.lastRenderedState = newState;
+  {
+    isDisallowedContextReadInDEV = false;
   }
-
-  return [newState, dispatch];
 }
-
-function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+function enterDisallowedContextReadInDEV() {
   {
-    warnAboutMultipleRenderersDEV(source);
+    isDisallowedContextReadInDEV = true;
+  }
+}
+function exitDisallowedContextReadInDEV() {
+  {
+    isDisallowedContextReadInDEV = false;
   }
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue, providerFiber);
+    context._currentValue = nextValue;
 
-  var getVersion = source._getVersion;
-  var version = getVersion(source._source); // Is it safe for this component to read from this source during the current render?
+    {
+      push(rendererCursorDEV, context._currentRenderer, providerFiber);
 
-  var isSafeToReadFromSource = false; // Check the version first.
-  // If this render has already been started with a specific version,
-  // we can use it alone to determine if we can safely read from the source.
+      if (
+        context._currentRenderer !== undefined &&
+        context._currentRenderer !== null &&
+        context._currentRenderer !== rendererSigil
+      ) {
+        error(
+          "Detected multiple renderers concurrently rendering the " +
+            "same context provider. This is currently unsupported."
+        );
+      }
 
-  var currentRenderVersion = getWorkInProgressVersion(source);
+      context._currentRenderer = rendererSigil;
+    }
+  }
+}
+function popProvider(context, providerFiber) {
+  var currentValue = valueCursor.current;
 
-  if (currentRenderVersion !== null) {
-    // It's safe to read if the store hasn't been mutated since the last time
-    // we read something.
-    isSafeToReadFromSource = currentRenderVersion === version;
-  } else {
-    // If there's no version, then this is the first time we've read from the
-    // source during the current render pass, so we need to do a bit more work.
-    // What we need to determine is if there are any hooks that already
-    // subscribed to the source, and if so, whether there are any pending
-    // mutations that haven't been synchronized yet.
-    //
-    // If there are no pending mutations, then `root.mutableReadLanes` will be
-    // empty, and we know we can safely read.
-    //
-    // If there *are* pending mutations, we may still be able to safely read
-    // if the currently rendering lanes are inclusive of the pending mutation
-    // lanes, since that guarantees that the value we're about to read from
-    // the source is consistent with the values that we read during the most
-    // recent mutation.
-    isSafeToReadFromSource = isSubsetOfLanes(
-      renderLanes$1,
-      root.mutableReadLanes
-    );
+  {
+    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = context._defaultValue;
+    } else {
+      context._currentValue = currentValue;
+    }
 
-    if (isSafeToReadFromSource) {
-      // If it's safe to read from this source during the current render,
-      // store the version in case other components read from it.
-      // A changed version number will let those components know to throw and restart the render.
-      setWorkInProgressVersion(source, version);
+    {
+      var currentRenderer = rendererCursorDEV.current;
+      pop(rendererCursorDEV, providerFiber);
+      context._currentRenderer = currentRenderer;
     }
   }
 
-  if (isSafeToReadFromSource) {
-    var snapshot = getSnapshot(source._source);
+  pop(valueCursor, providerFiber);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  var node = parent;
 
-    {
-      if (typeof snapshot === "function") {
-        error(
-          "Mutable source should not return a function as the snapshot value. " +
-            "Functions may close over mutable values and cause tearing."
-        );
+  while (node !== null) {
+    var alternate = node.alternate;
+
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
       }
+    } else if (
+      alternate !== null &&
+      !isSubsetOfLanes(alternate.childLanes, renderLanes)
+    ) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else;
+
+    if (node === propagationRoot) {
+      break;
     }
 
-    return snapshot;
-  } else {
-    // This handles the special case of a mutable source being shared between renderers.
-    // In that case, if the source is mutated between the first and second renderer,
-    // The second renderer don't know that it needs to reset the WIP version during unwind,
-    // (because the hook only marks sources as dirty if it's written to their WIP version).
-    // That would cause this tear check to throw again and eventually be visible to the user.
-    // We can avoid this infinite loop by explicitly marking the source as dirty.
-    //
-    // This can lead to tearing in the first renderer when it resumes,
-    // but there's nothing we can do about that (short of throwing here and refusing to continue the render).
-    markSourceAsDirty(source); // Intentioally throw an error to force React to retry synchronously. During
-    // the synchronous retry, it will block interleaved mutations, so we should
-    // get a consistent read. Therefore, the following error should never be
-    // visible to the user.
-    // We expect this error not to be thrown during the synchronous retry,
-    // because we blocked interleaved mutations.
+    node = node.return;
+  }
 
-    throw new Error(
-      "Cannot read from mutable source during the current render without tearing. This may be a bug in React. Please file an issue."
+  {
+    if (node !== propagationRoot) {
+      error(
+        "Expected to find the propagation root when scheduling context work. " +
+          "This error is likely caused by a bug in React. Please file an issue."
+      );
+    }
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  if (enableLazyContextPropagation) {
+    // TODO: This path is only used by Cache components. Update
+    // lazilyPropagateParentContextChanges to look for Cache components so they
+    // can take advantage of lazy propagation.
+    var forcePropagateEntireTree = true;
+    propagateContextChanges(
+      workInProgress,
+      [context],
+      renderLanes,
+      forcePropagateEntireTree
     );
+  } else {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
   }
 }
 
-function useMutableSource(hook, source, getSnapshot, subscribe) {
-  var root = getWorkInProgressRoot();
-
-  if (root === null) {
-    throw new Error(
-      "Expected a work-in-progress root. This is a bug in React. Please file an issue."
-    );
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+  // Only used by eager implementation
+  if (enableLazyContextPropagation) {
+    return;
   }
 
-  var getVersion = source._getVersion;
-  var version = getVersion(source._source);
-  var dispatcher = ReactCurrentDispatcher$1.current; // eslint-disable-next-line prefer-const
+  var fiber = workInProgress.child;
 
-  var _dispatcher$useState = dispatcher.useState(function () {
-      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    }),
-    currentSnapshot = _dispatcher$useState[0],
-    setSnapshot = _dispatcher$useState[1];
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
+  }
 
-  var snapshot = currentSnapshot; // Grab a handle to the state hook as well.
-  // We use it to clear the pending update queue if we have a new source.
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
 
-  var stateHook = workInProgressHook;
-  var memoizedState = hook.memoizedState;
-  var refs = memoizedState.refs;
-  var prevGetSnapshot = refs.getSnapshot;
-  var prevSource = memoizedState.source;
-  var prevSubscribe = memoizedState.subscribe;
-  var fiber = currentlyRenderingFiber$1;
-  hook.memoizedState = {
-    refs: refs,
-    source: source,
-    subscribe: subscribe
-  }; // Sync the values needed by our subscription handler after each commit.
+    var list = fiber.dependencies;
 
-  dispatcher.useEffect(
-    function () {
-      refs.getSnapshot = getSnapshot; // Normally the dispatch function for a state hook never changes,
-      // but this hook recreates the queue in certain cases  to avoid updates from stale sources.
-      // handleChange() below needs to reference the dispatch function without re-subscribing,
-      // so we use a ref to ensure that it always has the latest version.
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dependency = list.firstContext;
 
-      refs.setSnapshot = setSnapshot; // Check for a possible change between when we last rendered now.
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            var lane = pickArbitraryLane(renderLanes);
+            var update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
 
-      var maybeNewVersion = getVersion(source._source);
+            var updateQueue = fiber.updateQueue;
 
-      if (!objectIs(version, maybeNewVersion)) {
-        var maybeNewSnapshot = getSnapshot(source._source);
+            if (updateQueue === null);
+            else {
+              var sharedQueue = updateQueue.shared;
+              var pending = sharedQueue.pending;
 
-        {
-          if (typeof maybeNewSnapshot === "function") {
-            error(
-              "Mutable source should not return a function as the snapshot value. " +
-                "Functions may close over mutable values and cause tearing."
-            );
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
+
+              sharedQueue.pending = update;
+            }
           }
-        }
 
-        if (!objectIs(snapshot, maybeNewSnapshot)) {
-          setSnapshot(maybeNewSnapshot);
-          var lane = requestUpdateLane(fiber);
-          markRootMutableRead(root, lane);
-        } // If the source mutated between render and now,
-        // there may be state updates already scheduled from the old source.
-        // Entangle the updates so that they render in the same batch.
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          var alternate = fiber.alternate;
 
-        markRootEntangled(root, root.mutableReadLanes);
-      }
-    },
-    [getSnapshot, source, subscribe]
-  ); // If we got a new source or subscribe function, re-subscribe in a passive effect.
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
 
-  dispatcher.useEffect(
-    function () {
-      var handleChange = function () {
-        var latestGetSnapshot = refs.getSnapshot;
-        var latestSetSnapshot = refs.setSnapshot;
+          scheduleContextWorkOnParentPath(
+            fiber.return,
+            renderLanes,
+            workInProgress
+          ); // Mark the updated lanes on the list, too.
 
-        try {
-          latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
 
-          var lane = requestUpdateLane(fiber);
-          markRootMutableRead(root, lane);
-        } catch (error) {
-          // A selector might throw after a source mutation.
-          // e.g. it might try to read from a part of the store that no longer exists.
-          // In this case we should still schedule an update with React.
-          // Worst case the selector will throw again and then an error boundary will handle it.
-          latestSetSnapshot(function () {
-            throw error;
-          });
+          break;
         }
-      };
 
-      var unsubscribe = subscribe(source._source, handleChange);
-
-      {
-        if (typeof unsubscribe !== "function") {
-          error(
-            "Mutable source subscribe function must return an unsubscribe function."
-          );
-        }
+        dependency = dependency.next;
       }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      var parentSuspense = fiber.return;
 
-      return unsubscribe;
-    },
-    [source, subscribe]
-  ); // If any of the inputs to useMutableSource change, reading is potentially unsafe.
-  //
-  // If either the source or the subscription have changed we can't can't trust the update queue.
-  // Maybe the source changed in a way that the old subscription ignored but the new one depends on.
-  //
-  // If the getSnapshot function changed, we also shouldn't rely on the update queue.
-  // It's possible that the underlying source was mutated between the when the last "change" event fired,
-  // and when the current render (with the new getSnapshot function) is processed.
-  //
-  // In both cases, we need to throw away pending updates (since they are no longer relevant)
-  // and treat reading from the source as we do in the mount case.
-
-  if (
-    !objectIs(prevGetSnapshot, getSnapshot) ||
-    !objectIs(prevSource, source) ||
-    !objectIs(prevSubscribe, subscribe)
-  ) {
-    // Create a new queue and setState method,
-    // So if there are interleaved updates, they get pushed to the older queue.
-    // When this becomes current, the previous queue and dispatch method will be discarded,
-    // including any interleaving updates that occur.
-    var newQueue = {
-      pending: null,
-      lanes: NoLanes,
-      dispatch: null,
-      lastRenderedReducer: basicStateReducer,
-      lastRenderedState: snapshot
-    };
-    newQueue.dispatch = setSnapshot = dispatchSetState.bind(
-      null,
-      currentlyRenderingFiber$1,
-      newQueue
-    );
-    stateHook.queue = newQueue;
-    stateHook.baseQueue = null;
-    snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    stateHook.memoizedState = stateHook.baseState = snapshot;
-  }
-
-  return snapshot;
-}
-
-function mountMutableSource(source, getSnapshot, subscribe) {
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = {
-    refs: {
-      getSnapshot: getSnapshot,
-      setSnapshot: null
-    },
-    source: source,
-    subscribe: subscribe
-  };
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
+      if (parentSuspense === null) {
+        throw new Error(
+          "We just came from a parent so we must have had a parent. This is a bug in React."
+        );
+      }
 
-function updateMutableSource(source, getSnapshot, subscribe) {
-  var hook = updateWorkInProgressHook();
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      var _alternate = parentSuspense.alternate;
 
-function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-  var fiber = currentlyRenderingFiber$1;
-  var hook = mountWorkInProgressHook();
-  var nextSnapshot;
-  var isHydrating = getIsHydrating();
+      if (_alternate !== null) {
+        _alternate.lanes = mergeLanes(_alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
 
-  if (isHydrating) {
-    if (getServerSnapshot === undefined) {
-      throw new Error(
-        "Missing getServerSnapshot, which is required for " +
-          "server-rendered content. Will revert to client rendering."
+      scheduleContextWorkOnParentPath(
+        parentSuspense,
+        renderLanes,
+        workInProgress
       );
+      nextFiber = fiber.sibling;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
     }
 
-    nextSnapshot = getServerSnapshot();
-
-    {
-      if (!didWarnUncachedGetSnapshot) {
-        if (nextSnapshot !== getServerSnapshot()) {
-          error(
-            "The result of getServerSnapshot should be cached to avoid an infinite loop"
-          );
+    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;
 
-          didWarnUncachedGetSnapshot = true;
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
         }
-      }
-    }
-  } else {
-    nextSnapshot = getSnapshot();
 
-    {
-      if (!didWarnUncachedGetSnapshot) {
-        var cachedSnapshot = getSnapshot();
+        var sibling = nextFiber.sibling;
 
-        if (!objectIs(nextSnapshot, cachedSnapshot)) {
-          error(
-            "The result of getSnapshot should be cached to avoid an infinite loop"
-          );
+        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.
 
-          didWarnUncachedGetSnapshot = true;
-        }
+        nextFiber = nextFiber.return;
       }
-    } // Unless we're rendering a blocking lane, schedule a consistency check.
-    // Right before committing, we will walk the tree and check if any of the
-    // stores were mutated.
-    //
-    // We won't do this if we're hydrating server-rendered content, because if
-    // the content is stale, it's already visible anyway. Instead we'll patch
-    // it up in a passive effect.
-
-    var root = getWorkInProgressRoot();
-
-    if (root === null) {
-      throw new Error(
-        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
-      );
-    }
-
-    if (!includesBlockingLane(root, renderLanes$1)) {
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
     }
-  } // Read the current snapshot from the store on every render. This breaks the
-  // normal rules of React, and only works because store updates are
-  // always synchronous.
 
-  hook.memoizedState = nextSnapshot;
-  var inst = {
-    value: nextSnapshot,
-    getSnapshot: getSnapshot
-  };
-  hook.queue = inst; // Schedule an effect to subscribe to the store.
+    fiber = nextFiber;
+  }
+}
 
-  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
-  // this whenever subscribe, getSnapshot, or value changes. Because there's no
-  // clean-up function, and we track the deps correctly, we can call pushEffect
-  // directly, without storing any additional state. For the same reason, we
-  // don't need to set a static flag, either.
-  // TODO: We can move this to the passive phase once we add a pre-commit
-  // consistency check. See the next comment.
+function propagateContextChanges(
+  workInProgress,
+  contexts,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  // Only used by lazy implementation
+  if (!enableLazyContextPropagation) {
+    return;
+  }
 
-  fiber.flags |= Passive$1;
-  pushEffect(
-    HasEffect | Passive,
-    updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
-    undefined,
-    null
-  );
-  return nextSnapshot;
-}
+  var fiber = workInProgress.child;
 
-function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-  var fiber = currentlyRenderingFiber$1;
-  var hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
-  // normal rules of React, and only works because store updates are
-  // always synchronous.
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
+  }
 
-  var nextSnapshot = getSnapshot();
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
 
-  {
-    if (!didWarnUncachedGetSnapshot) {
-      var cachedSnapshot = getSnapshot();
+    var list = fiber.dependencies;
 
-      if (!objectIs(nextSnapshot, cachedSnapshot)) {
-        error(
-          "The result of getSnapshot should be cached to avoid an infinite loop"
-        );
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dep = list.firstContext;
 
-        didWarnUncachedGetSnapshot = true;
-      }
-    }
-  }
+      findChangedDep: while (dep !== null) {
+        // Assigning these to constants to help Flow
+        var dependency = dep;
+        var consumer = fiber;
 
-  var prevSnapshot = (currentHook || hook).memoizedState;
-  var snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
+        for (var i = 0; i < contexts.length; i++) {
+          var context = contexts[i]; // Check if the context matches.
+          // TODO: Compare selected values to bail out early.
 
-  if (snapshotChanged) {
-    hook.memoizedState = nextSnapshot;
-    markWorkInProgressReceivedUpdate();
-  }
+          if (dependency.context === context) {
+            // Match! Schedule an update on this fiber.
+            // In the lazy implementation, don't mark a dirty flag on the
+            // dependency itself. Not all changes are propagated, so we can't
+            // rely on the propagation function alone to determine whether
+            // something has changed; the consumer will check. In the future, we
+            // could add back a dirty flag as an optimization to avoid double
+            // checking, but until we have selectors it's not really worth
+            // the trouble.
+            consumer.lanes = mergeLanes(consumer.lanes, renderLanes);
+            var alternate = consumer.alternate;
 
-  var inst = hook.queue;
-  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [
-    subscribe
-  ]); // Whenever getSnapshot or subscribe changes, we need to check in the
-  // commit phase if there was an interleaved mutation. In concurrent mode
-  // this can happen all the time, but even in synchronous mode, an earlier
-  // effect may have mutated the store.
+            if (alternate !== null) {
+              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+            }
 
-  if (
-    inst.getSnapshot !== getSnapshot ||
-    snapshotChanged || // Check if the susbcribe function changed. We can save some memory by
-    // checking whether we scheduled a subscription effect above.
-    (workInProgressHook !== null &&
-      workInProgressHook.memoizedState.tag & HasEffect)
-  ) {
-    fiber.flags |= Passive$1;
-    pushEffect(
-      HasEffect | Passive,
-      updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
-      undefined,
-      null
-    ); // Unless we're rendering a blocking lane, schedule a consistency check.
-    // Right before committing, we will walk the tree and check if any of the
-    // stores were mutated.
+            scheduleContextWorkOnParentPath(
+              consumer.return,
+              renderLanes,
+              workInProgress
+            );
 
-    var root = getWorkInProgressRoot();
+            if (!forcePropagateEntireTree) {
+              // During lazy propagation, when we find a match, we can defer
+              // propagating changes to the children, because we're going to
+              // visit them during render. We should continue propagating the
+              // siblings, though
+              nextFiber = null;
+            } // Since we already found a match, we can stop traversing the
+            // dependency list.
 
-    if (root === null) {
-      throw new Error(
-        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
-      );
-    }
+            break findChangedDep;
+          }
+        }
 
-    if (!includesBlockingLane(root, renderLanes$1)) {
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
-    }
-  }
+        dep = dependency.next;
+      }
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      var parentSuspense = fiber.return;
 
-  return nextSnapshot;
-}
+      if (parentSuspense === null) {
+        throw new Error(
+          "We just came from a parent so we must have had a parent. This is a bug in React."
+        );
+      }
 
-function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
-  fiber.flags |= StoreConsistency;
-  var check = {
-    getSnapshot: getSnapshot,
-    value: renderedSnapshot
-  };
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      var _alternate2 = parentSuspense.alternate;
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.stores = [check];
-  } else {
-    var stores = componentUpdateQueue.stores;
+      if (_alternate2 !== null) {
+        _alternate2.lanes = mergeLanes(_alternate2.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
 
-    if (stores === null) {
-      componentUpdateQueue.stores = [check];
+      scheduleContextWorkOnParentPath(
+        parentSuspense,
+        renderLanes,
+        workInProgress
+      );
+      nextFiber = null;
     } else {
-      stores.push(check);
+      // Traverse down.
+      nextFiber = fiber.child;
     }
-  }
-}
 
-function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
-  // These are updated in the passive phase
-  inst.value = nextSnapshot;
-  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
-  // have been in an event that fired before the passive effects, or it could
-  // have been in a layout effect. In that case, we would have used the old
-  // snapsho and getSnapshot values to bail out. We need to check one more time.
+    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;
 
-  if (checkIfSnapshotChanged(inst)) {
-    // Force a re-render.
-    forceStoreRerender(fiber);
-  }
-}
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
 
-function subscribeToStore(fiber, inst, subscribe) {
-  var handleStoreChange = function () {
-    // The store changed. Check if the snapshot changed since the last time we
-    // read from the store.
-    if (checkIfSnapshotChanged(inst)) {
-      // Force a re-render.
-      forceStoreRerender(fiber);
-    }
-  }; // Subscribe to the store and return a clean-up function.
+        var sibling = nextFiber.sibling;
 
-  return subscribe(handleStoreChange);
-}
+        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.
 
-function checkIfSnapshotChanged(inst) {
-  var latestGetSnapshot = inst.getSnapshot;
-  var prevValue = inst.value;
+        nextFiber = nextFiber.return;
+      }
+    }
 
-  try {
-    var nextValue = latestGetSnapshot();
-    return !objectIs(prevValue, nextValue);
-  } catch (error) {
-    return true;
+    fiber = nextFiber;
   }
 }
 
-function forceStoreRerender(fiber) {
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+function lazilyPropagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = false;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
+} // Used for propagating a deferred tree (Suspense, Offscreen). We must propagate
+// to the entire subtree, because we won't revisit it until after the current
+// render has completed, at which point we'll have lost track of which providers
+// have changed.
 
-  if (root !== null) {
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-  }
+function propagateParentContextChangesToDeferredTree(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = true;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
 }
 
-function mountState(initialState) {
-  var hook = mountWorkInProgressHook();
+function propagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (!enableLazyContextPropagation) {
+    return;
+  } // Collect all the parent providers that changed. Since this is usually small
+  // number, we use an Array instead of Set.
 
-  if (typeof initialState === "function") {
-    // $FlowFixMe: Flow doesn't like mixed types
-    initialState = initialState();
-  }
+  var contexts = null;
+  var parent = workInProgress;
+  var isInsidePropagationBailout = false;
 
-  hook.memoizedState = hook.baseState = initialState;
-  var queue = {
-    pending: null,
-    lanes: NoLanes,
-    dispatch: null,
-    lastRenderedReducer: basicStateReducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = queue;
-  var dispatch = (queue.dispatch = dispatchSetState.bind(
-    null,
-    currentlyRenderingFiber$1,
-    queue
-  ));
-  return [hook.memoizedState, dispatch];
-}
+  while (parent !== null) {
+    if (!isInsidePropagationBailout) {
+      if ((parent.flags & NeedsPropagation) !== NoFlags$1) {
+        isInsidePropagationBailout = true;
+      } else if ((parent.flags & DidPropagateContext) !== NoFlags$1) {
+        break;
+      }
+    }
 
-function updateState(initialState) {
-  return updateReducer(basicStateReducer);
-}
+    if (parent.tag === ContextProvider) {
+      var currentParent = parent.alternate;
 
-function rerenderState(initialState) {
-  return rerenderReducer(basicStateReducer);
-}
+      if (currentParent === null) {
+        throw new Error("Should have a current fiber. This is a bug in React.");
+      }
 
-function pushEffect(tag, create, destroy, deps) {
-  var effect = {
-    tag: tag,
-    create: create,
-    destroy: destroy,
-    deps: deps,
-    // Circular
-    next: null
-  };
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+      var oldProps = currentParent.memoizedProps;
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.lastEffect = effect.next = effect;
-  } else {
-    var lastEffect = componentUpdateQueue.lastEffect;
+      if (oldProps !== null) {
+        var providerType = parent.type;
+        var context = providerType._context;
+        var newProps = parent.pendingProps;
+        var newValue = newProps.value;
+        var oldValue = oldProps.value;
 
-    if (lastEffect === null) {
-      componentUpdateQueue.lastEffect = effect.next = effect;
-    } else {
-      var firstEffect = lastEffect.next;
-      lastEffect.next = effect;
-      effect.next = firstEffect;
-      componentUpdateQueue.lastEffect = effect;
+        if (!objectIs(newValue, oldValue)) {
+          if (contexts !== null) {
+            contexts.push(context);
+          } else {
+            contexts = [context];
+          }
+        }
+      }
     }
-  }
-
-  return effect;
-}
-
-var stackContainsErrorMessage = null;
-
-function getCallerStackFrame() {
-  // eslint-disable-next-line react-internal/prod-error-codes
-  var stackFrames = new Error("Error message").stack.split("\n"); // Some browsers (e.g. Chrome) include the error message in the stack
-  // but others (e.g. Firefox) do not.
 
-  if (stackContainsErrorMessage === null) {
-    stackContainsErrorMessage = stackFrames[0].includes("Error message");
+    parent = parent.return;
   }
 
-  return stackContainsErrorMessage
-    ? stackFrames.slice(3, 4).join("\n")
-    : stackFrames.slice(2, 3).join("\n");
+  if (contexts !== null) {
+    // If there were any changed providers, search through the children and
+    // propagate their changes.
+    propagateContextChanges(
+      workInProgress,
+      contexts,
+      renderLanes,
+      forcePropagateEntireTree
+    );
+  } // This is an optimization so that we only propagate once per subtree. If a
+  // deeply nested child bails out, and it calls this propagation function, it
+  // uses this flag to know that the remaining ancestor providers have already
+  // been propagated.
+  //
+  // NOTE: This optimization is only necessary because we sometimes enter the
+  // begin phase of nodes that don't have any work scheduled on them —
+  // specifically, the siblings of a node that _does_ have scheduled work. The
+  // siblings will bail out and call this function again, even though we already
+  // propagated content changes to it and its subtree. So we use this flag to
+  // mark that the parent providers already propagated.
+  //
+  // Unfortunately, though, we need to ignore this flag when we're inside a
+  // tree whose context propagation was deferred — that's what the
+  // `NeedsPropagation` flag is for.
+  //
+  // If we could instead bail out before entering the siblings' begin phase,
+  // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
+  // Consider this as part of the next refactor to the fiber tree structure.
+
+  workInProgress.flags |= DidPropagateContext;
 }
 
-function mountRef(initialValue) {
-  var hook = mountWorkInProgressHook();
+function checkIfContextChanged(currentDependencies) {
+  if (!enableLazyContextPropagation) {
+    return false;
+  } // Iterate over the current dependencies to see if something changed. This
+  // only gets called if props and state has already bailed out, so it's a
+  // relatively uncommon path, except at the root of a changed subtree.
+  // Alternatively, we could move these comparisons into `readContext`, but
+  // that's a much hotter path, so I think this is an appropriate trade off.
 
-  if (enableUseRefAccessWarning) {
-    {
-      // Support lazy initialization pattern shown in docs.
-      // We need to store the caller stack frame so that we don't warn on subsequent renders.
-      var hasBeenInitialized = initialValue != null;
-      var lazyInitGetterStack = null;
-      var didCheckForLazyInit = false; // Only warn once per component+hook.
+  var dependency = currentDependencies.firstContext;
 
-      var didWarnAboutRead = false;
-      var didWarnAboutWrite = false;
-      var current = initialValue;
-      var ref = {
-        get current() {
-          if (!hasBeenInitialized) {
-            didCheckForLazyInit = true;
-            lazyInitGetterStack = getCallerStackFrame();
-          } else if (currentlyRenderingFiber$1 !== null && !didWarnAboutRead) {
-            if (
-              lazyInitGetterStack === null ||
-              lazyInitGetterStack !== getCallerStackFrame()
-            ) {
-              didWarnAboutRead = true;
+  while (dependency !== null) {
+    var context = dependency.context;
+    var newValue = context._currentValue;
+    var oldValue = dependency.memoizedValue;
 
-              warn(
-                "%s: Unsafe read of a mutable value during render.\n\n" +
-                  "Reading from a ref during render is only safe if:\n" +
-                  "1. The ref value has not been updated, or\n" +
-                  "2. The ref holds a lazily-initialized value that is only set once.\n",
-                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
-                  "Unknown"
-              );
-            }
-          }
+    if (!objectIs(newValue, oldValue)) {
+      return true;
+    }
 
-          return current;
-        },
+    dependency = dependency.next;
+  }
 
-        set current(value) {
-          if (currentlyRenderingFiber$1 !== null && !didWarnAboutWrite) {
-            if (hasBeenInitialized || !didCheckForLazyInit) {
-              didWarnAboutWrite = true;
+  return false;
+}
+function prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  var dependencies = workInProgress.dependencies;
 
-              warn(
-                "%s: Unsafe write of a mutable value during render.\n\n" +
-                  "Writing to a ref during render is only safe if the ref holds " +
-                  "a lazily-initialized value that is only set once.\n",
-                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
-                  "Unknown"
-              );
-            }
-          }
+  if (dependencies !== null) {
+    if (enableLazyContextPropagation) {
+      // Reset the work-in-progress list
+      dependencies.firstContext = null;
+    } else {
+      var firstContext = dependencies.firstContext;
 
-          hasBeenInitialized = true;
-          current = value;
-        }
-      };
-      Object.seal(ref);
-      hook.memoizedState = ref;
-      return ref;
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
+
+        dependencies.firstContext = null;
+      }
     }
-  } else {
-    var _ref2 = {
-      current: initialValue
-    };
-    hook.memoizedState = _ref2;
-    return _ref2;
   }
 }
+function readContext(context) {
+  {
+    // This warning would fire if you read context inside a Hook like useMemo.
+    // Unlike the class check below, it's not enforced in production for perf.
+    if (isDisallowedContextReadInDEV) {
+      error(
+        "Context can only be read while React is rendering. " +
+          "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+          "In function components, you can read it directly in the function body, but not " +
+          "inside Hooks like useReducer() or useMemo()."
+      );
+    }
+  }
 
-function updateRef(initialValue) {
-  var hook = updateWorkInProgressHook();
-  return hook.memoizedState;
+  return readContextForConsumer(currentlyRenderingFiber, context);
 }
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
+  }
 
-function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    HasEffect | hookFlags,
-    create,
-    undefined,
-    nextDeps
-  );
+  return readContextForConsumer(consumer, context);
 }
 
-function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var destroy = undefined; // currentHook is null when rerendering after a render phase state update.
+function readContextForConsumer(consumer, context) {
+  var value = isPrimaryRenderer
+    ? context._currentValue
+    : context._currentValue2;
+
+  if (lastFullyObservedContext === context);
+  else {
+    var contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
 
-  if (currentHook !== null) {
-    var prevEffect = currentHook.memoizedState;
-    destroy = prevEffect.destroy;
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw new Error(
+          "Context can only be read while React is rendering. " +
+            "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+            "In function components, you can read it directly in the function body, but not " +
+            "inside Hooks like useReducer() or useMemo()."
+        );
+      } // This is the first dependency for this component. Create a new list.
 
-    if (nextDeps !== null) {
-      var prevDeps = prevEffect.deps;
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
 
-      if (areHookInputsEqual(nextDeps, prevDeps)) {
-        hook.memoizedState = pushEffect(hookFlags, create, destroy, nextDeps);
-        return;
+      if (enableLazyContextPropagation) {
+        consumer.flags |= NeedsPropagation;
       }
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
     }
   }
 
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    HasEffect | hookFlags,
-    create,
-    destroy,
-    nextDeps
-  );
+  return value;
 }
 
-function mountEffect(create, deps) {
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    mountEffectImpl(
-      MountPassiveDev | Passive$1 | PassiveStatic,
-      Passive,
-      create,
-      deps
-    );
-  } else {
-    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
-  }
-}
+// replace it with a lightweight shim that only has the features we use.
 
-function updateEffect(create, deps) {
-  updateEffectImpl(Passive$1, Passive, create, deps);
-}
+var AbortControllerLocal =
+  typeof AbortController !== "undefined"
+    ? AbortController // $FlowFixMe[missing-this-annot]
+    : function AbortControllerShim() {
+        var listeners = [];
+        var signal = (this.signal = {
+          aborted: false,
+          addEventListener: function (type, listener) {
+            listeners.push(listener);
+          }
+        });
 
-function useEffectEventImpl(payload) {
-  currentlyRenderingFiber$1.flags |= Update;
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+        this.abort = function () {
+          signal.aborted = true;
+          listeners.forEach(function (listener) {
+            return listener();
+          });
+        };
+      }; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.events = [payload];
-  } else {
-    var events = componentUpdateQueue.events;
+var scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+  NormalPriority = Scheduler.unstable_NormalPriority;
+var CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
+};
 
-    if (events === null) {
-      componentUpdateQueue.events = [payload];
-    } else {
-      events.push(payload);
-    }
-  }
-}
+{
+  CacheContext._currentRenderer = null;
+  CacheContext._currentRenderer2 = null;
+} // Creates a new empty Cache instance with a ref-count of 0. The caller is responsible
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
 
-function mountEvent(callback) {
-  var hook = mountWorkInProgressHook();
-  var ref = {
-    impl: callback
+function createCache() {
+  var cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
   };
-  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
-
-  return function eventFn() {
-    if (isInvalidExecutionContextForEventFunction()) {
-      throw new Error(
-        "A function wrapped in useEffectEvent can't be called during rendering."
+  return cache;
+}
+function retainCache(cache) {
+  {
+    if (cache.controller.signal.aborted) {
+      warn(
+        "A cache instance was retained after it was already freed. " +
+          "This likely indicates a bug in React."
       );
     }
+  }
 
-    return ref.impl.apply(undefined, arguments);
-  };
-}
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
 
-function updateEvent(callback) {
-  var hook = updateWorkInProgressHook();
-  var ref = hook.memoizedState;
-  useEffectEventImpl({
-    ref: ref,
-    nextImpl: callback
-  }); // $FlowIgnore[incompatible-return]
+function releaseCache(cache) {
+  cache.refCount--;
 
-  return function eventFn() {
-    if (isInvalidExecutionContextForEventFunction()) {
-      throw new Error(
-        "A function wrapped in useEffectEvent can't be called during rendering."
+  {
+    if (cache.refCount < 0) {
+      warn(
+        "A cache instance was released after it was already freed. " +
+          "This likely indicates a bug in React."
       );
     }
+  }
 
-    return ref.impl.apply(undefined, arguments);
-  };
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, function () {
+      cache.controller.abort();
+    });
+  }
 }
-
-function mountInsertionEffect(create, deps) {
-  mountEffectImpl(Update, Insertion, create, deps);
+function pushCacheProvider(workInProgress, cache) {
+  pushProvider(workInProgress, CacheContext, cache);
 }
-
-function updateInsertionEffect(create, deps) {
-  return updateEffectImpl(Update, Insertion, create, deps);
+function popCacheProvider(workInProgress, cache) {
+  popProvider(CacheContext, workInProgress);
 }
 
-function mountLayoutEffect(create, deps) {
-  var fiberFlags = Update | LayoutStatic;
-
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    fiberFlags |= MountLayoutDev;
-  }
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+var NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
 
-  return mountEffectImpl(fiberFlags, Layout, create, deps);
-}
+var resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+// transitions. Therefore, we want to lazily combine transitions. Instead of
+// comparing the arrays of transitions when we combine them and storing them
+// and filtering out the duplicates, we will instead store the unprocessed transitions
+// in an array and actually filter them in the passive phase.
 
-function updateLayoutEffect(create, deps) {
-  return updateEffectImpl(Update, Layout, create, deps);
-}
+var transitionStack = createCursor(null);
 
-function imperativeHandleEffect(create, ref) {
-  if (typeof ref === "function") {
-    var refCallback = ref;
-    var inst = create();
-    refCallback(inst);
-    return function () {
-      refCallback(null);
-    };
-  } else if (ref !== null && ref !== undefined) {
-    var refObject = ref;
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
 
-    {
-      if (!refObject.hasOwnProperty("current")) {
-        error(
-          "Expected useImperativeHandle() first argument to either be a " +
-            "ref callback or React.createRef() object. Instead received: %s.",
-          "an object with keys {" + Object.keys(refObject).join(", ") + "}"
-        );
-      }
-    }
+  var cacheResumedFromPreviousRender = resumedCache.current;
 
-    var _inst = create();
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
 
-    refObject.current = _inst;
-    return function () {
-      refObject.current = null;
-    };
-  }
+  var root = getWorkInProgressRoot();
+  var cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
 }
 
-function mountImperativeHandle(ref, create, deps) {
-  {
-    if (typeof create !== "function") {
-      error(
-        "Expected useImperativeHandle() second argument to be a function " +
-          "that creates a handle. Instead received: %s.",
-        create !== null ? typeof create : "null"
-      );
-    }
-  } // TODO: If deps are provided, should we skip comparing the ref itself?
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  var cacheFromPool = peekCacheFromPool();
 
-  var effectDeps =
-    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-  var fiberFlags = Update | LayoutStatic;
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
 
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    fiberFlags |= MountLayoutDev;
+  var root = getWorkInProgressRoot();
+  var freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
+
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
   }
 
-  mountEffectImpl(
-    fiberFlags,
-    Layout,
-    imperativeHandleEffect.bind(null, create, ref),
-    effectDeps
-  );
+  return freshCache;
 }
-
-function updateImperativeHandle(ref, create, deps) {
+function pushRootTransition(workInProgress, root, renderLanes) {
+  if (enableTransitionTracing) {
+    var rootTransitions = getWorkInProgressTransitions();
+    push(transitionStack, rootTransitions, workInProgress);
+  }
+}
+function popRootTransition(workInProgress, root, renderLanes) {
+  if (enableTransitionTracing) {
+    pop(transitionStack, workInProgress);
+  }
+}
+function pushTransition(
+  offscreenWorkInProgress,
+  prevCachePool,
+  newTransitions
+) {
   {
-    if (typeof create !== "function") {
-      error(
-        "Expected useImperativeHandle() second argument to be a function " +
-          "that creates a handle. Instead received: %s.",
-        create !== null ? typeof create : "null"
-      );
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current, offscreenWorkInProgress);
+    } else {
+      push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
     }
-  } // TODO: If deps are provided, should we skip comparing the ref itself?
+  }
 
-  var effectDeps =
-    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-  updateEffectImpl(
-    Update,
-    Layout,
-    imperativeHandleEffect.bind(null, create, ref),
-    effectDeps
-  );
+  if (enableTransitionTracing) {
+    if (transitionStack.current === null) {
+      push(transitionStack, newTransitions, offscreenWorkInProgress);
+    } else if (newTransitions === null) {
+      push(transitionStack, transitionStack.current, offscreenWorkInProgress);
+    } else {
+      push(
+        transitionStack,
+        transitionStack.current.concat(newTransitions),
+        offscreenWorkInProgress
+      );
+    }
+  }
 }
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+    if (enableTransitionTracing) {
+      pop(transitionStack, workInProgress);
+    }
 
-function mountDebugValue(value, formatterFn) {
-  // This hook is normally a no-op.
-  // The react-debug-hooks package injects its own implementation
-  // so that e.g. DevTools can display custom hook values.
+    {
+      pop(resumedCache, workInProgress);
+    }
+  }
 }
+function getPendingTransitions() {
+  if (!enableTransitionTracing) {
+    return null;
+  }
 
-var updateDebugValue = mountDebugValue;
-
-function mountCallback(callback, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  hook.memoizedState = [callback, nextDeps];
-  return callback;
+  return transitionStack.current;
 }
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
 
-function updateCallback(callback, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var prevState = hook.memoizedState;
-
-  if (nextDeps !== null) {
-    var prevDeps = prevState[1];
+  var cacheFromPool = peekCacheFromPool();
 
-    if (areHookInputsEqual(nextDeps, prevDeps)) {
-      return prevState[0];
-    }
+  if (cacheFromPool === null) {
+    return null;
   }
 
-  hook.memoizedState = [callback, nextDeps];
-  return callback;
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue,
+    pool: cacheFromPool
+  };
 }
+function getOffscreenDeferredCache() {
+  var cacheFromPool = peekCacheFromPool();
 
-function mountMemo(nextCreate, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-
-  if (shouldDoubleInvokeUserFnsInHooksDEV) {
-    nextCreate();
+  if (cacheFromPool === null) {
+    return null;
   }
 
-  var nextValue = nextCreate();
-  hook.memoizedState = [nextValue, nextDeps];
-  return nextValue;
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue,
+    pool: cacheFromPool
+  };
 }
 
-function updateMemo(nextCreate, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
-
-  if (nextDeps !== null) {
-    var prevDeps = prevState[1];
-
-    if (areHookInputsEqual(nextDeps, prevDeps)) {
-      return prevState[0];
-    }
-  }
+function getSuspenseFallbackChild(fiber) {
+  return fiber.child.sibling.child;
+}
 
-  if (shouldDoubleInvokeUserFnsInHooksDEV) {
-    nextCreate();
-  }
+var emptyObject = {};
 
-  var nextValue = nextCreate();
-  hook.memoizedState = [nextValue, nextDeps];
-  return nextValue;
-}
+function collectScopedNodes(node, fn, scopedNodes) {
+  {
+    if (node.tag === HostComponent) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        stateNode = node.stateNode;
+      var instance = getPublicInstance(stateNode);
 
-function mountDeferredValue(value) {
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = value;
-  return value;
-}
+      if (
+        instance !== null &&
+        fn(type, memoizedProps || emptyObject, instance) === true
+      ) {
+        scopedNodes.push(instance);
+      }
+    }
 
-function updateDeferredValue(value) {
-  var hook = updateWorkInProgressHook();
-  var resolvedCurrentHook = currentHook;
-  var prevValue = resolvedCurrentHook.memoizedState;
-  return updateDeferredValueImpl(hook, prevValue, value);
-}
+    var child = node.child;
 
-function rerenderDeferredValue(value) {
-  var hook = updateWorkInProgressHook();
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
+    }
 
-  if (currentHook === null) {
-    // This is a rerender during a mount.
-    hook.memoizedState = value;
-    return value;
-  } else {
-    // This is a rerender during an update.
-    var prevValue = currentHook.memoizedState;
-    return updateDeferredValueImpl(hook, prevValue, value);
+    if (child !== null) {
+      collectScopedNodesFromChildren(child, fn, scopedNodes);
+    }
   }
 }
 
-function updateDeferredValueImpl(hook, prevValue, value) {
-  var shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes$1);
+function collectFirstScopedNode(node, fn) {
+  {
+    if (node.tag === HostComponent) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        stateNode = node.stateNode;
+      var instance = getPublicInstance(stateNode);
 
-  if (shouldDeferValue) {
-    // This is an urgent update. If the value has changed, keep using the
-    // previous value and spawn a deferred render to update it later.
-    if (!objectIs(value, prevValue)) {
-      // Schedule a deferred render
-      var deferredLane = claimNextTransitionLane();
-      currentlyRenderingFiber$1.lanes = mergeLanes(
-        currentlyRenderingFiber$1.lanes,
-        deferredLane
-      );
-      markSkippedUpdateLanes(deferredLane); // Set this to true to indicate that the rendered value is inconsistent
-      // from the latest value. The name "baseState" doesn't really match how we
-      // use it because we're reusing a state hook field instead of creating a
-      // new one.
+      if (instance !== null && fn(type, memoizedProps, instance) === true) {
+        return instance;
+      }
+    }
 
-      hook.baseState = true;
-    } // Reuse the previous value
+    var child = node.child;
 
-    return prevValue;
-  } else {
-    // This is not an urgent update, so we can use the latest value regardless
-    // of what it is. No need to defer it.
-    // However, if we're currently inside a spawned render, then we need to mark
-    // this as an update to prevent the fiber from bailing out.
-    //
-    // `baseState` is true when the current value is different from the rendered
-    // value. The name doesn't really match how we use it because we're reusing
-    // a state hook field instead of creating a new one.
-    if (hook.baseState) {
-      // Flip this back to false.
-      hook.baseState = false;
-      markWorkInProgressReceivedUpdate();
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
     }
 
-    hook.memoizedState = value;
-    return value;
+    if (child !== null) {
+      return collectFirstScopedNodeFromChildren(child, fn);
+    }
+  }
+
+  return null;
+}
+
+function collectScopedNodesFromChildren(startingChild, fn, scopedNodes) {
+  var child = startingChild;
+
+  while (child !== null) {
+    collectScopedNodes(child, fn, scopedNodes);
+    child = child.sibling;
   }
 }
 
-function startTransition(setPending, callback, options) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  setCurrentUpdatePriority(
-    higherEventPriority(previousPriority, ContinuousEventPriority)
-  );
-  setPending(true);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
-  var currentTransition = ReactCurrentBatchConfig$2.transition;
+function collectFirstScopedNodeFromChildren(startingChild, fn) {
+  var child = startingChild;
 
-  if (enableTransitionTracing) {
-    if (options !== undefined && options.name !== undefined) {
-      ReactCurrentBatchConfig$2.transition.name = options.name;
-      ReactCurrentBatchConfig$2.transition.startTime = now$1();
+  while (child !== null) {
+    var scopedNode = collectFirstScopedNode(child, fn);
+
+    if (scopedNode !== null) {
+      return scopedNode;
     }
-  }
 
-  {
-    ReactCurrentBatchConfig$2.transition._updatedFibers = new Set();
+    child = child.sibling;
   }
 
-  try {
-    setPending(false);
-    callback();
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$2.transition = prevTransition;
+  return null;
+}
 
-    {
-      if (prevTransition === null && currentTransition._updatedFibers) {
-        var updatedFibersCount = currentTransition._updatedFibers.size;
+function collectNearestContextValues(node, context, childContextValues) {
+  if (node.tag === ContextProvider && node.type._context === context) {
+    var contextValue = node.memoizedProps.value;
+    childContextValues.push(contextValue);
+  } else {
+    var child = node.child;
 
-        currentTransition._updatedFibers.clear();
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
+    }
 
-        if (updatedFibersCount > 10) {
-          warn(
-            "Detected a large number of updates inside startTransition. " +
-              "If this is due to a subscription please re-write it to use React provided hooks. " +
-              "Otherwise concurrent mode guarantees are off the table."
-          );
-        }
-      }
+    if (child !== null) {
+      collectNearestChildContextValues(child, context, childContextValues);
     }
   }
 }
 
-function mountTransition() {
-  var _mountState = mountState(false),
-    isPending = _mountState[0],
-    setPending = _mountState[1]; // The `start` method never changes.
+function collectNearestChildContextValues(
+  startingChild,
+  context,
+  childContextValues
+) {
+  var child = startingChild;
 
-  var start = startTransition.bind(null, setPending);
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = start;
-  return [isPending, start];
+  while (child !== null) {
+    collectNearestContextValues(child, context, childContextValues);
+    child = child.sibling;
+  }
 }
 
-function updateTransition() {
-  var _updateState = updateState(),
-    isPending = _updateState[0];
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
 
-  var hook = updateWorkInProgressHook();
-  var start = hook.memoizedState;
-  return [isPending, start];
-}
+  if (currentFiber === null) {
+    return null;
+  }
 
-function rerenderTransition() {
-  var _rerenderState = rerenderState(),
-    isPending = _rerenderState[0];
+  var child = currentFiber.child;
+  var scopedNodes = [];
 
-  var hook = updateWorkInProgressHook();
-  var start = hook.memoizedState;
-  return [isPending, start];
+  if (child !== null) {
+    collectScopedNodesFromChildren(child, fn, scopedNodes);
+  }
+
+  return scopedNodes.length === 0 ? null : scopedNodes;
 }
 
-function mountId() {
-  var hook = mountWorkInProgressHook();
-  var root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
-  // should do this in Fiber, too? Deferring this decision for now because
-  // there's no other place to store the prefix except for an internal field on
-  // the public createRoot object, which the fiber tree does not currently have
-  // a reference to.
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
 
-  var identifierPrefix = root.identifierPrefix;
-  var id;
+  if (currentFiber === null) {
+    return null;
+  }
 
-  if (getIsHydrating()) {
-    var treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
+  var child = currentFiber.child;
 
-    id = ":" + identifierPrefix + "R" + treeId; // Unless this is the first id at this level, append a number at the end
-    // that represents the position of this useId hook among all the useId
-    // hooks for this fiber.
+  if (child !== null) {
+    return collectFirstScopedNodeFromChildren(child, fn);
+  }
 
-    var localId = localIdCounter++;
+  return null;
+}
 
-    if (localId > 0) {
-      id += "H" + localId.toString(32);
+function containsNode$1(node) {
+  var fiber = getInstanceFromNode(node);
+
+  while (fiber !== null) {
+    if (fiber.tag === ScopeComponent && fiber.stateNode === this) {
+      return true;
     }
 
-    id += ":";
-  } else {
-    // Use a lowercase r prefix for client-generated ids.
-    var globalClientId = globalClientIdCounter++;
-    id = ":" + identifierPrefix + "r" + globalClientId.toString(32) + ":";
+    fiber = fiber.return;
   }
 
-  hook.memoizedState = id;
-  return id;
+  return false;
 }
 
-function updateId() {
-  var hook = updateWorkInProgressHook();
-  var id = hook.memoizedState;
-  return id;
-}
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
 
-function mountRefresh() {
-  var hook = mountWorkInProgressHook();
-  var refresh = (hook.memoizedState = refreshCache.bind(
-    null,
-    currentlyRenderingFiber$1
-  ));
-  return refresh;
+  if (currentFiber === null) {
+    return [];
+  }
+
+  var child = currentFiber.child;
+  var childContextValues = [];
+
+  if (child !== null) {
+    collectNearestChildContextValues(child, context, childContextValues);
+  }
+
+  return childContextValues;
 }
 
-function updateRefresh() {
-  var hook = updateWorkInProgressHook();
-  return hook.memoizedState;
+function createScopeInstance() {
+  return {
+    DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+    DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+    containsNode: containsNode$1,
+    getChildContextValues: getChildContextValues
+  };
 }
 
-function refreshCache(fiber, seedKey, seedValue) {
-  // TODO: Consider warning if the refresh is at discrete priority, or if we
-  // otherwise suspect that it wasn't batched properly.
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
 
-  var provider = fiber.return;
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
 
-  while (provider !== null) {
-    switch (provider.tag) {
-      case CacheComponent:
-      case HostRoot: {
-        // Schedule an update on the cache boundary to trigger a refresh.
-        var lane = requestUpdateLane(provider);
-        var refreshUpdate = createUpdate(lane);
-        var root = enqueueUpdate(provider, refreshUpdate, lane);
+function appendAllChildren(
+  parent,
+  workInProgress,
+  needsVisibilityToggle,
+  isHidden
+) {
+  {
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    var node = workInProgress.child;
 
-        if (root !== null) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, provider, lane, eventTime);
-          entangleTransitions(root, provider, lane);
-        } // TODO: If a refresh never commits, the new cache created here must be
-        // released. A simple case is start refreshing a cache boundary, but then
-        // unmount that boundary before the refresh completes.
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || node.tag === HostSingleton);
+      else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
 
-        var seededCache = createCache();
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-        if (seedKey !== null && seedKey !== undefined && root !== null) {
-          {
-            // Seed the cache with the value passed by the caller. This could be
-            // from a server mutation, or it could be a streaming response.
-            seededCache.data.set(seedKey, seedValue);
-          }
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
         }
 
-        var payload = {
-          cache: seededCache
-        };
-        refreshUpdate.payload = payload;
-        return;
-      }
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      node.sibling.return = node.return;
+      node = node.sibling;
     }
+  }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
 
-    provider = provider.return;
-  } // TODO: Warn if unmounted?
+function updateHostComponent(current, workInProgress, type, newProps) {
+  {
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    var oldProps = current.memoizedProps;
+
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    } // If we get updated because one of our children updated, we don't
+    // have newProps so we'll have to reuse them.
+    // TODO: Split the update API as separate for the props vs. children.
+    // Even better would be if children weren't special cased at all tho.
+
+    var instance = workInProgress.stateNode;
+    var currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host
+    // component is hitting the resume path. Figure out why. Possibly
+    // related to `hidden`.
+
+    var updatePayload = prepareUpdate(
+      instance,
+      type,
+      oldProps,
+      newProps,
+      currentHostContext
+    ); // TODO: Type this specific to this type of component.
+
+    workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
+    // is a new ref we mark this as an update. All the work is done in commitWork.
+
+    if (updatePayload) {
+      markUpdate(workInProgress);
+    }
+  }
 }
 
-function dispatchReducerAction(fiber, queue, action) {
+function updateHostText(current, workInProgress, oldText, newText) {
   {
-    if (typeof arguments[3] === "function") {
-      error(
-        "State updates from the useState() and useReducer() Hooks don't support the " +
-          "second callback argument. To execute a side effect after " +
-          "rendering, declare it in the component body with useEffect()."
-      );
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
     }
   }
+}
 
-  var lane = requestUpdateLane(fiber);
-  var update = {
-    lane: lane,
-    action: action,
-    hasEagerState: false,
-    eagerState: null,
-    next: null
-  };
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
 
-  if (isRenderPhaseUpdate(fiber)) {
-    enqueueRenderPhaseUpdate(queue, update);
-  } else {
-    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+  switch (renderState.tailMode) {
+    case "hidden": {
+      // Any insertions at the end of the tail list after this point
+      // should be invisible. If there are already mounted boundaries
+      // anything before them are not considered for collapsing.
+      // Therefore we need to go through the whole tail to find if
+      // there are any.
+      var tailNode = renderState.tail;
+      var lastTailNode = null;
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitionUpdate(root, queue, lane);
+      while (tailNode !== null) {
+        if (tailNode.alternate !== null) {
+          lastTailNode = tailNode;
+        }
+
+        tailNode = tailNode.sibling;
+      } // Next we're simply going to delete all insertions after the
+      // last rendered item.
+
+      if (lastTailNode === null) {
+        // All remaining items in the tail are insertions.
+        renderState.tail = null;
+      } else {
+        // Detach the insertion after the last node that was already
+        // inserted.
+        lastTailNode.sibling = null;
+      }
+
+      break;
     }
-  }
 
-  markUpdateInDevTools(fiber, lane, action);
-}
+    case "collapsed": {
+      // Any insertions at the end of the tail list after this point
+      // should be invisible. If there are already mounted boundaries
+      // anything before them are not considered for collapsing.
+      // Therefore we need to go through the whole tail to find if
+      // there are any.
+      var _tailNode = renderState.tail;
+      var _lastTailNode = null;
 
-function dispatchSetState(fiber, queue, action) {
-  {
-    if (typeof arguments[3] === "function") {
-      error(
-        "State updates from the useState() and useReducer() Hooks don't support the " +
-          "second callback argument. To execute a side effect after " +
-          "rendering, declare it in the component body with useEffect()."
-      );
+      while (_tailNode !== null) {
+        if (_tailNode.alternate !== null) {
+          _lastTailNode = _tailNode;
+        }
+
+        _tailNode = _tailNode.sibling;
+      } // Next we're simply going to delete all insertions after the
+      // last rendered item.
+
+      if (_lastTailNode === null) {
+        // All remaining items in the tail are insertions.
+        if (!hasRenderedATailFallback && renderState.tail !== null) {
+          // We suspended during the head. We want to show at least one
+          // row at the tail. So we'll keep on and cut off the rest.
+          renderState.tail.sibling = null;
+        } else {
+          renderState.tail = null;
+        }
+      } else {
+        // Detach the insertion after the last node that was already
+        // inserted.
+        _lastTailNode.sibling = null;
+      }
+
+      break;
     }
   }
+}
 
-  var lane = requestUpdateLane(fiber);
-  var update = {
-    lane: lane,
-    action: action,
-    hasEagerState: false,
-    eagerState: null,
-    next: null
-  };
+function bubbleProperties(completedWork) {
+  var didBailout =
+    completedWork.alternate !== null &&
+    completedWork.alternate.child === completedWork.child;
+  var newChildLanes = NoLanes;
+  var subtreeFlags = NoFlags$1;
 
-  if (isRenderPhaseUpdate(fiber)) {
-    enqueueRenderPhaseUpdate(queue, update);
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      var actualDuration = completedWork.actualDuration;
+      var treeBaseDuration = completedWork.selfBaseDuration;
+      var child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(child.lanes, child.childLanes)
+        );
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // When a fiber is cloned, its actualDuration is reset to 0. This value will
+        // only be updated if work is done on the fiber (i.e. it doesn't bailout).
+        // When work is done, it should bubble to the parent's actualDuration. If
+        // the fiber has not been cloned though, (meaning no work was done), then
+        // this value will reflect the amount of time spent working on a previous
+        // render. In that case it should not bubble. We determine whether it was
+        // cloned by comparing the child pointer.
+        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        actualDuration += child.actualDuration; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        treeBaseDuration += child.treeBaseDuration;
+        child = child.sibling;
+      }
+
+      completedWork.actualDuration = actualDuration;
+      completedWork.treeBaseDuration = treeBaseDuration;
+    } else {
+      var _child = completedWork.child;
+
+      while (_child !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child.lanes, _child.childLanes)
+        );
+        subtreeFlags |= _child.subtreeFlags;
+        subtreeFlags |= _child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        _child.return = completedWork;
+        _child = _child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
   } else {
-    var alternate = fiber.alternate;
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      var _treeBaseDuration = completedWork.selfBaseDuration;
+      var _child2 = completedWork.child;
 
-    if (
-      fiber.lanes === NoLanes &&
-      (alternate === null || alternate.lanes === NoLanes)
-    ) {
-      // The queue is currently empty, which means we can eagerly compute the
-      // next state before entering the render phase. If the new state is the
-      // same as the current state, we may be able to bail out entirely.
-      var lastRenderedReducer = queue.lastRenderedReducer;
+      while (_child2 !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child2.lanes, _child2.childLanes)
+        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
+        // so we should bubble those up even during a bailout. All the other
+        // flags have a lifetime only of a single render + commit, so we should
+        // ignore them.
 
-      if (lastRenderedReducer !== null) {
-        var prevDispatcher;
+        subtreeFlags |= _child2.subtreeFlags & StaticMask;
+        subtreeFlags |= _child2.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
 
-        {
-          prevDispatcher = ReactCurrentDispatcher$1.current;
-          ReactCurrentDispatcher$1.current =
-            InvalidNestedHooksDispatcherOnUpdateInDEV;
-        }
+        _treeBaseDuration += _child2.treeBaseDuration;
+        _child2 = _child2.sibling;
+      }
 
-        try {
-          var currentState = queue.lastRenderedState;
-          var eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
-          // it, on the update object. If the reducer hasn't changed by the
-          // time we enter the render phase, then the eager state can be used
-          // without calling the reducer again.
+      completedWork.treeBaseDuration = _treeBaseDuration;
+    } else {
+      var _child3 = completedWork.child;
+
+      while (_child3 !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child3.lanes, _child3.childLanes)
+        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
+        // so we should bubble those up even during a bailout. All the other
+        // flags have a lifetime only of a single render + commit, so we should
+        // ignore them.
 
-          update.hasEagerState = true;
-          update.eagerState = eagerState;
+        subtreeFlags |= _child3.subtreeFlags & StaticMask;
+        subtreeFlags |= _child3.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
 
-          if (objectIs(eagerState, currentState)) {
-            // Fast path. We can bail out without scheduling React to re-render.
-            // It's still possible that we'll need to rebase this update later,
-            // if the component re-renders for a different reason and by that
-            // time the reducer has changed.
-            // TODO: Do we still need to entangle transitions in this case?
-            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
-            return;
-          }
-        } catch (error) {
-          // Suppress the error. It will throw again in the render phase.
-        } finally {
-          {
-            ReactCurrentDispatcher$1.current = prevDispatcher;
-          }
-        }
+        _child3.return = completedWork;
+        _child3 = _child3.sibling;
       }
     }
 
-    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
-
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitionUpdate(root, queue, lane);
-    }
+    completedWork.subtreeFlags |= subtreeFlags;
   }
 
-  markUpdateInDevTools(fiber, lane, action);
-}
-
-function isRenderPhaseUpdate(fiber) {
-  var alternate = fiber.alternate;
-  return (
-    fiber === currentlyRenderingFiber$1 ||
-    (alternate !== null && alternate === currentlyRenderingFiber$1)
-  );
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
 }
 
-function enqueueRenderPhaseUpdate(queue, update) {
-  // This is a render phase update. Stash it in a lazily-created map of
-  // queue -> linked list of updates. After this render pass, we'll restart
-  // and apply the stashed updates on top of the work-in-progress hook.
-  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
-    true;
-  var pending = queue.pending;
-
-  if (pending === null) {
-    // This is the first update. Create a circular list.
-    update.next = update;
-  } else {
-    update.next = pending.next;
-    pending.next = update;
+function completeDehydratedSuspenseBoundary(
+  current,
+  workInProgress,
+  nextState
+) {
+  if (
+    hasUnhydratedTailNodes() &&
+    (workInProgress.mode & ConcurrentMode) !== NoMode &&
+    (workInProgress.flags & DidCapture) === NoFlags$1
+  ) {
+    warnIfUnhydratedTailNodes(workInProgress);
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | Incomplete | ShouldCapture;
+    return false;
   }
 
-  queue.pending = update;
-} // TODO: Move to ReactFiberConcurrentUpdates?
+  var wasHydrated = popHydrationState(workInProgress);
 
-function entangleTransitionUpdate(root, queue, lane) {
-  if (isTransitionLane(lane)) {
-    var queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
-    // must have finished. We can remove them from the shared queue, which
-    // represents a superset of the actually pending lanes. In some cases we
-    // may entangle more than we need to, but that's OK. In fact it's worse if
-    // we *don't* entangle when we should.
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw new Error(
+          "A dehydrated suspense component was completed without a hydrated node. " +
+            "This is probably a bug in React."
+        );
+      }
 
-    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
 
-    var newQueueLanes = mergeLanes(queueLanes, lane);
-    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
-    // the lane finished since the last time we entangled it. So we need to
-    // entangle it again, just to be sure.
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          var isTimedOutSuspense = nextState !== null;
 
-    markRootEntangled(root, newQueueLanes);
-  }
-}
+          if (isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var primaryChildFragment = workInProgress.child;
 
-function markUpdateInDevTools(fiber, lane, action) {
-  {
-    if (enableDebugTracing) {
-      if (fiber.mode & DebugTracingMode) {
-        var name = getComponentNameFromFiber(fiber) || "Unknown";
-        logStateUpdateScheduled(name, lane, action);
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
       }
-    }
-  }
-
-  if (enableSchedulingProfiler) {
-    markStateUpdateScheduled(fiber, lane);
-  }
-}
 
-var ContextOnlyDispatcher = {
-  readContext: readContext,
-  useCallback: throwInvalidHookError,
-  useContext: throwInvalidHookError,
-  useEffect: throwInvalidHookError,
-  useImperativeHandle: throwInvalidHookError,
-  useInsertionEffect: throwInvalidHookError,
-  useLayoutEffect: throwInvalidHookError,
-  useMemo: throwInvalidHookError,
-  useReducer: throwInvalidHookError,
-  useRef: throwInvalidHookError,
-  useState: throwInvalidHookError,
-  useDebugValue: throwInvalidHookError,
-  useDeferredValue: throwInvalidHookError,
-  useTransition: throwInvalidHookError,
-  useMutableSource: throwInvalidHookError,
-  useSyncExternalStore: throwInvalidHookError,
-  useId: throwInvalidHookError
-};
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
 
-{
-  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
-}
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
 
-{
-  ContextOnlyDispatcher.use = throwInvalidHookError;
-}
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
 
-{
-  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
-}
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          var _isTimedOutSuspense = nextState !== null;
 
-{
-  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
-}
+          if (_isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var _primaryChildFragment = workInProgress.child;
 
-var HooksDispatcherOnMountInDEV = null;
-var HooksDispatcherOnMountWithHookTypesInDEV = null;
-var HooksDispatcherOnUpdateInDEV = null;
-var HooksDispatcherOnRerenderInDEV = null;
-var InvalidNestedHooksDispatcherOnMountInDEV = null;
-var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
-var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
+            if (_primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                _primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
 
-{
-  var warnInvalidContextAccess = function () {
-    error(
-      "Context can only be read while React is rendering. " +
-        "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-        "In function components, you can read it directly in the function body, but not " +
-        "inside Hooks like useReducer() or useMemo()."
-    );
-  };
+      return false;
+    }
+  } else {
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
 
-  var warnInvalidHookAccess = function () {
-    error(
-      "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " +
-        "You can only call Hooks at the top level of your React function. " +
-        "For more information, see " +
-        "https://reactjs.org/link/rules-of-hooks"
-    );
-  };
+    return true;
+  }
+}
 
-  HooksDispatcherOnMountInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      mountHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  popTreeContext(workInProgress);
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      mountHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      mountHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      mountHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      mountHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      mountHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      mountHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      mountHookTypesDev();
-      return mountId();
+    case ClassComponent: {
+      bubbleProperties(workInProgress);
+      return null;
     }
-  };
 
-  {
-    HooksDispatcherOnMountInDEV.useCacheRefresh = function useCacheRefresh() {
-      currentHookNameInDev = "useCacheRefresh";
-      mountHookTypesDev();
-      return mountRefresh();
-    };
-  }
+    case HostRoot: {
+      var fiberRoot = workInProgress.stateNode;
 
-  {
-    HooksDispatcherOnMountInDEV.use = use;
-  }
+      if (enableTransitionTracing) {
+        var transitions = getWorkInProgressTransitions(); // We set the Passive flag here because if there are new transitions,
+        // we will need to schedule callbacks and process the transitions,
+        // which we do in the passive phase
 
-  {
-    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
-  }
+        if (transitions !== null) {
+          workInProgress.flags |= Passive$1;
+        }
+      }
 
-  {
-    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      mountHookTypesDev();
-      return mountEvent(callback);
-    };
-  }
+      {
+        var previousCache = null;
 
-  HooksDispatcherOnMountWithHookTypesInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+        if (current !== null) {
+          previousCache = current.memoizedState.cache;
+        }
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+        var cache = workInProgress.memoizedState.cache;
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+        if (cache !== previousCache) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
+        }
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+        popCacheProvider(workInProgress);
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return mountId();
-    }
-  };
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return mountRefresh();
-      };
-  }
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.use = use;
-  }
+      popRootTransition(workInProgress);
+      popHostContainer(workInProgress);
+      resetWorkInProgressVersions();
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
-  }
+      if (fiberRoot.pendingContext) {
+        fiberRoot.context = fiberRoot.pendingContext;
+        fiberRoot.pendingContext = null;
+      }
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        updateHookTypesDev();
-        return mountEvent(callback);
-      };
-  }
+      if (current === null || current.child === null) {
+        // If we hydrated, pop so that we can delete any remaining children
+        // that weren't hydrated.
+        var wasHydrated = popHydrationState(workInProgress);
 
-  HooksDispatcherOnUpdateInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+        if (wasHydrated) {
+          // If we hydrated, then we'll need to schedule an update for
+          // the commit side-effects on the root.
+          markUpdate(workInProgress);
+        } else {
+          if (current !== null) {
+            var prevState = current.memoizedState;
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+            if (
+              // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1
+            ) {
+              // Schedule an effect to clear this container at the start of the
+              // next commit. This handles the case of React rendering into a
+              // container with previous children. It's also safe to do for
+              // updates too, because current.child would only be null if the
+              // previous render was null (so the container would already
+              // be empty).
+              workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+              // recoverable errors during first hydration attempt. If so, add
+              // them to a queue so we can log them in the commit phase.
+
+              upgradeHydrationErrorsToRecoverable();
+            }
+          }
+        }
       }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+      bubbleProperties(workInProgress);
 
-      try {
-        return updateReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      if (enableTransitionTracing) {
+        if ((workInProgress.subtreeFlags & Visibility) !== NoFlags$1) {
+          // If any of our suspense children toggle visibility, this means that
+          // the pending boundaries array needs to be updated, which we only
+          // do in the passive phase.
+          workInProgress.flags |= Passive$1;
+        }
       }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      try {
-        return updateState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      return null;
+    }
+
+    case HostHoistable: {
+      {
+        var currentRef = current ? current.ref : null;
+
+        if (currentRef !== workInProgress.ref) {
+          markRef(workInProgress);
+        }
+
+        if (
+          // We are mounting and must Update this Hoistable in this commit
+          current === null || // We are transitioning to, from, or between Hoistable Resources
+          // and require an update
+          current.memoizedState !== workInProgress.memoizedState
+        ) {
+          markUpdate(workInProgress);
+        } else if (workInProgress.memoizedState === null) {
+          // We may have props to update on the Hoistable instance. We use the
+          // updateHostComponent path becuase it produces the update queue
+          // we need for Hoistables
+          updateHostComponent(
+            current,
+            workInProgress,
+            workInProgress.type,
+            workInProgress.pendingProps
+          );
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return updateDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return updateTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return updateId();
     }
-  };
+    // eslint-disable-next-line-no-fallthrough
 
-  {
-    HooksDispatcherOnUpdateInDEV.useCacheRefresh = function useCacheRefresh() {
-      currentHookNameInDev = "useCacheRefresh";
-      updateHookTypesDev();
-      return updateRefresh();
-    };
-  }
+    case HostSingleton: {
+      {
+        popHostContext(workInProgress);
+        var rootContainerInstance = getRootHostContainer();
+        var type = workInProgress.type;
 
-  {
-    HooksDispatcherOnUpdateInDEV.use = use;
-  }
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
 
-  {
-    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
-  }
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw new Error(
+                "We must have new props for new mounts. This error is likely " +
+                  "caused by a bug in React. Please file an issue."
+              );
+            } // This can happen when we abort work.
 
-  {
-    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      updateHookTypesDev();
-      return updateEvent(callback);
-    };
-  }
+            bubbleProperties(workInProgress);
+            return null;
+          }
 
-  HooksDispatcherOnRerenderInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+          var currentHostContext = getHostContext();
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+          var _wasHydrated = popHydrationState(workInProgress);
 
-      try {
-        return rerenderReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+          if (_wasHydrated) {
+            // We ignore the boolean indicating there is an updateQueue because
+            // it is used only to set text children and HostSingletons do not
+            // use them.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              rootContainerInstance,
+              currentHostContext,
+              true
+            );
+            markUpdate(workInProgress);
+          }
 
-      try {
-        return rerenderState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return rerenderDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return rerenderTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return updateId();
     }
-  };
+    // eslint-disable-next-line-no-fallthrough
 
-  {
-    HooksDispatcherOnRerenderInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
-  }
+    case HostComponent: {
+      popHostContext(workInProgress);
+      var _type = workInProgress.type;
 
-  {
-    HooksDispatcherOnRerenderInDEV.use = use;
-  }
+      if (current !== null && workInProgress.stateNode != null) {
+        updateHostComponent(current, workInProgress, _type, newProps);
 
-  {
-    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
-  }
+        if (current.ref !== workInProgress.ref) {
+          markRef(workInProgress);
+        }
+      } else {
+        if (!newProps) {
+          if (workInProgress.stateNode === null) {
+            throw new Error(
+              "We must have new props for new mounts. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          } // This can happen when we abort work.
 
-  {
-    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      updateHookTypesDev();
-      return updateEvent(callback);
-    };
-  }
+          bubbleProperties(workInProgress);
+          return null;
+        }
 
-  InvalidNestedHooksDispatcherOnMountInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+        var _currentHostContext2 = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+        // "stack" as the parent. Then append children as we go in beginWork
+        // or completeWork depending on whether we want to add them top->down or
+        // bottom->up. Top->down is faster in IE11.
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+        var _wasHydrated2 = popHydrationState(workInProgress);
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+        if (_wasHydrated2) {
+          // TODO: Move this and createInstance step into the beginPhase
+          // to consolidate.
+          if (
+            prepareToHydrateHostInstance(workInProgress, _currentHostContext2)
+          ) {
+            // If changes to the hydrated node need to be applied at the
+            // commit-phase we mark this as such.
+            markUpdate(workInProgress);
+          }
+        } else {
+          var _rootContainerInstance = getRootHostContainer();
+
+          var instance = createInstance(
+            _type,
+            newProps,
+            _rootContainerInstance,
+            _currentHostContext2,
+            workInProgress
+          );
+          appendAllChildren(instance, workInProgress);
+          workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+          // (eg DOM renderer supports auto-focus for certain elements).
+          // Make sure such renderers get scheduled for later work.
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+          if (finalizeInitialChildren(instance, _type, newProps)) {
+            markUpdate(workInProgress);
+          }
+        }
+
+        if (workInProgress.ref !== null) {
+          // If there is a ref on a host node we need to schedule a callback
+          markRef(workInProgress);
+        }
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountId();
+
+      bubbleProperties(workInProgress);
+      return null;
     }
-  };
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        mountHookTypesDev();
-        return mountRefresh();
-      };
-  }
+    case HostText: {
+      var newText = newProps;
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
-  }
+      if (current && workInProgress.stateNode != null) {
+        var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+        // to schedule a side-effect to do the updates.
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
-  }
+        updateHostText(current, workInProgress, oldText, newText);
+      } else {
+        if (typeof newText !== "string") {
+          if (workInProgress.stateNode === null) {
+            throw new Error(
+              "We must have new props for new mounts. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          } // This can happen when we abort work.
+        }
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        mountHookTypesDev();
-        return mountEvent(callback);
-      };
-  }
+        var _rootContainerInstance2 = getRootHostContainer();
 
-  InvalidNestedHooksDispatcherOnUpdateInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+        var _currentHostContext3 = getHostContext();
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+        var _wasHydrated3 = popHydrationState(workInProgress);
 
-      try {
-        return updateReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+        if (_wasHydrated3) {
+          if (prepareToHydrateHostTextInstance(workInProgress)) {
+            markUpdate(workInProgress);
+          }
+        } else {
+          workInProgress.stateNode = createTextInstance(
+            newText,
+            _rootContainerInstance2,
+            _currentHostContext3,
+            workInProgress
+          );
+        }
       }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      try {
-        return updateState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateId();
+      bubbleProperties(workInProgress);
+      return null;
     }
-  };
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
-  }
+    case SuspenseComponent: {
+      popSuspenseHandler(workInProgress);
+      var nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+      // to its own fiber type so that we can add other kinds of hydration
+      // boundaries that aren't associated with a Suspense tree. In anticipation
+      // of such a refactor, all the hydration logic is contained in
+      // this branch.
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
-  }
+      if (
+        current === null ||
+        (current.memoizedState !== null &&
+          current.memoizedState.dehydrated !== null)
+      ) {
+        var fallthroughToNormalSuspensePath =
+          completeDehydratedSuspenseBoundary(
+            current,
+            workInProgress,
+            nextState
+          );
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
-  }
+        if (!fallthroughToNormalSuspensePath) {
+          if (workInProgress.flags & ShouldCapture) {
+            // Special case. There were remaining unhydrated nodes. We treat
+            // this as a mismatch. Revert to client rendering.
+            return workInProgress;
+          } else {
+            // Did not finish hydrating, either because this is the initial
+            // render or because something suspended.
+            return null;
+          }
+        } // Continue with the normal Suspense path.
+      }
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        updateHookTypesDev();
-        return updateEvent(callback);
-      };
-  }
+      if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+        // Something suspended. Re-render with the fallback children.
+        workInProgress.lanes = renderLanes; // Do not reset the effect list.
 
-  InvalidNestedHooksDispatcherOnRerenderInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        } // Don't bubble properties in this case.
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+        return workInProgress;
       }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      try {
-        return rerenderReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+      var nextDidTimeout = nextState !== null;
+      var prevDidTimeout = current !== null && current.memoizedState !== null;
 
-      try {
-        return rerenderState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return rerenderDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return rerenderTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateId();
-    }
-  };
+      if (nextDidTimeout) {
+        var offscreenFiber = workInProgress.child;
+        var _previousCache = null;
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
-  }
+        if (
+          offscreenFiber.alternate !== null &&
+          offscreenFiber.alternate.memoizedState !== null &&
+          offscreenFiber.alternate.memoizedState.cachePool !== null
+        ) {
+          _previousCache =
+            offscreenFiber.alternate.memoizedState.cachePool.pool;
+        }
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
-  }
+        var _cache = null;
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
-  }
+        if (
+          offscreenFiber.memoizedState !== null &&
+          offscreenFiber.memoizedState.cachePool !== null
+        ) {
+          _cache = offscreenFiber.memoizedState.cachePool.pool;
+        }
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        updateHookTypesDev();
-        return updateEvent(callback);
-      };
-  }
-}
+        if (_cache !== _previousCache) {
+          // Run passive effects to retain/release the cache.
+          offscreenFiber.flags |= Passive$1;
+        }
+      } // If the suspended state of the boundary changes, we need to schedule
+      // a passive effect, which is when we process the transitions
 
-var now = Scheduler.unstable_now;
-var commitTime = 0;
-var layoutEffectStartTime = -1;
-var profilerStartTime = -1;
-var passiveEffectStartTime = -1;
-/**
- * Tracks whether the current update was a nested/cascading update (scheduled from a layout effect).
- *
- * The overall sequence is:
- *   1. render
- *   2. commit (and call `onRender`, `onCommit`)
- *   3. check for nested updates
- *   4. flush passive effects (and call `onPostCommit`)
- *
- * Nested updates are identified in step 3 above,
- * but step 4 still applies to the work that was just committed.
- * We use two flags to track nested updates then:
- * one tracks whether the upcoming update is a nested update,
- * and the other tracks whether the current update was a nested update.
- * The first value gets synced to the second at the start of the render phase.
- */
+      if (nextDidTimeout !== prevDidTimeout) {
+        if (enableTransitionTracing) {
+          var _offscreenFiber = workInProgress.child;
+          _offscreenFiber.flags |= Passive$1;
+        } // If the suspended state of the boundary changes, we need to schedule
+        // an effect to toggle the subtree's visibility. When we switch from
+        // fallback -> primary, the inner Offscreen fiber schedules this effect
+        // as part of its normal complete phase. But when we switch from
+        // primary -> fallback, the inner Offscreen fiber does not have a complete
+        // phase. So we need to schedule its effect here.
+        //
+        // We also use this flag to connect/disconnect the effects, but the same
+        // logic applies: when re-connecting, the Offscreen fiber's complete
+        // phase will handle scheduling the effect. It's only when the fallback
+        // is active that we have to do anything special.
 
-var currentUpdateIsNested = false;
-var nestedUpdateScheduled = false;
+        if (nextDidTimeout) {
+          var _offscreenFiber2 = workInProgress.child;
+          _offscreenFiber2.flags |= Visibility;
+        }
+      }
 
-function isCurrentUpdateNested() {
-  return currentUpdateIsNested;
-}
+      var wakeables = workInProgress.updateQueue;
 
-function markNestedUpdateScheduled() {
-  {
-    nestedUpdateScheduled = true;
-  }
-}
+      if (wakeables !== null) {
+        // Schedule an effect to attach a retry listener to the promise.
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
+      }
 
-function resetNestedUpdateFlag() {
-  {
-    currentUpdateIsNested = false;
-    nestedUpdateScheduled = false;
-  }
-}
+      if (
+        workInProgress.updateQueue !== null &&
+        workInProgress.memoizedProps.suspenseCallback != null
+      ) {
+        // Always notify the callback
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
+      }
 
-function syncNestedUpdateFlag() {
-  {
-    currentUpdateIsNested = nestedUpdateScheduled;
-    nestedUpdateScheduled = false;
-  }
-}
+      bubbleProperties(workInProgress);
 
-function getCommitTime() {
-  return commitTime;
-}
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          if (nextDidTimeout) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var primaryChildFragment = workInProgress.child;
 
-function recordCommitTime() {
-  commitTime = now();
-}
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
 
-function startProfilerTimer(fiber) {
-  profilerStartTime = now();
+      return null;
+    }
 
-  if (fiber.actualStartTime < 0) {
-    fiber.actualStartTime = now();
-  }
-}
+    case HostPortal:
+      popHostContainer(workInProgress);
 
-function stopProfilerTimerIfRunning(fiber) {
-  profilerStartTime = -1;
-}
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
+      }
 
-function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
-  if (profilerStartTime >= 0) {
-    var elapsedTime = now() - profilerStartTime;
-    fiber.actualDuration += elapsedTime;
+      bubbleProperties(workInProgress);
+      return null;
 
-    if (overrideBaseTime) {
-      fiber.selfBaseDuration = elapsedTime;
+    case ContextProvider:
+      // Pop provider fiber
+      var context = workInProgress.type._context;
+      popProvider(context, workInProgress);
+      bubbleProperties(workInProgress);
+      return null;
+
+    case IncompleteClassComponent: {
+      bubbleProperties(workInProgress);
+      return null;
     }
 
-    profilerStartTime = -1;
-  }
-}
+    case SuspenseListComponent: {
+      popSuspenseListContext(workInProgress);
+      var renderState = workInProgress.memoizedState;
 
-function recordLayoutEffectDuration(fiber) {
-  if (layoutEffectStartTime >= 0) {
-    var elapsedTime = now() - layoutEffectStartTime;
-    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
-    // Or the root (for the DevTools Profiler to read)
+      if (renderState === null) {
+        // We're running in the default, "independent" mode.
+        // We don't do anything in this mode.
+        bubbleProperties(workInProgress);
+        return null;
+      }
 
-    var parentFiber = fiber.return;
+      var didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+      var renderedTail = renderState.rendering;
 
-    while (parentFiber !== null) {
-      switch (parentFiber.tag) {
-        case HostRoot:
-          var root = parentFiber.stateNode;
-          root.effectDuration += elapsedTime;
-          return;
+      if (renderedTail === null) {
+        // We just rendered the head.
+        if (!didSuspendAlready) {
+          // This is the first pass. We need to figure out if anything is still
+          // suspended in the rendered set.
+          // If new content unsuspended, but there's still some content that
+          // didn't. Then we need to do a second pass that forces everything
+          // to keep showing their fallbacks.
+          // We might be suspended if something in this render pass suspended, or
+          // something in the previous committed pass suspended. Otherwise,
+          // there's no chance so we can skip the expensive call to
+          // findFirstSuspended.
+          var cannotBeSuspended =
+            renderHasNotSuspendedYet() &&
+            (current === null || (current.flags & DidCapture) === NoFlags$1);
 
-        case Profiler:
-          var parentStateNode = parentFiber.stateNode;
-          parentStateNode.effectDuration += elapsedTime;
-          return;
-      }
+          if (!cannotBeSuspended) {
+            var row = workInProgress.child;
 
-      parentFiber = parentFiber.return;
-    }
-  }
-}
+            while (row !== null) {
+              var suspended = findFirstSuspended(row);
 
-function recordPassiveEffectDuration(fiber) {
-  if (passiveEffectStartTime >= 0) {
-    var elapsedTime = now() - passiveEffectStartTime;
-    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
-    // Or the root (for the DevTools Profiler to read)
+              if (suspended !== null) {
+                didSuspendAlready = true;
+                workInProgress.flags |= DidCapture;
+                cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                // part of the second pass. In that case nothing will subscribe to
+                // its thenables. Instead, we'll transfer its thenables to the
+                // SuspenseList so that it can retry if they resolve.
+                // There might be multiple of these in the list but since we're
+                // going to wait for all of them anyway, it doesn't really matter
+                // which ones gets to ping. In theory we could get clever and keep
+                // track of how many dependencies remain but it gets tricky because
+                // in the meantime, we can add/remove/change items and dependencies.
+                // We might bail out of the loop before finding any but that
+                // doesn't matter since that means that the other boundaries that
+                // we did find already has their listeners attached.
 
-    var parentFiber = fiber.return;
+                var newThenables = suspended.updateQueue;
 
-    while (parentFiber !== null) {
-      switch (parentFiber.tag) {
-        case HostRoot:
-          var root = parentFiber.stateNode;
+                if (newThenables !== null) {
+                  workInProgress.updateQueue = newThenables;
+                  workInProgress.flags |= Update;
+                } // Rerender the whole list, but this time, we'll force fallbacks
+                // to stay in place.
+                // Reset the effect flags before doing the second pass since that's now invalid.
+                // Reset the child fibers to their original state.
 
-          if (root !== null) {
-            root.passiveEffectDuration += elapsedTime;
-          }
+                workInProgress.subtreeFlags = NoFlags$1;
+                resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                // immediately rerender the children.
 
-          return;
+                pushSuspenseListContext(
+                  workInProgress,
+                  setShallowSuspenseListContext(
+                    suspenseStackCursor.current,
+                    ForceSuspenseFallback
+                  )
+                ); // Don't bubble properties in this case.
 
-        case Profiler:
-          var parentStateNode = parentFiber.stateNode;
+                return workInProgress.child;
+              }
 
-          if (parentStateNode !== null) {
-            // Detached fibers have their state node cleared out.
-            // In this case, the return pointer is also cleared out,
-            // so we won't be able to report the time spent in this Profiler's subtree.
-            parentStateNode.passiveEffectDuration += elapsedTime;
+              row = row.sibling;
+            }
           }
 
-          return;
-      }
+          if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
+            // We have already passed our CPU deadline but we still have rows
+            // left in the tail. We'll just give up further attempts to render
+            // the main content and only render fallbacks.
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true;
+            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+            // to get it started back up to attempt the next item. While in terms
+            // of priority this work has the same priority as this current render,
+            // it's not part of the same transition once the transition has
+            // committed. If it's sync, we still want to yield so that it can be
+            // painted. Conceptually, this is really the same as pinging.
+            // We can use any RetryLane even if it's the one currently rendering
+            // since we're leaving it behind on this node.
 
-      parentFiber = parentFiber.return;
-    }
-  }
-}
+            workInProgress.lanes = SomeRetryLane;
+          }
+        } else {
+          cutOffTailIfNeeded(renderState, false);
+        } // Next we're going to render the tail.
+      } else {
+        // Append the rendered row to the child list.
+        if (!didSuspendAlready) {
+          var _suspended = findFirstSuspended(renderedTail);
 
-function startLayoutEffectTimer() {
-  layoutEffectStartTime = now();
-}
+          if (_suspended !== null) {
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+            // get lost if this row ends up dropped during a second pass.
 
-function startPassiveEffectTimer() {
-  passiveEffectStartTime = now();
-}
+            var _newThenables = _suspended.updateQueue;
 
-function transferActualDuration(fiber) {
-  // Transfer time spent rendering these children so we don't lose it
-  // after we rerender. This is used as a helper in special cases
-  // where we should count the work of multiple passes.
-  var child = fiber.child;
+            if (_newThenables !== null) {
+              workInProgress.updateQueue = _newThenables;
+              workInProgress.flags |= Update;
+            }
 
-  while (child) {
-    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
-    fiber.actualDuration += child.actualDuration;
-    child = child.sibling;
-  }
-}
+            cutOffTailIfNeeded(renderState, true); // This might have been modified.
 
-function resolveDefaultProps(Component, baseProps) {
-  if (Component && Component.defaultProps) {
-    // Resolve default props. Taken from ReactElement
-    var props = assign({}, baseProps);
-    var defaultProps = Component.defaultProps;
+            if (
+              renderState.tail === null &&
+              renderState.tailMode === "hidden" &&
+              !renderedTail.alternate &&
+              !getIsHydrating() // We don't cut it if we're hydrating.
+            ) {
+              // We're done.
+              bubbleProperties(workInProgress);
+              return null;
+            }
+          } else if (
+            // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now$1() * 2 - renderState.renderingStartTime >
+              getRenderTargetTime() &&
+            renderLanes !== OffscreenLane
+          ) {
+            // We have now passed our CPU deadline and we'll just give up further
+            // attempts to render the main content and only render fallbacks.
+            // The assumption is that this is usually faster.
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true;
+            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+            // to get it started back up to attempt the next item. While in terms
+            // of priority this work has the same priority as this current render,
+            // it's not part of the same transition once the transition has
+            // committed. If it's sync, we still want to yield so that it can be
+            // painted. Conceptually, this is really the same as pinging.
+            // We can use any RetryLane even if it's the one currently rendering
+            // since we're leaving it behind on this node.
 
-    for (var propName in defaultProps) {
-      if (props[propName] === undefined) {
-        props[propName] = defaultProps[propName];
+            workInProgress.lanes = SomeRetryLane;
+          }
+        }
+
+        if (renderState.isBackwards) {
+          // The effect list of the backwards tail will have been added
+          // to the end. This breaks the guarantee that life-cycles fire in
+          // sibling order but that isn't a strong guarantee promised by React.
+          // Especially since these might also just pop in during future commits.
+          // Append to the beginning of the list.
+          renderedTail.sibling = workInProgress.child;
+          workInProgress.child = renderedTail;
+        } else {
+          var previousSibling = renderState.last;
+
+          if (previousSibling !== null) {
+            previousSibling.sibling = renderedTail;
+          } else {
+            workInProgress.child = renderedTail;
+          }
+
+          renderState.last = renderedTail;
+        }
       }
-    }
 
-    return props;
-  }
+      if (renderState.tail !== null) {
+        // We still have tail rows to render.
+        // Pop a row.
+        var next = renderState.tail;
+        renderState.rendering = next;
+        renderState.tail = next.sibling;
+        renderState.renderingStartTime = now$1();
+        next.sibling = null; // Restore the context.
+        // TODO: We can probably just avoid popping it instead and only
+        // setting it the first time we go from not suspended to suspended.
 
-  return baseProps;
-}
+        var suspenseContext = suspenseStackCursor.current;
 
-var fakeInternalInstance = {};
-var didWarnAboutStateAssignmentForComponent;
-var didWarnAboutUninitializedState;
-var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
-var didWarnAboutLegacyLifecyclesAndDerivedState;
-var didWarnAboutUndefinedDerivedState;
-var didWarnAboutDirectlyAssigningPropsToState;
-var didWarnAboutInvalidateContextType;
-var didWarnOnInvalidCallback;
+        if (didSuspendAlready) {
+          suspenseContext = setShallowSuspenseListContext(
+            suspenseContext,
+            ForceSuspenseFallback
+          );
+        } else {
+          suspenseContext =
+            setDefaultShallowSuspenseListContext(suspenseContext);
+        }
 
-{
-  didWarnAboutStateAssignmentForComponent = new Set();
-  didWarnAboutUninitializedState = new Set();
-  didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
-  didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
-  didWarnAboutDirectlyAssigningPropsToState = new Set();
-  didWarnAboutUndefinedDerivedState = new Set();
-  didWarnAboutInvalidateContextType = new Set();
-  didWarnOnInvalidCallback = new Set(); // This is so gross but it's at least non-critical and can be removed if
-  // it causes problems. This is meant to give a nicer error message for
-  // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
-  // ...)) which otherwise throws a "_processChildContext is not a function"
-  // exception.
+        pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+        // Don't bubble properties in this case.
 
-  Object.defineProperty(fakeInternalInstance, "_processChildContext", {
-    enumerable: false,
-    value: function () {
-      throw new Error(
-        "_processChildContext is not available in React 16+. This likely " +
-          "means you have multiple copies of React and are attempting to nest " +
-          "a React 15 tree inside a React 16 tree using " +
-          "unstable_renderSubtreeIntoContainer, which isn't supported. Try " +
-          "to make sure you have only one copy of React (and ideally, switch " +
-          "to ReactDOM.createPortal)."
-      );
-    }
-  });
-  Object.freeze(fakeInternalInstance);
-}
+        return next;
+      }
 
-function warnOnInvalidCallback(callback, callerName) {
-  {
-    if (callback === null || typeof callback === "function") {
-      return;
+      bubbleProperties(workInProgress);
+      return null;
     }
 
-    var key = callerName + "_" + callback;
+    case ScopeComponent: {
+      {
+        if (current === null) {
+          var scopeInstance = createScopeInstance();
+          workInProgress.stateNode = scopeInstance;
+          prepareScopeUpdate(scopeInstance, workInProgress);
 
-    if (!didWarnOnInvalidCallback.has(key)) {
-      didWarnOnInvalidCallback.add(key);
+          if (workInProgress.ref !== null) {
+            markRef(workInProgress);
+            markUpdate(workInProgress);
+          }
+        } else {
+          if (workInProgress.ref !== null) {
+            markUpdate(workInProgress);
+          }
 
-      error(
-        "%s(...): Expected the last optional `callback` argument to be a " +
-          "function. Instead received: %s.",
-        callerName,
-        callback
-      );
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
     }
-  }
-}
 
-function warnOnUndefinedDerivedState(type, partialState) {
-  {
-    if (partialState === undefined) {
-      var componentName = getComponentNameFromType(type) || "Component";
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      popSuspenseHandler(workInProgress);
+      popHiddenContext(workInProgress);
+      var _nextState = workInProgress.memoizedState;
+      var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
 
-      if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
-        didWarnAboutUndefinedDerivedState.add(componentName);
+      if (workInProgress.tag === LegacyHiddenComponent);
+      else {
+        if (current !== null) {
+          var _prevState = current.memoizedState;
+          var prevIsHidden = _prevState !== null;
 
-        error(
-          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
-            "You have returned undefined.",
-          componentName
-        );
+          if (prevIsHidden !== nextIsHidden) {
+            workInProgress.flags |= Visibility;
+          }
+        } else {
+          // On initial mount, we only need a Visibility effect if the tree
+          // is hidden.
+          if (nextIsHidden) {
+            workInProgress.flags |= Visibility;
+          }
+        }
       }
-    }
-  }
-}
 
-function applyDerivedStateFromProps(
-  workInProgress,
-  ctor,
-  getDerivedStateFromProps,
-  nextProps
-) {
-  var prevState = workInProgress.memoizedState;
-  var partialState = getDerivedStateFromProps(nextProps, prevState);
+      if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+        bubbleProperties(workInProgress);
+      } else {
+        // Don't bubble properties for hidden children unless we're rendering
+        // at offscreen priority.
+        if (
+          includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes
+        ) {
+          bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+          // If so, we need to hide those nodes in the commit phase, so
+          // schedule a visibility effect.
+
+          if (
+            workInProgress.tag !== LegacyHiddenComponent &&
+            workInProgress.subtreeFlags & (Placement | Update)
+          ) {
+            workInProgress.flags |= Visibility;
+          }
+        }
+      }
+
+      if (workInProgress.updateQueue !== null) {
+        // Schedule an effect to attach Suspense retry listeners
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
+      }
+
+      {
+        var _previousCache2 = null;
+
+        if (
+          current !== null &&
+          current.memoizedState !== null &&
+          current.memoizedState.cachePool !== null
+        ) {
+          _previousCache2 = current.memoizedState.cachePool.pool;
+        }
+
+        var _cache2 = null;
 
-  {
-    if (workInProgress.mode & StrictLegacyMode) {
-      setIsStrictModeForDevtools(true);
+        if (
+          workInProgress.memoizedState !== null &&
+          workInProgress.memoizedState.cachePool !== null
+        ) {
+          _cache2 = workInProgress.memoizedState.cachePool.pool;
+        }
 
-      try {
-        // Invoke the function an extra time to help detect side-effects.
-        partialState = getDerivedStateFromProps(nextProps, prevState);
-      } finally {
-        setIsStrictModeForDevtools(false);
+        if (_cache2 !== _previousCache2) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
+        }
       }
+
+      popTransition(workInProgress, current);
+      return null;
     }
 
-    warnOnUndefinedDerivedState(ctor, partialState);
-  } // Merge the partial state and the previous state.
+    case CacheComponent: {
+      {
+        var _previousCache3 = null;
 
-  var memoizedState =
-    partialState === null || partialState === undefined
-      ? prevState
-      : assign({}, prevState, partialState);
-  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
-  // base state.
+        if (current !== null) {
+          _previousCache3 = current.memoizedState.cache;
+        }
 
-  if (workInProgress.lanes === NoLanes) {
-    // Queue is always non-null for classes
-    var updateQueue = workInProgress.updateQueue;
-    updateQueue.baseState = memoizedState;
-  }
-}
+        var _cache3 = workInProgress.memoizedState.cache;
 
-var classComponentUpdater = {
-  isMounted: isMounted,
-  // $FlowFixMe[missing-local-annot]
-  enqueueSetState: function (inst, payload, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.payload = payload;
+        if (_cache3 !== _previousCache3) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
+        }
 
-    if (callback !== undefined && callback !== null) {
-      {
-        warnOnInvalidCallback(callback, "setState");
+        popCacheProvider(workInProgress);
+        bubbleProperties(workInProgress);
       }
 
-      update.callback = callback;
+      return null;
     }
 
-    var root = enqueueUpdate(fiber, update, lane);
-
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var _instance3 = workInProgress.stateNode;
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logStateUpdateScheduled(name, lane, payload);
+        if (_instance3 !== null) {
+          popMarkerInstance(workInProgress);
         }
+
+        bubbleProperties(workInProgress);
       }
-    }
 
-    if (enableSchedulingProfiler) {
-      markStateUpdateScheduled(fiber, lane);
+      return null;
     }
-  },
-  enqueueReplaceState: function (inst, payload, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.tag = ReplaceState;
-    update.payload = payload;
+  }
 
-    if (callback !== undefined && callback !== null) {
-      {
-        warnOnInvalidCallback(callback, "replaceState");
-      }
+  throw new Error(
+    "Unknown unit of work tag (" +
+      workInProgress.tag +
+      "). This error is likely caused by a bug in " +
+      "React. Please file an issue."
+  );
+}
 
-      update.callback = callback;
-    }
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
 
-    var root = enqueueUpdate(fiber, update, lane);
+  switch (workInProgress.tag) {
+    case ClassComponent: {
+      var flags = workInProgress.flags;
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+      if (flags & ShouldCapture) {
+        workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logStateUpdateScheduled(name, lane, payload);
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
         }
+
+        return workInProgress;
       }
-    }
 
-    if (enableSchedulingProfiler) {
-      markStateUpdateScheduled(fiber, lane);
+      return null;
     }
-  },
-  // $FlowFixMe[missing-local-annot]
-  enqueueForceUpdate: function (inst, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.tag = ForceUpdate;
 
-    if (callback !== undefined && callback !== null) {
+    case HostRoot: {
       {
-        warnOnInvalidCallback(callback, "forceUpdate");
+        popCacheProvider(workInProgress);
       }
 
-      update.callback = callback;
-    }
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
 
-    var root = enqueueUpdate(fiber, update, lane);
+      popRootTransition(workInProgress);
+      popHostContainer(workInProgress);
+      resetWorkInProgressVersions();
+      var _flags = workInProgress.flags;
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+      if (
+        (_flags & ShouldCapture) !== NoFlags$1 &&
+        (_flags & DidCapture) === NoFlags$1
+      ) {
+        // There was an error during render that wasn't captured by a suspense
+        // boundary. Do a second pass on the root to unmount the children.
+        workInProgress.flags = (_flags & ~ShouldCapture) | DidCapture;
+        return workInProgress;
+      } // We unwound to the root without completing it. Exit.
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logForceUpdateScheduled(name, lane);
-        }
-      }
+      return null;
     }
 
-    if (enableSchedulingProfiler) {
-      markForceUpdateScheduled(fiber, lane);
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      // TODO: popHydrationState
+      popHostContext(workInProgress);
+      return null;
     }
-  }
-};
-
-function checkShouldComponentUpdate(
-  workInProgress,
-  ctor,
-  oldProps,
-  newProps,
-  oldState,
-  newState,
-  nextContext
-) {
-  var instance = workInProgress.stateNode;
-
-  if (typeof instance.shouldComponentUpdate === "function") {
-    var shouldUpdate = instance.shouldComponentUpdate(
-      newProps,
-      newState,
-      nextContext
-    );
 
-    {
-      if (workInProgress.mode & StrictLegacyMode) {
-        setIsStrictModeForDevtools(true);
+    case SuspenseComponent: {
+      popSuspenseHandler(workInProgress);
+      var suspenseState = workInProgress.memoizedState;
 
-        try {
-          // Invoke the function an extra time to help detect side-effects.
-          shouldUpdate = instance.shouldComponentUpdate(
-            newProps,
-            newState,
-            nextContext
+      if (suspenseState !== null && suspenseState.dehydrated !== null) {
+        if (workInProgress.alternate === null) {
+          throw new Error(
+            "Threw in newly mounted dehydrated component. This is likely a bug in " +
+              "React. Please file an issue."
           );
-        } finally {
-          setIsStrictModeForDevtools(false);
         }
-      }
 
-      if (shouldUpdate === undefined) {
-        error(
-          "%s.shouldComponentUpdate(): Returned undefined instead of a " +
-            "boolean value. Make sure to return true or false.",
-          getComponentNameFromType(ctor) || "Component"
-        );
+        resetHydrationState();
       }
-    }
-
-    return shouldUpdate;
-  }
-
-  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
-    return (
-      !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
-    );
-  }
 
-  return true;
-}
+      var _flags2 = workInProgress.flags;
 
-function checkClassInstance(workInProgress, ctor, newProps) {
-  var instance = workInProgress.stateNode;
+      if (_flags2 & ShouldCapture) {
+        workInProgress.flags = (_flags2 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
 
-  {
-    var name = getComponentNameFromType(ctor) || "Component";
-    var renderPresent = instance.render;
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
 
-    if (!renderPresent) {
-      if (ctor.prototype && typeof ctor.prototype.render === "function") {
-        error(
-          "%s(...): No `render` method found on the returned component " +
-            "instance: did you accidentally return an object from the constructor?",
-          name
-        );
-      } else {
-        error(
-          "%s(...): No `render` method found on the returned component " +
-            "instance: you may have forgotten to define `render`.",
-          name
-        );
+        return workInProgress;
       }
-    }
 
-    if (
-      instance.getInitialState &&
-      !instance.getInitialState.isReactClassApproved &&
-      !instance.state
-    ) {
-      error(
-        "getInitialState was defined on %s, a plain JavaScript class. " +
-          "This is only supported for classes created using React.createClass. " +
-          "Did you mean to define a state property instead?",
-        name
-      );
+      return null;
     }
 
-    if (
-      instance.getDefaultProps &&
-      !instance.getDefaultProps.isReactClassApproved
-    ) {
-      error(
-        "getDefaultProps was defined on %s, a plain JavaScript class. " +
-          "This is only supported for classes created using React.createClass. " +
-          "Use a static property to define defaultProps instead.",
-        name
-      );
-    }
+    case SuspenseListComponent: {
+      popSuspenseListContext(workInProgress); // SuspenseList doesn't actually catch anything. It should've been
+      // caught by a nested boundary. If not, it should bubble through.
 
-    if (instance.propTypes) {
-      error(
-        "propTypes was defined as an instance property on %s. Use a static " +
-          "property to define propTypes instead.",
-        name
-      );
+      return null;
     }
 
-    if (instance.contextType) {
-      error(
-        "contextType was defined as an instance property on %s. Use a static " +
-          "property to define contextType instead.",
-        name
-      );
-    }
+    case HostPortal:
+      popHostContainer(workInProgress);
+      return null;
 
-    {
-      if (ctor.childContextTypes) {
-        error(
-          "%s uses the legacy childContextTypes API which is no longer supported. " +
-            "Use React.createContext() instead.",
-          name
-        );
-      }
+    case ContextProvider:
+      var context = workInProgress.type._context;
+      popProvider(context, workInProgress);
+      return null;
 
-      if (ctor.contextTypes) {
-        error(
-          "%s uses the legacy contextTypes API which is no longer supported. " +
-            "Use React.createContext() with static contextType instead.",
-          name
-        );
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      popSuspenseHandler(workInProgress);
+      popHiddenContext(workInProgress);
+      popTransition(workInProgress, current);
+      var _flags3 = workInProgress.flags;
+
+      if (_flags3 & ShouldCapture) {
+        workInProgress.flags = (_flags3 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
+
+        return workInProgress;
       }
-    }
 
-    if (typeof instance.componentShouldUpdate === "function") {
-      error(
-        "%s has a method called " +
-          "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
-          "The name is phrased as a question because the function is " +
-          "expected to return a value.",
-        name
-      );
+      return null;
     }
 
-    if (
-      ctor.prototype &&
-      ctor.prototype.isPureReactComponent &&
-      typeof instance.shouldComponentUpdate !== "undefined"
-    ) {
-      error(
-        "%s has a method called shouldComponentUpdate(). " +
-          "shouldComponentUpdate should not be used when extending React.PureComponent. " +
-          "Please extend React.Component if shouldComponentUpdate is used.",
-        getComponentNameFromType(ctor) || "A pure component"
-      );
-    }
+    case CacheComponent:
+      {
+        popCacheProvider(workInProgress);
+      }
 
-    if (typeof instance.componentDidUnmount === "function") {
-      error(
-        "%s has a method called " +
-          "componentDidUnmount(). But there is no such lifecycle method. " +
-          "Did you mean componentWillUnmount()?",
-        name
-      );
-    }
+      return null;
 
-    if (typeof instance.componentDidReceiveProps === "function") {
-      error(
-        "%s has a method called " +
-          "componentDidReceiveProps(). But there is no such lifecycle method. " +
-          "If you meant to update the state in response to changing props, " +
-          "use componentWillReceiveProps(). If you meant to fetch data or " +
-          "run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
-        name
-      );
-    }
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        if (workInProgress.stateNode !== null) {
+          popMarkerInstance(workInProgress);
+        }
+      }
 
-    if (typeof instance.componentWillRecieveProps === "function") {
-      error(
-        "%s has a method called " +
-          "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
-        name
-      );
-    }
+      return null;
 
-    if (typeof instance.UNSAFE_componentWillRecieveProps === "function") {
-      error(
-        "%s has a method called " +
-          "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
-        name
-      );
-    }
+    default:
+      return null;
+  }
+}
 
-    var hasMutatedProps = instance.props !== newProps;
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
 
-    if (instance.props !== undefined && hasMutatedProps) {
-      error(
-        "%s(...): When calling super() in `%s`, make sure to pass " +
-          "up the same props that your component's constructor was passed.",
-        name,
-        name
-      );
+  switch (interruptedWork.tag) {
+    case ClassComponent: {
+      break;
     }
 
-    if (instance.defaultProps) {
-      error(
-        "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
-          " Instead, define defaultProps as a static property on %s.",
-        name,
-        name
-      );
-    }
+    case HostRoot: {
+      {
+        popCacheProvider(interruptedWork);
+      }
 
-    if (
-      typeof instance.getSnapshotBeforeUpdate === "function" &&
-      typeof instance.componentDidUpdate !== "function" &&
-      !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)
-    ) {
-      didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(interruptedWork);
+      }
 
-      error(
-        "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
-          "This component defines getSnapshotBeforeUpdate() only.",
-        getComponentNameFromType(ctor)
-      );
+      popRootTransition(interruptedWork);
+      popHostContainer(interruptedWork);
+      resetWorkInProgressVersions();
+      break;
     }
 
-    if (typeof instance.getDerivedStateFromProps === "function") {
-      error(
-        "%s: getDerivedStateFromProps() is defined as an instance method " +
-          "and will be ignored. Instead, declare it as a static method.",
-        name
-      );
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      popHostContext(interruptedWork);
+      break;
     }
 
-    if (typeof instance.getDerivedStateFromError === "function") {
-      error(
-        "%s: getDerivedStateFromError() is defined as an instance method " +
-          "and will be ignored. Instead, declare it as a static method.",
-        name
-      );
-    }
+    case HostPortal:
+      popHostContainer(interruptedWork);
+      break;
+
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
+
+    case SuspenseListComponent:
+      popSuspenseListContext(interruptedWork);
+      break;
+
+    case ContextProvider:
+      var context = interruptedWork.type._context;
+      popProvider(context, interruptedWork);
+      break;
+
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext(interruptedWork);
+      popTransition(interruptedWork, current);
+      break;
 
-    if (typeof ctor.getSnapshotBeforeUpdate === "function") {
-      error(
-        "%s: getSnapshotBeforeUpdate() is defined as a static method " +
-          "and will be ignored. Instead, declare it as an instance method.",
-        name
-      );
-    }
+    case CacheComponent:
+      {
+        popCacheProvider(interruptedWork);
+      }
 
-    var state = instance.state;
+      break;
 
-    if (state && (typeof state !== "object" || isArray(state))) {
-      error("%s.state: must be set to an object or null", name);
-    }
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        var instance = interruptedWork.stateNode;
 
-    if (
-      typeof instance.getChildContext === "function" &&
-      typeof ctor.childContextTypes !== "object"
-    ) {
-      error(
-        "%s.getChildContext(): childContextTypes must be defined in order to " +
-          "use getChildContext().",
-        name
-      );
-    }
+        if (instance !== null) {
+          popMarkerInstance(interruptedWork);
+        }
+      }
+
+      break;
   }
 }
 
-function adoptClassInstance(workInProgress, instance) {
-  instance.updater = classComponentUpdater;
-  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
+// Provided by www
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
 
-  set(instance, workInProgress);
+if (typeof ReactFbErrorUtils.invokeGuardedCallback !== "function") {
+  throw new Error(
+    "Expected ReactFbErrorUtils.invokeGuardedCallback to be a function."
+  );
+}
 
-  {
-    instance._reactInternalInstance = fakeInternalInstance;
-  }
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  // This will call `this.onError(err)` if an error was caught.
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
 }
 
-function constructClassInstance(workInProgress, ctor, props) {
-  var context = emptyContextObject;
-  var contextType = ctor.contextType;
+var hasError = false;
+var caughtError = null; // Used by event system to capture/rethrow the first error.
 
-  {
-    if ("contextType" in ctor) {
-      var isValid = // Allow null for conditional declaration
-        contextType === null ||
-        (contextType !== undefined &&
-          contextType.$$typeof === REACT_CONTEXT_TYPE &&
-          contextType._context === undefined); // Not a <Context.Consumer>
+var hasRethrowError = false;
+var rethrowError = null;
+var reporter = {
+  onError: function (error) {
+    hasError = true;
+    caughtError = error;
+  }
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
 
-      if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
-        didWarnAboutInvalidateContextType.add(ctor);
-        var addendum = "";
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
 
-        if (contextType === undefined) {
-          addendum =
-            " However, it is set to undefined. " +
-            "This can be caused by a typo or by mixing up named and default imports. " +
-            "This can also happen due to a circular dependency, so " +
-            "try moving the createContext() call to a separate file.";
-        } else if (typeof contextType !== "object") {
-          addendum = " However, it is set to a " + typeof contextType + ".";
-        } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
-          addendum = " Did you accidentally pass the Context.Provider instead?";
-        } else if (contextType._context !== undefined) {
-          // <Context.Consumer>
-          addendum = " Did you accidentally pass the Context.Consumer instead?";
-        } else {
-          addendum =
-            " However, it is set to an object with keys {" +
-            Object.keys(contextType).join(", ") +
-            "}.";
-        }
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
+) {
+  invokeGuardedCallback.apply(this, arguments);
 
-        error(
-          "%s defines an invalid contextType. " +
-            "contextType should point to the Context object returned by React.createContext().%s",
-          getComponentNameFromType(ctor) || "Component",
-          addendum
-        );
-      }
+  if (hasError) {
+    var error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
     }
   }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
 
-  if (typeof contextType === "object" && contextType !== null) {
-    context = readContext(contextType);
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    var error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function hasCaughtError() {
+  return hasError;
+}
+function clearCaughtError() {
+  if (hasError) {
+    var error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw new Error(
+      "clearCaughtError was called but no error was captured. This error " +
+        "is likely caused by a bug in React. Please file an issue."
+    );
   }
+}
 
-  var instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
+var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
 
-  {
-    if (workInProgress.mode & StrictLegacyMode) {
-      setIsStrictModeForDevtools(true);
+{
+  didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+} // Used during the commit phase to track the state of the Offscreen component stack.
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
 
-      try {
-        instance = new ctor(props, context); // eslint-disable-line no-new
-      } finally {
-        setIsStrictModeForDevtools(false);
-      }
-    }
-  }
+var offscreenSubtreeIsHidden = false;
+var offscreenSubtreeWasHidden = false;
+var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
+var nextEffect = null; // Used for Profiling builds to track updaters.
 
-  var state = (workInProgress.memoizedState =
-    instance.state !== null && instance.state !== undefined
-      ? instance.state
-      : null);
-  adoptClassInstance(workInProgress, instance);
+var inProgressLanes = null;
+var inProgressRoot = null;
 
-  {
-    if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
-      var componentName = getComponentNameFromType(ctor) || "Component";
+function shouldProfile(current) {
+  return (
+    (current.mode & ProfileMode) !== NoMode &&
+    (getExecutionContext() & CommitContext) !== NoContext
+  );
+}
 
-      if (!didWarnAboutUninitializedState.has(componentName)) {
-        didWarnAboutUninitializedState.add(componentName);
+function reportUncaughtErrorInDEV(error) {
+  // Wrapping each small part of the commit phase into a guarded
+  // callback is a bit too slow (https://github.com/facebook/react/pull/21666).
+  // But we rely on it to surface errors to DEV tools like overlays
+  // (https://github.com/facebook/react/issues/21712).
+  // As a compromise, rethrow only caught errors in a guard.
+  {
+    invokeGuardedCallback(null, function () {
+      throw error;
+    });
+    clearCaughtError();
+  }
+}
 
-        error(
-          "`%s` uses `getDerivedStateFromProps` but its initial state is " +
-            "%s. This is not recommended. Instead, define the initial state by " +
-            "assigning an object to `this.state` in the constructor of `%s`. " +
-            "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
-          componentName,
-          instance.state === null ? "null" : "undefined",
-          componentName
-        );
-      }
-    } // If new component APIs are defined, "unsafe" lifecycles won't be called.
-    // Warn about these lifecycles if they are present.
-    // Don't warn about react-lifecycles-compat polyfilled methods though.
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
 
-    if (
-      typeof ctor.getDerivedStateFromProps === "function" ||
-      typeof instance.getSnapshotBeforeUpdate === "function"
-    ) {
-      var foundWillMountName = null;
-      var foundWillReceivePropsName = null;
-      var foundWillUpdateName = null;
+  if (shouldProfile(current)) {
+    try {
+      startLayoutEffectTimer();
+      instance.componentWillUnmount();
+    } finally {
+      recordLayoutEffectDuration(current);
+    }
+  } else {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
 
-      if (
-        typeof instance.componentWillMount === "function" &&
-        instance.componentWillMount.__suppressDeprecationWarning !== true
-      ) {
-        foundWillMountName = "componentWillMount";
-      } else if (typeof instance.UNSAFE_componentWillMount === "function") {
-        foundWillMountName = "UNSAFE_componentWillMount";
-      }
+function safelyCallComponentWillUnmount(
+  current,
+  nearestMountedAncestor,
+  instance
+) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
 
-      if (
-        typeof instance.componentWillReceiveProps === "function" &&
-        instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
-      ) {
-        foundWillReceivePropsName = "componentWillReceiveProps";
-      } else if (
-        typeof instance.UNSAFE_componentWillReceiveProps === "function"
-      ) {
-        foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
-      }
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
 
-      if (
-        typeof instance.componentWillUpdate === "function" &&
-        instance.componentWillUpdate.__suppressDeprecationWarning !== true
-      ) {
-        foundWillUpdateName = "componentWillUpdate";
-      } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        foundWillUpdateName = "UNSAFE_componentWillUpdate";
-      }
+function safelyDetachRef(current, nearestMountedAncestor) {
+  var ref = current.ref;
+  var refCleanup = current.refCleanup;
 
-      if (
-        foundWillMountName !== null ||
-        foundWillReceivePropsName !== null ||
-        foundWillUpdateName !== null
-      ) {
-        var _componentName = getComponentNameFromType(ctor) || "Component";
+  if (ref !== null) {
+    if (typeof refCleanup === "function") {
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            refCleanup();
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        var finishedWork = current.alternate;
 
-        var newApiName =
-          typeof ctor.getDerivedStateFromProps === "function"
-            ? "getDerivedStateFromProps()"
-            : "getSnapshotBeforeUpdate()";
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === "function") {
+      var retVal;
 
-        if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
-          didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            retVal = ref(null);
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          retVal = ref(null);
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
 
+      {
+        if (typeof retVal === "function") {
           error(
-            "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" +
-              "The above lifecycles should be removed. Learn more about this warning here:\n" +
-              "https://reactjs.org/link/unsafe-component-lifecycles",
-            _componentName,
-            newApiName,
-            foundWillMountName !== null ? "\n  " + foundWillMountName : "",
-            foundWillReceivePropsName !== null
-              ? "\n  " + foundWillReceivePropsName
-              : "",
-            foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : ""
+            "Unexpected return value from a callback ref in %s. " +
+              "A callback ref should not return a function.",
+            getComponentNameFromFiber(current)
           );
         }
       }
+    } else {
+      // $FlowFixMe unable to narrow type to RefObject
+      ref.current = null;
     }
-  } // Cache unmasked context so we can avoid recreating masked context unless necessary.
+  }
+}
 
-  return instance;
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
 }
 
-function callComponentWillMount(workInProgress, instance) {
-  var oldState = instance.state;
+var focusedInstanceHandle = null;
+var shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  focusedInstanceHandle = prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
 
-  if (typeof instance.componentWillMount === "function") {
-    instance.componentWillMount();
-  }
+  var shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  focusedInstanceHandle = null;
+  return shouldFire;
+}
 
-  if (typeof instance.UNSAFE_componentWillMount === "function") {
-    instance.UNSAFE_componentWillMount();
-  }
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    var fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+    // Let's skip the whole loop if it's off.
 
-  if (oldState !== instance.state) {
     {
-      error(
-        "%s.componentWillMount(): Assigning directly to this.state is " +
-          "deprecated (except inside a component's " +
-          "constructor). Use setState instead.",
-        getComponentNameFromFiber(workInProgress) || "Component"
-      );
-    }
+      // TODO: Should wrap this in flags check, too, as optimization
+      var deletions = fiber.deletions;
 
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
-  }
-}
+      if (deletions !== null) {
+        for (var i = 0; i < deletions.length; i++) {
+          var deletion = deletions[i];
+          commitBeforeMutationEffectsDeletion(deletion);
+        }
+      }
+    }
 
-function callComponentWillReceiveProps(
-  workInProgress,
-  instance,
-  newProps,
-  nextContext
-) {
-  var oldState = instance.state;
+    var child = fiber.child;
 
-  if (typeof instance.componentWillReceiveProps === "function") {
-    instance.componentWillReceiveProps(newProps, nextContext);
+    if (
+      (fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 &&
+      child !== null
+    ) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
+    }
   }
+}
 
-  if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
-    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
-  }
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    setCurrentFiber(fiber);
 
-  if (instance.state !== oldState) {
-    {
-      var componentName =
-        getComponentNameFromFiber(workInProgress) || "Component";
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
 
-      if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
-        didWarnAboutStateAssignmentForComponent.add(componentName);
+    resetCurrentFiber();
+    var sibling = fiber.sibling;
 
-        error(
-          "%s.componentWillReceiveProps(): Assigning directly to " +
-            "this.state is deprecated (except inside a component's " +
-            "constructor). Use setState instead.",
-          componentName
-        );
-      }
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
     }
 
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
-  }
-} // Invokes the mount life-cycles on a previously never rendered instance.
-
-function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  {
-    checkClassInstance(workInProgress, ctor, newProps);
+    nextEffect = fiber.return;
   }
+}
 
-  var instance = workInProgress.stateNode;
-  instance.props = newProps;
-  instance.state = workInProgress.memoizedState;
-  instance.refs = {};
-  initializeUpdateQueue(workInProgress);
-  var contextType = ctor.contextType;
-
-  if (typeof contextType === "object" && contextType !== null) {
-    instance.context = readContext(contextType);
-  } else {
-    instance.context = emptyContextObject;
-  }
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  var current = finishedWork.alternate;
+  var flags = finishedWork.flags;
 
   {
-    if (instance.state === newProps) {
-      var componentName = getComponentNameFromType(ctor) || "Component";
+    if (!shouldFireAfterActiveInstanceBlur && focusedInstanceHandle !== null) {
+      // Check to see if the focused element was inside of a hidden (Suspense) subtree.
+      // TODO: Move this out of the hot path using a dedicated effect tag.
+      if (
+        finishedWork.tag === SuspenseComponent &&
+        isSuspenseBoundaryBeingHidden(current, finishedWork) && // $FlowFixMe[incompatible-call] found when upgrading Flow
+        doesFiberContain(finishedWork, focusedInstanceHandle)
+      ) {
+        shouldFireAfterActiveInstanceBlur = true;
+        beforeActiveInstanceBlur(finishedWork);
+      }
+    }
+  }
 
-      if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
-        didWarnAboutDirectlyAssigningPropsToState.add(componentName);
+  if ((flags & Snapshot) !== NoFlags$1) {
+    setCurrentFiber(finishedWork);
+  }
 
-        error(
-          "%s: It is not recommended to assign props directly to state " +
-            "because updates to props won't be reflected in state. " +
-            "In most cases, it is better to use props directly.",
-          componentName
-        );
+  switch (finishedWork.tag) {
+    case FunctionComponent: {
+      {
+        if ((flags & Update) !== NoFlags$1) {
+          commitUseEffectEventMount(finishedWork);
+        }
       }
-    }
 
-    if (workInProgress.mode & StrictLegacyMode) {
-      ReactStrictModeWarnings.recordLegacyContextWarning(
-        workInProgress,
-        instance
-      );
+      break;
     }
 
-    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
-      workInProgress,
-      instance
-    );
-  }
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      break;
+    }
 
-  instance.state = workInProgress.memoizedState;
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+    case ClassComponent: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        if (current !== null) {
+          var prevProps = current.memoizedProps;
+          var prevState = current.memoizedState;
+          var instance = finishedWork.stateNode; // We could update instance props and state here,
+          // but instead we rely on them being set during last render.
+          // TODO: revisit this when we implement resuming.
 
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    instance.state = workInProgress.memoizedState;
-  } // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+          {
+            if (
+              finishedWork.type === finishedWork.elementType &&
+              !didWarnAboutReassigningProps
+            ) {
+              if (instance.props !== finishedWork.memoizedProps) {
+                error(
+                  "Expected %s props to match memoized props before " +
+                    "getSnapshotBeforeUpdate. " +
+                    "This might either be because of a bug in React, or because " +
+                    "a component reassigns its own `this.props`. " +
+                    "Please file an issue.",
+                  getComponentNameFromFiber(finishedWork) || "instance"
+                );
+              }
 
-  if (
-    typeof ctor.getDerivedStateFromProps !== "function" &&
-    typeof instance.getSnapshotBeforeUpdate !== "function" &&
-    (typeof instance.UNSAFE_componentWillMount === "function" ||
-      typeof instance.componentWillMount === "function")
-  ) {
-    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
-    // process them now.
+              if (instance.state !== finishedWork.memoizedState) {
+                error(
+                  "Expected %s state to match memoized state before " +
+                    "getSnapshotBeforeUpdate. " +
+                    "This might either be because of a bug in React, or because " +
+                    "a component reassigns its own `this.state`. " +
+                    "Please file an issue.",
+                  getComponentNameFromFiber(finishedWork) || "instance"
+                );
+              }
+            }
+          }
 
-    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-    instance.state = workInProgress.memoizedState;
-  }
+          var snapshot = instance.getSnapshotBeforeUpdate(
+            finishedWork.elementType === finishedWork.type
+              ? prevProps
+              : resolveDefaultProps(finishedWork.type, prevProps),
+            prevState
+          );
 
-  if (typeof instance.componentDidMount === "function") {
-    var fiberFlags = Update | LayoutStatic;
+          {
+            var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
 
-    if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-      fiberFlags |= MountLayoutDev;
-    }
+            if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
+              didWarnSet.add(finishedWork.type);
 
-    workInProgress.flags |= fiberFlags;
-  }
-}
+              error(
+                "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
+                  "must be returned. You have returned undefined.",
+                getComponentNameFromFiber(finishedWork)
+              );
+            }
+          }
 
-function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  var instance = workInProgress.stateNode;
-  var oldProps = workInProgress.memoizedProps;
-  instance.props = oldProps;
-  var oldContext = instance.context;
-  var contextType = ctor.contextType;
-  var nextContext = emptyContextObject;
+          instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+        }
+      }
 
-  if (typeof contextType === "object" && contextType !== null) {
-    nextContext = readContext(contextType);
-  }
+      break;
+    }
 
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-  var hasNewLifecycles =
-    typeof getDerivedStateFromProps === "function" ||
-    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
-  // ever the previously attempted to render - not the "current". However,
-  // during componentDidUpdate we pass the "current" props.
-  // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+    case HostRoot: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        {
+          var root = finishedWork.stateNode;
+          clearContainer(root.containerInfo);
+        }
+      }
 
-  if (
-    !hasNewLifecycles &&
-    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
-      typeof instance.componentWillReceiveProps === "function")
-  ) {
-    if (oldProps !== newProps || oldContext !== nextContext) {
-      callComponentWillReceiveProps(
-        workInProgress,
-        instance,
-        newProps,
-        nextContext
-      );
+      break;
     }
-  }
-
-  resetHasForceUpdateBeforeProcessing();
-  var oldState = workInProgress.memoizedState;
-  var newState = (instance.state = oldState);
-  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-  newState = workInProgress.memoizedState;
 
-  if (
-    oldProps === newProps &&
-    oldState === newState &&
-    !hasContextChanged() &&
-    !checkHasForceUpdateAfterProcessing()
-  ) {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidMount === "function") {
-      var fiberFlags = Update | LayoutStatic;
+    case HostComponent:
+    case HostHoistable:
+    case HostSingleton:
+    case HostText:
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
 
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        fiberFlags |= MountLayoutDev;
+    default: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        throw new Error(
+          "This unit of work tag should not have side-effects. This error is " +
+            "likely caused by a bug in React. Please file an issue."
+        );
       }
-
-      workInProgress.flags |= fiberFlags;
     }
+  }
 
-    return false;
+  if ((flags & Snapshot) !== NoFlags$1) {
+    resetCurrentFiber();
   }
+}
 
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    newState = workInProgress.memoizedState;
+function commitBeforeMutationEffectsDeletion(deletion) {
+  {
+    // TODO (effects) It would be nice to avoid calling doesFiberContain()
+    // Maybe we can repurpose one of the subtreeFlags positions for this instead?
+    // Use it to store which part of the tree the focused instance is in?
+    // This assumes we can safely determine that instance during the "render" phase.
+    if (doesFiberContain(deletion, focusedInstanceHandle)) {
+      shouldFireAfterActiveInstanceBlur = true;
+      beforeActiveInstanceBlur(deletion);
+    }
   }
+}
 
-  var shouldUpdate =
-    checkHasForceUpdateAfterProcessing() ||
-    checkShouldComponentUpdate(
-      workInProgress,
-      ctor,
-      oldProps,
-      newProps,
-      oldState,
-      newState,
-      nextContext
-    );
+function commitHookEffectListUnmount(
+  flags,
+  finishedWork,
+  nearestMountedAncestor
+) {
+  var updateQueue = finishedWork.updateQueue;
+  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
 
-  if (shouldUpdate) {
-    // In order to support react-lifecycles-compat polyfilled components,
-    // Unsafe lifecycles should not be invoked for components using the new APIs.
-    if (
-      !hasNewLifecycles &&
-      (typeof instance.UNSAFE_componentWillMount === "function" ||
-        typeof instance.componentWillMount === "function")
-    ) {
-      if (typeof instance.componentWillMount === "function") {
-        instance.componentWillMount();
-      }
+  if (lastEffect !== null) {
+    var firstEffect = lastEffect.next;
+    var effect = firstEffect;
 
-      if (typeof instance.UNSAFE_componentWillMount === "function") {
-        instance.UNSAFE_componentWillMount();
-      }
-    }
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        var destroy = effect.destroy;
+        effect.destroy = undefined;
 
-    if (typeof instance.componentDidMount === "function") {
-      var _fiberFlags = Update | LayoutStatic;
+        if (destroy !== undefined) {
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStarted(finishedWork);
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStarted(finishedWork);
+            }
+          }
 
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        _fiberFlags |= MountLayoutDev;
-      }
+          {
+            if ((flags & Insertion) !== NoFlags) {
+              setIsRunningInsertionEffect(true);
+            }
+          }
 
-      workInProgress.flags |= _fiberFlags;
-    }
-  } else {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidMount === "function") {
-      var _fiberFlags2 = Update | LayoutStatic;
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
 
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        _fiberFlags2 |= MountLayoutDev;
+          {
+            if ((flags & Insertion) !== NoFlags) {
+              setIsRunningInsertionEffect(false);
+            }
+          }
+
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStopped();
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStopped();
+            }
+          }
+        }
       }
 
-      workInProgress.flags |= _fiberFlags2;
-    } // If shouldComponentUpdate returned false, we should still update the
-    // memoized state to indicate that this work can be reused.
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
 
-    workInProgress.memoizedProps = newProps;
-    workInProgress.memoizedState = newState;
-  } // Update the existing instance's state, props, and context pointers even
-  // if shouldComponentUpdate returns false.
+function commitHookEffectListMount(flags, finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
 
-  instance.props = newProps;
-  instance.state = newState;
-  instance.context = nextContext;
-  return shouldUpdate;
-} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+  if (lastEffect !== null) {
+    var firstEffect = lastEffect.next;
+    var effect = firstEffect;
 
-function updateClassInstance(
-  current,
-  workInProgress,
-  ctor,
-  newProps,
-  renderLanes
-) {
-  var instance = workInProgress.stateNode;
-  cloneUpdateQueue(current, workInProgress);
-  var unresolvedOldProps = workInProgress.memoizedProps;
-  var oldProps =
-    workInProgress.type === workInProgress.elementType
-      ? unresolvedOldProps
-      : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
-  instance.props = oldProps;
-  var unresolvedNewProps = workInProgress.pendingProps;
-  var oldContext = instance.context;
-  var contextType = ctor.contextType;
-  var nextContext = emptyContextObject;
+    do {
+      if ((effect.tag & flags) === flags) {
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStarted(finishedWork);
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStarted(finishedWork);
+          }
+        } // Mount
 
-  if (typeof contextType === "object" && contextType !== null) {
-    nextContext = readContext(contextType);
-  }
+        var create = effect.create;
 
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-  var hasNewLifecycles =
-    typeof getDerivedStateFromProps === "function" ||
-    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
-  // ever the previously attempted to render - not the "current". However,
-  // during componentDidUpdate we pass the "current" props.
-  // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+        {
+          if ((flags & Insertion) !== NoFlags) {
+            setIsRunningInsertionEffect(true);
+          }
+        }
 
-  if (
-    !hasNewLifecycles &&
-    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
-      typeof instance.componentWillReceiveProps === "function")
-  ) {
-    if (
-      unresolvedOldProps !== unresolvedNewProps ||
-      oldContext !== nextContext
-    ) {
-      callComponentWillReceiveProps(
-        workInProgress,
-        instance,
-        newProps,
-        nextContext
-      );
-    }
-  }
+        effect.destroy = create();
 
-  resetHasForceUpdateBeforeProcessing();
-  var oldState = workInProgress.memoizedState;
-  var newState = (instance.state = oldState);
-  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-  newState = workInProgress.memoizedState;
+        {
+          if ((flags & Insertion) !== NoFlags) {
+            setIsRunningInsertionEffect(false);
+          }
+        }
 
-  if (
-    unresolvedOldProps === unresolvedNewProps &&
-    oldState === newState &&
-    !hasContextChanged() &&
-    !checkHasForceUpdateAfterProcessing() &&
-    !(
-      enableLazyContextPropagation &&
-      current !== null &&
-      current.dependencies !== null &&
-      checkIfContextChanged(current.dependencies)
-    )
-  ) {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Update;
-      }
-    }
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStopped();
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStopped();
+          }
+        }
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Snapshot;
-      }
-    }
+        {
+          var destroy = effect.destroy;
 
-    return false;
-  }
+          if (destroy !== undefined && typeof destroy !== "function") {
+            var hookName = void 0;
 
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    newState = workInProgress.memoizedState;
-  }
+            if ((effect.tag & Layout) !== NoFlags$1) {
+              hookName = "useLayoutEffect";
+            } else if ((effect.tag & Insertion) !== NoFlags$1) {
+              hookName = "useInsertionEffect";
+            } else {
+              hookName = "useEffect";
+            }
 
-  var shouldUpdate =
-    checkHasForceUpdateAfterProcessing() ||
-    checkShouldComponentUpdate(
-      workInProgress,
-      ctor,
-      oldProps,
-      newProps,
-      oldState,
-      newState,
-      nextContext
-    ) || // TODO: In some cases, we'll end up checking if context has changed twice,
-    // both before and after `shouldComponentUpdate` has been called. Not ideal,
-    // but I'm loath to refactor this function. This only happens for memoized
-    // components so it's not that common.
-    (enableLazyContextPropagation &&
-      current !== null &&
-      current.dependencies !== null &&
-      checkIfContextChanged(current.dependencies));
+            var addendum = void 0;
+
+            if (destroy === null) {
+              addendum =
+                " You returned null. If your effect does not require clean " +
+                "up, return undefined (or nothing).";
+            } else if (typeof destroy.then === "function") {
+              addendum =
+                "\n\nIt looks like you wrote " +
+                hookName +
+                "(async () => ...) or returned a Promise. " +
+                "Instead, write the async function inside your effect " +
+                "and call it immediately:\n\n" +
+                hookName +
+                "(() => {\n" +
+                "  async function fetchData() {\n" +
+                "    // You can await here\n" +
+                "    const response = await MyAPI.getData(someId);\n" +
+                "    // ...\n" +
+                "  }\n" +
+                "  fetchData();\n" +
+                "}, [someId]); // Or [] if effect doesn't need props or state\n\n" +
+                "Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching";
+            } else {
+              addendum = " You returned: " + destroy;
+            }
 
-  if (shouldUpdate) {
-    // In order to support react-lifecycles-compat polyfilled components,
-    // Unsafe lifecycles should not be invoked for components using the new APIs.
-    if (
-      !hasNewLifecycles &&
-      (typeof instance.UNSAFE_componentWillUpdate === "function" ||
-        typeof instance.componentWillUpdate === "function")
-    ) {
-      if (typeof instance.componentWillUpdate === "function") {
-        instance.componentWillUpdate(newProps, newState, nextContext);
+            error(
+              "%s must not return anything besides a function, " +
+                "which is used for clean-up.%s",
+              hookName,
+              addendum
+            );
+          }
+        }
       }
 
-      if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
-      }
-    }
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
 
-    if (typeof instance.componentDidUpdate === "function") {
-      workInProgress.flags |= Update;
-    }
+function commitUseEffectEventMount(finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  var eventPayloads = updateQueue !== null ? updateQueue.events : null;
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      workInProgress.flags |= Snapshot;
-    }
-  } else {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Update;
-      }
+  if (eventPayloads !== null) {
+    for (var ii = 0; ii < eventPayloads.length; ii++) {
+      var _eventPayloads$ii = eventPayloads[ii],
+        ref = _eventPayloads$ii.ref,
+        nextImpl = _eventPayloads$ii.nextImpl;
+      ref.impl = nextImpl;
     }
+  }
+}
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Snapshot;
-      }
-    } // If shouldComponentUpdate returned false, we should still update the
-    // memoized props/state to indicate that this work can be reused.
+function commitPassiveEffectDurations(finishedRoot, finishedWork) {
+  if (getExecutionContext() & CommitContext) {
+    // Only Profilers with work in their subtree will have an Update effect scheduled.
+    if ((finishedWork.flags & Update) !== NoFlags$1) {
+      switch (finishedWork.tag) {
+        case Profiler: {
+          var passiveEffectDuration =
+            finishedWork.stateNode.passiveEffectDuration;
+          var _finishedWork$memoize = finishedWork.memoizedProps,
+            id = _finishedWork$memoize.id,
+            onPostCommit = _finishedWork$memoize.onPostCommit; // This value will still reflect the previous commit phase.
+          // It does not get reset until the start of the next commit phase.
 
-    workInProgress.memoizedProps = newProps;
-    workInProgress.memoizedState = newState;
-  } // Update the existing instance's state, props, and context pointers even
-  // if shouldComponentUpdate returns false.
+          var commitTime = getCommitTime();
+          var phase = finishedWork.alternate === null ? "mount" : "update";
 
-  instance.props = newProps;
-  instance.state = newState;
-  instance.context = nextContext;
-  return shouldUpdate;
-}
+          {
+            if (isCurrentUpdateNested()) {
+              phase = "nested-update";
+            }
+          }
 
-function createCapturedValueAtFiber(value, source) {
-  // If the value is an error, call this function immediately after it is thrown
-  // so the stack is accurate.
-  return {
-    value: value,
-    source: source,
-    stack: getStackByFiberInDevAndProd(source),
-    digest: null
-  };
-}
-function createCapturedValue(value, digest, stack) {
-  return {
-    value: value,
-    source: null,
-    stack: stack != null ? stack : null,
-    digest: digest != null ? digest : null
-  };
-}
+          if (typeof onPostCommit === "function") {
+            onPostCommit(id, phase, passiveEffectDuration, commitTime);
+          } // Bubble times to the next nearest ancestor Profiler.
+          // After we process that Profiler, we'll bubble further up.
 
-var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
+          var parentFiber = finishedWork.return;
 
-if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== "function") {
-  throw new Error(
-    "Expected ReactFiberErrorDialog.showErrorDialog to be a function."
-  );
-}
+          outer: while (parentFiber !== null) {
+            switch (parentFiber.tag) {
+              case HostRoot:
+                var root = parentFiber.stateNode;
+                root.passiveEffectDuration += passiveEffectDuration;
+                break outer;
 
-function showErrorDialog(boundary, errorInfo) {
-  var capturedError = {
-    componentStack: errorInfo.stack !== null ? errorInfo.stack : "",
-    error: errorInfo.value,
-    errorBoundary:
-      boundary !== null && boundary.tag === ClassComponent
-        ? boundary.stateNode
-        : null
-  };
-  return ReactFiberErrorDialogWWW.showErrorDialog(capturedError);
-}
+              case Profiler:
+                var parentStateNode = parentFiber.stateNode;
+                parentStateNode.passiveEffectDuration += passiveEffectDuration;
+                break outer;
+            }
 
-function logCapturedError(boundary, errorInfo) {
-  try {
-    var logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
-    // This enables renderers like ReactNative to better manage redbox behavior.
+            parentFiber = parentFiber.return;
+          }
 
-    if (logError === false) {
-      return;
+          break;
+        }
+      }
     }
+  }
+}
 
-    var error = errorInfo.value;
-
-    if (true) {
-      var source = errorInfo.source;
-      var stack = errorInfo.stack;
-      var componentStack = stack !== null ? stack : ""; // Browsers support silencing uncaught errors by calling
-      // `preventDefault()` in window `error` handler.
-      // We record this information as an expando on the error.
+function commitHookLayoutEffects(finishedWork, hookFlags) {
+  // At this point layout effects have already been destroyed (during mutation phase).
+  // This is done to prevent sibling component effects from interfering with each other,
+  // e.g. a destroy function in one component should never override a ref set
+  // by a create function in another component during the same commit.
+  if (shouldProfile(finishedWork)) {
+    try {
+      startLayoutEffectTimer();
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
 
-      if (error != null && error._suppressLogging) {
-        if (boundary.tag === ClassComponent) {
-          // The error is recoverable and was silenced.
-          // Ignore it and don't print the stack addendum.
-          // This is handy for testing error boundaries without noise.
-          return;
-        } // The error is fatal. Since the silencing might have
-        // been accidental, we'll surface it anyway.
-        // However, the browser would have silenced the original error
-        // so we'll print it first, and then print the stack addendum.
+    recordLayoutEffectDuration(finishedWork);
+  } else {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
 
-        console["error"](error); // Don't transform to our wrapper
-        // For a more detailed description of this block, see:
-        // https://github.com/facebook/react/pull/13384
-      }
+function commitClassLayoutLifecycles(finishedWork, current) {
+  var instance = finishedWork.stateNode;
 
-      var componentName = source ? getComponentNameFromFiber(source) : null;
-      var componentNameMessage = componentName
-        ? "The above error occurred in the <" + componentName + "> component:"
-        : "The above error occurred in one of your React components:";
-      var errorBoundaryMessage;
+  if (current === null) {
+    // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "componentDidMount. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-      if (boundary.tag === HostRoot) {
-        errorBoundaryMessage =
-          "Consider adding an error boundary to your tree to customize error handling behavior.\n" +
-          "Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.";
-      } else {
-        var errorBoundaryName =
-          getComponentNameFromFiber(boundary) || "Anonymous";
-        errorBoundaryMessage =
-          "React will try to recreate this component tree from scratch " +
-          ("using the error boundary you provided, " + errorBoundaryName + ".");
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "componentDidMount. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
       }
+    }
 
-      var combinedMessage =
-        componentNameMessage +
-        "\n" +
-        componentStack +
-        "\n\n" +
-        ("" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.
-      // We don't include the original error message and JS stack because the browser
-      // has already printed it. Even if the application swallows the error, it is still
-      // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
 
-      console["error"](combinedMessage); // Don't transform to our wrapper
+      recordLayoutEffectDuration(finishedWork);
+    } else {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
     }
-  } catch (e) {
-    // This method must not throw, or React internal state will get messed up.
-    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
-    // we want to report this error outside of the normal stack as a last resort.
-    // https://github.com/facebook/react/issues/13188
-    setTimeout(function () {
-      throw e;
-    });
-  }
-}
-
-function createRootErrorUpdate(fiber, errorInfo, lane) {
-  var update = createUpdate(lane); // Unmount the root by rendering null.
+  } else {
+    var prevProps =
+      finishedWork.elementType === finishedWork.type
+        ? current.memoizedProps
+        : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    var prevState = current.memoizedState; // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
 
-  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
-  // being called "element".
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "componentDidUpdate. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-  update.payload = {
-    element: null
-  };
-  var error = errorInfo.value;
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "componentDidUpdate. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
+      }
+    }
 
-  update.callback = function () {
-    onUncaughtError(error);
-    logCapturedError(fiber, errorInfo);
-  };
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
 
-  return update;
+      recordLayoutEffectDuration(finishedWork);
+    } else {
+      try {
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
 }
 
-function createClassErrorUpdate(fiber, errorInfo, lane) {
-  var update = createUpdate(lane);
-  update.tag = CaptureUpdate;
-  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  var updateQueue = finishedWork.updateQueue;
 
-  if (typeof getDerivedStateFromError === "function") {
-    var error$1 = errorInfo.value;
+  if (updateQueue !== null) {
+    var instance = finishedWork.stateNode;
 
-    update.payload = function () {
-      return getDerivedStateFromError(error$1);
-    };
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "processing the update queue. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-    update.callback = function () {
-      {
-        markFailedErrorBoundaryForHotReloading(fiber);
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "processing the update queue. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
       }
+    } // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
 
-      logCapturedError(fiber, errorInfo);
-    };
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
   }
+}
 
-  var inst = fiber.stateNode;
+function commitHostComponentMount(finishedWork) {
+  var type = finishedWork.type;
+  var props = finishedWork.memoizedProps;
+  var instance = finishedWork.stateNode;
 
-  if (inst !== null && typeof inst.componentDidCatch === "function") {
-    // $FlowFixMe[missing-this-annot]
-    update.callback = function callback() {
-      {
-        markFailedErrorBoundaryForHotReloading(fiber);
-      }
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
 
-      logCapturedError(fiber, errorInfo);
+function commitProfilerUpdate(finishedWork, current) {
+  if (getExecutionContext() & CommitContext) {
+    try {
+      var _finishedWork$memoize2 = finishedWork.memoizedProps,
+        onCommit = _finishedWork$memoize2.onCommit,
+        onRender = _finishedWork$memoize2.onRender;
+      var effectDuration = finishedWork.stateNode.effectDuration;
+      var commitTime = getCommitTime();
+      var phase = current === null ? "mount" : "update";
 
-      if (typeof getDerivedStateFromError !== "function") {
-        // To preserve the preexisting retry behavior of error boundaries,
-        // we keep track of which ones already failed during this batch.
-        // This gets reset before we yield back to the browser.
-        // TODO: Warn in strict mode if getDerivedStateFromError is
-        // not defined.
-        markLegacyErrorBoundaryAsFailed(this);
+      if (enableProfilerNestedUpdatePhase) {
+        if (isCurrentUpdateNested()) {
+          phase = "nested-update";
+        }
       }
 
-      var error$1 = errorInfo.value;
-      var stack = errorInfo.stack;
-      this.componentDidCatch(error$1, {
-        componentStack: stack !== null ? stack : ""
-      });
-
-      {
-        if (typeof getDerivedStateFromError !== "function") {
-          // If componentDidCatch is the only error boundary method defined,
-          // then it needs to call setState to recover from errors.
-          // If no state update is scheduled then the boundary will swallow the error.
-          if (!includesSomeLane(fiber.lanes, SyncLane)) {
-            error(
-              "%s: Error boundaries should implement getDerivedStateFromError(). " +
-                "In that method, return a state update to display an error message or fallback UI.",
-              getComponentNameFromFiber(fiber) || "Unknown"
-            );
-          }
-        }
+      if (typeof onRender === "function") {
+        onRender(
+          finishedWork.memoizedProps.id,
+          phase,
+          finishedWork.actualDuration,
+          finishedWork.treeBaseDuration,
+          finishedWork.actualStartTime,
+          commitTime
+        );
       }
-    };
-  }
 
-  return update;
-}
+      if (enableProfilerCommitHooks) {
+        if (typeof onCommit === "function") {
+          onCommit(
+            finishedWork.memoizedProps.id,
+            phase,
+            effectDuration,
+            commitTime
+          );
+        } // Schedule a passive effect for this Profiler to call onPostCommit hooks.
+        // This effect should be scheduled even if there is no onPostCommit callback for this Profiler,
+        // because the effect is also where times bubble to parent Profilers.
 
-function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
-  if (enableLazyContextPropagation) {
-    var currentSourceFiber = sourceFiber.alternate;
+        enqueuePendingPassiveProfilerEffect(finishedWork); // Propagate layout effect durations to the next nearest Profiler ancestor.
+        // Do not reset these values until the next render so DevTools has a chance to read them first.
 
-    if (currentSourceFiber !== null) {
-      // Since we never visited the children of the suspended component, we
-      // need to propagate the context change now, to ensure that we visit
-      // them during the retry.
-      //
-      // We don't have to do this for errors because we retry errors without
-      // committing in between. So this is specific to Suspense.
-      propagateParentContextChangesToDeferredTree(
-        currentSourceFiber,
-        sourceFiber,
-        rootRenderLanes
-      );
-    }
-  } // Reset the memoizedState to what it was before we attempted to render it.
-  // A legacy mode Suspense quirk, only relevant to hook components.
+        var parentFiber = finishedWork.return;
 
-  var tag = sourceFiber.tag;
+        outer: while (parentFiber !== null) {
+          switch (parentFiber.tag) {
+            case HostRoot:
+              var root = parentFiber.stateNode;
+              root.effectDuration += effectDuration;
+              break outer;
 
-  if (
-    (sourceFiber.mode & ConcurrentMode) === NoMode &&
-    (tag === FunctionComponent ||
-      tag === ForwardRef ||
-      tag === SimpleMemoComponent)
-  ) {
-    var currentSource = sourceFiber.alternate;
+            case Profiler:
+              var parentStateNode = parentFiber.stateNode;
+              parentStateNode.effectDuration += effectDuration;
+              break outer;
+          }
 
-    if (currentSource) {
-      sourceFiber.updateQueue = currentSource.updateQueue;
-      sourceFiber.memoizedState = currentSource.memoizedState;
-      sourceFiber.lanes = currentSource.lanes;
-    } else {
-      sourceFiber.updateQueue = null;
-      sourceFiber.memoizedState = null;
+          parentFiber = parentFiber.return;
+        }
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
   }
 }
 
-function markSuspenseBoundaryShouldCapture(
-  suspenseBoundary,
-  returnFiber,
-  sourceFiber,
-  root,
-  rootRenderLanes
+function commitLayoutEffectOnFiber(
+  finishedRoot,
+  current,
+  finishedWork,
+  committedLanes
 ) {
-  // This marks a Suspense boundary so that when we're unwinding the stack,
-  // it captures the suspended "exception" and does a second (fallback) pass.
-  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
-    // Legacy Mode Suspense
-    //
-    // If the boundary is in legacy mode, we should *not*
-    // suspend the commit. Pretend as if the suspended component rendered
-    // null and keep rendering. When the Suspense boundary completes,
-    // we'll do a second pass to render the fallback.
-    if (suspenseBoundary === returnFiber) {
-      // Special case where we suspended while reconciling the children of
-      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
-      // when a React.lazy component is a direct child of a
-      // Suspense boundary.
-      //
-      // Suspense boundaries are implemented as multiple fibers, but they
-      // are a single conceptual unit. The legacy mode behavior where we
-      // pretend the suspended fiber committed as `null` won't work,
-      // because in this case the "suspended" fiber is the inner
-      // Offscreen wrapper.
-      //
-      // Because the contents of the boundary haven't started rendering
-      // yet (i.e. nothing in the tree has partially rendered) we can
-      // switch to the regular, concurrent mode behavior: mark the
-      // boundary with ShouldCapture and enter the unwind phase.
-      suspenseBoundary.flags |= ShouldCapture;
-    } else {
-      suspenseBoundary.flags |= DidCapture;
-      sourceFiber.flags |= ForceUpdateForLegacySuspense; // 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.flags &= ~(LifecycleEffectMask | Incomplete);
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  var flags = finishedWork.flags;
 
-      if (sourceFiber.tag === ClassComponent) {
-        var currentSourceFiber = sourceFiber.alternate;
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-        if (currentSourceFiber === null) {
-          // This is a new mount. Change the tag so it's not mistaken for a
-          // completed class component. For example, we should not call
-          // componentWillUnmount if it is deleted.
-          sourceFiber.tag = IncompleteClassComponent;
-        } else {
-          // When we try rendering again, we should not reuse the current fiber,
-          // since it's known to be in an inconsistent state. Use a force update to
-          // prevent a bail out.
-          var update = createUpdate(SyncLane);
-          update.tag = ForceUpdate;
-          enqueueUpdate(sourceFiber, update, SyncLane);
-        }
-      } // The source fiber did not complete. Mark it with Sync priority to
-      // indicate that it still has pending work.
+      if (flags & Update) {
+        commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+      }
 
-      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+      break;
     }
 
-    return suspenseBoundary;
-  } // Confirmed that the boundary is in a concurrent mode tree. Continue
-  // with the normal suspend path.
-  //
-  // After this we'll use a set of heuristics to determine whether this
-  // render pass will run to completion or restart or "suspend" the commit.
-  // The actual logic for this is spread out in different places.
-  //
-  // This first principle is that if we're going to suspend when we complete
-  // a root, then we should also restart if we get an update or ping that
-  // might unsuspend it, and vice versa. The only reason to suspend is
-  // because you think you might want to restart before committing. However,
-  // it doesn't make sense to restart only while in the period we're suspended.
-  //
-  // Restarting too aggressively is also not good because it starves out any
-  // intermediate loading state. So we use heuristics to determine when.
-  // Suspense Heuristics
-  //
-  // If nothing threw a Promise or all the same fallbacks are already showing,
-  // then don't suspend/restart.
-  //
-  // If this is an initial render of a new tree of Suspense boundaries and
-  // those trigger a fallback, then don't suspend/restart. We want to ensure
-  // that we can show the initial loading state as quickly as possible.
-  //
-  // If we hit a "Delayed" case, such as when we'd switch from content back into
-  // a fallback, then we should always suspend/restart. Transitions apply
-  // to this case. If none is defined, JND is used instead.
-  //
-  // If we're already showing a fallback and it gets "retried", allowing us to show
-  // another level, but there's still an inner boundary that would show a fallback,
-  // then we suspend/restart for 500ms since the last time we showed a fallback
-  // anywhere in the tree. This effectively throttles progressive loading into a
-  // consistent train of commits. This also gives us an opportunity to restart to
-  // get to the completed state slightly earlier.
-  //
-  // If there's ambiguity due to batching it's resolved in preference of:
-  // 1) "delayed", 2) "initial render", 3) "retry".
-  //
-  // We want to ensure that a "busy" state doesn't get force committed. We want to
-  // ensure that new initial loading states can commit as soon as possible.
+    case ClassComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
-  // the begin phase to prevent an early bailout.
+      if (flags & Update) {
+        commitClassLayoutLifecycles(finishedWork, current);
+      }
 
-  suspenseBoundary.lanes = rootRenderLanes;
-  return suspenseBoundary;
-}
+      if (flags & Callback) {
+        commitClassCallbacks(finishedWork);
+      }
 
-function throwException(
-  root,
-  returnFiber,
-  sourceFiber,
-  value,
-  rootRenderLanes
-) {
-  // The source fiber did not complete.
-  sourceFiber.flags |= Incomplete;
+      if (flags & Ref) {
+        safelyAttachRef(finishedWork, finishedWork.return);
+      }
 
-  {
-    if (isDevToolsPresent) {
-      // If we have pending work still, restore the original updaters
-      restorePendingUpdaters(root, rootRenderLanes);
+      break;
     }
-  }
-
-  if (
-    value !== null &&
-    typeof value === "object" &&
-    typeof value.then === "function"
-  ) {
-    // This is a wakeable. The component suspended.
-    var wakeable = value;
-    resetSuspendedComponent(sourceFiber, rootRenderLanes);
 
-    {
-      if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
-        markDidThrowWhileHydratingDEV();
-      }
-    }
+    case HostRoot: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-    {
-      if (enableDebugTracing) {
-        if (sourceFiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(sourceFiber) || "Unknown";
-          logComponentSuspended(name, wakeable);
-        }
-      }
-    } // Mark the nearest Suspense boundary to switch to rendering a fallback.
+      if (flags & Callback) {
+        // TODO: I think this is now always non-null by the time it reaches the
+        // commit phase. Consider removing the type check.
+        var updateQueue = finishedWork.updateQueue;
 
-    var suspenseBoundary = getSuspenseHandler();
+        if (updateQueue !== null) {
+          var instance = null;
 
-    if (suspenseBoundary !== null) {
-      switch (suspenseBoundary.tag) {
-        case SuspenseComponent: {
-          // If this suspense boundary is not already showing a fallback, mark
-          // the in-progress render as suspended. We try to perform this logic
-          // as soon as soon as possible during the render phase, so the work
-          // loop can know things like whether it's OK to switch to other tasks,
-          // or whether it can wait for data to resolve before continuing.
-          // TODO: Most of these checks are already performed when entering a
-          // Suspense boundary. We should track the information on the stack so
-          // we don't have to recompute it on demand. This would also allow us
-          // to unify with `use` which needs to perform this logic even sooner,
-          // before `throwException` is called.
-          if (sourceFiber.mode & ConcurrentMode) {
-            if (getShellBoundary() === null) {
-              // Suspended in the "shell" of the app. This is an undesirable
-              // loading state. We should avoid committing this tree.
-              renderDidSuspendDelayIfPossible();
-            } else {
-              // If we suspended deeper than the shell, we don't need to delay
-              // the commmit. However, we still call renderDidSuspend if this is
-              // a new boundary, to tell the work loop that a new fallback has
-              // appeared during this render.
-              // TODO: Theoretically we should be able to delete this branch.
-              // It's currently used for two things: 1) to throttle the
-              // appearance of successive loading states, and 2) in
-              // SuspenseList, to determine whether the children include any
-              // pending fallbacks. For 1, we should apply throttling to all
-              // retries, not just ones that render an additional fallback. For
-              // 2, we should check subtreeFlags instead. Then we can delete
-              // this branch.
-              var current = suspenseBoundary.alternate;
+          if (finishedWork.child !== null) {
+            switch (finishedWork.child.tag) {
+              case HostSingleton:
+              case HostComponent:
+                instance = getPublicInstance(finishedWork.child.stateNode);
+                break;
 
-              if (current === null) {
-                renderDidSuspend();
-              }
+              case ClassComponent:
+                instance = finishedWork.child.stateNode;
+                break;
             }
           }
 
-          suspenseBoundary.flags &= ~ForceClientRender;
-          markSuspenseBoundaryShouldCapture(
-            suspenseBoundary,
-            returnFiber,
-            sourceFiber,
-            root,
-            rootRenderLanes
-          ); // Retry listener
-          //
-          // If the fallback does commit, we need to attach a different type of
-          // listener. This one schedules an update on the Suspense boundary to
-          // turn the fallback state off.
-          //
-          // Stash the wakeable on the boundary fiber so we can access it in the
-          // commit phase.
-          //
-          // When the wakeable resolves, we'll attempt to render the boundary
-          // again ("retry").
+          try {
+            commitCallbacks(updateQueue, instance);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
 
-          var wakeables = suspenseBoundary.updateQueue;
+      break;
+    }
 
-          if (wakeables === null) {
-            suspenseBoundary.updateQueue = new Set([wakeable]);
-          } else {
-            wakeables.add(wakeable);
-          }
+    case HostHoistable: {
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-          break;
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
         }
 
-        case OffscreenComponent: {
-          if (suspenseBoundary.mode & ConcurrentMode) {
-            suspenseBoundary.flags |= ShouldCapture;
-            var offscreenQueue = suspenseBoundary.updateQueue;
+        break;
+      }
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-            if (offscreenQueue === null) {
-              var newOffscreenQueue = {
-                transitions: null,
-                markerInstances: null,
-                wakeables: new Set([wakeable])
-              };
-              suspenseBoundary.updateQueue = newOffscreenQueue;
-            } else {
-              var _wakeables = offscreenQueue.wakeables;
+    case HostSingleton:
+    case HostComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+      // (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 (_wakeables === null) {
-                offscreenQueue.wakeables = new Set([wakeable]);
-              } else {
-                _wakeables.add(wakeable);
-              }
-            }
+      if (current === null && flags & Update) {
+        commitHostComponentMount(finishedWork);
+      }
 
-            break;
-          }
-        }
-        // eslint-disable-next-line no-fallthrough
+      if (flags & Ref) {
+        safelyAttachRef(finishedWork, finishedWork.return);
+      }
 
-        default: {
-          throw new Error(
-            "Unexpected Suspense handler tag (" +
-              suspenseBoundary.tag +
-              "). This " +
-              "is a bug in React."
-          );
-        }
-      } // We only attach ping listeners in concurrent mode. Legacy Suspense always
-      // commits fallbacks synchronously, so there are no pings.
+      break;
+    }
 
-      if (suspenseBoundary.mode & ConcurrentMode) {
-        attachPingListener(root, wakeable, rootRenderLanes);
+    case Profiler: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
+      // fire when the tree becomes visible again.
+
+      if (flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
       }
 
-      return;
-    } else {
-      // No boundary was found. Unless this is a sync update, this is OK.
-      // We can suspend and wait for more data to arrive.
-      if (root.tag === ConcurrentRoot) {
-        // In a concurrent root, suspending without a Suspense boundary is
-        // allowed. It will suspend indefinitely without committing.
-        //
-        // TODO: Should we have different behavior for discrete updates? What
-        // about flushSync? Maybe it should put the tree into an inert state,
-        // and potentially log a warning. Revisit this for a future release.
-        attachPingListener(root, wakeable, rootRenderLanes);
-        renderDidSuspendDelayIfPossible();
-        return;
-      } else {
-        // In a legacy root, suspending without a boundary is always an error.
-        var uncaughtSuspenseError = new Error(
-          "A component suspended while responding to synchronous input. This " +
-            "will cause the UI to be replaced with a loading indicator. To " +
-            "fix, updates that suspend should be wrapped " +
-            "with startTransition."
-        );
-        value = uncaughtSuspenseError;
+      break;
+    }
+
+    case SuspenseComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+      if (flags & Update) {
+        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
       }
+
+      break;
     }
-  } else {
-    // This is a regular error, not a Suspense wakeable.
-    if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
-      markDidThrowWhileHydratingDEV();
 
-      var _suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
-      // discarding the dehydrated content and switching to a client render.
-      // Instead of surfacing the error, find the nearest Suspense boundary
-      // and render it again without hydration.
+    case OffscreenComponent: {
+      var isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
 
-      if (_suspenseBoundary !== null) {
-        if ((_suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
-          // Set a flag to indicate that we should try rendering the normal
-          // children again, not the fallback.
-          _suspenseBoundary.flags |= ForceClientRender;
+      if (isModernRoot) {
+        var isHidden = finishedWork.memoizedState !== null;
+        var newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+
+        if (newOffscreenSubtreeIsHidden);
+        else {
+          // The Offscreen tree is visible.
+          var wasHidden = current !== null && current.memoizedState !== null;
+          var newOffscreenSubtreeWasHidden =
+            wasHidden || offscreenSubtreeWasHidden;
+          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+
+          if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+            // This is the root of a reappearing boundary. As we continue
+            // traversing the layout effects, we must also re-mount layout
+            // effects that were unmounted when the Offscreen subtree was
+            // hidden. So this is a superset of the normal commitLayoutEffects.
+            var includeWorkInProgressEffects =
+              (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+            recursivelyTraverseReappearLayoutEffects(
+              finishedRoot,
+              finishedWork,
+              includeWorkInProgressEffects
+            );
+          } else {
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          }
+
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
         }
+      } else {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      }
 
-        markSuspenseBoundaryShouldCapture(
-          _suspenseBoundary,
-          returnFiber,
-          sourceFiber,
-          root,
-          rootRenderLanes
-        ); // Even though the user may not be affected by this error, we should
-        // still log it so it can be fixed.
+      if (flags & Ref) {
+        var props = finishedWork.memoizedProps;
 
-        queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
-        return;
+        if (props.mode === "manual") {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        } else {
+          safelyDetachRef(finishedWork, finishedWork.return);
+        }
       }
+
+      break;
+    }
+
+    default: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      break;
     }
   }
+}
 
-  value = createCapturedValueAtFiber(value, sourceFiber);
-  renderDidError(value); // 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.
+function abortRootTransitions(
+  root,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    var rootTransitions = root.incompleteTransitions;
+    deletedTransitions.forEach(function (transition) {
+      if (rootTransitions.has(transition)) {
+        var transitionInstance = rootTransitions.get(transition);
 
-  var workInProgress = returnFiber;
+        if (transitionInstance.aborts === null) {
+          transitionInstance.aborts = [];
+        }
 
-  do {
-    switch (workInProgress.tag) {
-      case HostRoot: {
-        var _errorInfo = value;
-        workInProgress.flags |= ShouldCapture;
-        var lane = pickArbitraryLane(rootRenderLanes);
-        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
-        var update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
-        enqueueCapturedUpdate(workInProgress, update);
-        return;
+        transitionInstance.aborts.push(abort);
+
+        if (deletedOffscreenInstance !== null) {
+          if (
+            transitionInstance.pendingBoundaries !== null &&
+            transitionInstance.pendingBoundaries.has(deletedOffscreenInstance)
+          ) {
+            // $FlowFixMe[incompatible-use] found when upgrading Flow
+            transitionInstance.pendingBoundaries.delete(
+              deletedOffscreenInstance
+            );
+          }
+        }
       }
+    });
+  }
+}
 
-      case ClassComponent:
-        // Capture and retry
-        var errorInfo = value;
-        var ctor = workInProgress.type;
-        var instance = workInProgress.stateNode;
+function abortTracingMarkerTransitions(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    var markerInstance = abortedFiber.stateNode;
+    var markerTransitions = markerInstance.transitions;
+    var pendingBoundaries = markerInstance.pendingBoundaries;
 
+    if (markerTransitions !== null) {
+      // TODO: Refactor this code. Is there a way to move this code to
+      // the deletions phase instead of calculating it here while making sure
+      // complete is called appropriately?
+      deletedTransitions.forEach(function (transition) {
+        // If one of the transitions on the tracing marker is a transition
+        // that was in an aborted subtree, we will abort that tracing marker
         if (
-          (workInProgress.flags & DidCapture) === NoFlags$1 &&
-          (typeof ctor.getDerivedStateFromError === "function" ||
-            (instance !== null &&
-              typeof instance.componentDidCatch === "function" &&
-              !isAlreadyFailedLegacyErrorBoundary(instance)))
+          abortedFiber !== null &&
+          markerTransitions.has(transition) &&
+          (markerInstance.aborts === null ||
+            !markerInstance.aborts.includes(abort))
         ) {
-          workInProgress.flags |= ShouldCapture;
+          if (markerInstance.transitions !== null) {
+            if (markerInstance.aborts === null) {
+              markerInstance.aborts = [abort];
+              addMarkerIncompleteCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                markerInstance.transitions,
+                markerInstance.aborts
+              );
+            } else {
+              markerInstance.aborts.push(abort);
+            } // We only want to call onTransitionProgress when the marker hasn't been
+            // deleted
 
-          var _lane = pickArbitraryLane(rootRenderLanes);
+            if (
+              deletedOffscreenInstance !== null &&
+              !isInDeletedTree &&
+              pendingBoundaries !== null &&
+              pendingBoundaries.has(deletedOffscreenInstance)
+            ) {
+              pendingBoundaries.delete(deletedOffscreenInstance);
+              addMarkerProgressCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                deletedTransitions,
+                pendingBoundaries
+              );
+            }
+          }
+        }
+      });
+    }
+  }
+}
 
-          workInProgress.lanes = mergeLanes(workInProgress.lanes, _lane); // Schedule the error boundary to re-render using updated state
+function abortParentMarkerTransitionsForDeletedFiber(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    // Find all pending markers that are waiting on child suspense boundaries in the
+    // aborted subtree and cancels them
+    var fiber = abortedFiber;
 
-          var _update = createClassErrorUpdate(
-            workInProgress,
-            errorInfo,
-            _lane
+    while (fiber !== null) {
+      switch (fiber.tag) {
+        case TracingMarkerComponent:
+          abortTracingMarkerTransitions(
+            fiber,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance,
+            isInDeletedTree
           );
+          break;
 
-          enqueueCapturedUpdate(workInProgress, _update);
-          return;
-        }
-
-        break;
-    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+        case HostRoot:
+          var root = fiber.stateNode;
+          abortRootTransitions(
+            root,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance
+          );
+          break;
+      }
 
-    workInProgress = workInProgress.return;
-  } while (workInProgress !== null);
+      fiber = fiber.return;
+    }
+  }
 }
 
-var TransitionRoot = 0;
-var TransitionTracingMarker = 1;
-function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
+function commitTransitionProgress(offscreenFiber) {
   if (enableTransitionTracing) {
-    if (pendingTransitions !== null) {
-      var transitionStart = pendingTransitions.transitionStart;
-      var onTransitionStart = callbacks.onTransitionStart;
+    // This function adds suspense boundaries to the root
+    // or tracing marker's pendingBoundaries map.
+    // When a suspense boundary goes from a resolved to a fallback
+    // state we add the boundary to the map, and when it goes from
+    // a fallback to a resolved state, we remove the boundary from
+    // the map.
+    // We use stateNode on the Offscreen component as a stable object
+    // that doesnt change from render to render. This way we can
+    // distinguish between different Offscreen instances (vs. the same
+    // Offscreen instance with different fibers)
+    var offscreenInstance = offscreenFiber.stateNode;
+    var prevState = null;
+    var previousFiber = offscreenFiber.alternate;
 
-      if (transitionStart !== null && onTransitionStart != null) {
-        transitionStart.forEach(function (transition) {
-          return onTransitionStart(transition.name, transition.startTime);
-        });
-      }
+    if (previousFiber !== null && previousFiber.memoizedState !== null) {
+      prevState = previousFiber.memoizedState;
+    }
 
-      var markerProgress = pendingTransitions.markerProgress;
-      var onMarkerProgress = callbacks.onMarkerProgress;
+    var nextState = offscreenFiber.memoizedState;
+    var wasHidden = prevState !== null;
+    var isHidden = nextState !== null;
+    var pendingMarkers = offscreenInstance._pendingMarkers; // If there is a name on the suspense boundary, store that in
+    // the pending boundaries.
 
-      if (onMarkerProgress != null && markerProgress !== null) {
-        markerProgress.forEach(function (markerInstance, markerName) {
-          if (markerInstance.transitions !== null) {
-            // TODO: Clone the suspense object so users can't modify it
-            var pending =
-              markerInstance.pendingBoundaries !== null
-                ? Array.from(markerInstance.pendingBoundaries.values())
-                : [];
-            markerInstance.transitions.forEach(function (transition) {
-              onMarkerProgress(
-                transition.name,
-                markerName,
-                transition.startTime,
-                endTime,
-                pending
-              );
+    var name = null;
+    var parent = offscreenFiber.return;
+
+    if (
+      parent !== null &&
+      parent.tag === SuspenseComponent &&
+      parent.memoizedProps.unstable_name
+    ) {
+      name = parent.memoizedProps.unstable_name;
+    }
+
+    if (!wasHidden && isHidden) {
+      // The suspense boundaries was just hidden. Add the boundary
+      // to the pending boundary set if it's there
+      if (pendingMarkers !== null) {
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries;
+          var transitions = markerInstance.transitions;
+          var markerName = markerInstance.name;
+
+          if (
+            pendingBoundaries !== null &&
+            !pendingBoundaries.has(offscreenInstance)
+          ) {
+            pendingBoundaries.set(offscreenInstance, {
+              name: name
             });
+
+            if (transitions !== null) {
+              if (
+                markerInstance.tag === TransitionTracingMarker &&
+                markerName !== null
+              ) {
+                addMarkerProgressCallbackToPendingTransition(
+                  markerName,
+                  transitions,
+                  pendingBoundaries
+                );
+              } else if (markerInstance.tag === TransitionRoot) {
+                transitions.forEach(function (transition) {
+                  addTransitionProgressCallbackToPendingTransition(
+                    transition,
+                    pendingBoundaries
+                  );
+                });
+              }
+            }
           }
         });
       }
+    } else if (wasHidden && !isHidden) {
+      // The suspense boundary went from hidden to visible. Remove
+      // the boundary from the pending suspense boundaries set
+      // if it's there
+      if (pendingMarkers !== null) {
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries;
+          var transitions = markerInstance.transitions;
+          var markerName = markerInstance.name;
 
-      var markerComplete = pendingTransitions.markerComplete;
-      var onMarkerComplete = callbacks.onMarkerComplete;
-
-      if (markerComplete !== null && onMarkerComplete != null) {
-        markerComplete.forEach(function (transitions, markerName) {
-          transitions.forEach(function (transition) {
-            onMarkerComplete(
-              transition.name,
-              markerName,
-              transition.startTime,
-              endTime
-            );
-          });
-        });
-      }
+          if (
+            pendingBoundaries !== null &&
+            pendingBoundaries.has(offscreenInstance)
+          ) {
+            pendingBoundaries.delete(offscreenInstance);
 
-      var markerIncomplete = pendingTransitions.markerIncomplete;
-      var onMarkerIncomplete = callbacks.onMarkerIncomplete;
+            if (transitions !== null) {
+              if (
+                markerInstance.tag === TransitionTracingMarker &&
+                markerName !== null
+              ) {
+                addMarkerProgressCallbackToPendingTransition(
+                  markerName,
+                  transitions,
+                  pendingBoundaries
+                ); // If there are no more unresolved suspense boundaries, the interaction
+                // is considered finished
 
-      if (onMarkerIncomplete != null && markerIncomplete !== null) {
-        markerIncomplete.forEach(function (_ref, markerName) {
-          var transitions = _ref.transitions,
-            aborts = _ref.aborts;
-          transitions.forEach(function (transition) {
-            var filteredAborts = [];
-            aborts.forEach(function (abort) {
-              switch (abort.reason) {
-                case "marker": {
-                  filteredAborts.push({
-                    type: "marker",
-                    name: abort.name,
-                    endTime: endTime
-                  });
-                  break;
-                }
+                if (pendingBoundaries.size === 0) {
+                  if (markerInstance.aborts === null) {
+                    addMarkerCompleteCallbackToPendingTransition(
+                      markerName,
+                      transitions
+                    );
+                  }
 
-                case "suspense": {
-                  filteredAborts.push({
-                    type: "suspense",
-                    name: abort.name,
-                    endTime: endTime
-                  });
-                  break;
+                  markerInstance.transitions = null;
+                  markerInstance.pendingBoundaries = null;
+                  markerInstance.aborts = null;
                 }
+              } else if (markerInstance.tag === TransitionRoot) {
+                transitions.forEach(function (transition) {
+                  addTransitionProgressCallbackToPendingTransition(
+                    transition,
+                    pendingBoundaries
+                  );
+                });
               }
-            });
-
-            if (filteredAborts.length > 0) {
-              onMarkerIncomplete(
-                transition.name,
-                markerName,
-                transition.startTime,
-                filteredAborts
-              );
             }
-          });
+          }
         });
       }
+    }
+  }
+}
 
-      var transitionProgress = pendingTransitions.transitionProgress;
-      var onTransitionProgress = callbacks.onTransitionProgress;
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  var hostSubtreeRoot = null;
 
-      if (onTransitionProgress != null && transitionProgress !== null) {
-        transitionProgress.forEach(function (pending, transition) {
-          onTransitionProgress(
-            transition.name,
-            transition.startTime,
-            endTime,
-            Array.from(pending.values())
-          );
-        });
-      }
+  {
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    var node = finishedWork;
 
-      var transitionComplete = pendingTransitions.transitionComplete;
-      var onTransitionComplete = callbacks.onTransitionComplete;
+    while (true) {
+      if (
+        node.tag === HostComponent ||
+        node.tag === HostHoistable ||
+        node.tag === HostSingleton
+      ) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
 
-      if (transitionComplete !== null && onTransitionComplete != null) {
-        transitionComplete.forEach(function (transition) {
-          return onTransitionComplete(
-            transition.name,
-            transition.startTime,
-            endTime
-          );
-        });
+          try {
+            var instance = node.stateNode;
+
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            var _instance = node.stateNode;
+
+            if (isHidden) {
+              hideTextInstance(_instance);
+            } else {
+              unhideTextInstance(_instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (
+        (node.tag === OffscreenComponent ||
+          node.tag === LegacyHiddenComponent) &&
+        node.memoizedState !== null &&
+        node !== finishedWork
+      );
+      else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
       }
-    }
-  }
-} // For every tracing marker, store a pointer to it. We will later access it
-// to get the set of suspense boundaries that need to resolve before the
-// tracing marker can be logged as complete
-// This code lives separate from the ReactFiberTransition code because
-// we push and pop on the tracing marker, not the suspense boundary
 
-var markerInstanceStack = createCursor(null);
-function pushRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    // On the root, every transition gets mapped to it's own map of
-    // suspense boundaries. The transition is marked as complete when
-    // the suspense boundaries map is empty. We do this because every
-    // transition completes at different times and depends on different
-    // suspense boundaries to complete. We store all the transitions
-    // along with its map of suspense boundaries in the root incomplete
-    // transitions map. Each entry in this map functions like a tracing
-    // marker does, so we can push it onto the marker instance stack
-    var transitions = getWorkInProgressTransitions();
-    var root = workInProgress.stateNode;
+      if (node === finishedWork) {
+        return;
+      }
 
-    if (transitions !== null) {
-      transitions.forEach(function (transition) {
-        if (!root.incompleteTransitions.has(transition)) {
-          var markerInstance = {
-            tag: TransitionRoot,
-            transitions: new Set([transition]),
-            pendingBoundaries: null,
-            aborts: null,
-            name: null
-          };
-          root.incompleteTransitions.set(transition, markerInstance);
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
         }
-      });
-    }
 
-    var markerInstances = []; // For ever transition on the suspense boundary, we push the transition
-    // along with its map of pending suspense boundaries onto the marker
-    // instance stack.
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
 
-    root.incompleteTransitions.forEach(function (markerInstance) {
-      markerInstances.push(markerInstance);
-    });
-    push(markerInstanceStack, markerInstances, workInProgress);
-  }
-}
-function popRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    pop(markerInstanceStack, workInProgress);
-  }
-}
-function pushMarkerInstance(workInProgress, markerInstance) {
-  if (enableTransitionTracing) {
-    if (markerInstanceStack.current === null) {
-      push(markerInstanceStack, [markerInstance], workInProgress);
-    } else {
-      push(
-        markerInstanceStack,
-        markerInstanceStack.current.concat(markerInstance),
-        workInProgress
-      );
+        node = node.return;
+      }
+
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
+      }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
     }
   }
 }
-function popMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    pop(markerInstanceStack, workInProgress);
-  }
-}
-function getMarkerInstances() {
-  if (enableTransitionTracing) {
-    return markerInstanceStack.current;
-  }
 
-  return null;
-}
+function commitAttachRef(finishedWork) {
+  var ref = finishedWork.ref;
 
-var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
-// into a dehydrated boundary.
+  if (ref !== null) {
+    var instance = finishedWork.stateNode;
+    var instanceToUse;
 
-var SelectiveHydrationException = new Error(
-  "This is not a real error. It's an implementation detail of React's " +
-    "selective hydration feature. If this leaks into userspace, it's a bug in " +
-    "React. Please file an issue."
-);
-var didReceiveUpdate = false;
-var didWarnAboutBadClass;
-var didWarnAboutModulePatternComponent;
-var didWarnAboutContextTypeOnFunctionComponent;
-var didWarnAboutGetDerivedStateOnFunctionComponent;
-var didWarnAboutFunctionRefs;
-var didWarnAboutReassigningProps;
-var didWarnAboutRevealOrder;
-var didWarnAboutTailOptions;
-var didWarnAboutDefaultPropsOnFunctionComponent;
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
 
-{
-  didWarnAboutBadClass = {};
-  didWarnAboutModulePatternComponent = {};
-  didWarnAboutContextTypeOnFunctionComponent = {};
-  didWarnAboutGetDerivedStateOnFunctionComponent = {};
-  didWarnAboutFunctionRefs = {};
-  didWarnAboutReassigningProps = false;
-  didWarnAboutRevealOrder = {};
-  didWarnAboutTailOptions = {};
-  didWarnAboutDefaultPropsOnFunctionComponent = {};
-}
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
+
+    if (finishedWork.tag === ScopeComponent) {
+      instanceToUse = instance;
+    }
+
+    if (typeof ref === "function") {
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          finishedWork.refCleanup = ref(instanceToUse);
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
+        finishedWork.refCleanup = ref(instanceToUse);
+      }
+    } else {
+      {
+        if (!ref.hasOwnProperty("current")) {
+          error(
+            "Unexpected ref object provided for %s. " +
+              "Use either a ref-setter function or React.createRef().",
+            getComponentNameFromFiber(finishedWork)
+          );
+        }
+      } // $FlowFixMe unable to narrow type to the non-function case
 
-function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
-  if (current === 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
-    // we can optimize this reconciliation pass by not tracking side-effects.
-    workInProgress.child = mountChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    // If the current child is the same as the work in progress, it means that
-    // we haven't yet started any work on these children. Therefore, we use
-    // the clone algorithm to create a copy of all the current children.
-    // If we had any progressed work already, that is invalid at this point so
-    // let's throw it out.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      current.child,
-      nextChildren,
-      renderLanes
-    );
+      ref.current = instanceToUse;
+    }
   }
 }
 
-function forceUnmountCurrentAndReconcile(
-  current,
-  workInProgress,
-  nextChildren,
-  renderLanes
-) {
-  // This function is fork of reconcileChildren. It's used in cases where we
-  // want to reconcile without matching against the existing set. This has the
-  // effect of all current children being unmounted; even if the type and key
-  // are the same, the old child is unmounted and a new child is created.
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
   //
-  // To do this, we're going to go through the reconcile algorithm twice. In
-  // the first pass, we schedule a deletion for all the current children by
-  // passing null.
-  workInProgress.child = reconcileChildFibers(
-    workInProgress,
-    current.child,
-    null,
-    renderLanes
-  ); // In the second pass, we mount the new children. The trick here is that we
-  // pass null in place of where we usually pass the current child set. This has
-  // the effect of remounting all children regardless of whether their
-  // identities match.
+  // Ideally, we should also 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.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  var alternate = fiber.alternate;
 
-  workInProgress.child = reconcileChildFibers(
-    workInProgress,
-    null,
-    nextChildren,
-    renderLanes
-  );
+  if (alternate !== null) {
+    alternate.return = null;
+  }
+
+  fiber.return = null;
 }
 
-function updateForwardRef(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  // TODO: current can be non-null here even if the component
-  // hasn't yet mounted. This happens after the first render suspends.
-  // We'll need to figure out if this is fine or can cause issues.
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+function detachFiberAfterEffects(fiber) {
+  var alternate = fiber.alternate;
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
-      }
-    }
-  }
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
 
-  var render = Component.render;
-  var ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
 
-  var nextChildren;
-  var hasId;
-  prepareToReadContext(workInProgress, renderLanes);
+  if (fiber.tag === HostComponent) {
+    var hostInstance = fiber.stateNode;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
+    }
   }
 
+  fiber.stateNode = null;
+
   {
-    ReactCurrentOwner$1.current = workInProgress;
-    setIsRendering(true);
-    nextChildren = renderWithHooks(
-      current,
-      workInProgress,
-      render,
-      nextProps,
-      ref,
-      renderLanes
-    );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
+    fiber._debugOwner = null;
+  } // Theoretically, nothing in here should be necessary, because we already
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  fiber.updateQueue = null;
+}
+
+function getHostParentFiber(fiber) {
+  var parent = fiber.return;
+
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
+    }
+
+    parent = parent.return;
   }
 
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
+  throw new Error(
+    "Expected to find a host parent. This error is likely caused by a bug " +
+      "in React. Please file an issue."
+  );
+}
 
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+function isHostParent(fiber) {
+  return (
+    fiber.tag === HostComponent ||
+    fiber.tag === HostRoot ||
+    fiber.tag === HostHoistable ||
+    fiber.tag === HostSingleton ||
+    fiber.tag === HostPortal
+  );
 }
 
-function updateMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (current === null) {
-    var type = Component.type;
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  var node = fiber;
 
-    if (
-      isSimpleFunctionComponent(type) &&
-      Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
-      Component.defaultProps === undefined
-    ) {
-      var resolvedType = type;
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
 
-      {
-        resolvedType = resolveFunctionForHotReloading(type);
-      } // If this is a plain function component without default props,
-      // and with only the default shallow comparison, we upgrade it
-      // to a SimpleMemoComponent to allow fast path updates.
+      node = node.return;
+    }
 
-      workInProgress.tag = SimpleMemoComponent;
-      workInProgress.type = resolvedType;
+    node.sibling.return = node.return;
+    node = node.sibling;
 
-      {
-        validateFunctionComponentInDev(workInProgress, type);
+    while (
+      node.tag !== HostComponent &&
+      node.tag !== HostText &&
+      node.tag !== HostSingleton &&
+      node.tag !== DehydratedFragment
+    ) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
+
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
+      } else {
+        node.child.return = node;
+        node = node.child;
       }
+    } // Check if this host node is stable or about to be placed.
 
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        resolvedType,
-        nextProps,
-        renderLanes
-      );
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
     }
+  }
+}
 
-    {
-      var innerPropTypes = type.propTypes;
+function commitPlacement(finishedWork) {
+  {
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
 
-      if (innerPropTypes) {
-        // Inner memo component props aren't currently validated in createElement.
-        // We could move it there, but we'd still need this for lazy code path.
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(type)
-        );
+  var parentFiber = getHostParentFiber(finishedWork);
+
+  switch (parentFiber.tag) {
+    case HostSingleton: {
+      {
+        var parent = parentFiber.stateNode;
+        var before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
       }
+    }
+    // eslint-disable-next-line no-fallthrough
 
-      if (Component.defaultProps !== undefined) {
-        var componentName = getComponentNameFromType(type) || "Unknown";
+    case HostComponent: {
+      var _parent = parentFiber.stateNode;
 
-        if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
-          error(
-            "%s: Support for defaultProps will be removed from memo components " +
-              "in a future major release. Use JavaScript default parameters instead.",
-            componentName
-          );
+      if (parentFiber.flags & ContentReset) {
+        // Reset the text content of the parent before doing any insertions
+        resetTextContent(_parent); // Clear ContentReset from the effect tag
 
-          didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
-        }
+        parentFiber.flags &= ~ContentReset;
       }
+
+      var _before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+      // children to find all the terminal nodes.
+
+      insertOrAppendPlacementNode(finishedWork, _before, _parent);
+      break;
     }
 
-    var child = createFiberFromTypeAndProps(
-      Component.type,
-      null,
-      nextProps,
-      workInProgress,
-      workInProgress.mode,
-      renderLanes
-    );
-    child.ref = workInProgress.ref;
-    child.return = workInProgress;
-    workInProgress.child = child;
-    return child;
-  }
+    case HostRoot:
+    case HostPortal: {
+      var _parent2 = parentFiber.stateNode.containerInfo;
 
-  {
-    var _type = Component.type;
-    var _innerPropTypes = _type.propTypes;
+      var _before2 = getHostSibling(finishedWork);
 
-    if (_innerPropTypes) {
-      // Inner memo component props aren't currently validated in createElement.
-      // We could move it there, but we'd still need this for lazy code path.
-      checkPropTypes(
-        _innerPropTypes,
-        nextProps, // Resolved props
-        "prop",
-        getComponentNameFromType(_type)
+      insertOrAppendPlacementNodeIntoContainer(
+        finishedWork,
+        _before2,
+        _parent2
       );
+      break;
     }
+    // eslint-disable-next-line-no-fallthrough
+
+    default:
+      throw new Error(
+        "Invalid host parent fiber. This error is likely caused by a bug " +
+          "in React. Please file an issue."
+      );
   }
+}
 
-  var currentChild = current.child; // This is always exactly one child
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  var tag = node.tag;
+  var isHost = tag === HostComponent || tag === HostText;
 
-  var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
-    current,
-    renderLanes
-  );
+  if (isHost) {
+    var stateNode = node.stateNode;
 
-  if (!hasScheduledUpdateOrContext) {
-    // This will be the props with resolved defaultProps,
-    // unlike current.memoizedProps which will be the unresolved ones.
-    var prevProps = currentChild.memoizedProps; // Default to shallow comparison
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
+    }
+  } else if (tag === HostPortal || tag === HostSingleton);
+  else {
+    var child = node.child;
 
-    var compare = Component.compare;
-    compare = compare !== null ? compare : shallowEqual;
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      var sibling = child.sibling;
 
-    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
     }
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
-  var newChild = createWorkInProgress(currentChild, nextProps);
-  newChild.ref = workInProgress.ref;
-  newChild.return = workInProgress;
-  workInProgress.child = newChild;
-  return newChild;
+  }
 }
 
-function updateSimpleMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  // TODO: current can be non-null here even if the component
-  // hasn't yet mounted. This happens when the inner render suspends.
-  // We'll need to figure out if this is fine or can cause issues.
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var outerMemoType = workInProgress.elementType;
+function insertOrAppendPlacementNode(node, before, parent) {
+  var tag = node.tag;
+  var isHost = tag === HostComponent || tag === HostText;
 
-      if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
-        // We warn when you define propTypes on lazy()
-        // so let's just skip over it to find memo() outer wrapper.
-        // Inner props for memo are validated later.
-        var lazyComponent = outerMemoType;
-        var payload = lazyComponent._payload;
-        var init = lazyComponent._init;
+  if (isHost) {
+    var stateNode = node.stateNode;
 
-        try {
-          outerMemoType = init(payload);
-        } catch (x) {
-          outerMemoType = null;
-        } // Inner propTypes will be validated in the function component path.
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
+    }
+  } else if (tag === HostPortal || tag === HostSingleton);
+  else {
+    var child = node.child;
 
-        var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      var sibling = child.sibling;
 
-        if (outerPropTypes) {
-          checkPropTypes(
-            outerPropTypes,
-            nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
-            "prop",
-            getComponentNameFromType(outerMemoType)
-          );
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
+      }
+    }
+  }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
+
+var hostParent = null;
+var hostParentIsContainer = false;
+
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    var parent = returnFiber;
+
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent: {
+          hostParent = parent.stateNode;
+          hostParentIsContainer = false;
+          break findParent;
+        }
+
+        case HostRoot: {
+          hostParent = parent.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          break findParent;
+        }
+
+        case HostPortal: {
+          hostParent = parent.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          break findParent;
         }
       }
-    }
-  }
-
-  if (current !== null) {
-    var prevProps = current.memoizedProps;
-
-    if (
-      shallowEqual(prevProps, nextProps) &&
-      current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
-      workInProgress.type === current.type
-    ) {
-      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
-      // would during a normal fiber bailout.
-      //
-      // We don't have strong guarantees that the props object is referentially
-      // equal during updates where we can't bail out anyway — like if the props
-      // are shallowly equal, but there's a local state or context update in the
-      // same batch.
-      //
-      // However, as a principle, we should aim to make the behavior consistent
-      // across different ways of memoizing a component. For example, React.memo
-      // has a different internal Fiber layout if you pass a normal function
-      // component (SimpleMemoComponent) versus if you pass a different type
-      // like forwardRef (MemoComponent). But this is an implementation detail.
-      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
-      // affect whether the props object is reused during a bailout.
 
-      workInProgress.pendingProps = nextProps = prevProps;
+      parent = parent.return;
+    }
 
-      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
-        // The pending lanes were cleared at the beginning of beginWork. We're
-        // about to bail out, but there might be other lanes that weren't
-        // included in the current render. Usually, the priority level of the
-        // remaining updates is accumulated during the evaluation of the
-        // component (i.e. when processing the update queue). But since since
-        // we're bailing out early *without* evaluating the component, we need
-        // to account for it here, too. Reset to the value of the current fiber.
-        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
-        // because a MemoComponent fiber does not have hooks or an update queue;
-        // rather, it wraps around an inner component, which may or may not
-        // contains hooks.
-        // TODO: Move the reset at in beginWork out of the common path so that
-        // this is no longer necessary.
-        workInProgress.lanes = current.lanes;
-        return bailoutOnAlreadyFinishedWork(
-          current,
-          workInProgress,
-          renderLanes
-        );
-      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
-        // This is a special case that only exists for legacy mode.
-        // See https://github.com/facebook/react/pull/19216.
-        didReceiveUpdate = true;
-      }
+    if (hostParent === null) {
+      throw new Error(
+        "Expected to find a host parent. This error is likely caused by " +
+          "a bug in React. Please file an issue."
+      );
     }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
   }
 
-  return updateFunctionComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    renderLanes
-  );
+  detachFiberMutation(deletedFiber);
 }
 
-function updateOffscreenComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  var nextIsDetached =
-    (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
-  var prevState = current !== null ? current.memoizedState : null;
-  markRef$1(current, workInProgress);
+function recursivelyTraverseDeletionEffects(
+  finishedRoot,
+  nearestMountedAncestor,
+  parent
+) {
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  var child = parent.child;
 
-  if (
-    nextProps.mode === "hidden" ||
-    nextProps.mode === "unstable-defer-without-hiding" ||
-    nextIsDetached
-  ) {
-    // Rendering a hidden tree.
-    var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+  while (child !== null) {
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
+    child = child.sibling;
+  }
+}
 
-    if (didSuspend) {
-      // Something suspended inside a hidden tree
-      // Include the base lanes from the last render
-      var nextBaseLanes =
-        prevState !== null
-          ? mergeLanes(prevState.baseLanes, renderLanes)
-          : renderLanes;
+function commitDeletionEffectsOnFiber(
+  finishedRoot,
+  nearestMountedAncestor,
+  deletedFiber
+) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
 
-      if (current !== null) {
-        // Reset to the current children
-        var currentChild = (workInProgress.child = current.child); // The current render suspended, but there may be other lanes with
-        // pending work. We can't read `childLanes` from the current Offscreen
-        // fiber because we reset it when it was deferred; however, we can read
-        // the pending lanes from the child fibers.
+  switch (deletedFiber.tag) {
+    case HostHoistable: {
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        }
 
-        var currentChildLanes = NoLanes;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
 
-        while (currentChild !== null) {
-          currentChildLanes = mergeLanes(
-            mergeLanes(currentChildLanes, currentChild.lanes),
-            currentChild.childLanes
-          );
-          currentChild = currentChild.sibling;
+        if (deletedFiber.memoizedState) {
+          releaseResource(deletedFiber.memoizedState);
+        } else if (deletedFiber.stateNode) {
+          unmountHoistable(deletedFiber.stateNode);
         }
 
-        var lanesWeJustAttempted = nextBaseLanes;
-        var remainingChildLanes = removeLanes(
-          currentChildLanes,
-          lanesWeJustAttempted
-        );
-        workInProgress.childLanes = remainingChildLanes;
-      } else {
-        workInProgress.childLanes = NoLanes;
-        workInProgress.child = null;
+        return;
       }
+    }
+    // eslint-disable-next-line no-fallthrough
 
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        nextBaseLanes,
-        renderLanes
-      );
+    case HostSingleton: {
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        }
+
+        var prevHostParent = hostParent;
+        var prevHostParentIsContainer = hostParentIsContainer;
+        hostParent = deletedFiber.stateNode;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        ); // Normally this is called in passive unmount effect phase however with
+        // HostSingleton we warn if you acquire one that is already associated to
+        // a different fiber. To increase our chances of avoiding this, specifically
+        // if you keyed a HostSingleton so there will be a delete followed by a Placement
+        // we treat detach eagerly here
+
+        releaseSingletonInstance(deletedFiber.stateNode);
+        hostParent = prevHostParent;
+        hostParentIsContainer = prevHostParentIsContainer;
+        return;
+      }
     }
+    // eslint-disable-next-line no-fallthrough
 
-    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-      // In legacy sync mode, don't defer the subtree. Render it now.
-      // TODO: Consider how Offscreen should work with transitions in the future
-      var nextState = {
-        baseLanes: NoLanes,
-        cachePool: null
-      };
-      workInProgress.memoizedState = nextState;
+    case HostComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      } // Intentional fallthrough to next branch
+    }
+    // eslint-disable-next-line-no-fallthrough
 
+    case HostText: {
+      // We only need to remove the nearest host child. Set the host parent
+      // to `null` on the stack to indicate that nested children don't
+      // need to be removed.
       {
-        // push the cache pool even though we're going to bail out
-        // because otherwise there'd be a context mismatch
-        if (current !== null) {
-          pushTransition(workInProgress, null, null);
+        var _prevHostParent = hostParent;
+        var _prevHostParentIsContainer = hostParentIsContainer;
+        hostParent = null;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        hostParent = _prevHostParent;
+        hostParentIsContainer = _prevHostParentIsContainer;
+
+        if (hostParent !== null) {
+          // Now that all the child effects have unmounted, we can remove the
+          // node from the tree.
+          if (hostParentIsContainer) {
+            removeChildFromContainer(hostParent, deletedFiber.stateNode);
+          } else {
+            removeChild(hostParent, deletedFiber.stateNode);
+          }
         }
       }
 
-      reuseHiddenContextOnStack(workInProgress);
-      pushOffscreenSuspenseHandler(workInProgress);
-    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
-      // We're hidden, and we're not rendering at Offscreen. We will bail out
-      // and resume this tree later.
-      // Schedule this fiber to re-render at Offscreen priority
-      workInProgress.lanes = workInProgress.childLanes =
-        laneToLanes(OffscreenLane); // Include the base lanes from the last render
-
-      var _nextBaseLanes =
-        prevState !== null
-          ? mergeLanes(prevState.baseLanes, renderLanes)
-          : renderLanes;
+      return;
+    }
 
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        _nextBaseLanes,
-        renderLanes
-      );
-    } else {
-      // This is the second render. The surrounding visible content has already
-      // committed. Now we resume rendering the hidden tree.
-      // Rendering at offscreen, so we can clear the base lanes.
-      var _nextState = {
-        baseLanes: NoLanes,
-        cachePool: null
-      };
-      workInProgress.memoizedState = _nextState;
+    case DehydratedFragment: {
+      {
+        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
 
-      if (current !== null) {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        var prevCachePool = prevState !== null ? prevState.cachePool : null; // TODO: Consider if and how Offscreen pre-rendering should
-        // be attributed to the transition that spawned it
+        if (hydrationCallbacks !== null) {
+          var onDeleted = hydrationCallbacks.onDeleted;
 
-        pushTransition(workInProgress, prevCachePool, null);
-      } // Push the lanes that were skipped when we bailed out.
+          if (onDeleted) {
+            onDeleted(deletedFiber.stateNode);
+          }
+        }
+      } // Dehydrated fragments don't have any children
+      // Delete the dehydrated suspense boundary and all of its content.
 
-      if (prevState !== null) {
-        pushHiddenContext(workInProgress, prevState);
-      } else {
-        reuseHiddenContextOnStack(workInProgress);
+      {
+        if (hostParent !== null) {
+          if (hostParentIsContainer) {
+            clearSuspenseBoundaryFromContainer(
+              hostParent,
+              deletedFiber.stateNode
+            );
+          } else {
+            clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+          }
+        }
       }
 
-      pushOffscreenSuspenseHandler(workInProgress);
+      return;
     }
-  } else {
-    // Rendering a visible tree.
-    if (prevState !== null) {
-      // We're going from hidden -> visible.
-      var _prevCachePool = null;
 
+    case HostPortal: {
       {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        _prevCachePool = prevState.cachePool;
+        // When we go into a portal, it becomes the parent to remove from.
+        var _prevHostParent2 = hostParent;
+        var _prevHostParentIsContainer2 = hostParentIsContainer;
+        hostParent = deletedFiber.stateNode.containerInfo;
+        hostParentIsContainer = true;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        hostParent = _prevHostParent2;
+        hostParentIsContainer = _prevHostParentIsContainer2;
       }
 
-      var transitions = null;
+      return;
+    }
 
-      if (enableTransitionTracing) {
-        // We have now gone from hidden to visible, so any transitions should
-        // be added to the stack to get added to any Offscreen/suspense children
-        var instance = workInProgress.stateNode;
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        var updateQueue = deletedFiber.updateQueue;
 
-        if (instance !== null && instance._transitions != null) {
-          transitions = Array.from(instance._transitions);
-        }
-      }
+        if (updateQueue !== null) {
+          var lastEffect = updateQueue.lastEffect;
 
-      pushTransition(workInProgress, _prevCachePool, transitions); // Push the lanes that were skipped when we bailed out.
+          if (lastEffect !== null) {
+            var firstEffect = lastEffect.next;
+            var effect = firstEffect;
 
-      pushHiddenContext(workInProgress, prevState);
-      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+            do {
+              var _effect = effect,
+                destroy = _effect.destroy,
+                tag = _effect.tag;
 
-      workInProgress.memoizedState = null;
-    } else {
-      // We weren't previously hidden, and we still aren't, so there's nothing
-      // special to do. Need to push to the stack regardless, though, to avoid
-      // a push/pop misalignment.
-      {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        if (current !== null) {
-          pushTransition(workInProgress, null, null);
-        }
-      } // We're about to bail out, but we need to push this to the stack anyway
-      // to avoid a push/pop misalignment.
+              if (destroy !== undefined) {
+                if ((tag & Insertion) !== NoFlags) {
+                  safelyCallDestroy(
+                    deletedFiber,
+                    nearestMountedAncestor,
+                    destroy
+                  );
+                } else if ((tag & Layout) !== NoFlags) {
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStarted(deletedFiber);
+                  }
 
-      reuseHiddenContextOnStack(workInProgress);
-      reuseSuspenseHandlerOnStack(workInProgress);
-    }
-  }
+                  if (shouldProfile(deletedFiber)) {
+                    startLayoutEffectTimer();
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                    recordLayoutEffectDuration(deletedFiber);
+                  } else {
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                  }
 
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStopped();
+                  }
+                }
+              }
 
-function deferHiddenOffscreenComponent(
-  current,
-  workInProgress,
-  nextBaseLanes,
-  renderLanes
-) {
-  var nextState = {
-    baseLanes: nextBaseLanes,
-    // Save the cache pool so we can resume later.
-    cachePool: getOffscreenDeferredCache()
-  };
-  workInProgress.memoizedState = nextState;
+              effect = effect.next;
+            } while (effect !== firstEffect);
+          }
+        }
+      }
 
-  {
-    // push the cache pool even though we're going to bail out
-    // because otherwise there'd be a context mismatch
-    if (current !== null) {
-      pushTransition(workInProgress, null, null);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
     }
-  } // We're about to bail out, but we need to push this to the stack anyway
-  // to avoid a push/pop misalignment.
 
-  reuseHiddenContextOnStack(workInProgress);
-  pushOffscreenSuspenseHandler(workInProgress);
+    case ClassComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        var instance = deletedFiber.stateNode;
 
-  if (enableLazyContextPropagation && current !== null) {
-    // Since this tree will resume rendering in a separate render, we need
-    // to propagate parent contexts now so we don't lose track of which
-    // ones changed.
-    propagateParentContextChangesToDeferredTree(
-      current,
-      workInProgress,
-      renderLanes
-    );
-  }
+        if (typeof instance.componentWillUnmount === "function") {
+          safelyCallComponentWillUnmount(
+            deletedFiber,
+            nearestMountedAncestor,
+            instance
+          );
+        }
+      }
 
-  return null;
-} // Note: These happen to have identical begin phases, for now. We shouldn't hold
-// ourselves to this constraint, though. If the behavior diverges, we should
-// fork the function.
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
 
-var updateLegacyHiddenComponent = updateOffscreenComponent;
+    case ScopeComponent: {
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      }
 
-function updateCacheComponent(current, workInProgress, renderLanes) {
-  prepareToReadContext(workInProgress, renderLanes);
-  var parentCache = readContext(CacheContext);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
 
-  if (current === null) {
-    // Initial mount. Request a fresh cache from the pool.
-    var freshCache = requestCacheFromPool(renderLanes);
-    var initialState = {
-      parent: parentCache,
-      cache: freshCache
-    };
-    workInProgress.memoizedState = initialState;
-    initializeUpdateQueue(workInProgress);
-    pushCacheProvider(workInProgress, freshCache);
-  } else {
-    // Check for updates
-    if (includesSomeLane(current.lanes, renderLanes)) {
-      cloneUpdateQueue(current, workInProgress);
-      processUpdateQueue(workInProgress, null, null, renderLanes);
+    case OffscreenComponent: {
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+
+      if (deletedFiber.mode & ConcurrentMode) {
+        // If this offscreen component is hidden, we already unmounted it. Before
+        // deleting the children, track that it's already unmounted so that we
+        // don't attempt to unmount the effects again.
+        // TODO: If the tree is hidden, in most cases we should be able to skip
+        // over the nested children entirely. An exception is we haven't yet found
+        // the topmost host node to delete, which we already track on the stack.
+        // But the other case is portals, which need to be detached no matter how
+        // deeply they are nested. We should use a subtree flag to track whether a
+        // subtree includes a nested portal.
+        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+        offscreenSubtreeWasHidden =
+          prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+      } else {
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+      }
+
+      break;
     }
 
-    var prevState = current.memoizedState;
-    var nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
-    // a refresh.
+    default: {
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
+  }
+}
 
-    if (prevState.parent !== parentCache) {
-      // Refresh in parent. Update the parent.
-      var derivedState = {
-        parent: parentCache,
-        cache: parentCache
-      }; // Copied from getDerivedStateFromProps implementation. Once the update
-      // queue is empty, persist the derived state onto the base state.
+function commitSuspenseCallback(finishedWork) {
+  // TODO: Move this to passive phase
+  var newState = finishedWork.memoizedState;
 
-      workInProgress.memoizedState = derivedState;
+  if (newState !== null) {
+    var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
 
-      if (workInProgress.lanes === NoLanes) {
-        var updateQueue = workInProgress.updateQueue;
-        workInProgress.memoizedState = updateQueue.baseState = derivedState;
-      }
+    if (typeof suspenseCallback === "function") {
+      var wakeables = finishedWork.updateQueue;
 
-      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
-      // already did.
+      if (wakeables !== null) {
+        suspenseCallback(new Set(wakeables));
+      }
     } else {
-      // The parent didn't refresh. Now check if this cache did.
-      var nextCache = nextState.cache;
-      pushCacheProvider(workInProgress, nextCache);
-
-      if (nextCache !== prevState.cache) {
-        // This cache refreshed. Propagate a context change.
-        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      if (suspenseCallback !== undefined) {
+        error("Unexpected type for suspenseCallback.");
       }
     }
   }
+}
 
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-} // This should only be called if the name changes
-
-function updateTracingMarkerComponent(current, workInProgress, renderLanes) {
-  if (!enableTransitionTracing) {
-    return null;
-  } // TODO: (luna) Only update the tracing marker if it's newly rendered or it's name changed.
-  // A tracing marker is only associated with the transitions that rendered
-  // or updated it, so we can create a new set of transitions each time
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+  var newState = finishedWork.memoizedState;
 
-  if (current === null) {
-    var currentTransitions = getPendingTransitions();
+  if (newState === null) {
+    var current = finishedWork.alternate;
 
-    if (currentTransitions !== null) {
-      var markerInstance = {
-        tag: TransitionTracingMarker,
-        transitions: new Set(currentTransitions),
-        pendingBoundaries: null,
-        name: workInProgress.pendingProps.name,
-        aborts: null
-      };
-      workInProgress.stateNode = markerInstance; // We call the marker complete callback when all child suspense boundaries resolve.
-      // We do this in the commit phase on Offscreen. If the marker has no child suspense
-      // boundaries, we need to schedule a passive effect to make sure we call the marker
-      // complete callback.
+    if (current !== null) {
+      var prevState = current.memoizedState;
 
-      workInProgress.flags |= Passive$1;
-    }
-  } else {
-    {
-      if (current.memoizedProps.name !== workInProgress.pendingProps.name) {
-        error(
-          "Changing the name of a tracing marker after mount is not supported. " +
-            "To remount the tracing marker, pass it a new key."
-        );
-      }
-    }
-  }
+      if (prevState !== null) {
+        var suspenseInstance = prevState.dehydrated;
 
-  var instance = workInProgress.stateNode;
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
 
-  if (instance !== null) {
-    pushMarkerInstance(workInProgress, instance);
-  }
+            if (enableSuspenseCallback) {
+              var hydrationCallbacks = finishedRoot.hydrationCallbacks;
 
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+              if (hydrationCallbacks !== null) {
+                var onHydrated = hydrationCallbacks.onHydrated;
 
-function updateFragment(current, workInProgress, renderLanes) {
-  var nextChildren = workInProgress.pendingProps;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+                if (onHydrated) {
+                  onHydrated(suspenseInstance);
+                }
+              }
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+    }
+  }
 }
 
-function updateMode(current, workInProgress, renderLanes) {
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent: {
+      var retryCache = finishedWork.stateNode;
 
-function updateProfiler(current, workInProgress, renderLanes) {
-  {
-    workInProgress.flags |= Update;
+      if (retryCache === null) {
+        retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+      }
 
-    {
-      // Reset effect durations for the next eventual effect phase.
-      // These are reset during render to allow the DevTools commit hook a chance to read them,
-      var stateNode = workInProgress.stateNode;
-      stateNode.effectDuration = 0;
-      stateNode.passiveEffectDuration = 0;
+      return retryCache;
     }
-  }
 
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
+      var _retryCache = instance._retryCache;
 
-function markRef$1(current, workInProgress) {
-  var ref = workInProgress.ref;
+      if (_retryCache === null) {
+        _retryCache = instance._retryCache = new PossiblyWeakSet();
+      }
 
-  if (
-    (current === null && ref !== null) ||
-    (current !== null && current.ref !== ref)
-  ) {
-    // Schedule a Ref effect
-    workInProgress.flags |= Ref;
-    workInProgress.flags |= RefStatic;
+      return _retryCache;
+    }
+
+    default: {
+      throw new Error(
+        "Unexpected Suspense handler tag (" +
+          finishedWork.tag +
+          "). This is a " +
+          "bug in React."
+      );
+    }
   }
 }
 
-function updateFunctionComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+function detachOffscreenInstance(instance) {
+  var fiber = instance._current;
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
-      }
-    }
+  if (fiber === null) {
+    throw new Error(
+      "Calling Offscreen.detach before instance handle has been set."
+    );
   }
 
-  var context;
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
 
-  var nextChildren;
-  var hasId;
-  prepareToReadContext(workInProgress, renderLanes);
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
   }
+}
+function attachOffscreenInstance(instance) {
+  var fiber = instance._current;
 
-  {
-    ReactCurrentOwner$1.current = workInProgress;
-    setIsRendering(true);
-    nextChildren = renderWithHooks(
-      current,
-      workInProgress,
-      Component,
-      nextProps,
-      context,
-      renderLanes
+  if (fiber === null) {
+    throw new Error(
+      "Calling Offscreen.detach before instance handle has been set."
     );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
-
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
   }
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
   }
 
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
 }
 
-function replayFunctionComponent(
-  current,
-  workInProgress,
-  nextProps,
-  Component,
-  renderLanes
-) {
-  // This function is used to replay a component that previously suspended,
-  // after its data resolves. It's a simplified version of
-  // updateFunctionComponent that reuses the hooks from the previous attempt.
-  var context;
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  var retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(function (wakeable) {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
 
-  prepareToReadContext(workInProgress, renderLanes);
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+      {
+        if (isDevToolsPresent) {
+          if (inProgressLanes !== null && inProgressRoot !== null) {
+            // If we have pending work still, associate the original updaters with it.
+            restorePendingUpdaters(inProgressRoot, inProgressLanes);
+          } else {
+            throw Error(
+              "Expected finished root and lanes to be set. This is a bug in React."
+            );
+          }
+        }
+      }
 
-  var nextChildren = replaySuspendedComponentWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    context
-  );
-  var hasId = checkDidRenderIdHook();
+      wakeable.then(retry, retry);
+    }
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+// It returns false if the boundary is already hidden.
+// TODO: Use an effect tag.
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+function isSuspenseBoundaryBeingHidden(current, finishedWork) {
+  if (current !== null) {
+    var oldState = current.memoizedState;
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    if (oldState === null || oldState.dehydrated !== null) {
+      var newState = finishedWork.memoizedState;
+      return newState !== null && newState.dehydrated === null;
+    }
   }
 
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+  return false;
+}
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  setCurrentFiber(finishedWork);
+  commitMutationEffectsOnFiber(finishedWork, root);
+  setCurrentFiber(finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
 }
 
-function updateClassComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  {
-    // This is used by DevTools to force a boundary to error.
-    switch (shouldError(workInProgress)) {
-      case false: {
-        var _instance = workInProgress.stateNode;
-        var ctor = workInProgress.type; // TODO This way of resetting the error boundary state is a hack.
-        // Is there a better way to do this?
-
-        var tempInstance = new ctor(
-          workInProgress.memoizedProps,
-          _instance.context
-        );
-        var state = tempInstance.state;
-
-        _instance.updater.enqueueSetState(_instance, state, null);
-
-        break;
-      }
-
-      case true: {
-        workInProgress.flags |= DidCapture;
-        workInProgress.flags |= ShouldCapture; // eslint-disable-next-line react-internal/prod-error-codes
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  var deletions = parentFiber.deletions;
 
-        var error$1 = new Error("Simulated error coming from DevTools");
-        var lane = pickArbitraryLane(renderLanes);
-        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+  if (deletions !== null) {
+    for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i];
 
-        var update = createClassErrorUpdate(
-          workInProgress,
-          createCapturedValueAtFiber(error$1, workInProgress),
-          lane
-        );
-        enqueueCapturedUpdate(workInProgress, update);
-        break;
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
       }
     }
+  }
 
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
-
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
-      }
-    }
-  } // 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 prevDebugFiber = getCurrentFiber();
 
-  var hasContext;
+  if (parentFiber.subtreeFlags & MutationMask) {
+    var child = parentFiber.child;
 
-  if (isContextProvider()) {
-    hasContext = true;
-  } else {
-    hasContext = false;
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
+    }
   }
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var instance = workInProgress.stateNode;
-  var shouldUpdate;
+  setCurrentFiber(prevDebugFiber);
+}
 
-  if (instance === null) {
-    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
+var currentHoistableRoot = null;
 
-    constructClassInstance(workInProgress, Component, nextProps);
-    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
-    shouldUpdate = true;
-  } else if (current === null) {
-    // In a resume, we'll already have an instance we can reuse.
-    shouldUpdate = resumeMountClassInstance(
-      workInProgress,
-      Component,
-      nextProps,
-      renderLanes
-    );
-  } else {
-    shouldUpdate = updateClassInstance(
-      current,
-      workInProgress,
-      Component,
-      nextProps,
-      renderLanes
-    );
-  }
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  var current = finishedWork.alternate;
+  var flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
 
-  var nextUnitOfWork = finishClassComponent(
-    current,
-    workInProgress,
-    Component,
-    shouldUpdate,
-    hasContext,
-    renderLanes
-  );
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-  {
-    var inst = workInProgress.stateNode;
+      if (flags & Update) {
+        try {
+          commitHookEffectListUnmount(
+            Insertion | HasEffect,
+            finishedWork,
+            finishedWork.return
+          );
+          commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        } // Layout effects are destroyed during the mutation phase so that all
+        // destroy functions for all fibers are called before any create functions.
+        // This prevents sibling component effects from interfering with each other,
+        // e.g. a destroy function in one component should never override a ref set
+        // by a create function in another component during the same commit.
+
+        if (shouldProfile(finishedWork)) {
+          try {
+            startLayoutEffectTimer();
+            commitHookEffectListUnmount(
+              Layout | HasEffect,
+              finishedWork,
+              finishedWork.return
+            );
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
 
-    if (shouldUpdate && inst.props !== nextProps) {
-      if (!didWarnAboutReassigningProps) {
-        error(
-          "It looks like %s is reassigning its own `this.props` while rendering. " +
-            "This is not supported and can lead to confusing bugs.",
-          getComponentNameFromFiber(workInProgress) || "a component"
-        );
+          recordLayoutEffectDuration(finishedWork);
+        } else {
+          try {
+            commitHookEffectListUnmount(
+              Layout | HasEffect,
+              finishedWork,
+              finishedWork.return
+            );
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
       }
 
-      didWarnAboutReassigningProps = true;
+      return;
     }
-  }
 
-  return nextUnitOfWork;
-}
+    case ClassComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-function finishClassComponent(
-  current,
-  workInProgress,
-  Component,
-  shouldUpdate,
-  hasContext,
-  renderLanes
-) {
-  // Refs should update even if shouldComponentUpdate returns false
-  markRef$1(current, workInProgress);
-  var didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
+      }
 
-  if (!shouldUpdate && !didCaptureError) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  }
+      if (flags & Callback && offscreenSubtreeIsHidden) {
+        var updateQueue = finishedWork.updateQueue;
 
-  var instance = workInProgress.stateNode; // Rerender
+        if (updateQueue !== null) {
+          deferHiddenCallbacks(updateQueue);
+        }
+      }
 
-  ReactCurrentOwner$1.current = workInProgress;
-  var nextChildren;
+      return;
+    }
 
-  if (
-    didCaptureError &&
-    typeof Component.getDerivedStateFromError !== "function"
-  ) {
-    // If we captured an error, but getDerivedStateFromError is not defined,
-    // unmount all the children. componentDidCatch will schedule an update to
-    // re-render a fallback. This is temporary until we migrate everyone to
-    // the new API.
-    // TODO: Warn in a future release.
-    nextChildren = null;
+    case HostHoistable: {
+      {
+        // We cast because we always set the root at the React root and so it cannot be
+        // null while we are processing mutation effects
+        var hoistableRoot = currentHoistableRoot;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
 
-    {
-      stopProfilerTimerIfRunning();
-    }
-  } else {
-    if (enableSchedulingProfiler) {
-      markComponentRenderStarted(workInProgress);
-    }
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
 
-    {
-      setIsRendering(true);
-      nextChildren = instance.render();
+        if (flags & Update) {
+          var currentResource = current !== null ? current.memoizedState : null;
+          var newResource = finishedWork.memoizedState;
 
-      if (workInProgress.mode & StrictLegacyMode) {
-        setIsStrictModeForDevtools(true);
+          if (current === null) {
+            // We are mounting a new HostHoistable Fiber. We fork the mount
+            // behavior based on whether this instance is a Hoistable Instance
+            // or a Hoistable Resource
+            if (newResource === null) {
+              if (finishedWork.stateNode === null) {
+                finishedWork.stateNode = hydrateHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.memoizedProps,
+                  finishedWork
+                );
+              } else {
+                mountHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.stateNode
+                );
+              }
+            } else {
+              finishedWork.stateNode = acquireResource(
+                hoistableRoot,
+                newResource,
+                finishedWork.memoizedProps
+              );
+            }
+          } else if (currentResource !== newResource) {
+            // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+            if (currentResource === null) {
+              if (current.stateNode !== null) {
+                unmountHoistable(current.stateNode);
+              }
+            } else {
+              releaseResource(currentResource);
+            }
 
-        try {
-          instance.render();
-        } finally {
-          setIsStrictModeForDevtools(false);
+            if (newResource === null) {
+              mountHoistable(
+                hoistableRoot,
+                finishedWork.type,
+                finishedWork.stateNode
+              );
+            } else {
+              acquireResource(
+                hoistableRoot,
+                newResource,
+                finishedWork.memoizedProps
+              );
+            }
+          } else if (newResource === null && finishedWork.stateNode !== null) {
+            // We may have an update on a Hoistable element
+            var updatePayload = finishedWork.updateQueue;
+            finishedWork.updateQueue = null;
+
+            if (updatePayload !== null) {
+              try {
+                commitUpdate(
+                  finishedWork.stateNode,
+                  updatePayload,
+                  finishedWork.type,
+                  current.memoizedProps,
+                  finishedWork.memoizedProps,
+                  finishedWork
+                );
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          }
         }
-      }
 
-      setIsRendering(false);
+        return;
+      }
     }
+    // eslint-disable-next-line-no-fallthrough
 
-    if (enableSchedulingProfiler) {
-      markComponentRenderStopped();
-    }
-  } // React DevTools reads this flag.
+    case HostSingleton: {
+      {
+        if (flags & Update) {
+          var previousWork = finishedWork.alternate;
 
-  workInProgress.flags |= PerformedWork;
+          if (previousWork === null) {
+            var singleton = finishedWork.stateNode;
+            var props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
 
-  if (current !== null && didCaptureError) {
-    // If we're recovering from an error, reconcile without reusing any of
-    // the existing children. Conceptually, the normal children and the children
-    // that are shown on error are two different sets, so we shouldn't reuse
-    // normal children even if their identities match.
-    forceUnmountCurrentAndReconcile(
-      current,
-      workInProgress,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  } // Memoize state using the values we just used to render.
-  // TODO: Restructure so we never read values from the instance.
+            clearSingleton(singleton);
+            acquireSingletonInstance(
+              finishedWork.type,
+              props,
+              singleton,
+              finishedWork
+            );
+          }
+        }
+      }
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+    case HostComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-  return workInProgress.child;
-}
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
+      }
 
-function pushHostRootContext(workInProgress) {
-  var root = workInProgress.stateNode;
+      {
+        // TODO: ContentReset gets cleared by the children during the commit
+        // phase. This is a refactor hazard because it means we must read
+        // flags the flags after `commitReconciliationEffects` has already run;
+        // the order matters. We should refactor so that ContentReset does not
+        // rely on mutating the flag during commit. Like by setting a flag
+        // during the render phase instead.
+        if (finishedWork.flags & ContentReset) {
+          var instance = finishedWork.stateNode;
 
-  pushHostContainer(workInProgress, root.containerInfo);
-}
+          try {
+            resetTextContent(instance);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
 
-function updateHostRoot(current, workInProgress, renderLanes) {
-  pushHostRootContext(workInProgress);
+        if (flags & Update) {
+          var _instance2 = finishedWork.stateNode;
 
-  if (current === null) {
-    throw new Error("Should have a current fiber. This is a bug in React.");
-  }
+          if (_instance2 != null) {
+            // Commit the work prepared earlier.
+            var newProps = finishedWork.memoizedProps; // 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 nextProps = workInProgress.pendingProps;
-  var prevState = workInProgress.memoizedState;
-  var prevChildren = prevState.element;
-  cloneUpdateQueue(current, workInProgress);
-  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
-  var nextState = workInProgress.memoizedState;
-  var root = workInProgress.stateNode;
-  pushRootTransition(workInProgress);
+            var oldProps = current !== null ? current.memoizedProps : newProps;
+            var type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
 
-  if (enableTransitionTracing) {
-    pushRootMarkerInstance(workInProgress);
-  }
+            var _updatePayload = finishedWork.updateQueue;
+            finishedWork.updateQueue = null;
 
-  {
-    var nextCache = nextState.cache;
-    pushCacheProvider(workInProgress, nextCache);
+            if (_updatePayload !== null) {
+              try {
+                commitUpdate(
+                  _instance2,
+                  _updatePayload,
+                  type,
+                  oldProps,
+                  newProps,
+                  finishedWork
+                );
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          }
+        }
+      }
 
-    if (nextCache !== prevState.cache) {
-      // The root cache refreshed.
-      propagateContextChange(workInProgress, CacheContext, renderLanes);
+      return;
     }
-  } // Caution: React DevTools currently depends on this property
-  // being called "element".
 
-  var nextChildren = nextState.element;
+    case HostText: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-  if (prevState.isDehydrated) {
-    // This is a hydration root whose shell has not yet hydrated. We should
-    // attempt to hydrate.
-    // Flip isDehydrated to false to indicate that when this render
-    // finishes, the root will no longer be dehydrated.
-    var overrideState = {
-      element: nextChildren,
-      isDehydrated: false,
-      cache: nextState.cache
-    };
-    var updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
-    // have reducer functions so it doesn't need rebasing.
+      if (flags & Update) {
+        {
+          if (finishedWork.stateNode === null) {
+            throw new Error(
+              "This should have a text node initialized. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          }
 
-    updateQueue.baseState = overrideState;
-    workInProgress.memoizedState = overrideState;
+          var textInstance = finishedWork.stateNode;
+          var newText = finishedWork.memoizedProps; // 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.
 
-    if (workInProgress.flags & ForceClientRender) {
-      // Something errored during a previous attempt to hydrate the shell, so we
-      // forced a client render.
-      var recoverableError = createCapturedValueAtFiber(
-        new Error(
-          "There was an error while hydrating. Because the error happened outside " +
-            "of a Suspense boundary, the entire root will switch to " +
-            "client rendering."
-        ),
-        workInProgress
-      );
-      return mountHostRootWithoutHydrating(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes,
-        recoverableError
-      );
-    } else if (nextChildren !== prevChildren) {
-      var _recoverableError = createCapturedValueAtFiber(
-        new Error(
-          "This root received an early update, before anything was able " +
-            "hydrate. Switched the entire root to client rendering."
-        ),
-        workInProgress
-      );
+          var oldText = current !== null ? current.memoizedProps : newText;
 
-      return mountHostRootWithoutHydrating(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes,
-        _recoverableError
-      );
-    } else {
-      // The outermost shell has not hydrated yet. Start hydrating.
-      enterHydrationState(workInProgress);
+          try {
+            commitTextUpdate(textInstance, oldText, newText);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+
+      return;
+    }
 
+    case HostRoot: {
       {
-        var mutableSourceEagerHydrationData =
-          root.mutableSourceEagerHydrationData;
+        prepareToCommitHoistables();
+        var previousHoistableRoot = currentHoistableRoot;
+        currentHoistableRoot = getHoistableRoot(root.containerInfo);
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        currentHoistableRoot = previousHoistableRoot;
+        commitReconciliationEffects(finishedWork);
+      }
 
-        if (mutableSourceEagerHydrationData != null) {
-          for (var i = 0; i < mutableSourceEagerHydrationData.length; i += 2) {
-            var mutableSource = mutableSourceEagerHydrationData[i];
-            var version = mutableSourceEagerHydrationData[i + 1];
-            setWorkInProgressVersion(mutableSource, version);
+      if (flags & Update) {
+        {
+          if (current !== null) {
+            var prevRootState = current.memoizedState;
+
+            if (prevRootState.isDehydrated) {
+              try {
+                commitHydratedContainer(root.containerInfo);
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
           }
         }
       }
 
-      var child = mountChildFibers(
-        workInProgress,
-        null,
-        nextChildren,
-        renderLanes
-      );
-      workInProgress.child = child;
-      var node = child;
+      return;
+    }
 
-      while (node) {
-        // Mark each child as hydrating. This is a fast path to know whether this
-        // tree is part of a hydrating tree. This is used to determine if a child
-        // node has fully mounted yet, and for scheduling event replaying.
-        // Conceptually this is similar to Placement in that a new subtree is
-        // inserted into the React tree here. It just happens to not need DOM
-        // mutations because it already exists.
-        node.flags = (node.flags & ~Placement) | Hydrating;
-        node = node.sibling;
+    case HostPortal: {
+      {
+        var _previousHoistableRoot = currentHoistableRoot;
+        currentHoistableRoot = getHoistableRoot(
+          finishedWork.stateNode.containerInfo
+        );
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        currentHoistableRoot = _previousHoistableRoot;
       }
-    }
-  } else {
-    // Root is not dehydrated. Either this is a client-only root, or it
-    // already hydrated.
-    resetHydrationState();
 
-    if (nextChildren === prevChildren) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      return;
     }
 
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  }
-
-  return workInProgress.child;
-}
-
-function mountHostRootWithoutHydrating(
-  current,
-  workInProgress,
-  nextChildren,
-  renderLanes,
-  recoverableError
-) {
-  // Revert to client rendering.
-  resetHydrationState();
-  queueHydrationError(recoverableError);
-  workInProgress.flags |= ForceClientRender;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
-
-function updateHostComponent$1(current, workInProgress, renderLanes) {
-  pushHostContext(workInProgress);
+    case SuspenseComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      var offscreenFiber = finishedWork.child;
 
-  if (current === null) {
-    tryToClaimNextHydratableInstance(workInProgress);
-  }
+      if (offscreenFiber.flags & Visibility) {
+        var newState = offscreenFiber.memoizedState;
+        var isHidden = newState !== null;
 
-  var type = workInProgress.type;
-  var nextProps = workInProgress.pendingProps;
-  var prevProps = current !== null ? current.memoizedProps : null;
-  var nextChildren = nextProps.children;
-  var isDirectTextChild = shouldSetTextContent(type, nextProps);
+        if (isHidden) {
+          var wasHidden =
+            offscreenFiber.alternate !== null &&
+            offscreenFiber.alternate.memoizedState !== null;
 
-  if (isDirectTextChild) {
-    // We special case a direct text child of a host node. This is a common
-    // case. We won't handle it as a reified child. We will instead handle
-    // this in the host environment that also has access to this prop. That
-    // avoids allocating another HostText fiber and traversing it.
-    nextChildren = null;
-  } 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.flags |= ContentReset;
-  }
+          if (!wasHidden) {
+            // TODO: Move to passive phase
+            markCommitTimeOfFallback();
+          }
+        }
+      }
 
-  markRef$1(current, workInProgress);
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+      if (flags & Update) {
+        try {
+          commitSuspenseCallback(finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
 
-function updateHostHoistable(current, workInProgress, renderLanes) {
-  markRef$1(current, workInProgress);
-  var currentProps = current === null ? null : current.memoizedProps;
-  var resource = (workInProgress.memoizedState = getResource(
-    workInProgress.type,
-    currentProps,
-    workInProgress.pendingProps
-  ));
+        var wakeables = finishedWork.updateQueue;
 
-  if (current === null) {
-    if (!getIsHydrating() && resource === null) {
-      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
-      workInProgress.stateNode = createHoistableInstance(
-        workInProgress.type,
-        workInProgress.pendingProps,
-        getRootHostContainer(),
-        workInProgress
-      );
+        if (wakeables !== null) {
+          finishedWork.updateQueue = null;
+          attachSuspenseRetryListeners(finishedWork, wakeables);
+        }
+      }
+
+      return;
     }
-  } // Resources never have reconciler managed children. It is possible for
-  // the host implementation of getResource to consider children in the
-  // resource construction but they will otherwise be discarded. In practice
-  // this precludes all but the simplest children and Host specific warnings
-  // should be implemented to warn when children are passsed when otherwise not
-  // expected
 
-  return null;
-}
+    case OffscreenComponent: {
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
+      }
 
-function updateHostSingleton(current, workInProgress, renderLanes) {
-  pushHostContext(workInProgress);
+      var _newState = finishedWork.memoizedState;
 
-  if (current === null) {
-    claimHydratableSingleton(workInProgress);
-  }
+      var _isHidden = _newState !== null;
 
-  var nextChildren = workInProgress.pendingProps.children;
+      var _wasHidden = current !== null && current.memoizedState !== null;
 
-  if (current === null && !getIsHydrating()) {
-    // Similar to Portals we append Singleton children in the commit phase. So we
-    // Track insertions even on mount.
-    // TODO: Consider unifying this with how the root works.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  }
+      if (finishedWork.mode & ConcurrentMode) {
+        // Before committing the children, track on the stack whether this
+        // offscreen subtree was already hidden, so that we don't unmount the
+        // effects again.
+        var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || _isHidden;
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || _wasHidden;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+      } else {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+      }
 
-  markRef$1(current, workInProgress);
-  return workInProgress.child;
-}
+      commitReconciliationEffects(finishedWork);
+      var offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
 
-function updateHostText$1(current, workInProgress) {
-  if (current === null) {
-    tryToClaimNextHydratableTextInstance(workInProgress);
-  } // Nothing to do here. This is terminal. We'll do the completion step
-  // immediately after.
+      offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+      // to support batching of `attach` and `detach` calls.
 
-  return null;
-}
+      offscreenInstance._visibility &= ~OffscreenDetached;
+      offscreenInstance._visibility |=
+        offscreenInstance._pendingVisibility & OffscreenDetached;
 
-function mountLazyComponent(
-  _current,
-  workInProgress,
-  elementType,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
-  var props = workInProgress.pendingProps;
-  var lazyComponent = elementType;
-  var payload = lazyComponent._payload;
-  var init = lazyComponent._init;
-  var Component = init(payload); // Store the unwrapped component in the type.
+      if (flags & Visibility) {
+        // Track the current state on the Offscreen instance so we can
+        // read it during an event
+        if (_isHidden) {
+          offscreenInstance._visibility &= ~OffscreenVisible;
+        } else {
+          offscreenInstance._visibility |= OffscreenVisible;
+        }
 
-  workInProgress.type = Component;
-  var resolvedTag = (workInProgress.tag = resolveLazyComponentTag(Component));
-  var resolvedProps = resolveDefaultProps(Component, props);
-  var child;
+        if (_isHidden) {
+          var isUpdate = current !== null;
+          var wasHiddenByAncestorOffscreen =
+            offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+          //   - This is an update, not first mount.
+          //   - This Offscreen was not hidden before.
+          //   - Ancestor Offscreen was not hidden in previous commit.
 
-  switch (resolvedTag) {
-    case FunctionComponent: {
-      {
-        validateFunctionComponentInDev(workInProgress, Component);
-        workInProgress.type = Component =
-          resolveFunctionForHotReloading(Component);
-      }
+          if (isUpdate && !_wasHidden && !wasHiddenByAncestorOffscreen) {
+            if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+              // Disappear the layout effects of all the children
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+            }
+          }
+        } // Offscreen with manual mode manages visibility manually.
 
-      child = updateFunctionComponent(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
-    }
+        if (!isOffscreenManual(finishedWork)) {
+          // TODO: This needs to run whenever there's an insertion or update
+          // inside a hidden Offscreen tree.
+          hideOrUnhideAllChildren(finishedWork, _isHidden);
+        }
+      } // TODO: Move to passive phase
 
-    case ClassComponent: {
-      {
-        workInProgress.type = Component =
-          resolveClassForHotReloading(Component);
+      if (flags & Update) {
+        var offscreenQueue = finishedWork.updateQueue;
+
+        if (offscreenQueue !== null) {
+          var _wakeables = offscreenQueue.wakeables;
+
+          if (_wakeables !== null) {
+            offscreenQueue.wakeables = null;
+            attachSuspenseRetryListeners(finishedWork, _wakeables);
+          }
+        }
       }
 
-      child = updateClassComponent(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
+      return;
     }
 
-    case ForwardRef: {
-      {
-        workInProgress.type = Component =
-          resolveForwardRefForHotReloading(Component);
+    case SuspenseListComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+
+      if (flags & Update) {
+        var _wakeables2 = finishedWork.updateQueue;
+
+        if (_wakeables2 !== null) {
+          finishedWork.updateQueue = null;
+          attachSuspenseRetryListeners(finishedWork, _wakeables2);
+        }
       }
 
-      child = updateForwardRef(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
+      return;
     }
 
-    case MemoComponent: {
+    case ScopeComponent: {
       {
-        if (workInProgress.type !== workInProgress.elementType) {
-          var outerPropTypes = Component.propTypes;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: This is a temporary solution that allowed us to transition away
+        // from React Flare on www.
 
-          if (outerPropTypes) {
-            checkPropTypes(
-              outerPropTypes,
-              resolvedProps, // Resolved for outer only
-              "prop",
-              getComponentNameFromType(Component)
-            );
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(finishedWork, finishedWork.return);
           }
+
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
+
+        if (flags & Update) {
+          var scopeInstance = finishedWork.stateNode;
+          prepareScopeUpdate(scopeInstance, finishedWork);
         }
       }
 
-      child = updateMemoComponent(
-        null,
-        workInProgress,
-        Component,
-        resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
-        renderLanes
-      );
-      return child;
+      return;
     }
-  }
 
-  var hint = "";
-
-  {
-    if (
-      Component !== null &&
-      typeof Component === "object" &&
-      Component.$$typeof === REACT_LAZY_TYPE
-    ) {
-      hint = " Did you wrap a component in React.lazy() more than once?";
+    default: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      return;
     }
-  } // This message intentionally doesn't mention ForwardRef or MemoComponent
-  // because the fact that it's a separate type of work is an
-  // implementation detail.
-
-  throw new Error(
-    "Element type is invalid. Received a promise that resolves to: " +
-      Component +
-      ". " +
-      ("Lazy element type must resolve to a class or function." + hint)
-  );
+  }
 }
 
-function mountIncompleteClassComponent(
-  _current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  var flags = finishedWork.flags;
 
-  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
-  // 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.
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
 
-  var hasContext;
+    finishedWork.flags &= ~Placement;
+  }
 
-  if (isContextProvider()) {
-    hasContext = true;
-  } else {
-    hasContext = false;
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
   }
+}
 
-  prepareToReadContext(workInProgress, renderLanes);
-  constructClassInstance(workInProgress, Component, nextProps);
-  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
-  return finishClassComponent(
-    null,
-    workInProgress,
-    Component,
-    true,
-    hasContext,
-    renderLanes
-  );
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  var current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
 }
 
-function mountIndeterminateComponent(
-  _current,
-  workInProgress,
-  Component,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
-  var props = workInProgress.pendingProps;
-  var context;
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+  var prevDebugFiber = getCurrentFiber();
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var value;
-  var hasId;
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    var child = parentFiber.child;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
+    while (child !== null) {
+      setCurrentFiber(child);
+      var current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
+    }
   }
 
-  {
-    if (
-      Component.prototype &&
-      typeof Component.prototype.render === "function"
-    ) {
-      var componentName = getComponentNameFromType(Component) || "Unknown";
-
-      if (!didWarnAboutBadClass[componentName]) {
-        error(
-          "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
-            "This is likely to cause errors. Change %s to extend React.Component instead.",
-          componentName,
-          componentName
-        );
+  setCurrentFiber(prevDebugFiber);
+}
 
-        didWarnAboutBadClass[componentName] = true;
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      // TODO (Offscreen) Check: flags & LayoutStatic
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          commitHookEffectListUnmount(
+            Layout,
+            finishedWork,
+            finishedWork.return
+          );
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
+        commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
       }
-    }
 
-    if (workInProgress.mode & StrictLegacyMode) {
-      ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
     }
 
-    setIsRendering(true);
-    ReactCurrentOwner$1.current = workInProgress;
-    value = renderWithHooks(
-      null,
-      workInProgress,
-      Component,
-      props,
-      context,
-      renderLanes
-    );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
+    case ClassComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      var instance = finishedWork.stateNode;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  } // React DevTools reads this flag.
+      if (typeof instance.componentWillUnmount === "function") {
+        safelyCallComponentWillUnmount(
+          finishedWork,
+          finishedWork.return,
+          instance
+        );
+      }
 
-  workInProgress.flags |= PerformedWork;
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
 
-  {
-    // Support for module components is deprecated and is removed behind a flag.
-    // Whether or not it would crash later, we want to show a good message in DEV first.
-    if (
-      typeof value === "object" &&
-      value !== null &&
-      typeof value.render === "function" &&
-      value.$$typeof === undefined
-    ) {
-      var _componentName = getComponentNameFromType(Component) || "Unknown";
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
 
-      if (!didWarnAboutModulePatternComponent[_componentName]) {
-        error(
-          "The <%s /> component appears to be a function component that returns a class instance. " +
-            "Change %s to a class that extends React.Component instead. " +
-            "If you can't use a class try assigning the prototype on the function as a workaround. " +
-            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
-            "cannot be called with `new` by React.",
-          _componentName,
-          _componentName,
-          _componentName
-        );
+    case OffscreenComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      var isHidden = finishedWork.memoizedState !== null;
 
-        didWarnAboutModulePatternComponent[_componentName] = true;
+      if (isHidden);
+      else {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
       }
+
+      break;
+    }
+
+    default: {
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
     }
   }
+}
 
-  {
-    // Proceed under the assumption that this is a function component
-    workInProgress.tag = FunctionComponent;
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  var child = parentFiber.child;
 
-    {
-      if (Component.contextTypes) {
-        error(
-          "%s uses the legacy contextTypes API which is no longer supported. " +
-            "Use React.createContext() with React.useContext() instead.",
-          getComponentNameFromType(Component) || "Unknown"
-        );
-      }
-    }
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
 
-    if (getIsHydrating() && hasId) {
-      pushMaterializedTreeId(workInProgress);
+function reappearLayoutEffects(
+  finishedRoot,
+  current,
+  finishedWork, // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  includeWorkInProgressEffects
+) {
+  // Turn on layout effects in a tree that previously disappeared.
+  var flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Check flags & LayoutStatic
+
+      commitHookLayoutEffects(finishedWork, Layout);
+      break;
     }
 
-    reconcileChildren(null, workInProgress, value, renderLanes);
+    case ClassComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Check for LayoutStatic flag
+
+      var instance = finishedWork.stateNode;
+
+      if (typeof instance.componentDidMount === "function") {
+        try {
+          instance.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      } // Commit any callbacks that would have fired while the component
+      // was hidden.
+
+      var updateQueue = finishedWork.updateQueue;
 
-    {
-      validateFunctionComponentInDev(workInProgress, Component);
-    }
+      if (updateQueue !== null) {
+        commitHiddenCallbacks(updateQueue, instance);
+      } // If this is newly finished work, check for setState callbacks
 
-    return workInProgress.child;
-  }
-}
+      if (includeWorkInProgressEffects && flags & Callback) {
+        commitClassCallbacks(finishedWork);
+      } // TODO: Check flags & RefStatic
 
-function validateFunctionComponentInDev(workInProgress, Component) {
-  {
-    if (Component) {
-      if (Component.childContextTypes) {
-        error(
-          "%s(...): childContextTypes cannot be defined on a function component.",
-          Component.displayName || Component.name || "Component"
-        );
-      }
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
     }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
 
-    if (workInProgress.ref !== null) {
-      var info = "";
-      var ownerName = getCurrentFiberOwnerNameInDevOrNull();
-
-      if (ownerName) {
-        info += "\n\nCheck the render method of `" + ownerName + "`.";
-      }
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // Renderers may schedule work to be done after host components are mounted
+      // (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.
 
-      var warningKey = ownerName || "";
-      var debugSource = workInProgress._debugSource;
+      if (includeWorkInProgressEffects && current === null && flags & Update) {
+        commitHostComponentMount(finishedWork);
+      } // TODO: Check flags & Ref
 
-      if (debugSource) {
-        warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
-      }
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    }
 
-      if (!didWarnAboutFunctionRefs[warningKey]) {
-        didWarnAboutFunctionRefs[warningKey] = true;
+    case Profiler: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Figure out how Profiler updates should work with Offscreen
 
-        error(
-          "Function components cannot be given refs. " +
-            "Attempts to access this ref will fail. " +
-            "Did you mean to use React.forwardRef()?%s",
-          info
-        );
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
       }
-    }
 
-    if (Component.defaultProps !== undefined) {
-      var componentName = getComponentNameFromType(Component) || "Unknown";
+      break;
+    }
 
-      if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
-        error(
-          "%s: Support for defaultProps will be removed from function components " +
-            "in a future major release. Use JavaScript default parameters instead.",
-          componentName
-        );
+    case SuspenseComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Figure out how Suspense hydration callbacks should work
+      // with Offscreen.
 
-        didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
       }
+
+      break;
     }
 
-    if (typeof Component.getDerivedStateFromProps === "function") {
-      var _componentName3 = getComponentNameFromType(Component) || "Unknown";
+    case OffscreenComponent: {
+      var offscreenState = finishedWork.memoizedState;
+      var isHidden = offscreenState !== null;
 
-      if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
-        error(
-          "%s: Function components do not support getDerivedStateFromProps.",
-          _componentName3
+      if (isHidden);
+      else {
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
         );
+      } // TODO: Check flags & Ref
 
-        didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
-      }
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
     }
 
-    if (
-      typeof Component.contextType === "object" &&
-      Component.contextType !== null
-    ) {
-      var _componentName4 = getComponentNameFromType(Component) || "Unknown";
-
-      if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
-        error(
-          "%s: Function components do not support contextType.",
-          _componentName4
-        );
-
-        didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
-      }
+    default: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      );
+      break;
     }
   }
 }
 
-var SUSPENDED_MARKER = {
-  dehydrated: null,
-  treeContext: null,
-  retryLane: NoLane
-};
-
-function mountSuspenseOffscreenState(renderLanes) {
-  return {
-    baseLanes: renderLanes,
-    cachePool: getSuspendedCache()
-  };
-}
-
-function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
-  var cachePool = null;
-
-  {
-    var prevCachePool = prevOffscreenState.cachePool;
+function recursivelyTraverseReappearLayoutEffects(
+  finishedRoot,
+  parentFiber,
+  includeWorkInProgressEffects
+) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  var childShouldIncludeWorkInProgressEffects =
+    includeWorkInProgressEffects &&
+    (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
 
-    if (prevCachePool !== null) {
-      var parentCache = CacheContext._currentValue;
+  var prevDebugFiber = getCurrentFiber();
+  var child = parentFiber.child;
 
-      if (prevCachePool.parent !== parentCache) {
-        // Detected a refresh in the parent. This overrides any previously
-        // suspended cache.
-        cachePool = {
-          parent: parentCache,
-          pool: parentCache
-        };
-      } else {
-        // We can reuse the cache from last time. The only thing that would have
-        // overridden it is a parent refresh, which we checked for above.
-        cachePool = prevCachePool;
-      }
-    } else {
-      // If there's no previous cache pool, grab the current one.
-      cachePool = getSuspendedCache();
-    }
+  while (child !== null) {
+    var current = child.alternate;
+    reappearLayoutEffects(
+      finishedRoot,
+      current,
+      child,
+      childShouldIncludeWorkInProgressEffects
+    );
+    child = child.sibling;
   }
 
-  return {
-    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
-    cachePool: cachePool
-  };
-} // TODO: Probably should inline this back
+  setCurrentFiber(prevDebugFiber);
+}
 
-function shouldRemainOnFallback(current, workInProgress, renderLanes) {
-  // If we're already showing a fallback, there are cases where we need to
-  // remain on that fallback regardless of whether the content has resolved.
-  // For example, SuspenseList coordinates when nested content appears.
-  if (current !== null) {
-    var suspenseState = current.memoizedState;
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
 
-    if (suspenseState === null) {
-      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
-      // is true. More precise name might be "ForceRemainSuspenseFallback".
-      // Note: This is a factoring smell. Can't remain on a fallback if there's
-      // no fallback to remain on.
-      return false;
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
-  } // Not currently showing content. Consult the Suspense context.
 
-  var suspenseContext = suspenseStackCursor.current;
-  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
-}
-
-function getRemainingWorkInPrimaryTree(current, renderLanes) {
-  // TODO: Should not remove render lanes that were pinged during this render
-  return removeLanes(current.childLanes, renderLanes);
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
 }
 
-function updateSuspenseComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
-
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
   {
-    if (shouldSuspend(workInProgress)) {
-      workInProgress.flags |= DidCapture;
+    var previousCache = null;
+
+    if (
+      current !== null &&
+      current.memoizedState !== null &&
+      current.memoizedState.cachePool !== null
+    ) {
+      previousCache = current.memoizedState.cachePool.pool;
     }
-  }
 
-  var showFallback = false;
-  var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+    var nextCache = null;
 
-  if (didSuspend || shouldRemainOnFallback(current)) {
-    // Something in this boundary's subtree already suspended. Switch to
-    // rendering the fallback children.
-    showFallback = true;
-    workInProgress.flags &= ~DidCapture;
-  } // OK, the next part is confusing. We're about to reconcile the Suspense
-  // boundary's children. This involves some custom reconciliation logic. Two
-  // main reasons this is so complicated.
-  //
-  // First, Legacy Mode has different semantics for backwards compatibility. The
-  // primary tree will commit in an inconsistent state, so when we do the
-  // second pass to render the fallback, we do some exceedingly, uh, clever
-  // hacks to make that not totally break. Like transferring effects and
-  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
-  // because we bailout on the primary tree completely and leave it in its old
-  // state, no effects. Same as what we do for Offscreen (except that
-  // Offscreen doesn't have the first render pass).
-  //
-  // Second is hydration. During hydration, the Suspense fiber has a slightly
-  // different layout, where the child points to a dehydrated fragment, which
-  // contains the DOM rendered by the server.
-  //
-  // Third, even if you set all that aside, Suspense is like error boundaries in
-  // that we first we try to render one tree, and if that fails, we render again
-  // and switch to a different tree. Like a try/catch block. So we have to track
-  // which branch we're currently rendering. Ideally we would model this using
-  // a stack.
+    if (
+      finishedWork.memoizedState !== null &&
+      finishedWork.memoizedState.cachePool !== null
+    ) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
 
-  if (current === null) {
-    // Initial mount
-    // Special path for hydration
-    // If we're currently hydrating, try to hydrate this boundary.
-    if (getIsHydrating()) {
-      // We must push the suspense handler context *before* attempting to
-      // hydrate, to avoid a mismatch in case it errors.
-      if (showFallback) {
-        pushPrimaryTreeSuspenseHandler(workInProgress);
-      } else {
-        pushFallbackTreeSuspenseHandler(workInProgress);
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
       }
 
-      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
-
-      var suspenseState = workInProgress.memoizedState;
-
-      if (suspenseState !== null) {
-        var dehydrated = suspenseState.dehydrated;
-
-        if (dehydrated !== null) {
-          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
-        }
-      } // If hydration didn't succeed, fall through to the normal Suspense path.
-      // To avoid a stack mismatch we need to pop the Suspense handler that we
-      // pushed above. This will become less awkward when move the hydration
-      // logic to its own fiber.
-
-      popSuspenseHandler(workInProgress);
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
     }
+  }
 
-    var nextPrimaryChildren = nextProps.children;
-    var nextFallbackChildren = nextProps.fallback;
-
-    if (showFallback) {
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var fallbackFragment = mountSuspenseFallbackChildren(
-        workInProgress,
-        nextPrimaryChildren,
-        nextFallbackChildren,
-        renderLanes
-      );
-      var primaryChildFragment = workInProgress.child;
-      primaryChildFragment.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER;
+  if (enableTransitionTracing) {
+    // TODO: Pre-rendering should not be counted as part of a transition. We
+    // may add separate logs for pre-rendering, but it's not part of the
+    // primary metrics.
+    var offscreenState = finishedWork.memoizedState;
+    var queue = finishedWork.updateQueue;
+    var isHidden = offscreenState !== null;
 
-      if (enableTransitionTracing) {
-        var currentTransitions = getPendingTransitions();
+    if (queue !== null) {
+      if (isHidden) {
+        var transitions = queue.transitions;
 
-        if (currentTransitions !== null) {
-          var parentMarkerInstances = getMarkerInstances();
-          var offscreenQueue = primaryChildFragment.updateQueue;
+        if (transitions !== null) {
+          transitions.forEach(function (transition) {
+            // Add all the transitions saved in the update queue during
+            // the render phase (ie the transitions associated with this boundary)
+            // into the transitions set.
+            if (instance._transitions === null) {
+              instance._transitions = new Set();
+            }
 
-          if (offscreenQueue === null) {
-            var newOffscreenQueue = {
-              transitions: currentTransitions,
-              markerInstances: parentMarkerInstances,
-              wakeables: null
-            };
-            primaryChildFragment.updateQueue = newOffscreenQueue;
-          } else {
-            offscreenQueue.transitions = currentTransitions;
-            offscreenQueue.markerInstances = parentMarkerInstances;
-          }
+            instance._transitions.add(transition);
+          });
         }
-      }
-
-      return fallbackFragment;
-    } else if (typeof nextProps.unstable_expectedLoadTime === "number") {
-      // This is a CPU-bound tree. Skip this tree and show a placeholder to
-      // unblock the surrounding content. Then immediately retry after the
-      // initial commit.
-      pushFallbackTreeSuspenseHandler(workInProgress);
-
-      var _fallbackFragment = mountSuspenseFallbackChildren(
-        workInProgress,
-        nextPrimaryChildren,
-        nextFallbackChildren,
-        renderLanes
-      );
-
-      var _primaryChildFragment = workInProgress.child;
-      _primaryChildFragment.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
-      // Since nothing actually suspended, there will nothing to ping this to
-      // get it started back up to attempt the next item. While in terms of
-      // priority this work has the same priority as this current render, it's
-      // not part of the same transition once the transition has committed. If
-      // it's sync, we still want to yield so that it can be painted.
-      // Conceptually, this is really the same as pinging. We can use any
-      // RetryLane even if it's the one currently rendering since we're leaving
-      // it behind on this node.
-
-      workInProgress.lanes = SomeRetryLane;
-      return _fallbackFragment;
-    } else {
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
-    }
-  } else {
-    // This is an update.
-    // Special path for hydration
-    var prevState = current.memoizedState;
-
-    if (prevState !== null) {
-      var _dehydrated = prevState.dehydrated;
-
-      if (_dehydrated !== null) {
-        return updateDehydratedSuspenseComponent(
-          current,
-          workInProgress,
-          didSuspend,
-          nextProps,
-          _dehydrated,
-          prevState,
-          renderLanes
-        );
-      }
-    }
 
-    if (showFallback) {
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var _nextFallbackChildren = nextProps.fallback;
-      var _nextPrimaryChildren = nextProps.children;
-      var fallbackChildFragment = updateSuspenseFallbackChildren(
-        current,
-        workInProgress,
-        _nextPrimaryChildren,
-        _nextFallbackChildren,
-        renderLanes
-      );
-      var _primaryChildFragment2 = workInProgress.child;
-      var prevOffscreenState = current.child.memoizedState;
-      _primaryChildFragment2.memoizedState =
-        prevOffscreenState === null
-          ? mountSuspenseOffscreenState(renderLanes)
-          : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
+        var markerInstances = queue.markerInstances;
 
-      if (enableTransitionTracing) {
-        var _currentTransitions = getPendingTransitions();
+        if (markerInstances !== null) {
+          markerInstances.forEach(function (markerInstance) {
+            var markerTransitions = markerInstance.transitions; // There should only be a few tracing marker transitions because
+            // they should be only associated with the transition that
+            // caused them
 
-        if (_currentTransitions !== null) {
-          var _parentMarkerInstances = getMarkerInstances();
+            if (markerTransitions !== null) {
+              markerTransitions.forEach(function (transition) {
+                if (instance._transitions === null) {
+                  instance._transitions = new Set();
+                } else if (instance._transitions.has(transition)) {
+                  if (markerInstance.pendingBoundaries === null) {
+                    markerInstance.pendingBoundaries = new Map();
+                  }
 
-          var _offscreenQueue = _primaryChildFragment2.updateQueue;
-          var currentOffscreenQueue = current.updateQueue;
+                  if (instance._pendingMarkers === null) {
+                    instance._pendingMarkers = new Set();
+                  }
 
-          if (_offscreenQueue === null) {
-            var _newOffscreenQueue = {
-              transitions: _currentTransitions,
-              markerInstances: _parentMarkerInstances,
-              wakeables: null
-            };
-            _primaryChildFragment2.updateQueue = _newOffscreenQueue;
-          } else if (_offscreenQueue === currentOffscreenQueue) {
-            // If the work-in-progress queue is the same object as current, we
-            // can't modify it without cloning it first.
-            var _newOffscreenQueue2 = {
-              transitions: _currentTransitions,
-              markerInstances: _parentMarkerInstances,
-              wakeables:
-                currentOffscreenQueue !== null
-                  ? currentOffscreenQueue.wakeables
-                  : null
-            };
-            _primaryChildFragment2.updateQueue = _newOffscreenQueue2;
-          } else {
-            _offscreenQueue.transitions = _currentTransitions;
-            _offscreenQueue.markerInstances = _parentMarkerInstances;
-          }
+                  instance._pendingMarkers.add(markerInstance);
+                }
+              });
+            }
+          });
         }
       }
 
-      _primaryChildFragment2.childLanes = getRemainingWorkInPrimaryTree(
-        current,
-        renderLanes
-      );
-      workInProgress.memoizedState = SUSPENDED_MARKER;
-      return fallbackChildFragment;
-    } else {
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      var _nextPrimaryChildren2 = nextProps.children;
+      finishedWork.updateQueue = null;
+    }
+
+    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
 
-      var _primaryChildFragment3 = updateSuspensePrimaryChildren(
-        current,
-        workInProgress,
-        _nextPrimaryChildren2,
-        renderLanes
-      );
+    if (!isHidden) {
+      instance._transitions = null;
+      instance._pendingMarkers = null;
+    }
+  }
+}
 
-      workInProgress.memoizedState = null;
-      return _primaryChildFragment3;
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    var previousCache = null;
+
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
+
+    var nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
+
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
+
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
     }
   }
 }
 
-function mountSuspensePrimaryChildren(
-  workInProgress,
-  primaryChildren,
-  renderLanes
+function commitTracingMarkerPassiveMountEffect(finishedWork) {
+  // Get the transitions that were initiatized during the render
+  // and add a start transition callback for each of them
+  // We will only call this on initial mount of the tracing marker
+  // only if there are no suspense children
+  var instance = finishedWork.stateNode;
+
+  if (instance.transitions !== null && instance.pendingBoundaries === null) {
+    addMarkerCompleteCallbackToPendingTransition(
+      finishedWork.memoizedProps.name,
+      instance.transitions
+    );
+    instance.transitions = null;
+    instance.pendingBoundaries = null;
+    instance.aborts = null;
+    instance.name = null;
+  }
+}
+
+function commitPassiveMountEffects(
+  root,
+  finishedWork,
+  committedLanes,
+  committedTransitions
 ) {
-  var mode = workInProgress.mode;
-  var primaryChildProps = {
-    mode: "visible",
-    children: primaryChildren
-  };
-  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
-    primaryChildProps,
-    mode
+  setCurrentFiber(finishedWork);
+  commitPassiveMountOnFiber(
+    root,
+    finishedWork,
+    committedLanes,
+    committedTransitions
   );
-  primaryChildFragment.return = workInProgress;
-  workInProgress.child = primaryChildFragment;
-  return primaryChildFragment;
+  resetCurrentFiber();
 }
 
-function mountSuspenseFallbackChildren(
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
+function recursivelyTraversePassiveMountEffects(
+  root,
+  parentFiber,
+  committedLanes,
+  committedTransitions
 ) {
-  var mode = workInProgress.mode;
-  var progressedPrimaryFragment = workInProgress.child;
-  var primaryChildProps = {
-    mode: "hidden",
-    children: primaryChildren
-  };
-  var primaryChildFragment;
-  var fallbackChildFragment;
+  var prevDebugFiber = getCurrentFiber();
 
-  if (
-    (mode & ConcurrentMode) === NoMode &&
-    progressedPrimaryFragment !== null
-  ) {
-    // In legacy mode, we commit the primary tree as if it successfully
-    // completed, even though it's in an inconsistent state.
-    primaryChildFragment = progressedPrimaryFragment;
-    primaryChildFragment.childLanes = NoLanes;
-    primaryChildFragment.pendingProps = primaryChildProps;
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-    if (workInProgress.mode & ProfileMode) {
-      // Reset the durations from the first pass so they aren't included in the
-      // final amounts. This seems counterintuitive, since we're intentionally
-      // not measuring part of the render phase, but this makes it match what we
-      // do in Concurrent Mode.
-      primaryChildFragment.actualDuration = 0;
-      primaryChildFragment.actualStartTime = -1;
-      primaryChildFragment.selfBaseDuration = 0;
-      primaryChildFragment.treeBaseDuration = 0;
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitPassiveMountOnFiber(
+        root,
+        child,
+        committedLanes,
+        committedTransitions
+      );
+      child = child.sibling;
     }
-
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    );
-  } else {
-    primaryChildFragment = mountWorkInProgressOffscreenFiber(
-      primaryChildProps,
-      mode
-    );
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    );
   }
 
-  primaryChildFragment.return = workInProgress;
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
-  return fallbackChildFragment;
+  setCurrentFiber(prevDebugFiber);
 }
 
-function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
-  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
-  // this wrapper function to constrain it.
-  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
-}
+function commitPassiveMountOnFiber(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions
+) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  var flags = finishedWork.flags;
 
-function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
-  // The props argument to `createWorkInProgress` is `any` typed, so we use this
-  // wrapper function to constrain it.
-  return createWorkInProgress(current, offscreenProps);
-}
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-function updateSuspensePrimaryChildren(
-  current,
-  workInProgress,
-  primaryChildren,
-  renderLanes
-) {
-  var currentPrimaryChildFragment = current.child;
-  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
-  var primaryChildFragment = updateWorkInProgressOffscreenFiber(
-    currentPrimaryChildFragment,
-    {
-      mode: "visible",
-      children: primaryChildren
+      if (flags & Passive$1) {
+        commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+      }
+
+      break;
     }
-  );
 
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    primaryChildFragment.lanes = renderLanes;
-  }
+    case HostRoot: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-  primaryChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = null;
+      if (flags & Passive$1) {
+        {
+          var previousCache = null;
 
-  if (currentFallbackChildFragment !== null) {
-    // Delete the fallback child fragment
-    var deletions = workInProgress.deletions;
+          if (finishedWork.alternate !== null) {
+            previousCache = finishedWork.alternate.memoizedState.cache;
+          }
 
-    if (deletions === null) {
-      workInProgress.deletions = [currentFallbackChildFragment];
-      workInProgress.flags |= ChildDeletion;
-    } else {
-      deletions.push(currentFallbackChildFragment);
-    }
-  }
+          var nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+          // Note that on initial mount, previousCache and nextCache will be the same
+          // and this retain won't occur. To counter this, we instead retain the HostRoot's
+          // initial cache when creating the root itself (see createFiberRoot() in
+          // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+          // here, such that previous/next caches are retained correctly.
 
-  workInProgress.child = primaryChildFragment;
-  return primaryChildFragment;
-}
+          if (nextCache !== previousCache) {
+            retainCache(nextCache);
 
-function updateSuspenseFallbackChildren(
-  current,
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode;
-  var currentPrimaryChildFragment = current.child;
-  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
-  var primaryChildProps = {
-    mode: "hidden",
-    children: primaryChildren
-  };
-  var primaryChildFragment;
+            if (previousCache != null) {
+              releaseCache(previousCache);
+            }
+          }
+        }
 
-  if (
-    // In legacy mode, we commit the primary tree as if it successfully
-    // completed, even though it's in an inconsistent state.
-    (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
-    // already cloned. In legacy mode, the only case where this isn't true is
-    // when DevTools forces us to display a fallback; we skip the first render
-    // pass entirely and go straight to rendering the fallback. (In Concurrent
-    // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
-    // only codepath.)
-    workInProgress.child !== currentPrimaryChildFragment
-  ) {
-    var progressedPrimaryFragment = workInProgress.child;
-    primaryChildFragment = progressedPrimaryFragment;
-    primaryChildFragment.childLanes = NoLanes;
-    primaryChildFragment.pendingProps = primaryChildProps;
+        if (enableTransitionTracing) {
+          // Get the transitions that were initiatized during the render
+          // and add a start transition callback for each of them
+          var root = finishedWork.stateNode;
+          var incompleteTransitions = root.incompleteTransitions; // Initial render
 
-    if (workInProgress.mode & ProfileMode) {
-      // Reset the durations from the first pass so they aren't included in the
-      // final amounts. This seems counterintuitive, since we're intentionally
-      // not measuring part of the render phase, but this makes it match what we
-      // do in Concurrent Mode.
-      primaryChildFragment.actualDuration = 0;
-      primaryChildFragment.actualStartTime = -1;
-      primaryChildFragment.selfBaseDuration =
-        currentPrimaryChildFragment.selfBaseDuration;
-      primaryChildFragment.treeBaseDuration =
-        currentPrimaryChildFragment.treeBaseDuration;
-    } // The fallback fiber was added as a deletion during the first pass.
-    // However, since we're going to remain on the fallback, we no longer want
-    // to delete it.
+          if (committedTransitions !== null) {
+            committedTransitions.forEach(function (transition) {
+              addTransitionStartCallbackToPendingTransition(transition);
+            });
+            clearTransitionsForLanes(finishedRoot, committedLanes);
+          }
 
-    workInProgress.deletions = null;
-  } else {
-    primaryChildFragment = updateWorkInProgressOffscreenFiber(
-      currentPrimaryChildFragment,
-      primaryChildProps
-    ); // Since we're reusing a current tree, we need to reuse the flags, too.
-    // (We don't do this in legacy mode, because in legacy mode we don't re-use
-    // the current tree; see previous branch.)
+          incompleteTransitions.forEach(function (markerInstance, transition) {
+            var pendingBoundaries = markerInstance.pendingBoundaries;
 
-    primaryChildFragment.subtreeFlags =
-      currentPrimaryChildFragment.subtreeFlags & StaticMask;
-  }
+            if (pendingBoundaries === null || pendingBoundaries.size === 0) {
+              if (markerInstance.aborts === null) {
+                addTransitionCompleteCallbackToPendingTransition(transition);
+              }
 
-  var fallbackChildFragment;
+              incompleteTransitions.delete(transition);
+            }
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
+        }
+      }
 
-  if (currentFallbackChildFragment !== null) {
-    fallbackChildFragment = createWorkInProgress(
-      currentFallbackChildFragment,
-      fallbackChildren
-    );
-  } else {
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    ); // Needs a placement effect because the parent (the Suspense boundary) already
-    // mounted but this is a new fiber.
+      break;
+    }
 
-    fallbackChildFragment.flags |= Placement;
-  }
+    case LegacyHiddenComponent: {
+      {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
 
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
-  return fallbackChildFragment;
-}
+        if (flags & Passive$1) {
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+        }
+      }
 
-function retrySuspenseComponentWithoutHydrating(
-  current,
-  workInProgress,
-  renderLanes,
-  recoverableError
-) {
-  // Falling back to client rendering. Because this has performance
-  // implications, it's considered a recoverable error, even though the user
-  // likely won't observe anything wrong with the UI.
-  //
-  // The error is passed in as an argument to enforce that every caller provide
-  // a custom message, or explicitly opt out (currently the only path that opts
-  // out is legacy mode; every concurrent path provides an error).
-  if (recoverableError !== null) {
-    queueHydrationError(recoverableError);
-  } // This will add the old fiber to the deletion list
+      break;
+    }
 
-  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+    case OffscreenComponent: {
+      // TODO: Pass `current` as argument to this function
+      var _instance3 = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
 
-  var nextProps = workInProgress.pendingProps;
-  var primaryChildren = nextProps.children;
-  var primaryChildFragment = mountSuspensePrimaryChildren(
-    workInProgress,
-    primaryChildren
-  ); // Needs a placement effect because the parent (the Suspense boundary) already
-  // mounted but this is a new fiber.
+      if (isHidden) {
+        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          );
+        } else {
+          if (finishedWork.mode & ConcurrentMode) {
+            // The effects are currently disconnected. Since the tree is hidden,
+            // don't connect them. This also applies to the initial render.
+            {
+              // "Atomic" effects are ones that need to fire on every commit,
+              // even during pre-rendering. An example is updating the reference
+              // count on cache instances.
+              recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              );
+            }
+          } else {
+            // Legacy Mode: Fire the effects even if the tree is hidden.
+            _instance3._visibility |= OffscreenPassiveEffectsConnected;
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+          }
+        }
+      } else {
+        // Tree is visible
+        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          );
+        } else {
+          // The effects are currently disconnected. Reconnect them, while also
+          // firing effects inside newly mounted trees. This also applies to
+          // the initial render.
+          _instance3._visibility |= OffscreenPassiveEffectsConnected;
+          var includeWorkInProgressEffects =
+            (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+        }
+      }
 
-  primaryChildFragment.flags |= Placement;
-  workInProgress.memoizedState = null;
-  return primaryChildFragment;
-}
+      if (flags & Passive$1) {
+        var _current = finishedWork.alternate;
+        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
+      }
 
-function mountSuspenseFallbackAfterRetryWithoutHydrating(
-  current,
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var fiberMode = workInProgress.mode;
-  var primaryChildProps = {
-    mode: "visible",
-    children: primaryChildren
-  };
-  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
-    primaryChildProps,
-    fiberMode
-  );
-  var fallbackChildFragment = createFiberFromFragment(
-    fallbackChildren,
-    fiberMode,
-    renderLanes,
-    null
-  ); // Needs a placement effect because the parent (the Suspense
-  // boundary) already mounted but this is a new fiber.
+      break;
+    }
+
+    case CacheComponent: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current2 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current2, finishedWork);
+      }
+
+      break;
+    }
+
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
 
-  fallbackChildFragment.flags |= Placement;
-  primaryChildFragment.return = workInProgress;
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
+        if (flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
+        }
 
-  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
-    // We will have dropped the effect list which contains the
-    // deletion. We need to reconcile to delete the current child.
-    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-  }
+        break;
+      } // Intentional fallthrough to next branch
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-  return fallbackChildFragment;
+    default: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+      break;
+    }
+  }
 }
 
-function mountDehydratedSuspenseComponent(
-  workInProgress,
-  suspenseInstance,
-  renderLanes
+function recursivelyTraverseReconnectPassiveEffects(
+  finishedRoot,
+  parentFiber,
+  committedLanes,
+  committedTransitions,
+  includeWorkInProgressEffects
 ) {
-  // During the first pass, we'll bail out and not drill into the children.
-  // Instead, we'll leave the content in place and try to hydrate it later.
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    {
-      error(
-        "Cannot hydrate Suspense in legacy mode. Switch from " +
-          "ReactDOM.hydrate(element, container) to " +
-          "ReactDOMClient.hydrateRoot(container, <App />)" +
-          ".render(element) or remove the Suspense components from " +
-          "the server rendered components."
-      );
-    }
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  var childShouldIncludeWorkInProgressEffects =
+    includeWorkInProgressEffects &&
+    (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
 
-    workInProgress.lanes = laneToLanes(SyncLane);
-  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
-    // This is a client-only boundary. Since we won't get any content from the server
-    // for this, we need to schedule that at a higher priority based on when it would
-    // have timed out. In theory we could render it in this pass but it would have the
-    // wrong priority associated with it and will prevent hydration of parent path.
-    // Instead, we'll leave work left on it to render it in a separate commit.
-    // TODO This time should be the time at which the server rendered response that is
-    // a parent to this boundary was displayed. However, since we currently don't have
-    // a protocol to transfer that time, we'll just estimate it by using the current
-    // time. This will mean that Suspense timeouts are slightly shifted to later than
-    // they should be.
-    // Schedule a normal pri update to render this content.
-    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
-  } else {
-    // We'll continue hydrating the rest at offscreen priority since we'll already
-    // be showing the right content coming from the server, it is no rush.
-    workInProgress.lanes = laneToLanes(OffscreenLane);
+  var prevDebugFiber = getCurrentFiber();
+  var child = parentFiber.child;
+
+  while (child !== null) {
+    reconnectPassiveEffects(
+      finishedRoot,
+      child,
+      committedLanes,
+      committedTransitions,
+      childShouldIncludeWorkInProgressEffects
+    );
+    child = child.sibling;
   }
 
-  return null;
+  setCurrentFiber(prevDebugFiber);
 }
 
-function updateDehydratedSuspenseComponent(
-  current,
-  workInProgress,
-  didSuspend,
-  nextProps,
-  suspenseInstance,
-  suspenseState,
-  renderLanes
+function reconnectPassiveEffects(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions, // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  includeWorkInProgressEffects
 ) {
-  if (!didSuspend) {
-    // This is the first render pass. Attempt to hydrate.
-    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
-    // but after we've already committed once.
+  var flags = finishedWork.flags;
 
-    warnIfHydrating();
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      ); // TODO: Check for PassiveStatic flag
 
-    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        null
-      );
+      commitHookPassiveMountEffects(finishedWork, Passive);
+      break;
     }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
 
-    if (isSuspenseInstanceFallback(suspenseInstance)) {
-      // This boundary is in a permanent fallback state. In this case, we'll never
-      // get an update and we'll never be able to hydrate the final content. Let's just try the
-      // client side render instead.
-      var digest, message, stack;
-
+    case LegacyHiddenComponent: {
       {
-        var _getSuspenseInstanceF =
-          getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
 
-        digest = _getSuspenseInstanceF.digest;
-        message = _getSuspenseInstanceF.message;
-        stack = _getSuspenseInstanceF.stack;
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+        }
       }
 
-      var error;
+      break;
+    }
 
-      if (message) {
-        // eslint-disable-next-line react-internal/prod-error-codes
-        error = new Error(message);
+    case OffscreenComponent: {
+      var _instance4 = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
+
+      if (isHidden) {
+        if (_instance4._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+        } else {
+          if (finishedWork.mode & ConcurrentMode) {
+            // The effects are currently disconnected. Since the tree is hidden,
+            // don't connect them. This also applies to the initial render.
+            {
+              // "Atomic" effects are ones that need to fire on every commit,
+              // even during pre-rendering. An example is updating the reference
+              // count on cache instances.
+              recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              );
+            }
+          } else {
+            // Legacy Mode: Fire the effects even if the tree is hidden.
+            _instance4._visibility |= OffscreenPassiveEffectsConnected;
+            recursivelyTraverseReconnectPassiveEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions,
+              includeWorkInProgressEffects
+            );
+          }
+        }
       } else {
-        error = new Error(
-          "The server could not finish this Suspense boundary, likely " +
-            "due to an error during server rendering. Switched to " +
-            "client rendering."
+        // Tree is visible
+        // Since we're already inside a reconnecting tree, it doesn't matter
+        // whether the effects are currently connected. In either case, we'll
+        // continue traversing the tree and firing all the effects.
+        //
+        // We do need to set the "connected" flag on the instance, though.
+        _instance4._visibility |= OffscreenPassiveEffectsConnected;
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
         );
       }
 
-      error.digest = digest;
-      var capturedValue = createCapturedValue(error, digest, stack);
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        capturedValue
-      );
+      if (includeWorkInProgressEffects && flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current3 = finishedWork.alternate;
+        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
+      }
+
+      break;
     }
 
-    if (
-      enableLazyContextPropagation && // TODO: Factoring is a little weird, since we check this right below, too.
-      // But don't want to re-arrange the if-else chain until/unless this
-      // feature lands.
-      !didReceiveUpdate
-    ) {
-      // We need to check if any children have context before we decide to bail
-      // out, so propagate the changes now.
-      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
-    } // We use lanes to indicate that a child might depend on context, so if
-    // any context has changed, we need to treat is as if the input might have changed.
+    case CacheComponent: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      );
 
-    var hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+      if (includeWorkInProgressEffects && flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current4 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current4, finishedWork);
+      }
 
-    if (didReceiveUpdate || hasContextChanged) {
-      // This boundary has changed since the first render. This means that we are now unable to
-      // hydrate it. We might still be able to hydrate it using a higher priority lane.
-      var root = getWorkInProgressRoot();
+      break;
+    }
 
-      if (root !== null) {
-        var attemptHydrationAtLane = getBumpedLaneForHydration(
-          root,
-          renderLanes
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
         );
 
-        if (
-          attemptHydrationAtLane !== NoLane &&
-          attemptHydrationAtLane !== suspenseState.retryLane
-        ) {
-          // Intentionally mutating since this render will get interrupted. This
-          // is one of the very rare times where we mutate the current tree
-          // during the render phase.
-          suspenseState.retryLane = attemptHydrationAtLane; // TODO: Ideally this would inherit the event time of the current render
-
-          var eventTime = NoTimestamp;
-          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
-          scheduleUpdateOnFiber(
-            root,
-            current,
-            attemptHydrationAtLane,
-            eventTime
-          ); // Throw a special object that signals to the work loop that it should
-          // interrupt the current render.
-          //
-          // Because we're inside a React-only execution stack, we don't
-          // strictly need to throw here — we could instead modify some internal
-          // work loop state. But using an exception means we don't need to
-          // check for this case on every iteration of the work loop. So doing
-          // it this way moves the check out of the fast path.
-
-          throw SelectiveHydrationException;
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
         }
-      } // If we did not selectively hydrate, we'll continue rendering without
-      // hydrating. Mark this tree as suspended to prevent it from committing
-      // outside a transition.
-      //
-      // This path should only happen if the hydration lane already suspended.
-      // Currently, it also happens during sync updates because there is no
-      // hydration lane for sync updates.
-      // TODO: We should ideally have a sync hydration lane that we can apply to do
-      // a pass where we hydrate this subtree in place using the previous Context and then
-      // reapply the update afterwards.
-
-      renderDidSuspendDelayIfPossible();
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        null
-      );
-    } else if (isSuspenseInstancePending(suspenseInstance)) {
-      // This component is still pending more data from the server, so we can't hydrate its
-      // content. We treat it as if this component suspended itself. It might seem as if
-      // we could just try to render it client-side instead. However, this will perform a
-      // lot of unnecessary work and is unlikely to complete since it often will suspend
-      // on missing data anyway. Additionally, the server might be able to render more
-      // than we can on the client yet. In that case we'd end up with more fallback states
-      // on the client than if we just leave it alone. If the server times out or errors
-      // these should update this boundary to the permanent Fallback state instead.
-      // Mark it as having captured (i.e. suspended).
-      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
-
-      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
-
-      var retry = retryDehydratedSuspenseBoundary.bind(null, current);
-      registerSuspenseInstanceRetry(suspenseInstance, retry);
-      return null;
-    } else {
-      // This is the first attempt.
-      reenterHydrationStateFromDehydratedSuspenseInstance(
-        workInProgress,
-        suspenseInstance,
-        suspenseState.treeContext
-      );
-      var primaryChildren = nextProps.children;
-      var primaryChildFragment = mountSuspensePrimaryChildren(
-        workInProgress,
-        primaryChildren
-      ); // Mark the children as hydrating. This is a fast path to know whether this
-      // tree is part of a hydrating tree. This is used to determine if a child
-      // node has fully mounted yet, and for scheduling event replaying.
-      // Conceptually this is similar to Placement in that a new subtree is
-      // inserted into the React tree here. It just happens to not need DOM
-      // mutations because it already exists.
 
-      primaryChildFragment.flags |= Hydrating;
-      return primaryChildFragment;
+        break;
+      } // Intentional fallthrough to next branch
     }
-  } else {
-    // This is the second render pass. We already attempted to hydrated, but
-    // something either suspended or errored.
-    if (workInProgress.flags & ForceClientRender) {
-      // Something errored during hydration. Try again without hydrating.
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      workInProgress.flags &= ~ForceClientRender;
-
-      var _capturedValue = createCapturedValue(
-        new Error(
-          "There was an error while hydrating this Suspense boundary. " +
-            "Switched to client rendering."
-        )
-      );
+    // eslint-disable-next-line-no-fallthrough
 
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        _capturedValue
+    default: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
       );
-    } else if (workInProgress.memoizedState !== null) {
-      // Something suspended and we should still be in dehydrated mode.
-      // Leave the existing child in place.
-      // Push to avoid a mismatch
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
-      // but the normal suspense pass doesn't.
-
-      workInProgress.flags |= DidCapture;
-      return null;
-    } else {
-      // Suspended but we should no longer be in dehydrated mode.
-      // Therefore we now have to render the fallback.
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var nextPrimaryChildren = nextProps.children;
-      var nextFallbackChildren = nextProps.fallback;
-      var fallbackChildFragment =
-        mountSuspenseFallbackAfterRetryWithoutHydrating(
-          current,
-          workInProgress,
-          nextPrimaryChildren,
-          nextFallbackChildren,
-          renderLanes
-        );
-      var _primaryChildFragment4 = workInProgress.child;
-      _primaryChildFragment4.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER;
-      return fallbackChildFragment;
+      break;
     }
   }
 }
 
-function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
-  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
-  var alternate = fiber.alternate;
+function recursivelyTraverseAtomicPassiveEffects(
+  finishedRoot,
+  parentFiber,
+  committedLanes,
+  committedTransitions
+) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  var prevDebugFiber = getCurrentFiber(); // TODO: Add special flag for atomic effects
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
+
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
+    }
   }
 
-  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+  setCurrentFiber(prevDebugFiber);
 }
 
-function propagateSuspenseContextChange(
-  workInProgress,
-  firstChild,
-  renderLanes
+function commitAtomicPassiveEffects(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions
 ) {
-  // Mark any Suspense boundaries with fallbacks as having work to do.
-  // If they were previously forced into fallbacks, they may now be able
-  // to unblock.
-  var node = firstChild;
-
-  while (node !== null) {
-    if (node.tag === SuspenseComponent) {
-      var state = node.memoizedState;
-
-      if (state !== null) {
-        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
-      }
-    } else if (node.tag === SuspenseListComponent) {
-      // If the tail is hidden there might not be an Suspense boundaries
-      // to schedule work on. In this case we have to schedule it on the
-      // list itself.
-      // We don't have to traverse to the children of the list since
-      // the list will propagate the change when it rerenders.
-      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
-    } else if (node.child !== null) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
-
-    if (node === workInProgress) {
-      return;
-    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  var flags = finishedWork.flags;
 
-    while (node.sibling === null) {
-      // $FlowFixMe[incompatible-use] found when upgrading Flow
-      if (node.return === null || node.return === workInProgress) {
-        return;
-      }
+  switch (finishedWork.tag) {
+    case OffscreenComponent: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
 
-      node = node.return;
-    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var current = finishedWork.alternate;
+        var instance = finishedWork.stateNode;
+        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+      }
 
-    node.sibling.return = node.return;
-    node = node.sibling;
-  }
-}
+      break;
+    }
 
-function findLastContentRow(firstChild) {
-  // This is going to find the last row among these children that is already
-  // showing content on the screen, as opposed to being in fallback state or
-  // new. If a row has multiple Suspense boundaries, any of them being in the
-  // fallback state, counts as the whole row being in a fallback state.
-  // Note that the "rows" will be workInProgress, but any nested children
-  // will still be current since we haven't rendered them yet. The mounted
-  // order may not be the same as the new order. We use the new order.
-  var row = firstChild;
-  var lastContentRow = null;
+    case CacheComponent: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
 
-  while (row !== null) {
-    var currentRow = row.alternate; // New rows can't be content rows.
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current5 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current5, finishedWork);
+      }
 
-    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
-      lastContentRow = row;
+      break;
     }
+    // eslint-disable-next-line-no-fallthrough
 
-    row = row.sibling;
+    default: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+      break;
+    }
   }
-
-  return lastContentRow;
 }
 
-function validateRevealOrder(revealOrder) {
-  {
-    if (
-      revealOrder !== undefined &&
-      revealOrder !== "forwards" &&
-      revealOrder !== "backwards" &&
-      revealOrder !== "together" &&
-      !didWarnAboutRevealOrder[revealOrder]
-    ) {
-      didWarnAboutRevealOrder[revealOrder] = true;
-
-      if (typeof revealOrder === "string") {
-        switch (revealOrder.toLowerCase()) {
-          case "together":
-          case "forwards":
-          case "backwards": {
-            error(
-              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
-                'Use lowercase "%s" instead.',
-              revealOrder,
-              revealOrder.toLowerCase()
-            );
+function commitPassiveUnmountEffects(finishedWork) {
+  setCurrentFiber(finishedWork);
+  commitPassiveUnmountOnFiber(finishedWork);
+  resetCurrentFiber();
+}
 
-            break;
-          }
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  var previousFiber = parentFiber.alternate;
 
-          case "forward":
-          case "backward": {
-            error(
-              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
-                'React uses the -s suffix in the spelling. Use "%ss" instead.',
-              revealOrder,
-              revealOrder.toLowerCase()
-            );
+  if (previousFiber !== null) {
+    var detachedChild = previousFiber.child;
 
-            break;
-          }
+    if (detachedChild !== null) {
+      previousFiber.child = null;
 
-          default:
-            error(
-              '"%s" is not a supported revealOrder on <SuspenseList />. ' +
-                'Did you mean "together", "forwards" or "backwards"?',
-              revealOrder
-            );
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        var detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-            break;
-        }
-      } else {
-        error(
-          "%s is not a supported value for revealOrder on <SuspenseList />. " +
-            'Did you mean "together", "forwards" or "backwards"?',
-          revealOrder
-        );
-      }
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
     }
   }
 }
 
-function validateTailOptions(tailMode, revealOrder) {
-  {
-    if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
-      if (tailMode !== "collapsed" && tailMode !== "hidden") {
-        didWarnAboutTailOptions[tailMode] = true;
+function commitHookPassiveUnmountEffects(
+  finishedWork,
+  nearestMountedAncestor,
+  hookFlags
+) {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+  }
+}
 
-        error(
-          '"%s" is not a supported value for tail on <SuspenseList />. ' +
-            'Did you mean "collapsed" or "hidden"?',
-          tailMode
-        );
-      } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
-        didWarnAboutTailOptions[tailMode] = true;
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  var deletions = parentFiber.deletions;
 
-        error(
-          '<SuspenseList tail="%s" /> is only valid if revealOrder is ' +
-            '"forwards" or "backwards". ' +
-            'Did you mean to specify revealOrder="forwards"?',
-          tailMode
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
+
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
         );
       }
     }
-  }
-}
 
-function validateSuspenseListNestedChild(childSlot, index) {
-  {
-    var isAnArray = isArray(childSlot);
-    var isIterable =
-      !isAnArray && typeof getIteratorFn(childSlot) === "function";
+    detachAlternateSiblings(parentFiber);
+  }
 
-    if (isAnArray || isIterable) {
-      var type = isAnArray ? "array" : "iterable";
+  var prevDebugFiber = getCurrentFiber(); // TODO: Split PassiveMask into separate masks for mount and unmount?
 
-      error(
-        "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " +
-          "an additional SuspenseList to configure its revealOrder: " +
-          "<SuspenseList revealOrder=...> ... " +
-          "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " +
-          "</SuspenseList>",
-        type,
-        index,
-        type
-      );
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-      return false;
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
     }
   }
 
-  return true;
+  setCurrentFiber(prevDebugFiber);
 }
 
-function validateSuspenseListChildren(children, revealOrder) {
-  {
-    if (
-      (revealOrder === "forwards" || revealOrder === "backwards") &&
-      children !== undefined &&
-      children !== null &&
-      children !== false
-    ) {
-      if (isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-          if (!validateSuspenseListNestedChild(children[i], i)) {
-            return;
-          }
-        }
-      } else {
-        var iteratorFn = getIteratorFn(children);
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
 
-        if (typeof iteratorFn === "function") {
-          var childrenIterator = iteratorFn.call(children);
+      if (finishedWork.flags & Passive$1) {
+        commitHookPassiveUnmountEffects(
+          finishedWork,
+          finishedWork.return,
+          Passive | HasEffect
+        );
+      }
 
-          if (childrenIterator) {
-            var step = childrenIterator.next();
-            var _i = 0;
+      break;
+    }
 
-            for (; !step.done; step = childrenIterator.next()) {
-              if (!validateSuspenseListNestedChild(step.value, _i)) {
-                return;
-              }
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
 
-              _i++;
-            }
-          }
-        } else {
-          error(
-            'A single row was passed to a <SuspenseList revealOrder="%s" />. ' +
-              "This is not useful since it needs multiple rows. " +
-              "Did you mean to pass multiple children or an array?",
-            revealOrder
-          );
-        }
+      if (
+        isHidden &&
+        instance._visibility & OffscreenPassiveEffectsConnected && // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        (finishedWork.return === null ||
+          finishedWork.return.tag !== SuspenseComponent)
+      ) {
+        // The effects are currently connected. Disconnect them.
+        // TODO: Add option or heuristic to delay before disconnecting the
+        // effects. Then if the tree reappears before the delay has elapsed, we
+        // can skip toggling the effects entirely.
+        instance._visibility &= ~OffscreenPassiveEffectsConnected;
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      } else {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
       }
-    }
-  }
-}
 
-function initSuspenseListRenderState(
-  workInProgress,
-  isBackwards,
-  tail,
-  lastContentRow,
-  tailMode
-) {
-  var renderState = workInProgress.memoizedState;
+      break;
+    }
 
-  if (renderState === null) {
-    workInProgress.memoizedState = {
-      isBackwards: isBackwards,
-      rendering: null,
-      renderingStartTime: 0,
-      last: lastContentRow,
-      tail: tail,
-      tailMode: tailMode
-    };
-  } else {
-    // We can reuse the existing object from previous renders.
-    renderState.isBackwards = isBackwards;
-    renderState.rendering = null;
-    renderState.renderingStartTime = 0;
-    renderState.last = lastContentRow;
-    renderState.tail = tail;
-    renderState.tailMode = tailMode;
+    default: {
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
+      break;
+    }
   }
-} // This can end up rendering this component multiple passes.
-// The first pass splits the children fibers into two sets. A head and tail.
-// We first render the head. If anything is in fallback state, we do another
-// pass through beginWork to rerender all children (including the tail) with
-// the force suspend context. If the first render didn't have anything in
-// in fallback state. Then we render each row in the tail one-by-one.
-// That happens in the completeWork phase without going back to beginWork.
+}
 
-function updateSuspenseListComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var revealOrder = nextProps.revealOrder;
-  var tailMode = nextProps.tail;
-  var newChildren = nextProps.children;
-  validateRevealOrder(revealOrder);
-  validateTailOptions(tailMode, revealOrder);
-  validateSuspenseListChildren(newChildren, revealOrder);
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  var suspenseContext = suspenseStackCursor.current;
-  var shouldForceFallback = hasSuspenseListContext(
-    suspenseContext,
-    ForceSuspenseFallback
-  );
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  var deletions = parentFiber.deletions;
 
-  if (shouldForceFallback) {
-    suspenseContext = setShallowSuspenseListContext(
-      suspenseContext,
-      ForceSuspenseFallback
-    );
-    workInProgress.flags |= DidCapture;
-  } else {
-    var didSuspendBefore =
-      current !== null && (current.flags & DidCapture) !== NoFlags$1;
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
 
-    if (didSuspendBefore) {
-      // If we previously forced a fallback, we need to schedule work
-      // on any nested boundaries to let them know to try to render
-      // again. This is the same as context updating.
-      propagateSuspenseContextChange(
-        workInProgress,
-        workInProgress.child,
-        renderLanes
-      );
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
     }
 
-    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+    detachAlternateSiblings(parentFiber);
   }
 
-  pushSuspenseListContext(workInProgress, suspenseContext);
-
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    // In legacy mode, SuspenseList doesn't work so we just
-    // use make it a noop by treating it as the default revealOrder.
-    workInProgress.memoizedState = null;
-  } else {
-    switch (revealOrder) {
-      case "forwards": {
-        var lastContentRow = findLastContentRow(workInProgress.child);
-        var tail;
+  var prevDebugFiber = getCurrentFiber(); // TODO: Check PassiveStatic flag
 
-        if (lastContentRow === null) {
-          // The whole list is part of the tail.
-          // TODO: We could fast path by just rendering the tail now.
-          tail = workInProgress.child;
-          workInProgress.child = null;
-        } else {
-          // Disconnect the tail rows after the content row.
-          // We're going to render them separately later.
-          tail = lastContentRow.sibling;
-          lastContentRow.sibling = null;
-        }
+  var child = parentFiber.child;
 
-        initSuspenseListRenderState(
-          workInProgress,
-          false, // isBackwards
-          tail,
-          lastContentRow,
-          tailMode
-        );
-        break;
-      }
+  while (child !== null) {
+    setCurrentFiber(child);
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
 
-      case "backwards": {
-        // We're going to find the first row that has existing content.
-        // At the same time we're going to reverse the list of everything
-        // we pass in the meantime. That's going to be our tail in reverse
-        // order.
-        var _tail = null;
-        var row = workInProgress.child;
-        workInProgress.child = null;
+  setCurrentFiber(prevDebugFiber);
+}
 
-        while (row !== null) {
-          var currentRow = row.alternate; // New rows can't be content rows.
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      // TODO: Check PassiveStatic flag
+      commitHookPassiveUnmountEffects(
+        finishedWork,
+        finishedWork.return,
+        Passive
+      ); // When disconnecting passive effects, we fire the effects in the same
+      // order as during a deletiong: parent before child
 
-          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
-            // This is the beginning of the main content.
-            workInProgress.child = row;
-            break;
-          }
+      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      break;
+    }
 
-          var nextRow = row.sibling;
-          row.sibling = _tail;
-          _tail = row;
-          row = nextRow;
-        } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
 
-        initSuspenseListRenderState(
-          workInProgress,
-          true, // isBackwards
-          _tail,
-          null, // last
-          tailMode
-        );
-        break;
+      if (instance._visibility & OffscreenPassiveEffectsConnected) {
+        instance._visibility &= ~OffscreenPassiveEffectsConnected;
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
       }
 
-      case "together": {
-        initSuspenseListRenderState(
-          workInProgress,
-          false, // isBackwards
-          null, // tail
-          null, // last
-          undefined
-        );
-        break;
-      }
+      break;
+    }
 
-      default: {
-        // The default reveal order is the same as not having
-        // a boundary.
-        workInProgress.memoizedState = null;
-      }
+    default: {
+      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      break;
     }
   }
-
-  return workInProgress.child;
 }
 
-function updatePortalComponent(current, workInProgress, renderLanes) {
-  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-  var nextChildren = workInProgress.pendingProps;
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+  deletedSubtreeRoot,
+  nearestMountedAncestor
+) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect; // Deletion effects fire in parent -> child order
+    // TODO: Check if fiber has a PassiveStatic flag
 
-  if (current === 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
-    // the root always starts with a "current" with a null child.
-    // TODO: Consider unifying this with how the root works.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  }
+    setCurrentFiber(fiber);
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    resetCurrentFiber();
+    var child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
 
-  return workInProgress.child;
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
+        deletedSubtreeRoot
+      );
+    }
+  }
 }
 
-var hasWarnedAboutUsingNoValuePropOnContextProvider = false;
-
-function updateContextProvider(current, workInProgress, renderLanes) {
-  var providerType = workInProgress.type;
-  var context = providerType._context;
-  var newProps = workInProgress.pendingProps;
-  var oldProps = workInProgress.memoizedProps;
-  var newValue = newProps.value;
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
+  deletedSubtreeRoot
+) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    var sibling = fiber.sibling;
+    var returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
 
-  {
-    if (!("value" in newProps)) {
-      if (!hasWarnedAboutUsingNoValuePropOnContextProvider) {
-        hasWarnedAboutUsingNoValuePropOnContextProvider = true;
+    detachFiberAfterEffects(fiber);
 
-        error(
-          "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
-        );
-      }
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
     }
 
-    var providerPropTypes = workInProgress.type.propTypes;
-
-    if (providerPropTypes) {
-      checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider");
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
     }
+
+    nextEffect = returnFiber;
   }
+}
 
-  pushProvider(workInProgress, context, newValue);
+function commitPassiveUnmountInsideDeletedTreeOnFiber(
+  current,
+  nearestMountedAncestor
+) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+      break;
+    }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
 
-  if (enableLazyContextPropagation);
-  else {
-    if (oldProps !== null) {
-      var oldValue = oldProps.value;
+    case LegacyHiddenComponent:
+    case OffscreenComponent: {
+      {
+        if (
+          current.memoizedState !== null &&
+          current.memoizedState.cachePool !== null
+        ) {
+          var cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+          // Note that this is only reached in the non-suspended/visible case:
+          // when the content is suspended/hidden, the retain/release occurs
+          // via the parent Suspense component (see case above).
 
-      if (objectIs(oldValue, newValue)) {
-        // No change. Bailout early if children are the same.
-        if (oldProps.children === newProps.children && !hasContextChanged()) {
-          return bailoutOnAlreadyFinishedWork(
-            current,
-            workInProgress,
-            renderLanes
-          );
+          if (cache != null) {
+            retainCache(cache);
+          }
         }
-      } else {
-        // The context value changed. Search for matching consumers and schedule
-        // them to update.
-        propagateContextChange(workInProgress, context, renderLanes);
       }
-    }
-  }
 
-  var newChildren = newProps.children;
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  return workInProgress.child;
-}
+      break;
+    }
 
-var hasWarnedAboutUsingContextAsConsumer = false;
+    case SuspenseComponent: {
+      if (enableTransitionTracing) {
+        // We need to mark this fiber's parents as deleted
+        var offscreenFiber = current.child;
+        var instance = offscreenFiber.stateNode;
+        var transitions = instance._transitions;
 
-function updateContextConsumer(current, workInProgress, renderLanes) {
-  var context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
-  // DEV mode, we create a separate object for Context.Consumer that acts
-  // like a proxy to Context. This proxy object adds unnecessary code in PROD
-  // so we use the old behaviour (Context.Consumer references Context) to
-  // reduce size and overhead. The separate object references context via
-  // a property called "_context", which also gives us the ability to check
-  // in DEV mode if this property exists or not and warn if it does not.
+        if (transitions !== null) {
+          var abortReason = {
+            reason: "suspense",
+            name: current.memoizedProps.unstable_name || null
+          };
 
-  {
-    if (context._context === undefined) {
-      // This may be because it's a Context (rather than a Consumer).
-      // Or it may be because it's older React where they're the same thing.
-      // We only want to warn if we're sure it's a new React.
-      if (context !== context.Consumer) {
-        if (!hasWarnedAboutUsingContextAsConsumer) {
-          hasWarnedAboutUsingContextAsConsumer = true;
+          if (
+            current.memoizedState === null ||
+            current.memoizedState.dehydrated === null
+          ) {
+            abortParentMarkerTransitionsForDeletedFiber(
+              offscreenFiber,
+              abortReason,
+              transitions,
+              instance,
+              true
+            );
 
-          error(
-            "Rendering <Context> directly is not supported and will be removed in " +
-              "a future major release. Did you mean to render <Context.Consumer> instead?"
-          );
+            if (nearestMountedAncestor !== null) {
+              abortParentMarkerTransitionsForDeletedFiber(
+                nearestMountedAncestor,
+                abortReason,
+                transitions,
+                instance,
+                false
+              );
+            }
+          }
         }
       }
-    } else {
-      context = context._context;
+
+      break;
     }
-  }
 
-  var newProps = workInProgress.pendingProps;
-  var render = newProps.children;
+    case CacheComponent: {
+      {
+        var _cache = current.memoizedState.cache;
+        releaseCache(_cache);
+      }
 
-  {
-    if (typeof render !== "function") {
-      error(
-        "A context consumer was rendered with multiple children, or a child " +
-          "that isn't a function. A context consumer expects a single child " +
-          "that is a function. If you did pass a function, make sure there " +
-          "is no trailing or leading whitespace around it."
-      );
+      break;
     }
-  }
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var newValue = readContext(context);
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        // We need to mark this fiber's parents as deleted
+        var _instance5 = current.stateNode;
+        var _transitions = _instance5.transitions;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+        if (_transitions !== null) {
+          var _abortReason = {
+            reason: "marker",
+            name: current.memoizedProps.name
+          };
+          abortParentMarkerTransitionsForDeletedFiber(
+            current,
+            _abortReason,
+            _transitions,
+            null,
+            true
+          );
 
-  var newChildren;
+          if (nearestMountedAncestor !== null) {
+            abortParentMarkerTransitionsForDeletedFiber(
+              nearestMountedAncestor,
+              _abortReason,
+              _transitions,
+              null,
+              false
+            );
+          }
+        }
+      }
 
-  {
-    ReactCurrentOwner$1.current = workInProgress;
-    setIsRendering(true);
-    newChildren = render(newValue);
-    setIsRendering(false);
+      break;
+    }
   }
-
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  return workInProgress.child;
 }
 
-function updateScopeComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+function invokeLayoutEffectMountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListMount(Layout | HasEffect, fiber);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-function markWorkInProgressReceivedUpdate() {
-  didReceiveUpdate = true;
-}
-function checkIfWorkInProgressReceivedUpdate() {
-  return didReceiveUpdate;
-}
+        break;
+      }
 
-function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    if (current !== null) {
-      // A lazy component only mounts if it suspended inside a non-
-      // concurrent tree, in an inconsistent state. We want to treat it like
-      // a new mount, even though an empty version of it already committed.
-      // Disconnect the alternate pointers.
-      current.alternate = null;
-      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+      case ClassComponent: {
+        var instance = fiber.stateNode;
 
-      workInProgress.flags |= Placement;
+        try {
+          instance.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
+
+        break;
+      }
     }
   }
 }
 
-function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
-  if (current !== null) {
-    // Reuse previous dependencies
-    workInProgress.dependencies = current.dependencies;
-  }
-
+function invokePassiveEffectMountInDEV(fiber) {
   {
-    // Don't update "base" render times for bailouts.
-    stopProfilerTimerIfRunning();
-  }
-
-  markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.
-
-  if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
-    // 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.
-    if (enableLazyContextPropagation && current !== null) {
-      // Before bailing out, check if there are any context changes in
-      // the children.
-      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListMount(Passive | HasEffect, fiber);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
-        return null;
+        break;
       }
-    } else {
-      return null;
     }
-  } // This fiber doesn't have work, but its subtree does. Clone the child
-  // fibers and continue.
-
-  cloneChildFibers(current, workInProgress);
-  return workInProgress.child;
+  }
 }
 
-function remountFiber(current, oldWorkInProgress, newWorkInProgress) {
+function invokeLayoutEffectUnmountInDEV(fiber) {
   {
-    var returnFiber = oldWorkInProgress.return;
-
-    if (returnFiber === null) {
-      // eslint-disable-next-line react-internal/prod-error-codes
-      throw new Error("Cannot swap the root fiber.");
-    } // Disconnect from the old current.
-    // It will get deleted.
-
-    current.alternate = null;
-    oldWorkInProgress.alternate = null; // Connect to the new tree.
-
-    newWorkInProgress.index = oldWorkInProgress.index;
-    newWorkInProgress.sibling = oldWorkInProgress.sibling;
-    newWorkInProgress.return = oldWorkInProgress.return;
-    newWorkInProgress.ref = oldWorkInProgress.ref; // Replace the child/sibling pointers above it.
-
-    if (oldWorkInProgress === returnFiber.child) {
-      returnFiber.child = newWorkInProgress;
-    } else {
-      var prevSibling = returnFiber.child;
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-      if (prevSibling === null) {
-        // eslint-disable-next-line react-internal/prod-error-codes
-        throw new Error("Expected parent to have a child.");
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+        break;
+      }
 
-      while (prevSibling.sibling !== oldWorkInProgress) {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        prevSibling = prevSibling.sibling;
+      case ClassComponent: {
+        var instance = fiber.stateNode;
 
-        if (prevSibling === null) {
-          // eslint-disable-next-line react-internal/prod-error-codes
-          throw new Error("Expected to find the previous sibling.");
+        if (typeof instance.componentWillUnmount === "function") {
+          safelyCallComponentWillUnmount(fiber, fiber.return, instance);
         }
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-      prevSibling.sibling = newWorkInProgress;
-    } // Delete the old fiber and place the new one.
-    // Since the old fiber is disconnected, we have to schedule it manually.
-
-    var deletions = returnFiber.deletions;
 
-    if (deletions === null) {
-      returnFiber.deletions = [current];
-      returnFiber.flags |= ChildDeletion;
-    } else {
-      deletions.push(current);
+        break;
+      }
     }
-
-    newWorkInProgress.flags |= Placement; // Restart work from the new fiber.
-
-    return newWorkInProgress;
   }
 }
 
-function checkScheduledUpdateOrContext(current, renderLanes) {
-  // Before performing an early bailout, we must check if there are pending
-  // updates or context.
-  var updateLanes = current.lanes;
-
-  if (includesSomeLane(updateLanes, renderLanes)) {
-    return true;
-  } // No pending update, but because context is propagated lazily, we need
-  // to check for a context change before we bail out.
-
-  if (enableLazyContextPropagation) {
-    var dependencies = current.dependencies;
-
-    if (dependencies !== null && checkIfContextChanged(dependencies)) {
-      return true;
+function invokePassiveEffectUnmountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
+      }
     }
   }
+}
 
-  return false;
+function getCacheSignal() {
+  var cache = readContext(CacheContext);
+  return cache.controller.signal;
 }
 
-function attemptEarlyBailoutIfNoScheduledUpdate(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  // 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);
-      pushRootTransition(workInProgress);
+function getCacheForType(resourceType) {
+  var cache = readContext(CacheContext);
+  var cacheForType = cache.data.get(resourceType);
 
-      if (enableTransitionTracing) {
-        pushRootMarkerInstance(workInProgress);
-      }
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
+  }
 
-      {
-        var cache = current.memoizedState.cache;
-        pushCacheProvider(workInProgress, cache);
-      }
+  return cacheForType;
+}
 
-      resetHydrationState();
-      break;
+var DefaultCacheDispatcher = {
+  getCacheSignal: getCacheSignal,
+  getCacheForType: getCacheForType
+};
 
-    case HostSingleton:
-    case HostComponent:
-      pushHostContext(workInProgress);
-      break;
+if (typeof Symbol === "function" && Symbol.for) {
+  var symbolFor = Symbol.for;
+  symbolFor("selector.component");
+  symbolFor("selector.has_pseudo_class");
+  symbolFor("selector.role");
+  symbolFor("selector.test_id");
+  symbolFor("selector.text");
+}
+var commitHooks = [];
+function onCommitRoot() {
+  {
+    commitHooks.forEach(function (commitHook) {
+      return commitHook();
+    });
+  }
+}
 
-    case ClassComponent: {
-      break;
-    }
+var ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;
+function isLegacyActEnvironment(fiber) {
+  {
+    // Legacy mode. We preserve the behavior of React 17's act. It assumes an
+    // act environment whenever `jest` is defined, but you can still turn off
+    // spurious warnings by setting IS_REACT_ACT_ENVIRONMENT explicitly
+    // to false.
+    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
+        ? IS_REACT_ACT_ENVIRONMENT
+        : undefined; // $FlowFixMe - Flow doesn't know about jest
 
-    case HostPortal:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      break;
+    var jestIsDefined = typeof jest !== "undefined";
+    return jestIsDefined && isReactActEnvironmentGlobal !== false;
+  }
+}
+function isConcurrentActEnvironment() {
+  {
+    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
+        ? IS_REACT_ACT_ENVIRONMENT
+        : undefined;
 
-    case ContextProvider: {
-      var newValue = workInProgress.memoizedProps.value;
-      var context = workInProgress.type._context;
-      pushProvider(workInProgress, context, newValue);
-      break;
+    if (
+      !isReactActEnvironmentGlobal &&
+      ReactCurrentActQueue$1.current !== null
+    ) {
+      // TODO: Include link to relevant documentation page.
+      error(
+        "The current testing environment is not configured to support " +
+          "act(...)"
+      );
     }
 
-    case Profiler:
-      {
-        // Profiler should only call onRender when one of its descendants actually rendered.
-        var hasChildWork = includesSomeLane(
-          renderLanes,
-          workInProgress.childLanes
-        );
+    return isReactActEnvironmentGlobal;
+  }
+}
 
-        if (hasChildWork) {
-          workInProgress.flags |= Update;
-        }
+var postPaintCallbackScheduled = false;
+var callbacks = [];
+function schedulePostPaintCallback(callback) {
+  callbacks.push(callback);
 
-        {
-          // Reset effect durations for the next eventual effect phase.
-          // These are reset during render to allow the DevTools commit hook a chance to read them,
-          var stateNode = workInProgress.stateNode;
-          stateNode.effectDuration = 0;
-          stateNode.passiveEffectDuration = 0;
-        }
+  if (!postPaintCallbackScheduled) {
+    postPaintCallbackScheduled = true;
+    requestPostPaintCallback(function (endTime) {
+      for (var i = 0; i < callbacks.length; i++) {
+        callbacks[i](endTime);
       }
 
-      break;
+      postPaintCallbackScheduled = false;
+      callbacks = [];
+    });
+  }
+}
 
-    case SuspenseComponent: {
-      var state = workInProgress.memoizedState;
+var ceil = Math.ceil;
+var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+  ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+var NoContext =
+  /*             */
+  0;
+var BatchedContext =
+  /*               */
+  1;
+var RenderContext =
+  /*         */
+  2;
+var CommitContext =
+  /*         */
+  4;
+var RootInProgress = 0;
+var RootFatalErrored = 1;
+var RootErrored = 2;
+var RootSuspended = 3;
+var RootSuspendedWithDelay = 4;
+var RootCompleted = 5;
+var RootDidNotComplete = 6; // Describes where we are in the React execution stack
 
-      if (state !== null) {
-        if (state.dehydrated !== null) {
-          // We're not going to render the children, so this is just to maintain
-          // push/pop symmetry
-          pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
-          // been unsuspended it has committed as a resolved Suspense component.
-          // If it needs to be retried, it should have work scheduled on it.
+var executionContext = NoContext; // The root we're working on
 
-          workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
-          // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+var workInProgressRoot = null; // The fiber we're working on
 
-          return null;
-        } // If this boundary is currently timed out, we need to decide
-        // whether to retry the primary children, or to skip over it and
-        // go straight to the fallback. Check the priority of the primary
-        // child fragment.
+var workInProgress = null; // The lanes we're rendering
 
-        var primaryChildFragment = workInProgress.child;
-        var primaryChildLanes = primaryChildFragment.childLanes;
+var workInProgressRootRenderLanes = NoLanes;
+var NotSuspended = 0;
+var SuspendedOnError = 1;
+var SuspendedOnData = 2;
+var SuspendedOnImmediate = 3;
+var SuspendedOnDeprecatedThrowPromise = 4;
+var SuspendedAndReadyToContinue = 5;
+var SuspendedOnHydration = 6; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
 
-        if (includesSomeLane(renderLanes, primaryChildLanes)) {
-          // The primary children have pending work. Use the normal path
-          // to attempt to render the primary children again.
-          return updateSuspenseComponent(current, workInProgress, renderLanes);
-        } else {
-          // The primary child fragment does not have pending work marked
-          // on it
-          pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
-          // priority. Bailout.
+var workInProgressSuspendedReason = NotSuspended;
+var workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
 
-          var child = bailoutOnAlreadyFinishedWork(
-            current,
-            workInProgress,
-            renderLanes
-          );
+var workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with renderLanes.
 
-          if (child !== null) {
-            // The fallback children have pending work. Skip over the
-            // primary children and work on the fallback.
-            return child.sibling;
-          } else {
-            // Note: We can return `null` here because we already checked
-            // whether there were nested context consumers, via the call to
-            // `bailoutOnAlreadyFinishedWork` above.
-            return null;
-          }
-        }
-      } else {
-        pushPrimaryTreeSuspenseHandler(workInProgress);
-      }
+var renderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
 
-      break;
-    }
+var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
 
-    case SuspenseListComponent: {
-      var didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
+var workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
 
-      var _hasChildWork = includesSomeLane(
-        renderLanes,
-        workInProgress.childLanes
-      );
+var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
 
-      if (enableLazyContextPropagation && !_hasChildWork) {
-        // Context changes may not have been propagated yet. We need to do
-        // that now, before we can decide whether to bail out.
-        // TODO: We use `childLanes` as a heuristic for whether there is
-        // remaining work in a few places, including
-        // `bailoutOnAlreadyFinishedWork` and
-        // `updateDehydratedSuspenseComponent`. We should maybe extract this
-        // into a dedicated function.
-        lazilyPropagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes
-        );
-        _hasChildWork = includesSomeLane(
-          renderLanes,
-          workInProgress.childLanes
-        );
-      }
+var workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
 
-      if (didSuspendBefore) {
-        if (_hasChildWork) {
-          // If something was in fallback state last time, and we have all the
-          // same children then we're still in progressive loading state.
-          // Something might get unblocked by state updates or retries in the
-          // tree which will affect the tail. So we need to use the normal
-          // path to compute the correct tail.
-          return updateSuspenseListComponent(
-            current,
-            workInProgress,
-            renderLanes
-          );
-        } // If none of the children had any work, that means that none of
-        // them got retried so they'll still be blocked in the same way
-        // as before. We can fast bail out.
+var workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.
 
-        workInProgress.flags |= DidCapture;
-      } // If nothing suspended before and we're rendering the same children,
-      // then the tail doesn't matter. Anything new that suspends will work
-      // in the "together" mode, so we can continue from the state we had.
+var workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
 
-      var renderState = workInProgress.memoizedState;
+var workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train
+// model where we don't commit new loading states in too quick succession.
 
-      if (renderState !== null) {
-        // Reset to the "together" mode in case we've started a different
-        // update in the past but didn't complete it.
-        renderState.rendering = null;
-        renderState.tail = null;
-        renderState.lastEffect = null;
-      }
+var globalMostRecentFallbackTime = 0;
+var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
 
-      pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
 
-      if (_hasChildWork) {
-        break;
-      } else {
-        // If none of the children had any work, that means that none of
-        // them got retried so they'll still be blocked in the same way
-        // as before. We can fast bail out.
-        return null;
-      }
+var RENDER_TIMEOUT_MS = 500;
+var workInProgressTransitions = null;
+function getWorkInProgressTransitions() {
+  return workInProgressTransitions;
+}
+var currentPendingTransitionCallbacks = null;
+var currentEndTime = null;
+function addTransitionStartCallbackToPendingTransition(transition) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: [],
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
     }
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      // Need to check if the tree still needs to be deferred. This is
-      // almost identical to the logic used in the normal update path,
-      // so we'll just enter that. The only difference is we'll bail out
-      // at the next level instead of this one, because the child props
-      // have not changed. Which is fine.
-      // TODO: Probably should refactor `beginWork` to split the bailout
-      // path from the normal path. I'm tempted to do a labeled break here
-      // but I won't :)
-      workInProgress.lanes = NoLanes;
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    if (currentPendingTransitionCallbacks.transitionStart === null) {
+      currentPendingTransitionCallbacks.transitionStart = [];
     }
 
-    case CacheComponent: {
-      {
-        var _cache = current.memoizedState.cache;
-        pushCacheProvider(workInProgress, _cache);
-      }
-
-      break;
+    currentPendingTransitionCallbacks.transitionStart.push(transition);
+  }
+}
+function addMarkerProgressCallbackToPendingTransition(
+  markerName,
+  transitions,
+  pendingBoundaries
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: new Map(),
+        markerIncomplete: null,
+        markerComplete: null
+      };
     }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        var instance = workInProgress.stateNode;
-
-        if (instance !== null) {
-          pushMarkerInstance(workInProgress, instance);
-        }
-      }
+    if (currentPendingTransitionCallbacks.markerProgress === null) {
+      currentPendingTransitionCallbacks.markerProgress = new Map();
     }
-  }
 
-  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
+      pendingBoundaries: pendingBoundaries,
+      transitions: transitions
+    });
+  }
 }
+function addMarkerIncompleteCallbackToPendingTransition(
+  markerName,
+  transitions,
+  aborts
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: new Map(),
+        markerComplete: null
+      };
+    }
 
-function beginWork$1(current, workInProgress, renderLanes) {
-  {
-    if (workInProgress._debugNeedsRemount && current !== null) {
-      // This will restart the begin phase with a new fiber.
-      return remountFiber(
-        current,
-        workInProgress,
-        createFiberFromTypeAndProps(
-          workInProgress.type,
-          workInProgress.key,
-          workInProgress.pendingProps,
-          workInProgress._debugOwner || null,
-          workInProgress.mode,
-          workInProgress.lanes
-        )
-      );
+    if (currentPendingTransitionCallbacks.markerIncomplete === null) {
+      currentPendingTransitionCallbacks.markerIncomplete = new Map();
     }
+
+    currentPendingTransitionCallbacks.markerIncomplete.set(markerName, {
+      transitions: transitions,
+      aborts: aborts
+    });
   }
+}
+function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: new Map()
+      };
+    }
 
-  if (current !== null) {
-    var oldProps = current.memoizedProps;
-    var newProps = workInProgress.pendingProps;
+    if (currentPendingTransitionCallbacks.markerComplete === null) {
+      currentPendingTransitionCallbacks.markerComplete = new Map();
+    }
 
-    if (
-      oldProps !== newProps ||
-      hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
-      workInProgress.type !== current.type
-    ) {
-      // If props or context changed, mark the fiber as having performed work.
-      // This may be unset if the props are determined to be equal later (memo).
-      didReceiveUpdate = true;
-    } else {
-      // Neither props nor legacy context changes. Check if there's a pending
-      // update or context change.
-      var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
-        current,
-        renderLanes
-      );
+    currentPendingTransitionCallbacks.markerComplete.set(
+      markerName,
+      transitions
+    );
+  }
+}
+function addTransitionProgressCallbackToPendingTransition(
+  transition,
+  boundaries
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: new Map(),
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
+    }
 
-      if (
-        !hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
-        // may not be work scheduled on `current`, so we check for this flag.
-        (workInProgress.flags & DidCapture) === NoFlags$1
-      ) {
-        // No pending updates or context. Bail out now.
-        didReceiveUpdate = false;
-        return attemptEarlyBailoutIfNoScheduledUpdate(
-          current,
-          workInProgress,
-          renderLanes
-        );
-      }
+    if (currentPendingTransitionCallbacks.transitionProgress === null) {
+      currentPendingTransitionCallbacks.transitionProgress = new Map();
+    }
 
-      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
-        // This is a special case that only exists for legacy mode.
-        // See https://github.com/facebook/react/pull/19216.
-        didReceiveUpdate = true;
-      } else {
-        // An update was scheduled on this fiber, but there are no new props
-        // nor legacy context. Set this to false. If an update queue or context
-        // consumer produces a changed value, it will set this to true. Otherwise,
-        // the component will assume the children have not changed and bail out.
-        didReceiveUpdate = false;
-      }
+    currentPendingTransitionCallbacks.transitionProgress.set(
+      transition,
+      boundaries
+    );
+  }
+}
+function addTransitionCompleteCallbackToPendingTransition(transition) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: [],
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
     }
-  } else {
-    didReceiveUpdate = false;
 
-    if (getIsHydrating() && isForkedChild(workInProgress)) {
-      // Check if this child belongs to a list of muliple children in
-      // its parent.
-      //
-      // In a true multi-threaded implementation, we would render children on
-      // parallel threads. This would represent the beginning of a new render
-      // thread for this subtree.
-      //
-      // We only use this for id generation during hydration, which is why the
-      // logic is located in this special branch.
-      var slotIndex = workInProgress.index;
-      var numberOfForks = getForksAtLevel();
-      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    if (currentPendingTransitionCallbacks.transitionComplete === null) {
+      currentPendingTransitionCallbacks.transitionComplete = [];
     }
-  } // Before entering the begin phase, clear pending update priority.
-  // TODO: This assumes that we're about to evaluate the component and process
-  // the update queue. However, there's an exception: SimpleMemoComponent
-  // sometimes bails out later in the begin phase. This indicates that we should
-  // move this assignment out of the common path and into each branch.
 
-  workInProgress.lanes = NoLanes;
+    currentPendingTransitionCallbacks.transitionComplete.push(transition);
+  }
+}
 
-  switch (workInProgress.tag) {
-    case IndeterminateComponent: {
-      return mountIndeterminateComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        renderLanes
-      );
-    }
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+}
 
-    case LazyComponent: {
-      var elementType = workInProgress.elementType;
-      return mountLazyComponent(
-        current,
-        workInProgress,
-        elementType,
-        renderLanes
-      );
-    }
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+var hasUncaughtError = false;
+var firstUncaughtError = null;
+var legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+// to track which root is currently committing layout effects.
 
-    case FunctionComponent: {
-      var Component = workInProgress.type;
-      var unresolvedProps = workInProgress.pendingProps;
-      var resolvedProps =
-        workInProgress.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      return updateFunctionComponent(
-        current,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-    }
+var rootCommittingMutationOrLayoutEffects = null;
+var rootDoesHavePassiveEffects = false;
+var rootWithPendingPassiveEffects = null;
+var pendingPassiveEffectsLanes = NoLanes;
+var pendingPassiveProfilerEffects = [];
+var pendingPassiveEffectsRemainingLanes = NoLanes;
+var pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+
+var NESTED_UPDATE_LIMIT = 50;
+var nestedUpdateCount = 0;
+var rootWithNestedUpdates = null;
+var isFlushingPassiveEffects = false;
+var didScheduleUpdateDuringPassiveEffects = false;
+var NESTED_PASSIVE_UPDATE_LIMIT = 50;
+var nestedPassiveUpdateCount = 0;
+var rootWithPassiveNestedUpdates = null; // If two updates are scheduled within the same event, we should treat their
+// event times as simultaneous, even if the actual clock time has advanced
+// between the first and second call.
+
+var currentEventTime = NoTimestamp;
+var currentEventTransitionLane = NoLanes;
+var isRunningInsertionEffect = false;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
+}
+function requestEventTime() {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    // We're inside React, so it's fine to read the actual time.
+    return now$1();
+  } // We're not inside React, so we may be in the middle of a browser event.
 
-    case ClassComponent: {
-      var _Component = workInProgress.type;
-      var _unresolvedProps = workInProgress.pendingProps;
+  if (currentEventTime !== NoTimestamp) {
+    // Use the same start time for all updates until we enter React again.
+    return currentEventTime;
+  } // This is the first update since React yielded. Compute a new start time.
 
-      var _resolvedProps =
-        workInProgress.elementType === _Component
-          ? _unresolvedProps
-          : resolveDefaultProps(_Component, _unresolvedProps);
+  currentEventTime = now$1();
+  return currentEventTime;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  var mode = fiber.mode;
 
-      return updateClassComponent(
-        current,
-        workInProgress,
-        _Component,
-        _resolvedProps,
-        renderLanes
-      );
-    }
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    (executionContext & RenderContext) !== NoContext &&
+    workInProgressRootRenderLanes !== NoLanes
+  ) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
+  }
 
-    case HostRoot:
-      return updateHostRoot(current, workInProgress, renderLanes);
+  var isTransition = requestCurrentTransition() !== NoTransition;
 
-    case HostHoistable: {
-      return updateHostHoistable(current, workInProgress);
-    }
+  if (isTransition) {
+    if (ReactCurrentBatchConfig$1.transition !== null) {
+      var transition = ReactCurrentBatchConfig$1.transition;
 
-    // eslint-disable-next-line no-fallthrough
+      if (!transition._updatedFibers) {
+        transition._updatedFibers = new Set();
+      }
 
-    case HostSingleton: {
-      return updateHostSingleton(current, workInProgress, renderLanes);
+      transition._updatedFibers.add(fiber);
+    } // The algorithm for assigning an update to a lane should be stable for all
+    // updates at the same priority within the same event. To do this, the
+    // inputs to the algorithm must be the same.
+    //
+    // The trick we use is to cache the first of each of these inputs within an
+    // event. Then reset the cached values once we can be sure the event is
+    // over. Our heuristic for that is whenever we enter a concurrent work loop.
+
+    if (currentEventTransitionLane === NoLane) {
+      // All transitions within the same event are assigned the same lane.
+      currentEventTransitionLane = claimNextTransitionLane();
     }
 
-    // eslint-disable-next-line no-fallthrough
+    return currentEventTransitionLane;
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
 
-    case HostComponent:
-      return updateHostComponent$1(current, workInProgress, renderLanes);
+  var updateLane = getCurrentUpdatePriority();
 
-    case HostText:
-      return updateHostText$1(current, workInProgress);
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
 
-    case SuspenseComponent:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
+  var eventLane = getCurrentEventPriority();
+  return eventLane;
+}
 
-    case HostPortal:
-      return updatePortalComponent(current, workInProgress, renderLanes);
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  var mode = fiber.mode;
 
-    case ForwardRef: {
-      var type = workInProgress.type;
-      var _unresolvedProps2 = workInProgress.pendingProps;
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  }
 
-      var _resolvedProps2 =
-        workInProgress.elementType === type
-          ? _unresolvedProps2
-          : resolveDefaultProps(type, _unresolvedProps2);
+  return claimNextRetryLane();
+}
 
-      return updateForwardRef(
-        current,
-        workInProgress,
-        type,
-        _resolvedProps2,
-        renderLanes
-      );
+function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+  {
+    if (isRunningInsertionEffect) {
+      error("useInsertionEffect must not schedule updates.");
     }
+  }
 
-    case Fragment:
-      return updateFragment(current, workInProgress, renderLanes);
+  {
+    if (isFlushingPassiveEffects) {
+      didScheduleUpdateDuringPassiveEffects = true;
+    }
+  } // Check if the work loop is currently suspended and waiting for data to
+  // finish loading.
 
-    case Mode:
-      return updateMode(current, workInProgress, renderLanes);
+  if (
+    workInProgressSuspendedReason === SuspendedOnData &&
+    root === workInProgressRoot
+  ) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes);
+  } // Mark that the root has a pending update.
 
-    case Profiler:
-      return updateProfiler(current, workInProgress, renderLanes);
+  markRootUpdated(root, lane, eventTime);
 
-    case ContextProvider:
-      return updateContextProvider(current, workInProgress, renderLanes);
+  if (
+    (executionContext & RenderContext) !== NoLanes &&
+    root === workInProgressRoot
+  ) {
+    // This update was dispatched during the render phase. This is a mistake
+    // if the update originates from user space (with the exception of local
+    // hook updates, which are handled differently and don't reach this
+    // function), but there are some internal React features that use this as
+    // an implementation detail, like selective hydration.
+    warnAboutRenderPhaseUpdatesInDEV(fiber); // Track lanes that were updated during the render phase
+  } else {
+    // This is a normal update, scheduled from outside the render phase. For
+    // example, during an input event.
+    {
+      if (isDevToolsPresent) {
+        addFiberToLanesMap(root, fiber, lane);
+      }
+    }
 
-    case ContextConsumer:
-      return updateContextConsumer(current, workInProgress, renderLanes);
+    warnIfUpdatesNotWrappedWithActDEV(fiber);
 
-    case MemoComponent: {
-      var _type2 = workInProgress.type;
-      var _unresolvedProps3 = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+    if (enableProfilerNestedUpdateScheduledHook) {
+      if (
+        (executionContext & CommitContext) !== NoContext &&
+        root === rootCommittingMutationOrLayoutEffects
+      ) {
+        if (fiber.mode & ProfileMode) {
+          var current = fiber;
 
-      var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
+          while (current !== null) {
+            if (current.tag === Profiler) {
+              var _current$memoizedProp = current.memoizedProps,
+                id = _current$memoizedProp.id,
+                onNestedUpdateScheduled =
+                  _current$memoizedProp.onNestedUpdateScheduled;
 
-      {
-        if (workInProgress.type !== workInProgress.elementType) {
-          var outerPropTypes = _type2.propTypes;
+              if (typeof onNestedUpdateScheduled === "function") {
+                onNestedUpdateScheduled(id);
+              }
+            }
 
-          if (outerPropTypes) {
-            checkPropTypes(
-              outerPropTypes,
-              _resolvedProps3, // Resolved for outer only
-              "prop",
-              getComponentNameFromType(_type2)
-            );
+            current = current.return;
           }
         }
       }
-
-      _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
-      return updateMemoComponent(
-        current,
-        workInProgress,
-        _type2,
-        _resolvedProps3,
-        renderLanes
-      );
-    }
-
-    case SimpleMemoComponent: {
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
-      );
     }
 
-    case IncompleteClassComponent: {
-      var _Component2 = workInProgress.type;
-      var _unresolvedProps4 = workInProgress.pendingProps;
-
-      var _resolvedProps4 =
-        workInProgress.elementType === _Component2
-          ? _unresolvedProps4
-          : resolveDefaultProps(_Component2, _unresolvedProps4);
-
-      return mountIncompleteClassComponent(
-        current,
-        workInProgress,
-        _Component2,
-        _resolvedProps4,
-        renderLanes
-      );
-    }
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig$1.transition;
 
-    case SuspenseListComponent: {
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    }
+      if (transition !== null && transition.name != null) {
+        if (transition.startTime === -1) {
+          transition.startTime = now$1();
+        }
 
-    case ScopeComponent: {
-      {
-        return updateScopeComponent(current, workInProgress, renderLanes);
+        addTransitionToLanesMap(root, transition, lane);
       }
     }
 
-    case OffscreenComponent: {
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    }
-
-    case LegacyHiddenComponent: {
-      {
-        return updateLegacyHiddenComponent(
-          current,
-          workInProgress,
-          renderLanes
+    if (root === workInProgressRoot) {
+      // Received an update to a tree that's in the middle of rendering. Mark
+      // that there was an interleaved update work on this root. Unless the
+      // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
+      // phase update. In that case, we don't treat render phase updates as if
+      // they were interleaved, for backwards compat reasons.
+      if (
+        deferRenderPhaseUpdateToNextBatch ||
+        (executionContext & RenderContext) === NoContext
+      ) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(
+          workInProgressRootInterleavedUpdatedLanes,
+          lane
         );
       }
-    }
 
-    case CacheComponent: {
-      {
-        return updateCacheComponent(current, workInProgress, renderLanes);
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes);
       }
     }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        return updateTracingMarkerComponent(
-          current,
-          workInProgress,
-          renderLanes
-        );
-      }
+    ensureRootIsScheduled(root, eventTime);
 
-      break;
+    if (
+      lane === SyncLane &&
+      executionContext === NoContext &&
+      (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+      !ReactCurrentActQueue.isBatchingLegacy
+    ) {
+      // Flush the synchronous work now, unless we're already working or inside
+      // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+      // scheduleCallbackForFiber to preserve the ability to schedule a callback
+      // without immediately flushing it. We only do this for user-initiated
+      // updates, to preserve historical behavior of legacy mode.
+      resetRenderTimer();
+      flushSyncCallbacksOnlyInLegacyMode();
     }
   }
-
-  throw new Error(
-    "Unknown unit of work tag (" +
-      workInProgress.tag +
-      "). This error is likely caused by a bug in " +
-      "React. Please file an issue."
-  );
-}
-
-var valueCursor = createCursor(null);
-var rendererCursorDEV;
-
-{
-  rendererCursorDEV = createCursor(null);
-}
-
-var rendererSigil;
-
-{
-  // Use this to detect multiple renderers using the same context
-  rendererSigil = {};
-}
-
-var currentlyRenderingFiber = null;
-var lastContextDependency = null;
-var lastFullyObservedContext = null;
-var isDisallowedContextReadInDEV = false;
-function resetContextDependencies() {
-  // This is called right before React yields execution, to ensure `readContext`
-  // cannot be called outside the render phase.
-  currentlyRenderingFiber = null;
-  lastContextDependency = null;
-  lastFullyObservedContext = null;
-
-  {
-    isDisallowedContextReadInDEV = false;
-  }
-}
-function enterDisallowedContextReadInDEV() {
-  {
-    isDisallowedContextReadInDEV = true;
-  }
 }
-function exitDisallowedContextReadInDEV() {
-  {
-    isDisallowedContextReadInDEV = false;
-  }
+function scheduleInitialHydrationOnRoot(root, lane, eventTime) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
+  //
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  var current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane, eventTime);
+  ensureRootIsScheduled(root, eventTime);
 }
-function pushProvider(providerFiber, context, nextValue) {
-  {
-    push(valueCursor, context._currentValue, providerFiber);
-    context._currentValue = nextValue;
-
-    {
-      push(rendererCursorDEV, context._currentRenderer, providerFiber);
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (
+    // TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We
+    // decided not to enable it.
+    (!deferRenderPhaseUpdateToNextBatch ||
+      (fiber.mode & ConcurrentMode) === NoMode) &&
+    (executionContext & RenderContext) !== NoContext
+  );
+} // Use this function to schedule a task for a root. There's only one task per
+// root; if a task was already scheduled, we'll check to make sure the priority
+// of the existing task is the same as the priority of the next level that the
+// root has work on. This function is called on every update, and right before
+// exiting a task.
 
-      if (
-        context._currentRenderer !== undefined &&
-        context._currentRenderer !== null &&
-        context._currentRenderer !== rendererSigil
-      ) {
-        error(
-          "Detected multiple renderers concurrently rendering the " +
-            "same context provider. This is currently unsupported."
-        );
-      }
+function ensureRootIsScheduled(root, currentTime) {
+  var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
 
-      context._currentRenderer = rendererSigil;
-    }
-  }
-}
-function popProvider(context, providerFiber) {
-  var currentValue = valueCursor.current;
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
 
-  {
-    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
-      context._currentValue = context._defaultValue;
-    } else {
-      context._currentValue = currentValue;
-    }
+  var nextLanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
+  );
 
-    {
-      var currentRenderer = rendererCursorDEV.current;
-      pop(rendererCursorDEV, providerFiber);
-      context._currentRenderer = currentRenderer;
+  if (nextLanes === NoLanes) {
+    // Special case: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
     }
-  }
 
-  pop(valueCursor, providerFiber);
-}
-function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
-  // Update the child lanes of all the ancestors, including the alternates.
-  var node = parent;
-
-  while (node !== null) {
-    var alternate = node.alternate;
-
-    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
-      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
+    return;
+  } // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
 
-      if (alternate !== null) {
-        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
-      }
-    } else if (
-      alternate !== null &&
-      !isSubsetOfLanes(alternate.childLanes, renderLanes)
-    ) {
-      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
-    } else;
+  if (
+    workInProgressSuspendedReason === SuspendedOnData &&
+    workInProgressRoot === root
+  ) {
+    root.callbackPriority = NoLane;
+    root.callbackNode = null;
+    return;
+  } // We use the highest priority lane to represent the priority of the callback.
 
-    if (node === propagationRoot) {
-      break;
-    }
+  var newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.
 
-    node = node.return;
-  }
+  var existingCallbackPriority = root.callbackPriority;
 
-  {
-    if (node !== propagationRoot) {
-      error(
-        "Expected to find the propagation root when scheduling context work. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
-    }
-  }
-}
-function propagateContextChange(workInProgress, context, renderLanes) {
-  if (enableLazyContextPropagation) {
-    // TODO: This path is only used by Cache components. Update
-    // lazilyPropagateParentContextChanges to look for Cache components so they
-    // can take advantage of lazy propagation.
-    var forcePropagateEntireTree = true;
-    propagateContextChanges(
-      workInProgress,
-      [context],
-      renderLanes,
-      forcePropagateEntireTree
-    );
-  } else {
-    propagateContextChange_eager(workInProgress, context, renderLanes);
-  }
-}
+  if (
+    existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-scheduled
+    // on the `act` queue.
+    !(
+      ReactCurrentActQueue.current !== null &&
+      existingCallbackNode !== fakeActCallbackNode
+    )
+  ) {
+    {
+      // If we're going to re-use an existing task, it needs to exist.
+      // Assume that discrete update microtasks are non-cancellable and null.
+      // TODO: Temporary until we confirm this warning is not fired.
+      if (
+        existingCallbackNode == null &&
+        !includesSyncLane(existingCallbackPriority)
+      ) {
+        error(
+          "Expected scheduled callback to exist. This error is likely caused by a bug in React. Please file an issue."
+        );
+      }
+    } // The priority hasn't changed. We can reuse the existing task. Exit.
 
-function propagateContextChange_eager(workInProgress, context, renderLanes) {
-  // Only used by eager implementation
-  if (enableLazyContextPropagation) {
     return;
   }
 
-  var fiber = workInProgress.child;
+  if (existingCallbackNode != null) {
+    // Cancel the existing callback. We'll schedule a new one below.
+    cancelCallback(existingCallbackNode);
+  } // Schedule a new callback.
 
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
-  }
+  var newCallbackNode;
 
-  while (fiber !== null) {
-    var nextFiber = void 0; // Visit this fiber.
+  if (includesSyncLane(newCallbackPriority)) {
+    // Special case: Sync React callbacks are scheduled on a special
+    // internal queue
+    if (root.tag === LegacyRoot) {
+      if (ReactCurrentActQueue.isBatchingLegacy !== null) {
+        ReactCurrentActQueue.didScheduleLegacyUpdate = true;
+      }
 
-    var list = fiber.dependencies;
+      scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));
+    } else {
+      scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
+    }
 
-    if (list !== null) {
-      nextFiber = fiber.child;
-      var dependency = list.firstContext;
+    {
+      // Flush the queue in a microtask.
+      if (ReactCurrentActQueue.current !== null) {
+        // Inside `act`, use our internal `act` queue so that these get flushed
+        // at the end of the current scope even when using the sync version
+        // of `act`.
+        ReactCurrentActQueue.current.push(flushSyncCallbacks);
+      } else {
+        scheduleMicrotask(function () {
+          // In Safari, appending an iframe forces microtasks to run.
+          // https://github.com/facebook/react/issues/22459
+          // We don't support running callbacks in the middle of render
+          // or commit so we need to check against that.
+          if (
+            (executionContext & (RenderContext | CommitContext)) ===
+            NoContext
+          ) {
+            // Note that this would still prematurely flush the callbacks
+            // if this happens outside render or commit phase (e.g. in an event).
+            flushSyncCallbacks();
+          }
+        });
+      }
+    }
 
-      while (dependency !== null) {
-        // Check if the context matches.
-        if (dependency.context === context) {
-          // Match! Schedule an update on this fiber.
-          if (fiber.tag === ClassComponent) {
-            // Schedule a force update on the work-in-progress.
-            var lane = pickArbitraryLane(renderLanes);
-            var update = createUpdate(lane);
-            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
-            // update to the current fiber, too, which means it will persist even if
-            // this render is thrown away. Since it's a race condition, not sure it's
-            // worth fixing.
-            // Inlined `enqueueUpdate` to remove interleaved update check
+    newCallbackNode = null;
+  } else {
+    var schedulerPriorityLevel;
 
-            var updateQueue = fiber.updateQueue;
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
+        break;
 
-            if (updateQueue === null);
-            else {
-              var sharedQueue = updateQueue.shared;
-              var pending = sharedQueue.pending;
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
 
-              if (pending === null) {
-                // This is the first update. Create a circular list.
-                update.next = update;
-              } else {
-                update.next = pending.next;
-                pending.next = update;
-              }
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
 
-              sharedQueue.pending = update;
-            }
-          }
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
 
-          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
-          var alternate = fiber.alternate;
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
+    }
 
-          if (alternate !== null) {
-            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-          }
+    newCallbackNode = scheduleCallback(
+      schedulerPriorityLevel,
+      performConcurrentWorkOnRoot.bind(null, root)
+    );
+  }
 
-          scheduleContextWorkOnParentPath(
-            fiber.return,
-            renderLanes,
-            workInProgress
-          ); // Mark the updated lanes on the list, too.
+  root.callbackPriority = newCallbackPriority;
+  root.callbackNode = newCallbackNode;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
 
-          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
-          // dependency list.
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  {
+    resetNestedUpdateFlag();
+  } // Since we know we're in a React event, we can clear the current
+  // event time. The next update will compute a new event time.
 
-          break;
-        }
+  currentEventTime = NoTimestamp;
+  currentEventTransitionLane = NoLanes;
 
-        dependency = dependency.next;
-      }
-    } else if (fiber.tag === ContextProvider) {
-      // Don't scan deeper if this is a matching provider
-      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-    } else if (fiber.tag === DehydratedFragment) {
-      // If a dehydrated suspense boundary is in this subtree, we don't know
-      // if it will have any context consumers in it. The best we can do is
-      // mark it as having updates.
-      var parentSuspense = fiber.return;
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
 
-      if (parentSuspense === null) {
-        throw new Error(
-          "We just came from a parent so we must have had a parent. This is a bug in React."
-        );
-      }
+  var originalCallbackNode = root.callbackNode;
+  var didFlushPassiveEffects = flushPassiveEffects();
 
-      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
-      var _alternate = parentSuspense.alternate;
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
+    }
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
 
-      if (_alternate !== null) {
-        _alternate.lanes = mergeLanes(_alternate.lanes, renderLanes);
-      } // This is intentionally passing this fiber as the parent
-      // because we want to schedule this fiber as having work
-      // on its children. We'll use the childLanes on
-      // this fiber to indicate that a context has changed.
+  var lanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
+  );
 
-      scheduleContextWorkOnParentPath(
-        parentSuspense,
-        renderLanes,
-        workInProgress
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
+
+  var shouldTimeSlice =
+    !includesBlockingLane(root, lanes) &&
+    !includesExpiredLane(root, lanes) &&
+    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
+  var exitStatus = shouldTimeSlice
+    ? renderRootConcurrent(root, lanes)
+    : renderRootSync(root, lanes);
+
+  if (exitStatus !== RootInProgress) {
+    if (exitStatus === RootErrored) {
+      // If something threw an error, try rendering one more time. We'll
+      // render synchronously to block concurrent data mutations, and we'll
+      // includes all pending updates are included. If it still fails after
+      // the second attempt, we'll give up and commit the resulting tree.
+      var originallyAttemptedLanes = lanes;
+      var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+        root,
+        originallyAttemptedLanes
       );
-      nextFiber = fiber.sibling;
-    } else {
-      // Traverse down.
-      nextFiber = fiber.child;
+
+      if (errorRetryLanes !== NoLanes) {
+        lanes = errorRetryLanes;
+        exitStatus = recoverFromConcurrentError(
+          root,
+          originallyAttemptedLanes,
+          errorRetryLanes
+        );
+      }
     }
 
-    if (nextFiber !== null) {
-      // Set the return pointer of the child to the work-in-progress fiber.
-      nextFiber.return = fiber;
+    if (exitStatus === RootFatalErrored) {
+      var fatalError = workInProgressRootFatalError;
+      prepareFreshStack(root, NoLanes);
+      markRootSuspended(root, lanes);
+      ensureRootIsScheduled(root, now$1());
+      throw fatalError;
+    }
+
+    if (exitStatus === RootDidNotComplete) {
+      // The render unwound without completing the tree. This happens in special
+      // cases where need to exit the current render without producing a
+      // consistent tree or committing.
+      markRootSuspended(root, lanes);
     } else {
-      // No child. Traverse to next sibling.
-      nextFiber = fiber;
+      // The render completed.
+      // Check if this render may have yielded to a concurrent event, and if so,
+      // confirm that any newly rendered stores are consistent.
+      // TODO: It's possible that even a concurrent render may never have yielded
+      // to the main thread, if it was fast enough, or if it expired. We could
+      // skip the consistency check in that case, too.
+      var renderWasConcurrent = !includesBlockingLane(root, lanes);
+      var finishedWork = root.current.alternate;
 
-      while (nextFiber !== null) {
-        if (nextFiber === workInProgress) {
-          // We're back to the root of this subtree. Exit.
-          nextFiber = null;
-          break;
-        }
+      if (
+        renderWasConcurrent &&
+        !isRenderConsistentWithExternalStores(finishedWork)
+      ) {
+        // A store was mutated in an interleaved event. Render again,
+        // synchronously, to block further mutations.
+        exitStatus = renderRootSync(root, lanes); // We need to check again if something threw
 
-        var sibling = nextFiber.sibling;
+        if (exitStatus === RootErrored) {
+          var _originallyAttemptedLanes = lanes;
 
-        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.
+          var _errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+            root,
+            _originallyAttemptedLanes
+          );
 
-        nextFiber = nextFiber.return;
-      }
-    }
+          if (_errorRetryLanes !== NoLanes) {
+            lanes = _errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(
+              root,
+              _originallyAttemptedLanes,
+              _errorRetryLanes
+            ); // We assume the tree is now consistent because we didn't yield to any
+            // concurrent events.
+          }
+        }
 
-    fiber = nextFiber;
-  }
-}
+        if (exitStatus === RootFatalErrored) {
+          var _fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes);
+          ensureRootIsScheduled(root, now$1());
+          throw _fatalError;
+        } // FIXME: Need to check for RootDidNotComplete again. The factoring here
+        // isn't ideal.
+      } // We now have a consistent tree. The next step is either to commit it,
+      // or, if something suspended, wait to commit it after a timeout.
 
-function propagateContextChanges(
-  workInProgress,
-  contexts,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  // Only used by lazy implementation
-  if (!enableLazyContextPropagation) {
-    return;
+      root.finishedWork = finishedWork;
+      root.finishedLanes = lanes;
+      finishConcurrentRender(root, exitStatus, lanes);
+    }
   }
 
-  var fiber = workInProgress.child;
+  ensureRootIsScheduled(root, now$1());
 
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
   }
 
-  while (fiber !== null) {
-    var nextFiber = void 0; // Visit this fiber.
-
-    var list = fiber.dependencies;
-
-    if (list !== null) {
-      nextFiber = fiber.child;
-      var dep = list.firstContext;
+  return null;
+}
 
-      findChangedDep: while (dep !== null) {
-        // Assigning these to constants to help Flow
-        var dependency = dep;
-        var consumer = fiber;
+function recoverFromConcurrentError(
+  root,
+  originallyAttemptedLanes,
+  errorRetryLanes
+) {
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  var wasRootDehydrated = isRootDehydrated(root);
 
-        for (var i = 0; i < contexts.length; i++) {
-          var context = contexts[i]; // Check if the context matches.
-          // TODO: Compare selected values to bail out early.
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    var rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
 
-          if (dependency.context === context) {
-            // Match! Schedule an update on this fiber.
-            // In the lazy implementation, don't mark a dirty flag on the
-            // dependency itself. Not all changes are propagated, so we can't
-            // rely on the propagation function alone to determine whether
-            // something has changed; the consumer will check. In the future, we
-            // could add back a dirty flag as an optimization to avoid double
-            // checking, but until we have selectors it's not really worth
-            // the trouble.
-            consumer.lanes = mergeLanes(consumer.lanes, renderLanes);
-            var alternate = consumer.alternate;
+    {
+      errorHydratingContainer(root.containerInfo);
+    }
+  }
 
-            if (alternate !== null) {
-              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-            }
+  var exitStatus = renderRootSync(root, errorRetryLanes);
 
-            scheduleContextWorkOnParentPath(
-              consumer.return,
-              renderLanes,
-              workInProgress
-            );
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(
+        root.errorRecoveryDisabledLanes,
+        originallyAttemptedLanes
+      ); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
 
-            if (!forcePropagateEntireTree) {
-              // During lazy propagation, when we find a match, we can defer
-              // propagating changes to the children, because we're going to
-              // visit them during render. We should continue propagating the
-              // siblings, though
-              nextFiber = null;
-            } // Since we already found a match, we can stop traversing the
-            // dependency list.
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
 
-            break findChangedDep;
-          }
-        }
+    var errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
 
-        dep = dependency.next;
-      }
-    } else if (fiber.tag === DehydratedFragment) {
-      // If a dehydrated suspense boundary is in this subtree, we don't know
-      // if it will have any context consumers in it. The best we can do is
-      // mark it as having updates.
-      var parentSuspense = fiber.return;
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
+  }
 
-      if (parentSuspense === null) {
-        throw new Error(
-          "We just came from a parent so we must have had a parent. This is a bug in React."
-        );
-      }
+  return exitStatus;
+}
 
-      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
-      var _alternate2 = parentSuspense.alternate;
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(
+      workInProgressRootRecoverableErrors,
+      errors
+    );
+  }
+}
 
-      if (_alternate2 !== null) {
-        _alternate2.lanes = mergeLanes(_alternate2.lanes, renderLanes);
-      } // This is intentionally passing this fiber as the parent
-      // because we want to schedule this fiber as having work
-      // on its children. We'll use the childLanes on
-      // this fiber to indicate that a context has changed.
+function finishConcurrentRender(root, exitStatus, lanes) {
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored: {
+      throw new Error("Root did not complete. This is a bug in React.");
+    }
+    // Flow knows about invariant, so it complains if I add a break
+    // statement, but eslint doesn't know about invariant, so it complains
+    // if I do. eslint-disable-next-line no-fallthrough
 
-      scheduleContextWorkOnParentPath(
-        parentSuspense,
-        renderLanes,
-        workInProgress
+    case RootErrored: {
+      // We should have already attempted to retry this tree. If we reached
+      // this point, it errored again. Commit it.
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
       );
-      nextFiber = null;
-    } else {
-      // 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;
+    case RootSuspended: {
+      markRootSuspended(root, lanes); // We have an acceptable loading state. We need to figure out if we
+      // should immediately commit it or wait a bit.
+
+      if (
+        includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
+        !shouldForceFlushFallbacksInDEV()
+      ) {
+        // This render only included retries, no updates. Throttle committing
+        // retries so that we don't show too many loading states too quickly.
+        var msUntilTimeout =
+          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
+
+        if (msUntilTimeout > 10) {
+          var nextLanes = getNextLanes(root, NoLanes);
+
+          if (nextLanes !== NoLanes) {
+            // There's additional work on this root.
+            break;
+          } // The render is suspended, it hasn't timed out, and there's no
+          // lower priority work to do. Instead of committing the fallback
+          // immediately, wait for more data to arrive.
 
-      while (nextFiber !== null) {
-        if (nextFiber === workInProgress) {
-          // We're back to the root of this subtree. Exit.
-          nextFiber = null;
+          root.timeoutHandle = scheduleTimeout(
+            commitRoot.bind(
+              null,
+              root,
+              workInProgressRootRecoverableErrors,
+              workInProgressTransitions
+            ),
+            msUntilTimeout
+          );
           break;
         }
+      } // The work expired. Commit immediately.
 
-        var sibling = nextFiber.sibling;
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
+    }
 
-        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.
+    case RootSuspendedWithDelay: {
+      markRootSuspended(root, lanes);
 
-        nextFiber = nextFiber.return;
+      if (includesOnlyTransitions(lanes)) {
+        // This is a transition, so we should exit without committing a
+        // placeholder and without scheduling a timeout. Delay indefinitely
+        // until we receive more data.
+        break;
       }
-    }
 
-    fiber = nextFiber;
-  }
-}
+      if (!shouldForceFlushFallbacksInDEV()) {
+        // This is not a transition, but we did trigger an avoided state.
+        // Schedule a placeholder to display after a short delay, using the Just
+        // Noticeable Difference.
+        // TODO: Is the JND optimization worth the added complexity? If this is
+        // the only reason we track the event time, then probably not.
+        // Consider removing.
+        var mostRecentEventTime = getMostRecentEventTime(root, lanes);
+        var eventTimeMs = mostRecentEventTime;
+        var timeElapsedMs = now$1() - eventTimeMs;
 
-function lazilyPropagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  var forcePropagateEntireTree = false;
-  propagateParentContextChanges(
-    current,
-    workInProgress,
-    renderLanes,
-    forcePropagateEntireTree
-  );
-} // Used for propagating a deferred tree (Suspense, Offscreen). We must propagate
-// to the entire subtree, because we won't revisit it until after the current
-// render has completed, at which point we'll have lost track of which providers
-// have changed.
+        var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
 
-function propagateParentContextChangesToDeferredTree(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  var forcePropagateEntireTree = true;
-  propagateParentContextChanges(
-    current,
-    workInProgress,
-    renderLanes,
-    forcePropagateEntireTree
-  );
-}
+        if (_msUntilTimeout > 10) {
+          // Instead of committing the fallback immediately, wait for more data
+          // to arrive.
+          root.timeoutHandle = scheduleTimeout(
+            commitRoot.bind(
+              null,
+              root,
+              workInProgressRootRecoverableErrors,
+              workInProgressTransitions
+            ),
+            _msUntilTimeout
+          );
+          break;
+        }
+      } // Commit the placeholder.
 
-function propagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (!enableLazyContextPropagation) {
-    return;
-  } // Collect all the parent providers that changed. Since this is usually small
-  // number, we use an Array instead of Set.
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
+    }
 
-  var contexts = null;
-  var parent = workInProgress;
-  var isInsidePropagationBailout = false;
+    case RootCompleted: {
+      // The work completed. Ready to commit.
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
+    }
 
-  while (parent !== null) {
-    if (!isInsidePropagationBailout) {
-      if ((parent.flags & NeedsPropagation) !== NoFlags$1) {
-        isInsidePropagationBailout = true;
-      } else if ((parent.flags & DidPropagateContext) !== NoFlags$1) {
-        break;
-      }
+    default: {
+      throw new Error("Unknown root exit status.");
     }
+  }
+}
 
-    if (parent.tag === ContextProvider) {
-      var currentParent = parent.alternate;
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  var node = finishedWork;
 
-      if (currentParent === null) {
-        throw new Error("Should have a current fiber. This is a bug in React.");
-      }
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      var updateQueue = node.updateQueue;
 
-      var oldProps = currentParent.memoizedProps;
+      if (updateQueue !== null) {
+        var checks = updateQueue.stores;
 
-      if (oldProps !== null) {
-        var providerType = parent.type;
-        var context = providerType._context;
-        var newProps = parent.pendingProps;
-        var newValue = newProps.value;
-        var oldValue = oldProps.value;
+        if (checks !== null) {
+          for (var i = 0; i < checks.length; i++) {
+            var check = checks[i];
+            var getSnapshot = check.getSnapshot;
+            var renderedValue = check.value;
 
-        if (!objectIs(newValue, oldValue)) {
-          if (contexts !== null) {
-            contexts.push(context);
-          } else {
-            contexts = [context];
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
           }
         }
       }
     }
 
-    parent = parent.return;
-  }
-
-  if (contexts !== null) {
-    // If there were any changed providers, search through the children and
-    // propagate their changes.
-    propagateContextChanges(
-      workInProgress,
-      contexts,
-      renderLanes,
-      forcePropagateEntireTree
-    );
-  } // This is an optimization so that we only propagate once per subtree. If a
-  // deeply nested child bails out, and it calls this propagation function, it
-  // uses this flag to know that the remaining ancestor providers have already
-  // been propagated.
-  //
-  // NOTE: This optimization is only necessary because we sometimes enter the
-  // begin phase of nodes that don't have any work scheduled on them —
-  // specifically, the siblings of a node that _does_ have scheduled work. The
-  // siblings will bail out and call this function again, even though we already
-  // propagated content changes to it and its subtree. So we use this flag to
-  // mark that the parent providers already propagated.
-  //
-  // Unfortunately, though, we need to ignore this flag when we're inside a
-  // tree whose context propagation was deferred — that's what the
-  // `NeedsPropagation` flag is for.
-  //
-  // If we could instead bail out before entering the siblings' begin phase,
-  // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
-  // Consider this as part of the next refactor to the fiber tree structure.
-
-  workInProgress.flags |= DidPropagateContext;
-}
+    var child = node.child;
 
-function checkIfContextChanged(currentDependencies) {
-  if (!enableLazyContextPropagation) {
-    return false;
-  } // Iterate over the current dependencies to see if something changed. This
-  // only gets called if props and state has already bailed out, so it's a
-  // relatively uncommon path, except at the root of a changed subtree.
-  // Alternatively, we could move these comparisons into `readContext`, but
-  // that's a much hotter path, so I think this is an appropriate trade off.
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
+    }
 
-  var dependency = currentDependencies.firstContext;
+    if (node === finishedWork) {
+      return true;
+    }
 
-  while (dependency !== null) {
-    var context = dependency.context;
-    var newValue = context._currentValue;
-    var oldValue = dependency.memoizedValue;
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
+      }
 
-    if (!objectIs(newValue, oldValue)) {
-      return true;
+      node = node.return;
     }
 
-    dependency = dependency.next;
-  }
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
 
-  return false;
+  return true;
 }
-function prepareToReadContext(workInProgress, renderLanes) {
-  currentlyRenderingFiber = workInProgress;
-  lastContextDependency = null;
-  lastFullyObservedContext = null;
-  var dependencies = workInProgress.dependencies;
-
-  if (dependencies !== null) {
-    if (enableLazyContextPropagation) {
-      // Reset the work-in-progress list
-      dependencies.firstContext = null;
-    } else {
-      var firstContext = dependencies.firstContext;
 
-      if (firstContext !== null) {
-        if (includesSomeLane(dependencies.lanes, renderLanes)) {
-          // Context list has a pending update. Mark that this fiber performed work.
-          markWorkInProgressReceivedUpdate();
-        } // Reset the work-in-progress list
+function markRootSuspended(root, suspendedLanes) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(
+    suspendedLanes,
+    workInProgressRootInterleavedUpdatedLanes
+  );
+  markRootSuspended$1(root, suspendedLanes);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
 
-        dependencies.firstContext = null;
-      }
-    }
-  }
-}
-function readContext(context) {
+function performSyncWorkOnRoot(root) {
   {
-    // This warning would fire if you read context inside a Hook like useMemo.
-    // Unlike the class check below, it's not enforced in production for perf.
-    if (isDisallowedContextReadInDEV) {
-      error(
-        "Context can only be read while React is rendering. " +
-          "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-          "In function components, you can read it directly in the function body, but not " +
-          "inside Hooks like useReducer() or useMemo()."
-      );
-    }
+    syncNestedUpdateFlag();
   }
 
-  return readContextForConsumer(currentlyRenderingFiber, context);
-}
-function readContextDuringReconcilation(consumer, context, renderLanes) {
-  if (currentlyRenderingFiber === null) {
-    prepareToReadContext(consumer, renderLanes);
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
   }
 
-  return readContextForConsumer(consumer, context);
-}
-
-function readContextForConsumer(consumer, context) {
-  var value = context._currentValue;
+  flushPassiveEffects();
+  var lanes = getNextLanes(root, NoLanes);
 
-  if (lastFullyObservedContext === context);
-  else {
-    var contextItem = {
-      context: context,
-      memoizedValue: value,
-      next: null
-    };
+  if (!includesSyncLane(lanes)) {
+    // There's no remaining sync work left.
+    ensureRootIsScheduled(root, now$1());
+    return null;
+  }
 
-    if (lastContextDependency === null) {
-      if (consumer === null) {
-        throw new Error(
-          "Context can only be read while React is rendering. " +
-            "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-            "In function components, you can read it directly in the function body, but not " +
-            "inside Hooks like useReducer() or useMemo()."
-        );
-      } // This is the first dependency for this component. Create a new list.
+  var exitStatus = renderRootSync(root, lanes);
 
-      lastContextDependency = contextItem;
-      consumer.dependencies = {
-        lanes: NoLanes,
-        firstContext: contextItem
-      };
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    var originallyAttemptedLanes = lanes;
+    var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+      root,
+      originallyAttemptedLanes
+    );
 
-      if (enableLazyContextPropagation) {
-        consumer.flags |= NeedsPropagation;
-      }
-    } else {
-      // Append a new context item.
-      lastContextDependency = lastContextDependency.next = contextItem;
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(
+        root,
+        originallyAttemptedLanes,
+        errorRetryLanes
+      );
     }
   }
 
-  return value;
-}
-
-// replace it with a lightweight shim that only has the features we use.
+  if (exitStatus === RootFatalErrored) {
+    var fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes);
+    ensureRootIsScheduled(root, now$1());
+    throw fatalError;
+  }
 
-var AbortControllerLocal =
-  typeof AbortController !== "undefined"
-    ? AbortController // $FlowFixMe[missing-this-annot]
-    : function AbortControllerShim() {
-        var listeners = [];
-        var signal = (this.signal = {
-          aborted: false,
-          addEventListener: function (type, listener) {
-            listeners.push(listener);
-          }
-        });
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes);
+    ensureRootIsScheduled(root, now$1());
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
 
-        this.abort = function () {
-          signal.aborted = true;
-          listeners.forEach(function (listener) {
-            return listener();
-          });
-        };
-      }; // Intentionally not named imports because Rollup would
-// use dynamic dispatch for CommonJS interop named imports.
+  var finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(
+    root,
+    workInProgressRootRecoverableErrors,
+    workInProgressTransitions
+  ); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
 
-var scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
-  NormalPriority = Scheduler.unstable_NormalPriority;
-var CacheContext = {
-  $$typeof: REACT_CONTEXT_TYPE,
-  // We don't use Consumer/Provider for Cache components. So we'll cheat.
-  Consumer: null,
-  Provider: null,
-  // We'll initialize these at the root.
-  _currentValue: null,
-  _currentValue2: null,
-  _threadCount: 0,
-  _defaultValue: null,
-  _globalName: null
-};
+  ensureRootIsScheduled(root, now$1());
+  return null;
+}
 
-{
-  CacheContext._currentRenderer = null;
-  CacheContext._currentRenderer2 = null;
-} // Creates a new empty Cache instance with a ref-count of 0. The caller is responsible
-// for retaining the cache once it is in use (retainCache), and releasing the cache
-// once it is no longer needed (releaseCache).
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    markRootEntangled(root, mergeLanes(lanes, SyncLane));
+    ensureRootIsScheduled(root, now$1());
 
-function createCache() {
-  var cache = {
-    controller: new AbortControllerLocal(),
-    data: new Map(),
-    refCount: 0
-  };
-  return cache;
-}
-function retainCache(cache) {
-  {
-    if (cache.controller.signal.aborted) {
-      warn(
-        "A cache instance was retained after it was already freed. " +
-          "This likely indicates a bug in React."
-      );
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer();
+      flushSyncCallbacks();
     }
   }
+}
+function getExecutionContext() {
+  return executionContext;
+}
+function batchedUpdates$1(fn, a) {
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
 
-  cache.refCount++;
-} // Cleanup a cache instance, potentially freeing it if there are no more references
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
 
-function releaseCache(cache) {
-  cache.refCount--;
+    if (
+      executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+      !ReactCurrentActQueue.isBatchingLegacy
+    ) {
+      resetRenderTimer();
+      flushSyncCallbacksOnlyInLegacyMode();
+    }
+  }
+}
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
 
-  {
-    if (cache.refCount < 0) {
-      warn(
-        "A cache instance was released after it was already freed. " +
-          "This likely indicates a bug in React."
-      );
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (
+    rootWithPendingPassiveEffects !== null &&
+    rootWithPendingPassiveEffects.tag === LegacyRoot &&
+    (executionContext & (RenderContext | CommitContext)) === NoContext
+  ) {
+    flushPassiveEffects();
+  }
+
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+  var previousPriority = getCurrentUpdatePriority();
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
     }
-  }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
 
-  if (cache.refCount === 0) {
-    scheduleCallback$1(NormalPriority, function () {
-      cache.controller.abort();
-    });
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncCallbacks();
+    }
   }
 }
-function pushCacheProvider(workInProgress, cache) {
-  pushProvider(workInProgress, CacheContext, cache);
+function isAlreadyRendering() {
+  // Used by the renderer to print a warning if certain APIs are called from
+  // the wrong context.
+  return (executionContext & (RenderContext | CommitContext)) !== NoContext;
 }
-function popCacheProvider(workInProgress, cache) {
-  popProvider(CacheContext, workInProgress);
+function isInvalidExecutionContextForEventFunction() {
+  // Used to throw if certain APIs are called from the wrong context.
+  return (executionContext & RenderContext) !== NoContext;
 }
+function flushControlled(fn) {
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+  var previousPriority = getCurrentUpdatePriority();
 
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig;
-var NoTransition = null;
-function requestCurrentTransition() {
-  return ReactCurrentBatchConfig$1.transition;
-} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
-// used during the previous render by placing it here, on the stack.
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    fn();
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext;
 
-var resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
-// transitions. Therefore, we want to lazily combine transitions. Instead of
-// comparing the arrays of transitions when we combine them and storing them
-// and filtering out the duplicates, we will instead store the unprocessed transitions
-// in an array and actually filter them in the passive phase.
+    if (executionContext === NoContext) {
+      // Flush the immediate callbacks that were scheduled during this batch
+      resetRenderTimer();
+      flushSyncCallbacks();
+    }
+  }
+} // This is called by the HiddenContext module when we enter or leave a
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
 
-var transitionStack = createCursor(null);
+function setRenderLanes(subtreeRenderLanes) {
+  renderLanes = subtreeRenderLanes;
+}
+function getRenderLanes() {
+  return renderLanes;
+}
 
-function peekCacheFromPool() {
-  // If we're rendering inside a Suspense boundary that is currently hidden,
-  // we should use the same cache that we used during the previous render, if
-  // one exists.
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  var interruptedWork;
 
-  var cacheResumedFromPreviousRender = resumedCache.current;
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind();
+    interruptedWork = workInProgress;
+  }
 
-  if (cacheResumedFromPreviousRender !== null) {
-    return cacheResumedFromPreviousRender;
-  } // Otherwise, check the root's cache pool.
+  while (interruptedWork !== null) {
+    var current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
+  }
 
-  var root = getWorkInProgressRoot();
-  var cacheFromRootCachePool = root.pooledCache;
-  return cacheFromRootCachePool;
+  workInProgress = null;
 }
 
-function requestCacheFromPool(renderLanes) {
-  // Similar to previous function, except if there's not already a cache in the
-  // pool, we allocate a new one.
-  var cacheFromPool = peekCacheFromPool();
-
-  if (cacheFromPool !== null) {
-    return cacheFromPool;
-  } // Create a fresh cache and add it to the root cache pool. A cache can have
-  // multiple owners:
-  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
-  //   are originally created (TODO: except during refreshes, until we implement
-  //   this correctly). The root takes ownership immediately when the cache is
-  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
-  //   and the return value of this function is a &Arc<Cache> (borrowed).
-  // - One of several fiber types: host root, cache boundary, suspense
-  //   component. These retain and release in the commit phase.
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  var timeoutHandle = root.timeoutHandle;
 
-  var root = getWorkInProgressRoot();
-  var freshCache = createCache();
-  root.pooledCache = freshCache;
-  retainCache(freshCache);
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
 
-  if (freshCache !== null) {
-    root.pooledCacheLanes |= renderLanes;
+    cancelTimeout(timeoutHandle);
   }
 
-  return freshCache;
-}
-function pushRootTransition(workInProgress, root, renderLanes) {
-  if (enableTransitionTracing) {
-    var rootTransitions = getWorkInProgressTransitions();
-    push(transitionStack, rootTransitions, workInProgress);
-  }
-}
-function popRootTransition(workInProgress, root, renderLanes) {
-  if (enableTransitionTracing) {
-    pop(transitionStack, workInProgress);
-  }
-}
-function pushTransition(
-  offscreenWorkInProgress,
-  prevCachePool,
-  newTransitions
-) {
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  var rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = renderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null;
+  finishQueueingConcurrentUpdates();
+
   {
-    if (prevCachePool === null) {
-      push(resumedCache, resumedCache.current, offscreenWorkInProgress);
-    } else {
-      push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
-    }
+    ReactStrictModeWarnings.discardPendingWarnings();
   }
 
-  if (enableTransitionTracing) {
-    if (transitionStack.current === null) {
-      push(transitionStack, newTransitions, offscreenWorkInProgress);
-    } else if (newTransitions === null) {
-      push(transitionStack, transitionStack.current, offscreenWorkInProgress);
-    } else {
-      push(
-        transitionStack,
-        transitionStack.current.concat(newTransitions),
-        offscreenWorkInProgress
-      );
-    }
-  }
+  return rootWorkInProgress;
 }
-function popTransition(workInProgress, current) {
-  if (current !== null) {
-    if (enableTransitionTracing) {
-      pop(transitionStack, workInProgress);
-    }
 
-    {
-      pop(resumedCache, workInProgress);
-    }
-  }
+function resetSuspendedWorkLoopOnUnwind() {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind();
+  resetChildReconcilerOnUnwind();
 }
-function getPendingTransitions() {
-  if (!enableTransitionTracing) {
-    return null;
+
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  resetCurrentFiber();
+  ReactCurrentOwner.current = null;
+
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
+      ? SuspendedOnData
+      : SuspendedOnImmediate;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    var isWakeable =
+      thrownValue !== null &&
+      typeof thrownValue === "object" &&
+      typeof thrownValue.then === "function";
+    workInProgressSuspendedReason = isWakeable // A wakeable object was thrown by a legacy Suspense implementation.
+      ? // This has slightly different behavior than suspending with `use`.
+        SuspendedOnDeprecatedThrowPromise // This is a regular error. If something earlier in the component already
+      : // suspended, we must clear the thenable state to unblock the work loop.
+        SuspendedOnError;
   }
 
-  return transitionStack.current;
-}
-function getSuspendedCache() {
-  // cache that would have been used to render fresh data during this render,
-  // if there was any, so that we can resume rendering with the same cache when
-  // we receive more data.
+  workInProgressThrownValue = thrownValue;
+  var erroredWork = workInProgress;
 
-  var cacheFromPool = peekCacheFromPool();
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue;
+    return;
+  }
 
-  if (cacheFromPool === null) {
-    return null;
+  if (erroredWork.mode & ProfileMode) {
+    // Record the time spent rendering before an error was thrown. This
+    // avoids inaccurate Profiler durations in the case of a
+    // suspended render.
+    stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
   }
 
-  return {
-    // We must also save the parent, so that when we resume we can detect
-    // a refresh.
-    parent: CacheContext._currentValue,
-    pool: cacheFromPool
-  };
-}
-function getOffscreenDeferredCache() {
-  var cacheFromPool = peekCacheFromPool();
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
 
-  if (cacheFromPool === null) {
-    return null;
-  }
+    switch (workInProgressSuspendedReason) {
+      case SuspendedOnError: {
+        markComponentErrored(
+          erroredWork,
+          thrownValue,
+          workInProgressRootRenderLanes
+        );
+        break;
+      }
 
-  return {
-    // We must also store the parent, so that when we resume we can detect
-    // a refresh.
-    parent: CacheContext._currentValue,
-    pool: cacheFromPool
-  };
+      case SuspendedOnData:
+      case SuspendedOnImmediate:
+      case SuspendedOnDeprecatedThrowPromise:
+      case SuspendedAndReadyToContinue: {
+        var wakeable = thrownValue;
+        markComponentSuspended(
+          erroredWork,
+          wakeable,
+          workInProgressRootRenderLanes
+        );
+        break;
+      }
+    }
+  }
 }
 
-function getSuspenseFallbackChild(fiber) {
-  return fiber.child.sibling.child;
-}
+function shouldAttemptToSuspendUntilDataResolves() {
+  // Check if there are other pending updates that might possibly unblock this
+  // component from suspending. This mirrors the check in
+  // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+  // TODO: Consider unwinding immediately, using the
+  // SuspendedOnHydration mechanism.
+  if (
+    includesNonIdleWork(workInProgressRootSkippedLanes) ||
+    includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)
+  ) {
+    // Suspend normally. renderDidSuspendDelayIfPossible will handle
+    // interrupting the work loop.
+    return false;
+  } // TODO: We should be able to remove the equivalent check in
+  // finishConcurrentRender, and rely just on this one.
 
-var emptyObject = {};
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    // If we're rendering inside the "shell" of the app, it's better to suspend
+    // rendering and wait for the data to resolve. Otherwise, we should switch
+    // to a fallback and continue rendering.
+    return getShellBoundary() === null;
+  }
 
-function collectScopedNodes(node, fn, scopedNodes) {
-  {
-    if (node.tag === HostComponent) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        stateNode = node.stateNode;
-      var instance = getPublicInstance(stateNode);
+  var handler = getSuspenseHandler();
 
-      if (
-        instance !== null &&
-        fn(type, memoizedProps || emptyObject, instance) === true
-      ) {
-        scopedNodes.push(instance);
-      }
+  if (handler === null);
+  else {
+    if (includesOnlyRetries(workInProgressRootRenderLanes)) {
+      // During a retry, we can suspend rendering if the nearest Suspense boundary
+      // is the boundary of the "shell", because we're guaranteed not to block
+      // any new content from appearing.
+      return handler === getShellBoundary();
     }
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+  // TODO: We should wait during Offscreen prerendering, too.
 
-    var child = node.child;
+  return false;
+}
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
-    }
+function pushDispatcher(container) {
+  prepareRendererToRender(container);
+  var prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
 
-    if (child !== null) {
-      collectScopedNodesFromChildren(child, fn, scopedNodes);
-    }
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
   }
 }
 
-function collectFirstScopedNode(node, fn) {
+function popDispatcher(prevDispatcher) {
+  resetRendererAfterRender();
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
+
+function pushCacheDispatcher() {
   {
-    if (node.tag === HostComponent) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        stateNode = node.stateNode;
-      var instance = getPublicInstance(stateNode);
+    var prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
 
-      if (instance !== null && fn(type, memoizedProps, instance) === true) {
-        return instance;
-      }
-    }
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
 
-    var child = node.child;
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now$1();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(
+    lane,
+    workInProgressRootSkippedLanes
+  );
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
-    }
+  if (
+    workInProgressRoot !== null &&
+    (includesNonIdleWork(workInProgressRootSkippedLanes) ||
+      includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))
+  ) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    // $FlowFixMe[incompatible-call] need null check workInProgressRoot
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
 
-    if (child !== null) {
-      return collectFirstScopedNodeFromChildren(child, fn);
-    }
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
+  } else {
+    workInProgressRootConcurrentErrors.push(error);
   }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
 
-  return null;
-}
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
 
-function collectScopedNodesFromChildren(startingChild, fn, scopedNodes) {
-  var child = startingChild;
+function renderRootSync(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  var prevDispatcher = pushDispatcher(root.containerInfo);
+  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
 
-  while (child !== null) {
-    collectScopedNodes(child, fn, scopedNodes);
-    child = child.sibling;
-  }
-}
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        var memoizedUpdaters = root.memoizedUpdaters;
 
-function collectFirstScopedNodeFromChildren(startingChild, fn) {
-  var child = startingChild;
+        if (memoizedUpdaters.size > 0) {
+          restorePendingUpdaters(root, workInProgressRootRenderLanes);
+          memoizedUpdaters.clear();
+        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
+        // If we bailout on this work, we'll move them back (like above).
+        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
+        // That way we can keep the current update and future updates separate.
 
-  while (child !== null) {
-    var scopedNode = collectFirstScopedNode(child, fn);
+        movePendingFibersToMemoized(root, lanes);
+      }
+    }
 
-    if (scopedNode !== null) {
-      return scopedNode;
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    prepareFreshStack(root, lanes);
+  }
+
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
     }
+  }
 
-    child = child.sibling;
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
   }
 
-  return null;
-}
+  outer: do {
+    try {
+      if (
+        workInProgressSuspendedReason !== NotSuspended &&
+        workInProgress !== null
+      ) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        var unitOfWork = workInProgress;
+        var thrownValue = workInProgressThrownValue;
 
-function collectNearestContextValues(node, context, childContextValues) {
-  if (node.tag === ContextProvider && node.type._context === context) {
-    var contextValue = node.memoizedProps.value;
-    childContextValues.push(contextValue);
-  } else {
-    var child = node.child;
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration: {
+            // Selective hydration. An update flowed into a dehydrated tree.
+            // Interrupt the current render so the work loop can switch to the
+            // hydration lane.
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootDidNotComplete;
+            break outer;
+          }
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
-    }
+          default: {
+            // Continue with the normal work loop.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
+          }
+        }
+      }
 
-    if (child !== null) {
-      collectNearestChildContextValues(child, context, childContextValues);
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
     }
-  }
-}
+  } while (true);
 
-function collectNearestChildContextValues(
-  startingChild,
-  context,
-  childContextValues
-) {
-  var child = startingChild;
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
 
-  while (child !== null) {
-    collectNearestContextValues(child, context, childContextValues);
-    child = child.sibling;
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw new Error(
+      "Cannot commit an incomplete root. This error is likely caused by a " +
+        "bug in React. Please file an issue."
+    );
   }
-}
-
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
 
-  if (currentFiber === null) {
-    return null;
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
   }
 
-  var child = currentFiber.child;
-  var scopedNodes = [];
+  if (enableSchedulingProfiler) {
+    markRenderStopped();
+  } // Set this to null to indicate there's no in-progress render.
 
-  if (child !== null) {
-    collectScopedNodesFromChildren(child, fn, scopedNodes);
-  }
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
 
-  return scopedNodes.length === 0 ? null : scopedNodes;
-}
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
 
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
+/** @noinline */
 
-  if (currentFiber === null) {
-    return null;
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
   }
+}
 
-  var child = currentFiber.child;
+function renderRootConcurrent(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  var prevDispatcher = pushDispatcher(root.containerInfo);
+  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
 
-  if (child !== null) {
-    return collectFirstScopedNodeFromChildren(child, fn);
-  }
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        var memoizedUpdaters = root.memoizedUpdaters;
 
-  return null;
-}
+        if (memoizedUpdaters.size > 0) {
+          restorePendingUpdaters(root, workInProgressRootRenderLanes);
+          memoizedUpdaters.clear();
+        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
+        // If we bailout on this work, we'll move them back (like above).
+        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
+        // That way we can keep the current update and future updates separate.
 
-function containsNode(node) {
-  var fiber = getInstanceFromNode(node);
+        movePendingFibersToMemoized(root, lanes);
+      }
+    }
 
-  while (fiber !== null) {
-    if (fiber.tag === ScopeComponent && fiber.stateNode === this) {
-      return true;
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
     }
+  }
 
-    fiber = fiber.return;
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
   }
 
-  return false;
-}
+  outer: do {
+    try {
+      if (
+        workInProgressSuspendedReason !== NotSuspended &&
+        workInProgress !== null
+      ) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        var unitOfWork = workInProgress;
+        var thrownValue = workInProgressThrownValue;
 
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnError: {
+            // Unwind then continue with the normal work loop.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
+          }
 
-  if (currentFiber === null) {
-    return [];
-  }
+          case SuspendedOnData: {
+            var thenable = thrownValue;
 
-  var child = currentFiber.child;
-  var childContextValues = [];
+            if (isThenableResolved(thenable)) {
+              // The data resolved. Try rendering the component again.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(unitOfWork);
+              break;
+            } // The work loop is suspended on data. We should wait for it to
+            // resolve before continuing to render.
+            // TODO: Handle the case where the promise resolves synchronously.
+            // Usually this is handled when we instrument the promise to add a
+            // `status` field, but if the promise already has a status, we won't
+            // have added a listener until right here.
 
-  if (child !== null) {
-    collectNearestChildContextValues(child, context, childContextValues);
-  }
+            var onResolution = function () {
+              // Check if the root is still suspended on this promise.
+              if (
+                workInProgressSuspendedReason === SuspendedOnData &&
+                workInProgressRoot === root
+              ) {
+                // Mark the root as ready to continue rendering.
+                workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              } // Ensure the root is scheduled. We should do this even if we're
+              // currently working on a different root, so that we resume
+              // rendering later.
 
-  return childContextValues;
-}
+              ensureRootIsScheduled(root, now$1());
+            };
 
-function createScopeInstance() {
-  return {
-    DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-    DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-    containsNode: containsNode,
-    getChildContextValues: getChildContextValues
-  };
-}
+            thenable.then(onResolution, onResolution);
+            break outer;
+          }
 
-function markUpdate(workInProgress) {
-  // Tag the fiber with an update effect. This turns a Placement into
-  // a PlacementAndUpdate.
-  workInProgress.flags |= Update;
-}
+          case SuspendedOnImmediate: {
+            // If this fiber just suspended, it's possible the data is already
+            // cached. Yield to the main thread to give it a chance to ping. If
+            // it does, we can retry immediately without unwinding the stack.
+            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+            break outer;
+          }
 
-function markRef(workInProgress) {
-  workInProgress.flags |= Ref | RefStatic;
-}
+          case SuspendedAndReadyToContinue: {
+            var _thenable = thrownValue;
 
-function appendAllChildren(
-  parent,
-  workInProgress,
-  needsVisibilityToggle,
-  isHidden
-) {
-  {
-    // We only have the top Fiber that was created but we need recurse down its
-    // children to find all the terminal nodes.
-    var node = workInProgress.child;
+            if (isThenableResolved(_thenable)) {
+              // The data resolved. Try rendering the component again.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(unitOfWork);
+            } else {
+              // Otherwise, unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            }
 
-    while (node !== null) {
-      if (node.tag === HostComponent || node.tag === HostText) {
-        appendInitialChild(parent, node.stateNode);
-      } else if (node.tag === HostPortal || node.tag === HostSingleton);
-      else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
+            break;
+          }
 
-      if (node === workInProgress) {
-        return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+          case SuspendedOnDeprecatedThrowPromise: {
+            // Suspended by an old implementation that uses the `throw promise`
+            // pattern. The newer replaying behavior can cause subtle issues
+            // like infinite ping loops. So we maintain the old behavior and
+            // always unwind.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
+          }
 
-      while (node.sibling === null) {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        if (node.return === null || node.return === workInProgress) {
-          return;
+          case SuspendedOnHydration: {
+            // Selective hydration. An update flowed into a dehydrated tree.
+            // Interrupt the current render so the work loop can switch to the
+            // hydration lane.
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootDidNotComplete;
+            break outer;
+          }
+
+          default: {
+            throw new Error(
+              "Unexpected SuspendedReason. This is a bug in React."
+            );
+          }
         }
+      }
 
-        node = node.return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (true && ReactCurrentActQueue.current !== null) {
+        // `act` special case: If we're inside an `act` scope, don't consult
+        // `shouldYield`. Always keep working until the render is complete.
+        // This is not just an optimization: in a unit test environment, we
+        // can't trust the result of `shouldYield`, because the host I/O is
+        // likely mocked.
+        workLoopSync();
+      } else {
+        workLoopConcurrent();
+      }
 
-      node.sibling.return = node.return;
-      node = node.sibling;
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
     }
-  }
-} // An unfortunate fork of appendAllChildren because we have two different parent types.
+  } while (true);
+
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
 
-function updateHostComponent(current, workInProgress, type, newProps) {
   {
-    // If we have an alternate, that means this is an update and we need to
-    // schedule a side-effect to do the updates.
-    var oldProps = current.memoizedProps;
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
+  } // Check if the tree has completed.
 
-    if (oldProps === newProps) {
-      // In mutation mode, this is sufficient for a bailout because
-      // we won't touch this node even if children changed.
-      return;
-    } // If we get updated because one of our children updated, we don't
-    // have newProps so we'll have to reuse them.
-    // TODO: Split the update API as separate for the props vs. children.
-    // Even better would be if children weren't special cased at all tho.
+  if (workInProgress !== null) {
+    // Still work remaining.
+    if (enableSchedulingProfiler) {
+      markRenderYielded();
+    }
 
-    var instance = workInProgress.stateNode;
-    var currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host
-    // component is hitting the resume path. Figure out why. Possibly
-    // related to `hidden`.
+    return RootInProgress;
+  } else {
+    // Completed the tree.
+    if (enableSchedulingProfiler) {
+      markRenderStopped();
+    } // Set this to null to indicate there's no in-progress render.
 
-    var updatePayload = prepareUpdate(
-      instance,
-      type,
-      oldProps,
-      newProps,
-      currentHostContext
-    ); // TODO: Type this specific to this type of component.
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
 
-    workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
-    // is a new ref we mark this as an update. All the work is done in commitWork.
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
 
-    if (updatePayload) {
-      markUpdate(workInProgress);
-    }
+    return workInProgressRootExitStatus;
   }
 }
+/** @noinline */
 
-function updateHostText(current, workInProgress, oldText, newText) {
-  {
-    // If the text differs, mark it as an update. All the work in done in commitWork.
-    if (oldText !== newText) {
-      markUpdate(workInProgress);
-    }
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
   }
 }
 
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (getIsHydrating()) {
-    // If we're hydrating, we should consume as many items as we can
-    // so we don't leave any behind.
-    return;
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. 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 = unitOfWork.alternate;
+  setCurrentFiber(unitOfWork);
+  var next;
+
+  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
+    startProfilerTimer(unitOfWork);
+    next = beginWork(current, unitOfWork, renderLanes);
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } else {
+    next = beginWork(current, unitOfWork, renderLanes);
   }
 
-  switch (renderState.tailMode) {
-    case "hidden": {
-      // Any insertions at the end of the tail list after this point
-      // should be invisible. If there are already mounted boundaries
-      // anything before them are not considered for collapsing.
-      // Therefore we need to go through the whole tail to find if
-      // there are any.
-      var tailNode = renderState.tail;
-      var lastTailNode = null;
+  resetCurrentFiber();
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
 
-      while (tailNode !== null) {
-        if (tailNode.alternate !== null) {
-          lastTailNode = tailNode;
-        }
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
 
-        tailNode = tailNode.sibling;
-      } // Next we're simply going to delete all insertions after the
-      // last rendered item.
+  ReactCurrentOwner.current = null;
+}
 
-      if (lastTailNode === null) {
-        // All remaining items in the tail are insertions.
-        renderState.tail = null;
-      } else {
-        // Detach the insertion after the last node that was already
-        // inserted.
-        lastTailNode.sibling = null;
-      }
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  var current = unitOfWork.alternate;
+  setCurrentFiber(unitOfWork);
+  var next;
+  setCurrentFiber(unitOfWork);
+  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+
+  if (isProfilingMode) {
+    startProfilerTimer(unitOfWork);
+  }
+
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent: {
+      // Because it suspended with `use`, we can assume it's a
+      // function component.
+      unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
+    }
+    // eslint-disable-next-line no-fallthrough
+
+    case FunctionComponent:
+    case ForwardRef: {
+      // Resolve `defaultProps`. This logic is copied from `beginWork`.
+      // TODO: Consider moving this switch statement into that module. Also,
+      // could maybe use this as an opportunity to say `use` doesn't work with
+      // `defaultProps` :)
+      var Component = unitOfWork.type;
+      var unresolvedProps = unitOfWork.pendingProps;
+      var resolvedProps =
+        unitOfWork.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      next = replayFunctionComponent(
+        current,
+        unitOfWork,
+        resolvedProps,
+        Component,
+        workInProgressRootRenderLanes
+      );
+      break;
+    }
+
+    case SimpleMemoComponent: {
+      var _Component = unitOfWork.type;
+      var nextProps = unitOfWork.pendingProps;
+      next = replayFunctionComponent(
+        current,
+        unitOfWork,
+        nextProps,
+        _Component,
+        workInProgressRootRenderLanes
+      );
+      break;
+    }
 
+    default: {
+      // Other types besides function components are reset completely before
+      // being replayed. Currently this only happens when a Usable type is
+      // reconciled — the reconciler will suspend.
+      //
+      // We reset the fiber back to its original state; however, this isn't
+      // a full "unwind" because we're going to reuse the promises that were
+      // reconciled previously. So it's intentional that we don't call
+      // resetSuspendedWorkLoopOnUnwind here.
+      unwindInterruptedWork(current, unitOfWork);
+      unitOfWork = workInProgress = resetWorkInProgress(
+        unitOfWork,
+        renderLanes
+      );
+      next = beginWork(current, unitOfWork, renderLanes);
       break;
     }
+  }
 
-    case "collapsed": {
-      // Any insertions at the end of the tail list after this point
-      // should be invisible. If there are already mounted boundaries
-      // anything before them are not considered for collapsing.
-      // Therefore we need to go through the whole tail to find if
-      // there are any.
-      var _tailNode = renderState.tail;
-      var _lastTailNode = null;
+  if (isProfilingMode) {
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } // The begin phase finished successfully without suspending. Return to the
+  // normal work loop.
 
-      while (_tailNode !== null) {
-        if (_tailNode.alternate !== null) {
-          _lastTailNode = _tailNode;
-        }
+  resetCurrentFiber();
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
 
-        _tailNode = _tailNode.sibling;
-      } // Next we're simply going to delete all insertions after the
-      // last rendered item.
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
 
-      if (_lastTailNode === null) {
-        // All remaining items in the tail are insertions.
-        if (!hasRenderedATailFallback && renderState.tail !== null) {
-          // We suspended during the head. We want to show at least one
-          // row at the tail. So we'll keep on and cut off the rest.
-          renderState.tail.sibling = null;
-        } else {
-          renderState.tail = null;
-        }
-      } else {
-        // Detach the insertion after the last node that was already
-        // inserted.
-        _lastTailNode.sibling = null;
-      }
+  ReactCurrentOwner.current = null;
+}
 
-      break;
-    }
+function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind();
+  var returnFiber = unitOfWork.return;
+
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
   }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(
+      workInProgressRoot,
+      returnFiber,
+      unitOfWork,
+      thrownValue,
+      workInProgressRootRenderLanes
+    );
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  } // Return to the normal work loop.
+
+  completeUnitOfWork(unitOfWork);
 }
 
-function bubbleProperties(completedWork) {
-  var didBailout =
-    completedWork.alternate !== null &&
-    completedWork.alternate.child === completedWork.child;
-  var newChildLanes = NoLanes;
-  var subtreeFlags = NoFlags$1;
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  var completedWork = unitOfWork;
 
-  if (!didBailout) {
-    // Bubble up the earliest expiration time.
-    if ((completedWork.mode & ProfileMode) !== NoMode) {
-      // In profiling mode, resetChildExpirationTime is also used to reset
-      // profiler durations.
-      var actualDuration = completedWork.actualDuration;
-      var treeBaseDuration = completedWork.selfBaseDuration;
-      var child = completedWork.child;
+  do {
+    // The current, flushed, state of this fiber is the alternate. 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 = completedWork.alternate;
+    var returnFiber = completedWork.return; // Check if the work completed or if something threw.
 
-      while (child !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(child.lanes, child.childLanes)
-        );
-        subtreeFlags |= child.subtreeFlags;
-        subtreeFlags |= child.flags; // When a fiber is cloned, its actualDuration is reset to 0. This value will
-        // only be updated if work is done on the fiber (i.e. it doesn't bailout).
-        // When work is done, it should bubble to the parent's actualDuration. If
-        // the fiber has not been cloned though, (meaning no work was done), then
-        // this value will reflect the amount of time spent working on a previous
-        // render. In that case it should not bubble. We determine whether it was
-        // cloned by comparing the child pointer.
-        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    if ((completedWork.flags & Incomplete) === NoFlags$1) {
+      setCurrentFiber(completedWork);
+      var next = void 0;
 
-        actualDuration += child.actualDuration; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+      if ((completedWork.mode & ProfileMode) === NoMode) {
+        next = completeWork(current, completedWork, renderLanes);
+      } else {
+        startProfilerTimer(completedWork);
+        next = completeWork(current, completedWork, renderLanes); // Update render duration assuming we didn't error.
 
-        treeBaseDuration += child.treeBaseDuration;
-        child = child.sibling;
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
       }
 
-      completedWork.actualDuration = actualDuration;
-      completedWork.treeBaseDuration = treeBaseDuration;
-    } else {
-      var _child = completedWork.child;
+      resetCurrentFiber();
 
-      while (_child !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child.lanes, _child.childLanes)
-        );
-        subtreeFlags |= _child.subtreeFlags;
-        subtreeFlags |= _child.flags; // Update the return pointer so the tree is consistent. This is a code
-        // smell because it assumes the commit phase is never concurrent with
-        // the render phase. Will address during refactor to alternate model.
+      if (next !== null) {
+        // Completing this fiber spawned new work. Work on that next.
+        workInProgress = next;
+        return;
+      }
+    } else {
+      // This fiber did not complete because something threw. Pop values off
+      // the stack without entering the complete phase. If this is a boundary,
+      // capture values if possible.
+      var _next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.
 
-        _child.return = completedWork;
-        _child = _child.sibling;
+      if (_next !== null) {
+        // 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
+        // from the effect tag.
+        _next.flags &= HostEffectMask;
+        workInProgress = _next;
+        return;
       }
-    }
 
-    completedWork.subtreeFlags |= subtreeFlags;
-  } else {
-    // Bubble up the earliest expiration time.
-    if ((completedWork.mode & ProfileMode) !== NoMode) {
-      // In profiling mode, resetChildExpirationTime is also used to reset
-      // profiler durations.
-      var _treeBaseDuration = completedWork.selfBaseDuration;
-      var _child2 = completedWork.child;
+      if ((completedWork.mode & ProfileMode) !== NoMode) {
+        // Record the render duration for the fiber that errored.
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
 
-      while (_child2 !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child2.lanes, _child2.childLanes)
-        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
-        // so we should bubble those up even during a bailout. All the other
-        // flags have a lifetime only of a single render + commit, so we should
-        // ignore them.
+        var actualDuration = completedWork.actualDuration;
+        var child = completedWork.child;
 
-        subtreeFlags |= _child2.subtreeFlags & StaticMask;
-        subtreeFlags |= _child2.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+        while (child !== null) {
+          // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+          actualDuration += child.actualDuration;
+          child = child.sibling;
+        }
 
-        _treeBaseDuration += _child2.treeBaseDuration;
-        _child2 = _child2.sibling;
+        completedWork.actualDuration = actualDuration;
       }
 
-      completedWork.treeBaseDuration = _treeBaseDuration;
-    } else {
-      var _child3 = completedWork.child;
+      if (returnFiber !== null) {
+        // Mark the parent fiber as incomplete and clear its subtree flags.
+        returnFiber.flags |= Incomplete;
+        returnFiber.subtreeFlags = NoFlags$1;
+        returnFiber.deletions = null;
+      } else {
+        // We've unwound all the way to the root.
+        workInProgressRootExitStatus = RootDidNotComplete;
+        workInProgress = null;
+        return;
+      }
+    }
 
-      while (_child3 !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child3.lanes, _child3.childLanes)
-        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
-        // so we should bubble those up even during a bailout. All the other
-        // flags have a lifetime only of a single render + commit, so we should
-        // ignore them.
+    var siblingFiber = completedWork.sibling;
 
-        subtreeFlags |= _child3.subtreeFlags & StaticMask;
-        subtreeFlags |= _child3.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
-        // smell because it assumes the commit phase is never concurrent with
-        // the render phase. Will address during refactor to alternate model.
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-        _child3.return = completedWork;
-        _child3 = _child3.sibling;
-      }
-    }
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
 
-    completedWork.subtreeFlags |= subtreeFlags;
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
+
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
   }
+}
 
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
+function commitRoot(root, recoverableErrors, transitions) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  var previousUpdateLanePriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(
+      root,
+      recoverableErrors,
+      transitions,
+      previousUpdateLanePriority
+    );
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
+
+  return null;
 }
 
-function completeDehydratedSuspenseBoundary(
-  current,
-  workInProgress,
-  nextState
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
 ) {
-  if (
-    hasUnhydratedTailNodes() &&
-    (workInProgress.mode & ConcurrentMode) !== NoMode &&
-    (workInProgress.flags & DidCapture) === NoFlags$1
-  ) {
-    warnIfUnhydratedTailNodes(workInProgress);
-    resetHydrationState();
-    workInProgress.flags |= ForceClientRender | Incomplete | ShouldCapture;
-    return false;
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
+
+  flushRenderPhaseStrictModeWarningsInDEV();
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
   }
 
-  var wasHydrated = popHydrationState(workInProgress);
+  var finishedWork = root.finishedWork;
+  var lanes = root.finishedLanes;
 
-  if (nextState !== null && nextState.dehydrated !== null) {
-    // We might be inside a hydration state the first time we're picking up this
-    // Suspense boundary, and also after we've reentered it for further hydration.
-    if (current === null) {
-      if (!wasHydrated) {
-        throw new Error(
-          "A dehydrated suspense component was completed without a hydrated node. " +
-            "This is probably a bug in React."
-        );
-      }
+  {
+    if (enableDebugTracing) {
+      logCommitStarted(lanes);
+    }
+  }
 
-      prepareToHydrateHostSuspenseInstance(workInProgress);
-      bubbleProperties(workInProgress);
+  if (enableSchedulingProfiler) {
+    markCommitStarted(lanes);
+  }
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          var isTimedOutSuspense = nextState !== null;
+  if (finishedWork === null) {
+    {
+      if (enableDebugTracing) {
+        logCommitStopped();
+      }
+    }
 
-          if (isTimedOutSuspense) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var primaryChildFragment = workInProgress.child;
+    if (enableSchedulingProfiler) {
+      markCommitStopped();
+    }
 
-            if (primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                primaryChildFragment.treeBaseDuration;
-            }
-          }
-        }
+    return null;
+  } else {
+    {
+      if (lanes === NoLanes) {
+        error(
+          "root.finishedLanes should not be empty during a commit. This is a " +
+            "bug in React."
+        );
       }
+    }
+  }
 
-      return false;
-    } else {
-      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
-      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
-      resetHydrationState();
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
 
-      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
-        // This boundary did not suspend so it's now hydrated and unsuspended.
-        workInProgress.memoizedState = null;
-      } // If nothing suspended, we need to schedule an effect to mark this boundary
-      // as having hydrated so events know that they're free to be invoked.
-      // It's also a signal to replay events and the suspense callback.
-      // If something suspended, schedule an effect to attach retry listeners.
-      // So we might as well always mark this.
+  if (finishedWork === root.current) {
+    throw new Error(
+      "Cannot commit the same tree as before. This error is likely caused by " +
+        "a bug in React. Please file an issue."
+    );
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
 
-      workInProgress.flags |= Update;
-      bubbleProperties(workInProgress);
+  root.callbackNode = null;
+  root.callbackPriority = NoLane; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          var _isTimedOutSuspense = nextState !== null;
+  var remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
 
-          if (_isTimedOutSuspense) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var _primaryChildFragment = workInProgress.child;
+  var concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes);
 
-            if (_primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                _primaryChildFragment.treeBaseDuration;
-            }
-          }
-        }
-      }
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
 
-      return false;
+  if (
+    (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 ||
+    (finishedWork.flags & PassiveMask) !== NoFlags$1
+  ) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
+
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+
+        return null;
+      });
     }
-  } else {
-    // Successfully completed this tree. If this was a forced client render,
-    // there may have been recoverable errors during first hydration
-    // attempt. If so, add them to a queue so we can log them in the
-    // commit phase.
-    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
 
-    return true;
-  }
-}
+  var subtreeHasEffects =
+    (finishedWork.subtreeFlags &
+      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
+    NoFlags$1;
+  var rootHasEffect =
+    (finishedWork.flags &
+      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
+    NoFlags$1;
 
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
+  if (subtreeHasEffects || rootHasEffect) {
+    var prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    var prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
 
-  popTreeContext(workInProgress);
+    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
 
-  switch (workInProgress.tag) {
-    case IndeterminateComponent:
-    case LazyComponent:
-    case SimpleMemoComponent:
-    case FunctionComponent:
-    case ForwardRef:
-    case Fragment:
-    case Mode:
-    case Profiler:
-    case ContextConsumer:
-    case MemoComponent:
-      bubbleProperties(workInProgress);
-      return null;
+    var shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
 
-    case ClassComponent: {
-      bubbleProperties(workInProgress);
-      return null;
+    {
+      // Mark the current commit time to be shared by all Profilers in this
+      // batch. This enables them to be grouped later.
+      recordCommitTime();
     }
 
-    case HostRoot: {
-      var fiberRoot = workInProgress.stateNode;
+    if (enableProfilerNestedUpdateScheduledHook) {
+      // Track the root here, rather than in commitLayoutEffects(), because of ref setters.
+      // Updates scheduled during ref detachment should also be flagged.
+      rootCommittingMutationOrLayoutEffects = root;
+    } // The next phase is the mutation phase, where we mutate the host tree.
 
-      if (enableTransitionTracing) {
-        var transitions = getWorkInProgressTransitions(); // We set the Passive flag here because if there are new transitions,
-        // we will need to schedule callbacks and process the transitions,
-        // which we do in the passive phase
+    commitMutationEffects(root, finishedWork, lanes);
 
-        if (transitions !== null) {
-          workInProgress.flags |= Passive$1;
-        }
+    {
+      if (shouldFireAfterActiveInstanceBlur) {
+        afterActiveInstanceBlur();
       }
+    }
 
-      {
-        var previousCache = null;
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
 
-        if (current !== null) {
-          previousCache = current.memoizedState.cache;
-        }
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+    // the host tree after it's been mutated. The idiomatic use case for this is
+    // layout, but class component lifecycles also fire here for legacy reasons.
 
-        var cache = workInProgress.memoizedState.cache;
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStarted(lanes);
+      }
+    }
 
-        if (cache !== previousCache) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
-        }
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStarted(lanes);
+    }
 
-        popCacheProvider(workInProgress);
-      }
+    commitLayoutEffects(finishedWork, root, lanes);
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(workInProgress);
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStopped();
       }
+    }
 
-      popRootTransition(workInProgress);
-      popHostContainer(workInProgress);
-      resetWorkInProgressVersions();
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStopped();
+    }
 
-      if (fiberRoot.pendingContext) {
-        fiberRoot.context = fiberRoot.pendingContext;
-        fiberRoot.pendingContext = null;
-      }
+    if (enableProfilerNestedUpdateScheduledHook) {
+      rootCommittingMutationOrLayoutEffects = null;
+    } // Tell Scheduler to yield at the end of the frame, so the browser has an
+    // opportunity to paint.
 
-      if (current === null || current.child === null) {
-        // If we hydrated, pop so that we can delete any remaining children
-        // that weren't hydrated.
-        var wasHydrated = popHydrationState(workInProgress);
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
 
-        if (wasHydrated) {
-          // If we hydrated, then we'll need to schedule an update for
-          // the commit side-effects on the root.
-          markUpdate(workInProgress);
-        } else {
-          if (current !== null) {
-            var prevState = current.memoizedState;
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+    // no effects.
+    // TODO: Maybe there's a better way to report this.
 
-            if (
-              // Check if this is a client root
-              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
-              (workInProgress.flags & ForceClientRender) !== NoFlags$1
-            ) {
-              // Schedule an effect to clear this container at the start of the
-              // next commit. This handles the case of React rendering into a
-              // container with previous children. It's also safe to do for
-              // updates too, because current.child would only be null if the
-              // previous render was null (so the container would already
-              // be empty).
-              workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
-              // recoverable errors during first hydration attempt. If so, add
-              // them to a queue so we can log them in the commit phase.
+    {
+      recordCommitTime();
+    }
+  }
 
-              upgradeHydrationErrorsToRecoverable();
-            }
-          }
-        }
-      }
-      bubbleProperties(workInProgress);
+  var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
 
-      if (enableTransitionTracing) {
-        if ((workInProgress.subtreeFlags & Visibility) !== NoFlags$1) {
-          // If any of our suspense children toggle visibility, this means that
-          // the pending boundaries array needs to be updated, which we only
-          // do in the passive phase.
-          workInProgress.flags |= Passive$1;
-        }
-      }
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
 
-      return null;
+    {
+      nestedPassiveUpdateCount = 0;
+      rootWithPassiveNestedUpdates = null;
     }
+  } // Read this again, since an effect might have updated it
 
-    case HostHoistable: {
-      {
-        var currentRef = current ? current.ref : null;
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
 
-        if (currentRef !== workInProgress.ref) {
-          markRef(workInProgress);
-        }
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
+  }
 
-        if (
-          // We are mounting and must Update this Hoistable in this commit
-          current === null || // We are transitioning to, from, or between Hoistable Resources
-          // and require an update
-          current.memoizedState !== workInProgress.memoizedState
-        ) {
-          markUpdate(workInProgress);
-        } else if (workInProgress.memoizedState === null) {
-          // We may have props to update on the Hoistable instance. We use the
-          // updateHostComponent path becuase it produces the update queue
-          // we need for Hoistables
-          updateHostComponent(
-            current,
-            workInProgress,
-            workInProgress.type,
-            workInProgress.pendingProps
-          );
-        }
+  {
+    if (!rootDidHavePassiveEffects) {
+      commitDoubleInvokeEffectsInDEV(root, false);
+    }
+  }
 
-        bubbleProperties(workInProgress);
-        return null;
-      }
+  onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
+
+  {
+    if (isDevToolsPresent) {
+      root.memoizedUpdaters.clear();
     }
-    // eslint-disable-next-line-no-fallthrough
+  }
 
-    case HostSingleton: {
-      {
-        popHostContext(workInProgress);
-        var rootContainerInstance = getRootHostContainer();
-        var type = workInProgress.type;
+  {
+    onCommitRoot();
+  } // Always call this before exiting `commitRoot`, to ensure that any
+  // additional work on this root is scheduled.
 
-        if (current !== null && workInProgress.stateNode != null) {
-          updateHostComponent(current, workInProgress, type, newProps);
+  ensureRootIsScheduled(root, now$1());
 
-          if (current.ref !== workInProgress.ref) {
-            markRef(workInProgress);
-          }
-        } else {
-          if (!newProps) {
-            if (workInProgress.stateNode === null) {
-              throw new Error(
-                "We must have new props for new mounts. This error is likely " +
-                  "caused by a bug in React. Please file an issue."
-              );
-            } // This can happen when we abort work.
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    var onRecoverableError = root.onRecoverableError;
 
-            bubbleProperties(workInProgress);
-            return null;
-          }
+    for (var i = 0; i < recoverableErrors.length; i++) {
+      var recoverableError = recoverableErrors[i];
+      var errorInfo = makeErrorInfo(
+        recoverableError.digest,
+        recoverableError.stack
+      );
+      onRecoverableError(recoverableError.value, errorInfo);
+    }
+  }
 
-          var currentHostContext = getHostContext();
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    var error$1 = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error$1;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
 
-          var _wasHydrated = popHydrationState(workInProgress);
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
 
-          if (_wasHydrated) {
-            // We ignore the boolean indicating there is an updateQueue because
-            // it is used only to set text children and HostSingletons do not
-            // use them.
-            prepareToHydrateHostInstance(workInProgress, currentHostContext);
-          } else {
-            workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              rootContainerInstance,
-              currentHostContext,
-              true
-            );
-            markUpdate(workInProgress);
-          }
+  remainingLanes = root.pendingLanes;
 
-          if (workInProgress.ref !== null) {
-            // If there is a ref on a host node we need to schedule a callback
-            markRef(workInProgress);
-          }
-        }
+  if (includesSyncLane(remainingLanes)) {
+    {
+      markNestedUpdateScheduled();
+    } // Count the number of times the root synchronously re-renders without
+    // finishing. If there are too many, it indicates an infinite update loop.
 
-        bubbleProperties(workInProgress);
-        return null;
-      }
+    if (root === rootWithNestedUpdates) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
     }
-    // eslint-disable-next-line-no-fallthrough
-
-    case HostComponent: {
-      popHostContext(workInProgress);
-      var _type = workInProgress.type;
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
 
-      if (current !== null && workInProgress.stateNode != null) {
-        updateHostComponent(current, workInProgress, _type, newProps);
+  flushSyncCallbacks();
 
-        if (current.ref !== workInProgress.ref) {
-          markRef(workInProgress);
-        }
-      } else {
-        if (!newProps) {
-          if (workInProgress.stateNode === null) {
-            throw new Error(
-              "We must have new props for new mounts. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          } // This can happen when we abort work.
+  {
+    if (enableDebugTracing) {
+      logCommitStopped();
+    }
+  }
 
-          bubbleProperties(workInProgress);
-          return null;
-        }
+  if (enableSchedulingProfiler) {
+    markCommitStopped();
+  }
 
-        var _currentHostContext2 = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
-        // "stack" as the parent. Then append children as we go in beginWork
-        // or completeWork depending on whether we want to add them top->down or
-        // bottom->up. Top->down is faster in IE11.
+  if (enableTransitionTracing) {
+    // We process transitions during passive effects. However, passive effects can be
+    // processed synchronously during the commit phase as well as asynchronously after
+    // paint. At the end of the commit phase, we schedule a callback that will be called
+    // after the next paint. If the transitions have already been processed (passive
+    // effect phase happened synchronously), we will schedule a callback to process
+    // the transitions. However, if we don't have any pending transition callbacks, this
+    // means that the transitions have yet to be processed (passive effects processed after paint)
+    // so we will store the end time of paint so that we can process the transitions
+    // and then call the callback via the correct end time.
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
 
-        var _wasHydrated2 = popHydrationState(workInProgress);
+    if (prevRootTransitionCallbacks !== null) {
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
 
-        if (_wasHydrated2) {
-          // TODO: Move this and createInstance step into the beginPhase
-          // to consolidate.
-          if (
-            prepareToHydrateHostInstance(workInProgress, _currentHostContext2)
-          ) {
-            // If changes to the hydrated node need to be applied at the
-            // commit-phase we mark this as such.
-            markUpdate(workInProgress);
-          }
+        if (prevPendingTransitionCallbacks !== null) {
+          currentPendingTransitionCallbacks = null;
+          scheduleCallback(IdlePriority, function () {
+            processTransitionCallbacks(
+              prevPendingTransitionCallbacks,
+              endTime,
+              prevRootTransitionCallbacks
+            );
+          });
         } else {
-          var _rootContainerInstance = getRootHostContainer();
+          currentEndTime = endTime;
+        }
+      });
+    }
+  }
 
-          var instance = createInstance(
-            _type,
-            newProps,
-            _rootContainerInstance,
-            _currentHostContext2,
-            workInProgress
-          );
-          appendAllChildren(instance, workInProgress);
-          workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
-          // (eg DOM renderer supports auto-focus for certain elements).
-          // Make sure such renderers get scheduled for later work.
+  return null;
+}
 
-          if (finalizeInitialChildren(instance, _type, newProps)) {
-            markUpdate(workInProgress);
-          }
-        }
+function makeErrorInfo(digest, componentStack) {
+  {
+    var errorInfo = {
+      componentStack: componentStack,
+      digest: digest
+    };
+    Object.defineProperty(errorInfo, "digest", {
+      configurable: false,
+      enumerable: true,
+      get: function () {
+        error(
+          'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
+            " This property is deprecated and will be removed in a future version of React." +
+            " To access the digest of an Error look for this property on the Error instance itself."
+        );
 
-        if (workInProgress.ref !== null) {
-          // If there is a ref on a host node we need to schedule a callback
-          markRef(workInProgress);
-        }
+        return digest;
       }
+    });
+    return errorInfo;
+  }
+}
 
-      bubbleProperties(workInProgress);
-      return null;
-    }
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    var pooledCacheLanes = (root.pooledCacheLanes &= remainingLanes);
 
-    case HostText: {
-      var newText = newProps;
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      var pooledCache = root.pooledCache;
 
-      if (current && workInProgress.stateNode != null) {
-        var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
-        // to schedule a side-effect to do the updates.
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
+      }
+    }
+  }
+}
 
-        updateHostText(current, workInProgress, oldText, newText);
-      } else {
-        if (typeof newText !== "string") {
-          if (workInProgress.stateNode === null) {
-            throw new Error(
-              "We must have new props for new mounts. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          } // This can happen when we abort work.
-        }
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    var root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
 
-        var _rootContainerInstance2 = getRootHostContainer();
+    var remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    var prevTransition = ReactCurrentBatchConfig$1.transition;
+    var previousPriority = getCurrentUpdatePriority();
 
-        var _currentHostContext3 = getHostContext();
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
 
-        var _wasHydrated3 = popHydrationState(workInProgress);
+      releaseRootPooledCache(root, remainingLanes);
+    }
+  }
 
-        if (_wasHydrated3) {
-          if (prepareToHydrateHostTextInstance(workInProgress)) {
-            markUpdate(workInProgress);
-          }
-        } else {
-          workInProgress.stateNode = createTextInstance(
-            newText,
-            _rootContainerInstance2,
-            _currentHostContext3,
-            workInProgress
-          );
-        }
-      }
+  return false;
+}
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  {
+    pendingPassiveProfilerEffects.push(fiber);
 
-      bubbleProperties(workInProgress);
-      return null;
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects();
+        return null;
+      });
     }
+  }
+}
 
-    case SuspenseComponent: {
-      popSuspenseHandler(workInProgress);
-      var nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
-      // to its own fiber type so that we can add other kinds of hydration
-      // boundaries that aren't associated with a Suspense tree. In anticipation
-      // of such a refactor, all the hydration logic is contained in
-      // this branch.
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
 
-      if (
-        current === null ||
-        (current.memoizedState !== null &&
-          current.memoizedState.dehydrated !== null)
-      ) {
-        var fallthroughToNormalSuspensePath =
-          completeDehydratedSuspenseBoundary(
-            current,
-            workInProgress,
-            nextState
-          );
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects;
+  var lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
+
+  pendingPassiveEffectsLanes = NoLanes;
+
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Cannot flush passive effects while already rendering.");
+  }
+
+  {
+    isFlushingPassiveEffects = true;
+    didScheduleUpdateDuringPassiveEffects = false;
 
-        if (!fallthroughToNormalSuspensePath) {
-          if (workInProgress.flags & ShouldCapture) {
-            // Special case. There were remaining unhydrated nodes. We treat
-            // this as a mismatch. Revert to client rendering.
-            return workInProgress;
-          } else {
-            // Did not finish hydrating, either because this is the initial
-            // render or because something suspended.
-            return null;
-          }
-        } // Continue with the normal Suspense path.
-      }
+    if (enableDebugTracing) {
+      logPassiveEffectsStarted(lanes);
+    }
+  }
 
-      if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
-        // Something suspended. Re-render with the fallback children.
-        workInProgress.lanes = renderLanes; // Do not reset the effect list.
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStarted(lanes);
+  }
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        } // Don't bubble properties in this case.
+  var prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
 
-        return workInProgress;
-      }
+  {
+    var profilerEffects = pendingPassiveProfilerEffects;
+    pendingPassiveProfilerEffects = [];
 
-      var nextDidTimeout = nextState !== null;
-      var prevDidTimeout = current !== null && current.memoizedState !== null;
+    for (var i = 0; i < profilerEffects.length; i++) {
+      var fiber = profilerEffects[i];
+      commitPassiveEffectDurations(root, fiber);
+    }
+  }
 
-      if (nextDidTimeout) {
-        var offscreenFiber = workInProgress.child;
-        var _previousCache = null;
+  {
+    if (enableDebugTracing) {
+      logPassiveEffectsStopped();
+    }
+  }
 
-        if (
-          offscreenFiber.alternate !== null &&
-          offscreenFiber.alternate.memoizedState !== null &&
-          offscreenFiber.alternate.memoizedState.cachePool !== null
-        ) {
-          _previousCache =
-            offscreenFiber.alternate.memoizedState.cachePool.pool;
-        }
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStopped();
+  }
 
-        var _cache = null;
+  {
+    commitDoubleInvokeEffectsInDEV(root, true);
+  }
 
-        if (
-          offscreenFiber.memoizedState !== null &&
-          offscreenFiber.memoizedState.cachePool !== null
-        ) {
-          _cache = offscreenFiber.memoizedState.cachePool.pool;
-        }
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
 
-        if (_cache !== _previousCache) {
-          // Run passive effects to retain/release the cache.
-          offscreenFiber.flags |= Passive$1;
-        }
-      } // If the suspended state of the boundary changes, we need to schedule
-      // a passive effect, which is when we process the transitions
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    var prevEndTime = currentEndTime;
 
-      if (nextDidTimeout !== prevDidTimeout) {
-        if (enableTransitionTracing) {
-          var _offscreenFiber = workInProgress.child;
-          _offscreenFiber.flags |= Passive$1;
-        } // If the suspended state of the boundary changes, we need to schedule
-        // an effect to toggle the subtree's visibility. When we switch from
-        // fallback -> primary, the inner Offscreen fiber schedules this effect
-        // as part of its normal complete phase. But when we switch from
-        // primary -> fallback, the inner Offscreen fiber does not have a complete
-        // phase. So we need to schedule its effect here.
-        //
-        // We also use this flag to connect/disconnect the effects, but the same
-        // logic applies: when re-connecting, the Offscreen fiber's complete
-        // phase will handle scheduling the effect. It's only when the fallback
-        // is active that we have to do anything special.
+    if (
+      prevPendingTransitionCallbacks !== null &&
+      prevRootTransitionCallbacks !== null &&
+      prevEndTime !== null
+    ) {
+      currentPendingTransitionCallbacks = null;
+      currentEndTime = null;
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
+        );
+      });
+    }
+  }
 
-        if (nextDidTimeout) {
-          var _offscreenFiber2 = workInProgress.child;
-          _offscreenFiber2.flags |= Visibility;
-        }
+  {
+    // If additional passive effects were scheduled, increment a counter. If this
+    // exceeds the limit, we'll fire a warning.
+    if (didScheduleUpdateDuringPassiveEffects) {
+      if (root === rootWithPassiveNestedUpdates) {
+        nestedPassiveUpdateCount++;
+      } else {
+        nestedPassiveUpdateCount = 0;
+        rootWithPassiveNestedUpdates = root;
       }
+    } else {
+      nestedPassiveUpdateCount = 0;
+    }
 
-      var wakeables = workInProgress.updateQueue;
+    isFlushingPassiveEffects = false;
+    didScheduleUpdateDuringPassiveEffects = false;
+  } // TODO: Move to commitPassiveMountEffects
 
-      if (wakeables !== null) {
-        // Schedule an effect to attach a retry listener to the promise.
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+  onPostCommitRoot(root);
 
-      if (
-        workInProgress.updateQueue !== null &&
-        workInProgress.memoizedProps.suspenseCallback != null
-      ) {
-        // Always notify the callback
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+  {
+    var stateNode = root.current.stateNode;
+    stateNode.effectDuration = 0;
+    stateNode.passiveEffectDuration = 0;
+  }
 
-      bubbleProperties(workInProgress);
+  return true;
+}
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          if (nextDidTimeout) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var primaryChildFragment = workInProgress.child;
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return (
+    legacyErrorBoundariesThatAlreadyFailed !== null &&
+    legacyErrorBoundariesThatAlreadyFailed.has(instance)
+  );
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
 
-            if (primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                primaryChildFragment.treeBaseDuration;
-            }
-          }
-        }
-      }
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
+  }
+}
 
-      return null;
-    }
+var onUncaughtError = prepareToThrowUncaughtError;
 
-    case HostPortal:
-      popHostContainer(workInProgress);
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  var errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  var root = enqueueUpdate(rootFiber, update, SyncLane);
+  var eventTime = requestEventTime();
 
-      if (current === null) {
-        preparePortalMount(workInProgress.stateNode.containerInfo);
-      }
+  if (root !== null) {
+    markRootUpdated(root, SyncLane, eventTime);
+    ensureRootIsScheduled(root, eventTime);
+  }
+}
 
-      bubbleProperties(workInProgress);
-      return null;
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
+  {
+    reportUncaughtErrorInDEV(error$1);
+    setIsRunningInsertionEffect(false);
+  }
 
-    case ContextProvider:
-      // Pop provider fiber
-      var context = workInProgress.type._context;
-      popProvider(context, workInProgress);
-      bubbleProperties(workInProgress);
-      return null;
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error$1);
+    return;
+  }
 
-    case IncompleteClassComponent: {
-      bubbleProperties(workInProgress);
-      return null;
-    }
+  var fiber = null;
 
-    case SuspenseListComponent: {
-      popSuspenseListContext(workInProgress);
-      var renderState = workInProgress.memoizedState;
+  if (skipUnmountedBoundaries) {
+    fiber = nearestMountedAncestor;
+  } else {
+    fiber = sourceFiber.return;
+  }
 
-      if (renderState === null) {
-        // We're running in the default, "independent" mode.
-        // We don't do anything in this mode.
-        bubbleProperties(workInProgress);
-        return null;
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error$1);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      var ctor = fiber.type;
+      var instance = fiber.stateNode;
+
+      if (
+        typeof ctor.getDerivedStateFromError === "function" ||
+        (typeof instance.componentDidCatch === "function" &&
+          !isAlreadyFailedLegacyErrorBoundary(instance))
+      ) {
+        var errorInfo = createCapturedValueAtFiber(error$1, sourceFiber);
+        var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        var root = enqueueUpdate(fiber, update, SyncLane);
+        var eventTime = requestEventTime();
+
+        if (root !== null) {
+          markRootUpdated(root, SyncLane, eventTime);
+          ensureRootIsScheduled(root, eventTime);
+        }
+
+        return;
       }
+    }
 
-      var didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
-      var renderedTail = renderState.rendering;
+    fiber = fiber.return;
+  }
 
-      if (renderedTail === null) {
-        // We just rendered the head.
-        if (!didSuspendAlready) {
-          // This is the first pass. We need to figure out if anything is still
-          // suspended in the rendered set.
-          // If new content unsuspended, but there's still some content that
-          // didn't. Then we need to do a second pass that forces everything
-          // to keep showing their fallbacks.
-          // We might be suspended if something in this render pass suspended, or
-          // something in the previous committed pass suspended. Otherwise,
-          // there's no chance so we can skip the expensive call to
-          // findFirstSuspended.
-          var cannotBeSuspended =
-            renderHasNotSuspendedYet() &&
-            (current === null || (current.flags & DidCapture) === NoFlags$1);
+  {
+    // TODO: Until we re-land skipUnmountedBoundaries (see #20147), this warning
+    // will fire for errors that are thrown by destroy functions inside deleted
+    // trees. What it should instead do is propagate the error to the parent of
+    // the deleted tree. In the meantime, do not add this warning to the
+    // allowlist; this is only for our internal use.
+    error(
+      "Internal React error: Attempted to capture a commit phase error " +
+        "inside a detached tree. This indicates a bug in React. Likely " +
+        "causes include deleting the same fiber more than once, committing an " +
+        "already-finished tree, or an inconsistent return pointer.\n\n" +
+        "Error message:\n\n%s",
+      error$1
+    );
+  }
+}
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
+  //
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
+  //
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  var pingCache = root.pingCache;
+  var threadIDs;
 
-          if (!cannotBeSuspended) {
-            var row = workInProgress.child;
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
 
-            while (row !== null) {
-              var suspended = findFirstSuspended(row);
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    }
+  }
 
-              if (suspended !== null) {
-                didSuspendAlready = true;
-                workInProgress.flags |= DidCapture;
-                cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
-                // part of the second pass. In that case nothing will subscribe to
-                // its thenables. Instead, we'll transfer its thenables to the
-                // SuspenseList so that it can retry if they resolve.
-                // There might be multiple of these in the list but since we're
-                // going to wait for all of them anyway, it doesn't really matter
-                // which ones gets to ping. In theory we could get clever and keep
-                // track of how many dependencies remain but it gets tricky because
-                // in the meantime, we can add/remove/change items and dependencies.
-                // We might bail out of the loop before finding any but that
-                // doesn't matter since that means that the other boundaries that
-                // we did find already has their listeners attached.
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
 
-                var newThenables = suspended.updateQueue;
+    threadIDs.add(lanes);
+    var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
 
-                if (newThenables !== null) {
-                  workInProgress.updateQueue = newThenables;
-                  workInProgress.flags |= Update;
-                } // Rerender the whole list, but this time, we'll force fallbacks
-                // to stay in place.
-                // Reset the effect flags before doing the second pass since that's now invalid.
-                // Reset the child fibers to their original state.
+    {
+      if (isDevToolsPresent) {
+        // If we have pending work still, restore the original updaters
+        restorePendingUpdaters(root, lanes);
+      }
+    }
 
-                workInProgress.subtreeFlags = NoFlags$1;
-                resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
-                // immediately rerender the children.
+    wakeable.then(ping, ping);
+  }
+}
 
-                pushSuspenseListContext(
-                  workInProgress,
-                  setShallowSuspenseListContext(
-                    suspenseStackCursor.current,
-                    ForceSuspenseFallback
-                  )
-                ); // Don't bubble properties in this case.
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
 
-                return workInProgress.child;
-              }
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
 
-              row = row.sibling;
-            }
-          }
+  var eventTime = requestEventTime();
+  markRootPinged(root, pingedLanes);
+  warnIfSuspenseResolutionNotWrappedWithActDEV(root);
 
-          if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
-            // We have already passed our CPU deadline but we still have rows
-            // left in the tail. We'll just give up further attempts to render
-            // the main content and only render fallbacks.
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true;
-            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
-            // to get it started back up to attempt the next item. While in terms
-            // of priority this work has the same priority as this current render,
-            // it's not part of the same transition once the transition has
-            // committed. If it's sync, we still want to yield so that it can be
-            // painted. Conceptually, this is really the same as pinging.
-            // We can use any RetryLane even if it's the one currently rendering
-            // since we're leaving it behind on this node.
+  if (
+    workInProgressRoot === root &&
+    isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)
+  ) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (
+      workInProgressRootExitStatus === RootSuspendedWithDelay ||
+      (workInProgressRootExitStatus === RootSuspended &&
+        includesOnlyRetries(workInProgressRootRenderLanes) &&
+        now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
+    ) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
+      }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(
+        workInProgressRootPingedLanes,
+        pingedLanes
+      );
+    }
+  }
 
-            workInProgress.lanes = SomeRetryLane;
-          }
-        } else {
-          cutOffTailIfNeeded(renderState, false);
-        } // Next we're going to render the tail.
-      } else {
-        // Append the rendered row to the child list.
-        if (!didSuspendAlready) {
-          var _suspended = findFirstSuspended(renderedTail);
+  ensureRootIsScheduled(root, eventTime);
+}
 
-          if (_suspended !== null) {
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
-            // get lost if this row ends up dropped during a second pass.
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
 
-            var _newThenables = _suspended.updateQueue;
+  var eventTime = requestEventTime();
+  var root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
 
-            if (_newThenables !== null) {
-              workInProgress.updateQueue = _newThenables;
-              workInProgress.flags |= Update;
-            }
+  if (root !== null) {
+    markRootUpdated(root, retryLane, eventTime);
+    ensureRootIsScheduled(root, eventTime);
+  }
+}
 
-            cutOffTailIfNeeded(renderState, true); // This might have been modified.
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState;
+  var retryLane = NoLane;
 
-            if (
-              renderState.tail === null &&
-              renderState.tailMode === "hidden" &&
-              !renderedTail.alternate &&
-              !getIsHydrating() // We don't cut it if we're hydrating.
-            ) {
-              // We're done.
-              bubbleProperties(workInProgress);
-              return null;
-            }
-          } else if (
-            // The time it took to render last row is greater than the remaining
-            // time we have to render. So rendering one more row would likely
-            // exceed it.
-            now$1() * 2 - renderState.renderingStartTime >
-              getRenderTargetTime() &&
-            renderLanes !== OffscreenLane
-          ) {
-            // We have now passed our CPU deadline and we'll just give up further
-            // attempts to render the main content and only render fallbacks.
-            // The assumption is that this is usually faster.
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true;
-            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
-            // to get it started back up to attempt the next item. While in terms
-            // of priority this work has the same priority as this current render,
-            // it's not part of the same transition once the transition has
-            // committed. If it's sync, we still want to yield so that it can be
-            // painted. Conceptually, this is really the same as pinging.
-            // We can use any RetryLane even if it's the one currently rendering
-            // since we're leaving it behind on this node.
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
 
-            workInProgress.lanes = SomeRetryLane;
-          }
-        }
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = NoLane; // Default
 
-        if (renderState.isBackwards) {
-          // The effect list of the backwards tail will have been added
-          // to the end. This breaks the guarantee that life-cycles fire in
-          // sibling order but that isn't a strong guarantee promised by React.
-          // Especially since these might also just pop in during future commits.
-          // Append to the beginning of the list.
-          renderedTail.sibling = workInProgress.child;
-          workInProgress.child = renderedTail;
-        } else {
-          var previousSibling = renderState.last;
+  var retryCache;
 
-          if (previousSibling !== null) {
-            previousSibling.sibling = renderedTail;
-          } else {
-            workInProgress.child = renderedTail;
-          }
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
 
-          renderState.last = renderedTail;
-        }
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
       }
 
-      if (renderState.tail !== null) {
-        // We still have tail rows to render.
-        // Pop a row.
-        var next = renderState.tail;
-        renderState.rendering = next;
-        renderState.tail = next.sibling;
-        renderState.renderingStartTime = now$1();
-        next.sibling = null; // Restore the context.
-        // TODO: We can probably just avoid popping it instead and only
-        // setting it the first time we go from not suspended to suspended.
+      break;
 
-        var suspenseContext = suspenseStackCursor.current;
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
 
-        if (didSuspendAlready) {
-          suspenseContext = setShallowSuspenseListContext(
-            suspenseContext,
-            ForceSuspenseFallback
-          );
-        } else {
-          suspenseContext =
-            setDefaultShallowSuspenseListContext(suspenseContext);
-        }
+    case OffscreenComponent: {
+      var instance = boundaryFiber.stateNode;
+      retryCache = instance._retryCache;
+      break;
+    }
 
-        pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
-        // Don't bubble properties in this case.
+    default:
+      throw new Error(
+        "Pinged unknown suspense boundary type. " +
+          "This is probably a bug in React."
+      );
+  }
 
-        return next;
-      }
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
+  }
 
-      bubbleProperties(workInProgress);
-      return null;
-    }
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+} // Computes the next Just Noticeable Difference (JND) boundary.
+// The theory is that a person can't tell the difference between small differences in time.
+// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
+// difference in the experience. However, waiting for longer might mean that we can avoid
+// showing an intermediate loading state. The longer we have already waited, the harder it
+// is to tell small differences in time. Therefore, the longer we've already waited,
+// the longer we can wait additionally. At some point we have to give up though.
+// We pick a train model where the next boundary commits at a consistent schedule.
+// These particular numbers are vague estimates. We expect to adjust them based on research.
 
-    case ScopeComponent: {
-      {
-        if (current === null) {
-          var scopeInstance = createScopeInstance();
-          workInProgress.stateNode = scopeInstance;
-          prepareScopeUpdate(scopeInstance, workInProgress);
+function jnd(timeElapsed) {
+  return timeElapsed < 120
+    ? 120
+    : timeElapsed < 480
+    ? 480
+    : timeElapsed < 1080
+    ? 1080
+    : timeElapsed < 1920
+    ? 1920
+    : timeElapsed < 3000
+    ? 3000
+    : timeElapsed < 4320
+    ? 4320
+    : ceil(timeElapsed / 1960) * 1960;
+}
 
-          if (workInProgress.ref !== null) {
-            markRef(workInProgress);
-            markUpdate(workInProgress);
-          }
-        } else {
-          if (workInProgress.ref !== null) {
-            markUpdate(workInProgress);
-          }
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    nestedPassiveUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    rootWithPassiveNestedUpdates = null;
+    throw new Error(
+      "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."
+    );
+  }
 
-          if (current.ref !== workInProgress.ref) {
-            markRef(workInProgress);
-          }
-        }
+  {
+    if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
+      nestedPassiveUpdateCount = 0;
+      rootWithPassiveNestedUpdates = null;
 
-        bubbleProperties(workInProgress);
-        return null;
-      }
+      error(
+        "Maximum update depth exceeded. This can happen when a component " +
+          "calls setState inside useEffect, but useEffect either doesn't " +
+          "have a dependency array, or one of the dependencies changes on " +
+          "every render."
+      );
     }
+  }
+}
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      popSuspenseHandler(workInProgress);
-      popHiddenContext(workInProgress);
-      var _nextState = workInProgress.memoizedState;
-      var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
+function flushRenderPhaseStrictModeWarningsInDEV() {
+  {
+    ReactStrictModeWarnings.flushLegacyContextWarning();
+    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+  }
+}
 
-      if (workInProgress.tag === LegacyHiddenComponent);
-      else {
-        if (current !== null) {
-          var _prevState = current.memoizedState;
-          var prevIsHidden = _prevState !== null;
+function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
+  {
+    {
+      legacyCommitDoubleInvokeEffectsInDEV(root.current, hasPassiveEffects);
+    }
+  }
+}
 
-          if (prevIsHidden !== nextIsHidden) {
-            workInProgress.flags |= Visibility;
-          }
-        } else {
-          // On initial mount, we only need a Visibility effect if the tree
-          // is hidden.
-          if (nextIsHidden) {
-            workInProgress.flags |= Visibility;
-          }
-        }
-      }
+function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
+  // TODO (StrictEffects) Should we set a marker on the root if it contains strict effects
+  // so we don't traverse unnecessarily? similar to subtreeFlags but just at the root level.
+  // Maybe not a big deal since this is DEV only behavior.
+  setCurrentFiber(fiber);
+  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectUnmountInDEV);
 
-      if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
-        bubbleProperties(workInProgress);
-      } else {
-        // Don't bubble properties for hidden children unless we're rendering
-        // at offscreen priority.
-        if (
-          includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
-          (workInProgress.flags & DidCapture) === NoLanes
-        ) {
-          bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
-          // If so, we need to hide those nodes in the commit phase, so
-          // schedule a visibility effect.
+  if (hasPassiveEffects) {
+    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectUnmountInDEV);
+  }
 
-          if (
-            workInProgress.tag !== LegacyHiddenComponent &&
-            workInProgress.subtreeFlags & (Placement | Update)
-          ) {
-            workInProgress.flags |= Visibility;
-          }
-        }
-      }
+  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectMountInDEV);
 
-      if (workInProgress.updateQueue !== null) {
-        // Schedule an effect to attach Suspense retry listeners
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+  if (hasPassiveEffects) {
+    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectMountInDEV);
+  }
 
-      {
-        var _previousCache2 = null;
+  resetCurrentFiber();
+}
 
-        if (
-          current !== null &&
-          current.memoizedState !== null &&
-          current.memoizedState.cachePool !== null
-        ) {
-          _previousCache2 = current.memoizedState.cachePool.pool;
-        }
+function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
+  var current = firstChild;
+  var subtreeRoot = null;
 
-        var _cache2 = null;
+  while (current != null) {
+    var primarySubtreeFlag = current.subtreeFlags & fiberFlags;
 
-        if (
-          workInProgress.memoizedState !== null &&
-          workInProgress.memoizedState.cachePool !== null
-        ) {
-          _cache2 = workInProgress.memoizedState.cachePool.pool;
-        }
+    if (
+      current !== subtreeRoot &&
+      current.child != null &&
+      primarySubtreeFlag !== NoFlags$1
+    ) {
+      current = current.child;
+    } else {
+      if ((current.flags & fiberFlags) !== NoFlags$1) {
+        invokeEffectFn(current);
+      }
 
-        if (_cache2 !== _previousCache2) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
-        }
+      if (current.sibling !== null) {
+        current = current.sibling;
+      } else {
+        current = subtreeRoot = current.return;
       }
+    }
+  }
+}
 
-      popTransition(workInProgress, current);
-      return null;
+var didWarnStateUpdateForNotYetMountedComponent = null;
+function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
+  {
+    if ((executionContext & RenderContext) !== NoContext) {
+      // We let the other warning about render phase updates deal with this one.
+      return;
     }
 
-    case CacheComponent: {
-      {
-        var _previousCache3 = null;
+    if (!(fiber.mode & ConcurrentMode)) {
+      return;
+    }
 
-        if (current !== null) {
-          _previousCache3 = current.memoizedState.cache;
-        }
+    var tag = fiber.tag;
 
-        var _cache3 = workInProgress.memoizedState.cache;
+    if (
+      tag !== IndeterminateComponent &&
+      tag !== HostRoot &&
+      tag !== ClassComponent &&
+      tag !== FunctionComponent &&
+      tag !== ForwardRef &&
+      tag !== MemoComponent &&
+      tag !== SimpleMemoComponent
+    ) {
+      // Only warn for user-defined components, not internal ones like Suspense.
+      return;
+    } // We show the whole stack but dedupe on the top component's name because
+    // the problematic code almost always lies inside that component.
 
-        if (_cache3 !== _previousCache3) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
-        }
+    var componentName = getComponentNameFromFiber(fiber) || "ReactComponent";
 
-        popCacheProvider(workInProgress);
-        bubbleProperties(workInProgress);
-      }
+    if (didWarnStateUpdateForNotYetMountedComponent !== null) {
+      if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-      return null;
+      didWarnStateUpdateForNotYetMountedComponent.add(componentName);
+    } else {
+      didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
     }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        var _instance3 = workInProgress.stateNode;
+    var previousFiber = current;
 
-        if (_instance3 !== null) {
-          popMarkerInstance(workInProgress);
-        }
+    try {
+      setCurrentFiber(fiber);
 
-        bubbleProperties(workInProgress);
+      error(
+        "Can't perform a React state update on a component that hasn't mounted yet. " +
+          "This indicates that you have a side-effect in your render function that " +
+          "asynchronously later calls tries to update the component. Move this work to " +
+          "useEffect instead."
+      );
+    } finally {
+      if (previousFiber) {
+        setCurrentFiber(fiber);
+      } else {
+        resetCurrentFiber();
       }
-
-      return null;
     }
   }
-
-  throw new Error(
-    "Unknown unit of work tag (" +
-      workInProgress.tag +
-      "). This error is likely caused by a bug in " +
-      "React. Please file an issue."
-  );
 }
+var beginWork;
 
-function unwindWork(current, workInProgress, renderLanes) {
-  // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
-  popTreeContext(workInProgress);
-
-  switch (workInProgress.tag) {
-    case ClassComponent: {
-      var flags = workInProgress.flags;
+if (replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+  var dummyFiber = null;
 
-      if (flags & ShouldCapture) {
-        workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
+  beginWork = function (current, unitOfWork, lanes) {
+    // If a component throws an error, we replay it again in a synchronously
+    // dispatched event, so that the debugger will treat it as an uncaught
+    // error See ReactErrorUtils for more information.
+    // Before entering the begin phase, copy the work-in-progress onto a dummy
+    // fiber. If beginWork throws, we'll use this to reset the state.
+    var originalWorkInProgressCopy = assignFiberPropertiesInDEV(
+      dummyFiber,
+      unitOfWork
+    );
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        }
+    try {
+      return beginWork$1(current, unitOfWork, lanes);
+    } catch (originalError) {
+      if (
+        didSuspendOrErrorWhileHydratingDEV() ||
+        originalError === SuspenseException ||
+        originalError === SelectiveHydrationException ||
+        (originalError !== null &&
+          typeof originalError === "object" &&
+          typeof originalError.then === "function")
+      ) {
+        // Don't replay promises.
+        // Don't replay errors if we are hydrating and have already suspended or handled an error
+        throw originalError;
+      } // Don't reset current debug fiber, since we're about to work on the
+      // same fiber again.
+      // Unwind the failed stack frame
 
-        return workInProgress;
-      }
+      resetSuspendedWorkLoopOnUnwind();
+      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
 
-      return null;
-    }
+      assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
 
-    case HostRoot: {
-      {
-        popCacheProvider(workInProgress);
-      }
+      if (unitOfWork.mode & ProfileMode) {
+        // Reset the profiler timer.
+        startProfilerTimer(unitOfWork);
+      } // Run beginWork again.
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(workInProgress);
-      }
+      invokeGuardedCallback(
+        null,
+        beginWork$1,
+        null,
+        current,
+        unitOfWork,
+        lanes
+      );
 
-      popRootTransition(workInProgress);
-      popHostContainer(workInProgress);
-      resetWorkInProgressVersions();
-      var _flags = workInProgress.flags;
+      if (hasCaughtError()) {
+        var replayError = clearCaughtError();
 
-      if (
-        (_flags & ShouldCapture) !== NoFlags$1 &&
-        (_flags & DidCapture) === NoFlags$1
-      ) {
-        // There was an error during render that wasn't captured by a suspense
-        // boundary. Do a second pass on the root to unmount the children.
-        workInProgress.flags = (_flags & ~ShouldCapture) | DidCapture;
-        return workInProgress;
-      } // We unwound to the root without completing it. Exit.
+        if (
+          typeof replayError === "object" &&
+          replayError !== null &&
+          replayError._suppressLogging &&
+          typeof originalError === "object" &&
+          originalError !== null &&
+          !originalError._suppressLogging
+        ) {
+          // If suppressed, let the flag carry over to the original error which is the one we'll rethrow.
+          originalError._suppressLogging = true;
+        }
+      } // We always throw the original error in case the second render pass is not idempotent.
+      // This can happen if a memoized function or CommonJS module doesn't throw after first invocation.
 
-      return null;
+      throw originalError;
     }
+  };
+} else {
+  beginWork = beginWork$1;
+}
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      // TODO: popHydrationState
-      popHostContext(workInProgress);
-      return null;
-    }
+var didWarnAboutUpdateInRender = false;
+var didWarnAboutUpdateInRenderForAnotherComponent;
 
-    case SuspenseComponent: {
-      popSuspenseHandler(workInProgress);
-      var suspenseState = workInProgress.memoizedState;
+{
+  didWarnAboutUpdateInRenderForAnotherComponent = new Set();
+}
 
-      if (suspenseState !== null && suspenseState.dehydrated !== null) {
-        if (workInProgress.alternate === null) {
-          throw new Error(
-            "Threw in newly mounted dehydrated component. This is likely a bug in " +
-              "React. Please file an issue."
-          );
-        }
+function warnAboutRenderPhaseUpdatesInDEV(fiber) {
+  {
+    if (isRendering) {
+      switch (fiber.tag) {
+        case FunctionComponent:
+        case ForwardRef:
+        case SimpleMemoComponent: {
+          var renderingComponentName =
+            (workInProgress && getComponentNameFromFiber(workInProgress)) ||
+            "Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
 
-        resetHydrationState();
-      }
+          var dedupeKey = renderingComponentName;
 
-      var _flags2 = workInProgress.flags;
+          if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
+            didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
+            var setStateComponentName =
+              getComponentNameFromFiber(fiber) || "Unknown";
+
+            error(
+              "Cannot update a component (`%s`) while rendering a " +
+                "different component (`%s`). To locate the bad setState() call inside `%s`, " +
+                "follow the stack trace as described in https://reactjs.org/link/setstate-in-render",
+              setStateComponentName,
+              renderingComponentName,
+              renderingComponentName
+            );
+          }
+
+          break;
+        }
+
+        case ClassComponent: {
+          if (!didWarnAboutUpdateInRender) {
+            error(
+              "Cannot update during an existing state transition (such as " +
+                "within `render`). Render methods should be a pure " +
+                "function of props and state."
+            );
 
-      if (_flags2 & ShouldCapture) {
-        workInProgress.flags = (_flags2 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+            didWarnAboutUpdateInRender = true;
+          }
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
+          break;
         }
-
-        return workInProgress;
       }
+    }
+  }
+}
 
-      return null;
+function restorePendingUpdaters(root, lanes) {
+  {
+    if (isDevToolsPresent) {
+      var memoizedUpdaters = root.memoizedUpdaters;
+      memoizedUpdaters.forEach(function (schedulingFiber) {
+        addFiberToLanesMap(root, schedulingFiber, lanes);
+      }); // This function intentionally does not clear memoized updaters.
+      // Those may still be relevant to the current commit
+      // and a future one (e.g. Suspense).
     }
+  }
+}
+var fakeActCallbackNode = {}; // $FlowFixMe[missing-local-annot]
 
-    case SuspenseListComponent: {
-      popSuspenseListContext(workInProgress); // SuspenseList doesn't actually catch anything. It should've been
-      // caught by a nested boundary. If not, it should bubble through.
+function scheduleCallback(priorityLevel, callback) {
+  {
+    // If we're currently inside an `act` scope, bypass Scheduler and push to
+    // the `act` queue instead.
+    var actQueue = ReactCurrentActQueue.current;
 
-      return null;
+    if (actQueue !== null) {
+      actQueue.push(callback);
+      return fakeActCallbackNode;
+    } else {
+      return scheduleCallback$2(priorityLevel, callback);
     }
+  }
+}
 
-    case HostPortal:
-      popHostContainer(workInProgress);
-      return null;
-
-    case ContextProvider:
-      var context = workInProgress.type._context;
-      popProvider(context, workInProgress);
-      return null;
+function cancelCallback(callbackNode) {
+  if (callbackNode === fakeActCallbackNode) {
+    return;
+  } // In production, always call Scheduler. This function will be stripped out.
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      popSuspenseHandler(workInProgress);
-      popHiddenContext(workInProgress);
-      popTransition(workInProgress, current);
-      var _flags3 = workInProgress.flags;
+  return cancelCallback$1(callbackNode);
+}
 
-      if (_flags3 & ShouldCapture) {
-        workInProgress.flags = (_flags3 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+function shouldForceFlushFallbacksInDEV() {
+  // Never force flush in production. This function should get stripped out.
+  return ReactCurrentActQueue.current !== null;
+}
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        }
+function warnIfUpdatesNotWrappedWithActDEV(fiber) {
+  {
+    if (fiber.mode & ConcurrentMode) {
+      if (!isConcurrentActEnvironment()) {
+        // Not in an act environment. No need to warn.
+        return;
+      }
+    } else {
+      // Legacy mode has additional cases where we suppress a warning.
+      if (!isLegacyActEnvironment()) {
+        // Not in an act environment. No need to warn.
+        return;
+      }
 
-        return workInProgress;
+      if (executionContext !== NoContext) {
+        // Legacy mode doesn't warn if the update is batched, i.e.
+        // batchedUpdates or flushSync.
+        return;
       }
 
-      return null;
+      if (
+        fiber.tag !== FunctionComponent &&
+        fiber.tag !== ForwardRef &&
+        fiber.tag !== SimpleMemoComponent
+      ) {
+        // For backwards compatibility with pre-hooks code, legacy mode only
+        // warns for updates that originate from a hook.
+        return;
+      }
     }
 
-    case CacheComponent:
-      {
-        popCacheProvider(workInProgress);
-      }
+    if (ReactCurrentActQueue.current === null) {
+      var previousFiber = current;
 
-      return null;
+      try {
+        setCurrentFiber(fiber);
 
-    case TracingMarkerComponent:
-      if (enableTransitionTracing) {
-        if (workInProgress.stateNode !== null) {
-          popMarkerInstance(workInProgress);
+        error(
+          "An update to %s inside a test was not wrapped in act(...).\n\n" +
+            "When testing, code that causes React state updates should be " +
+            "wrapped into act(...):\n\n" +
+            "act(() => {\n" +
+            "  /* fire events that update state */\n" +
+            "});\n" +
+            "/* assert on the output */\n\n" +
+            "This ensures that you're testing the behavior the user would see " +
+            "in the browser." +
+            " Learn more at https://reactjs.org/link/wrap-tests-with-act",
+          getComponentNameFromFiber(fiber)
+        );
+      } finally {
+        if (previousFiber) {
+          setCurrentFiber(fiber);
+        } else {
+          resetCurrentFiber();
         }
       }
+    }
+  }
+}
 
-      return null;
+function warnIfSuspenseResolutionNotWrappedWithActDEV(root) {
+  {
+    if (
+      root.tag !== LegacyRoot &&
+      isConcurrentActEnvironment() &&
+      ReactCurrentActQueue.current === null
+    ) {
+      error(
+        "A suspended resource finished loading inside a test, but the event " +
+          "was not wrapped in act(...).\n\n" +
+          "When testing, code that resolves suspended data should be wrapped " +
+          "into act(...):\n\n" +
+          "act(() => {\n" +
+          "  /* finish loading suspended data */\n" +
+          "});\n" +
+          "/* assert on the output */\n\n" +
+          "This ensures that you're testing the behavior the user would see " +
+          "in the browser." +
+          " Learn more at https://reactjs.org/link/wrap-tests-with-act"
+      );
+    }
+  }
+}
 
-    default:
-      return null;
+function setIsRunningInsertionEffect(isRunning) {
+  {
+    isRunningInsertionEffect = isRunning;
   }
 }
 
-function unwindInterruptedWork(current, interruptedWork, renderLanes) {
-  // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
-  popTreeContext(interruptedWork);
+/* eslint-disable react-internal/prod-error-codes */
+// Used by React Refresh runtime through DevTools Global Hook.
 
-  switch (interruptedWork.tag) {
-    case ClassComponent: {
-      break;
+var resolveFamily = null;
+var failedBoundaries = null;
+var setRefreshHandler = function (handler) {
+  {
+    resolveFamily = handler;
+  }
+};
+function resolveFunctionForHotReloading(type) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return type;
     }
 
-    case HostRoot: {
-      {
-        popCacheProvider(interruptedWork);
-      }
+    var family = resolveFamily(type);
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(interruptedWork);
-      }
+    if (family === undefined) {
+      return type;
+    } // Use the latest known implementation.
 
-      popRootTransition(interruptedWork);
-      popHostContainer(interruptedWork);
-      resetWorkInProgressVersions();
-      break;
+    return family.current;
+  }
+}
+function resolveClassForHotReloading(type) {
+  // No implementation differences.
+  return resolveFunctionForHotReloading(type);
+}
+function resolveForwardRefForHotReloading(type) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return type;
     }
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      popHostContext(interruptedWork);
-      break;
-    }
+    var family = resolveFamily(type);
 
-    case HostPortal:
-      popHostContainer(interruptedWork);
-      break;
+    if (family === undefined) {
+      // Check if we're dealing with a real forwardRef. Don't want to crash early.
+      if (
+        type !== null &&
+        type !== undefined &&
+        typeof type.render === "function"
+      ) {
+        // ForwardRef is special because its resolved .type is an object,
+        // but it's possible that we only have its inner render function in the map.
+        // If that inner render function is different, we'll build a new forwardRef type.
+        var currentRender = resolveFunctionForHotReloading(type.render);
 
-    case SuspenseComponent:
-      popSuspenseHandler(interruptedWork);
-      break;
+        if (type.render !== currentRender) {
+          var syntheticType = {
+            $$typeof: REACT_FORWARD_REF_TYPE,
+            render: currentRender
+          };
 
-    case SuspenseListComponent:
-      popSuspenseListContext(interruptedWork);
-      break;
+          if (type.displayName !== undefined) {
+            syntheticType.displayName = type.displayName;
+          }
 
-    case ContextProvider:
-      var context = interruptedWork.type._context;
-      popProvider(context, interruptedWork);
-      break;
+          return syntheticType;
+        }
+      }
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent:
-      popSuspenseHandler(interruptedWork);
-      popHiddenContext(interruptedWork);
-      popTransition(interruptedWork, current);
-      break;
+      return type;
+    } // Use the latest known implementation.
 
-    case CacheComponent:
-      {
-        popCacheProvider(interruptedWork);
-      }
+    return family.current;
+  }
+}
+function isCompatibleFamilyForHotReloading(fiber, element) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return false;
+    }
 
-      break;
+    var prevType = fiber.elementType;
+    var nextType = element.type; // If we got here, we know types aren't === equal.
 
-    case TracingMarkerComponent:
-      if (enableTransitionTracing) {
-        var instance = interruptedWork.stateNode;
+    var needsCompareFamilies = false;
+    var $$typeofNextType =
+      typeof nextType === "object" && nextType !== null
+        ? nextType.$$typeof
+        : null;
 
-        if (instance !== null) {
-          popMarkerInstance(interruptedWork);
+    switch (fiber.tag) {
+      case ClassComponent: {
+        if (typeof nextType === "function") {
+          needsCompareFamilies = true;
         }
+
+        break;
       }
 
-      break;
-  }
-}
+      case FunctionComponent: {
+        if (typeof nextType === "function") {
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          // We don't know the inner type yet.
+          // We're going to assume that the lazy inner type is stable,
+          // and so it is sufficient to avoid reconciling it away.
+          // We're not going to unwrap or actually use the new lazy type.
+          needsCompareFamilies = true;
+        }
 
-var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+        break;
+      }
 
-{
-  didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
-} // Used during the commit phase to track the state of the Offscreen component stack.
-// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+      case ForwardRef: {
+        if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          needsCompareFamilies = true;
+        }
 
-var offscreenSubtreeIsHidden = false;
-var offscreenSubtreeWasHidden = false;
-var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
-var nextEffect = null; // Used for Profiling builds to track updaters.
+        break;
+      }
 
-var inProgressLanes = null;
-var inProgressRoot = null;
+      case MemoComponent:
+      case SimpleMemoComponent: {
+        if ($$typeofNextType === REACT_MEMO_TYPE) {
+          // TODO: if it was but can no longer be simple,
+          // we shouldn't set this.
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          needsCompareFamilies = true;
+        }
 
-function shouldProfile(current) {
-  return (
-    (current.mode & ProfileMode) !== NoMode &&
-    (getExecutionContext() & CommitContext) !== NoContext
-  );
-}
+        break;
+      }
 
-function reportUncaughtErrorInDEV(error) {
-  // Wrapping each small part of the commit phase into a guarded
-  // callback is a bit too slow (https://github.com/facebook/react/pull/21666).
-  // But we rely on it to surface errors to DEV tools like overlays
-  // (https://github.com/facebook/react/issues/21712).
-  // As a compromise, rethrow only caught errors in a guard.
-  {
-    invokeGuardedCallback(null, function () {
-      throw error;
-    });
-    clearCaughtError();
-  }
-}
+      default:
+        return false;
+    } // Check if both types have a family and it's the same one.
 
-function callComponentWillUnmountWithTimer(current, instance) {
-  instance.props = current.memoizedProps;
-  instance.state = current.memoizedState;
+    if (needsCompareFamilies) {
+      // Note: memo() and forwardRef() we'll compare outer rather than inner type.
+      // This means both of them need to be registered to preserve state.
+      // If we unwrapped and compared the inner types for wrappers instead,
+      // then we would risk falsely saying two separate memo(Foo)
+      // calls are equivalent because they wrap the same Foo function.
+      var prevFamily = resolveFamily(prevType); // $FlowFixMe[not-a-function] found when upgrading Flow
 
-  if (shouldProfile(current)) {
-    try {
-      startLayoutEffectTimer();
-      instance.componentWillUnmount();
-    } finally {
-      recordLayoutEffectDuration(current);
+      if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
+        return true;
+      }
     }
-  } else {
-    instance.componentWillUnmount();
-  }
-} // Capture errors so they don't interrupt unmounting.
 
-function safelyCallComponentWillUnmount(
-  current,
-  nearestMountedAncestor,
-  instance
-) {
-  try {
-    callComponentWillUnmountWithTimer(current, instance);
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
-  }
-} // Capture errors so they don't interrupt mounting.
-
-function safelyAttachRef(current, nearestMountedAncestor) {
-  try {
-    commitAttachRef(current);
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+    return false;
   }
 }
+function markFailedErrorBoundaryForHotReloading(fiber) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return;
+    }
 
-function safelyDetachRef(current, nearestMountedAncestor) {
-  var ref = current.ref;
-  var refCleanup = current.refCleanup;
-
-  if (ref !== null) {
-    if (typeof refCleanup === "function") {
-      try {
-        if (shouldProfile(current)) {
-          try {
-            startLayoutEffectTimer();
-            refCleanup();
-          } finally {
-            recordLayoutEffectDuration(current);
-          }
-        } else {
-          refCleanup();
-        }
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      } finally {
-        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
-        current.refCleanup = null;
-        var finishedWork = current.alternate;
+    if (typeof WeakSet !== "function") {
+      return;
+    }
 
-        if (finishedWork != null) {
-          finishedWork.refCleanup = null;
-        }
-      }
-    } else if (typeof ref === "function") {
-      var retVal;
+    if (failedBoundaries === null) {
+      failedBoundaries = new WeakSet();
+    }
 
-      try {
-        if (shouldProfile(current)) {
-          try {
-            startLayoutEffectTimer();
-            retVal = ref(null);
-          } finally {
-            recordLayoutEffectDuration(current);
-          }
-        } else {
-          retVal = ref(null);
-        }
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      }
+    failedBoundaries.add(fiber);
+  }
+}
+var scheduleRefresh = function (root, update) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return;
+    }
 
-      {
-        if (typeof retVal === "function") {
-          error(
-            "Unexpected return value from a callback ref in %s. " +
-              "A callback ref should not return a function.",
-            getComponentNameFromFiber(current)
-          );
-        }
-      }
-    } else {
-      // $FlowFixMe unable to narrow type to RefObject
-      ref.current = null;
+    var staleFamilies = update.staleFamilies,
+      updatedFamilies = update.updatedFamilies;
+    flushPassiveEffects();
+    flushSync$1(function () {
+      scheduleFibersWithFamiliesRecursively(
+        root.current,
+        updatedFamilies,
+        staleFamilies
+      );
+    });
+  }
+};
+var scheduleRoot = function (root, element) {
+  {
+    if (root.context !== emptyContextObject) {
+      // Super edge case: root has a legacy _renderSubtree context
+      // but we don't know the parentComponent so we can't pass it.
+      // Just ignore. We'll delete this with _renderSubtree code path later.
+      return;
     }
+
+    flushPassiveEffects();
+    flushSync$1(function () {
+      updateContainer(element, root, null, null);
+    });
   }
-}
+};
+
+function scheduleFibersWithFamiliesRecursively(
+  fiber,
+  updatedFamilies,
+  staleFamilies
+) {
+  {
+    var alternate = fiber.alternate,
+      child = fiber.child,
+      sibling = fiber.sibling,
+      tag = fiber.tag,
+      type = fiber.type;
+    var candidateType = null;
 
-function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
-  try {
-    destroy();
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
-  }
-}
+    switch (tag) {
+      case FunctionComponent:
+      case SimpleMemoComponent:
+      case ClassComponent:
+        candidateType = type;
+        break;
 
-var focusedInstanceHandle = null;
-var shouldFireAfterActiveInstanceBlur = false;
-function commitBeforeMutationEffects(root, firstChild) {
-  focusedInstanceHandle = prepareForCommit();
-  nextEffect = firstChild;
-  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
+      case ForwardRef:
+        candidateType = type.render;
+        break;
+    }
 
-  var shouldFire = shouldFireAfterActiveInstanceBlur;
-  shouldFireAfterActiveInstanceBlur = false;
-  focusedInstanceHandle = null;
-  return shouldFire;
-}
+    if (resolveFamily === null) {
+      throw new Error("Expected resolveFamily to be set during hot reload.");
+    }
 
-function commitBeforeMutationEffects_begin() {
-  while (nextEffect !== null) {
-    var fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
-    // Let's skip the whole loop if it's off.
+    var needsRender = false;
+    var needsRemount = false;
 
-    {
-      // TODO: Should wrap this in flags check, too, as optimization
-      var deletions = fiber.deletions;
+    if (candidateType !== null) {
+      var family = resolveFamily(candidateType);
 
-      if (deletions !== null) {
-        for (var i = 0; i < deletions.length; i++) {
-          var deletion = deletions[i];
-          commitBeforeMutationEffectsDeletion(deletion);
+      if (family !== undefined) {
+        if (staleFamilies.has(family)) {
+          needsRemount = true;
+        } else if (updatedFamilies.has(family)) {
+          if (tag === ClassComponent) {
+            needsRemount = true;
+          } else {
+            needsRender = true;
+          }
         }
       }
     }
 
-    var child = fiber.child;
+    if (failedBoundaries !== null) {
+      if (
+        failedBoundaries.has(fiber) || // $FlowFixMe[incompatible-use] found when upgrading Flow
+        (alternate !== null && failedBoundaries.has(alternate))
+      ) {
+        needsRemount = true;
+      }
+    }
 
-    if (
-      (fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 &&
-      child !== null
-    ) {
-      child.return = fiber;
-      nextEffect = child;
-    } else {
-      commitBeforeMutationEffects_complete();
+    if (needsRemount) {
+      fiber._debugNeedsRemount = true;
     }
-  }
-}
 
-function commitBeforeMutationEffects_complete() {
-  while (nextEffect !== null) {
-    var fiber = nextEffect;
-    setCurrentFiber(fiber);
+    if (needsRemount || needsRender) {
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-    try {
-      commitBeforeMutationEffectsOnFiber(fiber);
-    } catch (error) {
-      captureCommitPhaseError(fiber, fiber.return, error);
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
     }
 
-    resetCurrentFiber();
-    var sibling = fiber.sibling;
+    if (child !== null && !needsRemount) {
+      scheduleFibersWithFamiliesRecursively(
+        child,
+        updatedFamilies,
+        staleFamilies
+      );
+    }
 
     if (sibling !== null) {
-      sibling.return = fiber.return;
-      nextEffect = sibling;
-      return;
+      scheduleFibersWithFamiliesRecursively(
+        sibling,
+        updatedFamilies,
+        staleFamilies
+      );
     }
-
-    nextEffect = fiber.return;
   }
 }
 
-function commitBeforeMutationEffectsOnFiber(finishedWork) {
-  var current = finishedWork.alternate;
-  var flags = finishedWork.flags;
+var findHostInstancesForRefresh = function (root, families) {
+  {
+    var hostInstances = new Set();
+    var types = new Set(
+      families.map(function (family) {
+        return family.current;
+      })
+    );
+    findHostInstancesForMatchingFibersRecursively(
+      root.current,
+      types,
+      hostInstances
+    );
+    return hostInstances;
+  }
+};
 
+function findHostInstancesForMatchingFibersRecursively(
+  fiber,
+  types,
+  hostInstances
+) {
   {
-    if (!shouldFireAfterActiveInstanceBlur && focusedInstanceHandle !== null) {
-      // Check to see if the focused element was inside of a hidden (Suspense) subtree.
-      // TODO: Move this out of the hot path using a dedicated effect tag.
-      if (
-        finishedWork.tag === SuspenseComponent &&
-        isSuspenseBoundaryBeingHidden(current, finishedWork) && // $FlowFixMe[incompatible-call] found when upgrading Flow
-        doesFiberContain(finishedWork, focusedInstanceHandle)
-      ) {
-        shouldFireAfterActiveInstanceBlur = true;
-        beforeActiveInstanceBlur(finishedWork);
-      }
+    var child = fiber.child,
+      sibling = fiber.sibling,
+      tag = fiber.tag,
+      type = fiber.type;
+    var candidateType = null;
+
+    switch (tag) {
+      case FunctionComponent:
+      case SimpleMemoComponent:
+      case ClassComponent:
+        candidateType = type;
+        break;
+
+      case ForwardRef:
+        candidateType = type.render;
+        break;
     }
-  }
 
-  if ((flags & Snapshot) !== NoFlags$1) {
-    setCurrentFiber(finishedWork);
-  }
+    var didMatch = false;
 
-  switch (finishedWork.tag) {
-    case FunctionComponent: {
-      {
-        if ((flags & Update) !== NoFlags$1) {
-          commitUseEffectEventMount(finishedWork);
-        }
+    if (candidateType !== null) {
+      if (types.has(candidateType)) {
+        didMatch = true;
       }
-
-      break;
     }
 
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      break;
+    if (didMatch) {
+      // We have a match. This only drills down to the closest host components.
+      // There's no need to search deeper because for the purpose of giving
+      // visual feedback, "flashing" outermost parent rectangles is sufficient.
+      findHostInstancesForFiberShallowly(fiber, hostInstances);
+    } else {
+      // If there's no match, maybe there will be one further down in the child tree.
+      if (child !== null) {
+        findHostInstancesForMatchingFibersRecursively(
+          child,
+          types,
+          hostInstances
+        );
+      }
     }
 
-    case ClassComponent: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        if (current !== null) {
-          var prevProps = current.memoizedProps;
-          var prevState = current.memoizedState;
-          var instance = finishedWork.stateNode; // We could update instance props and state here,
-          // but instead we rely on them being set during last render.
-          // TODO: revisit this when we implement resuming.
+    if (sibling !== null) {
+      findHostInstancesForMatchingFibersRecursively(
+        sibling,
+        types,
+        hostInstances
+      );
+    }
+  }
+}
 
-          {
-            if (
-              finishedWork.type === finishedWork.elementType &&
-              !didWarnAboutReassigningProps
-            ) {
-              if (instance.props !== finishedWork.memoizedProps) {
-                error(
-                  "Expected %s props to match memoized props before " +
-                    "getSnapshotBeforeUpdate. " +
-                    "This might either be because of a bug in React, or because " +
-                    "a component reassigns its own `this.props`. " +
-                    "Please file an issue.",
-                  getComponentNameFromFiber(finishedWork) || "instance"
-                );
-              }
+function findHostInstancesForFiberShallowly(fiber, hostInstances) {
+  {
+    var foundHostInstances = findChildHostInstancesForFiberShallowly(
+      fiber,
+      hostInstances
+    );
 
-              if (instance.state !== finishedWork.memoizedState) {
-                error(
-                  "Expected %s state to match memoized state before " +
-                    "getSnapshotBeforeUpdate. " +
-                    "This might either be because of a bug in React, or because " +
-                    "a component reassigns its own `this.state`. " +
-                    "Please file an issue.",
-                  getComponentNameFromFiber(finishedWork) || "instance"
-                );
-              }
-            }
-          }
+    if (foundHostInstances) {
+      return;
+    } // If we didn't find any host children, fallback to closest host parent.
 
-          var snapshot = instance.getSnapshotBeforeUpdate(
-            finishedWork.elementType === finishedWork.type
-              ? prevProps
-              : resolveDefaultProps(finishedWork.type, prevProps),
-            prevState
-          );
+    var node = fiber;
 
-          {
-            var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
+    while (true) {
+      switch (node.tag) {
+        case HostSingleton:
+        case HostComponent:
+          hostInstances.add(node.stateNode);
+          return;
 
-            if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
-              didWarnSet.add(finishedWork.type);
+        case HostPortal:
+          hostInstances.add(node.stateNode.containerInfo);
+          return;
 
-              error(
-                "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
-                  "must be returned. You have returned undefined.",
-                getComponentNameFromFiber(finishedWork)
-              );
-            }
-          }
+        case HostRoot:
+          hostInstances.add(node.stateNode.containerInfo);
+          return;
+      }
 
-          instance.__reactInternalSnapshotBeforeUpdate = snapshot;
-        }
+      if (node.return === null) {
+        throw new Error("Expected to reach root first.");
       }
 
-      break;
+      node = node.return;
     }
+  }
+}
 
-    case HostRoot: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        {
-          var root = finishedWork.stateNode;
-          clearContainer(root.containerInfo);
-        }
+function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
+  {
+    var node = fiber;
+    var foundHostInstances = false;
+
+    while (true) {
+      if (
+        node.tag === HostComponent ||
+        node.tag === HostHoistable ||
+        node.tag === HostSingleton
+      ) {
+        // We got a match.
+        foundHostInstances = true;
+        hostInstances.add(node.stateNode); // There may still be more, so keep searching.
+      } else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
       }
 
-      break;
-    }
+      if (node === fiber) {
+        return foundHostInstances;
+      }
 
-    case HostComponent:
-    case HostHoistable:
-    case HostSingleton:
-    case HostText:
-    case HostPortal:
-    case IncompleteClassComponent:
-      // Nothing to do for these component types
-      break;
+      while (node.sibling === null) {
+        if (node.return === null || node.return === fiber) {
+          return foundHostInstances;
+        }
 
-    default: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        throw new Error(
-          "This unit of work tag should not have side-effects. This error is " +
-            "likely caused by a bug in React. Please file an issue."
-        );
+        node = node.return;
       }
+
+      node.sibling.return = node.return;
+      node = node.sibling;
     }
   }
 
-  if ((flags & Snapshot) !== NoFlags$1) {
-    resetCurrentFiber();
-  }
+  return false;
 }
 
-function commitBeforeMutationEffectsDeletion(deletion) {
-  {
-    // TODO (effects) It would be nice to avoid calling doesFiberContain()
-    // Maybe we can repurpose one of the subtreeFlags positions for this instead?
-    // Use it to store which part of the tree the focused instance is in?
-    // This assumes we can safely determine that instance during the "render" phase.
-    if (doesFiberContain(deletion, focusedInstanceHandle)) {
-      shouldFireAfterActiveInstanceBlur = true;
-      beforeActiveInstanceBlur(deletion);
-    }
+var hasBadMapPolyfill;
+
+{
+  hasBadMapPolyfill = false;
+
+  try {
+    var nonExtensibleObject = Object.preventExtensions({});
+    /* eslint-disable no-new */
+
+    new Map([[nonExtensibleObject, null]]);
+    new Set([nonExtensibleObject]);
+    /* eslint-enable no-new */
+  } catch (e) {
+    // TODO: Consider warning about bad polyfills
+    hasBadMapPolyfill = true;
   }
 }
 
-function commitHookEffectListUnmount(
-  flags,
-  finishedWork,
-  nearestMountedAncestor
-) {
-  var updateQueue = finishedWork.updateQueue;
-  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
 
-  if (lastEffect !== null) {
-    var firstEffect = lastEffect.next;
-    var effect = firstEffect;
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
 
-    do {
-      if ((effect.tag & flags) === flags) {
-        // Unmount
-        var destroy = effect.destroy;
-        effect.destroy = undefined;
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  this.childLanes = NoLanes;
+  this.alternate = null;
 
-        if (destroy !== undefined) {
-          if (enableSchedulingProfiler) {
-            if ((flags & Passive) !== NoFlags) {
-              markComponentPassiveEffectUnmountStarted(finishedWork);
-            } else if ((flags & Layout) !== NoFlags) {
-              markComponentLayoutEffectUnmountStarted(finishedWork);
-            }
-          }
+  {
+    // Note: The following is done to avoid a v8 performance cliff.
+    //
+    // Initializing the fields below to smis and later updating them with
+    // double values will cause Fibers to end up having separate shapes.
+    // This behavior/bug has something to do with Object.preventExtension().
+    // Fortunately this only impacts DEV builds.
+    // Unfortunately it makes React unusably slow for some applications.
+    // To work around this, initialize the fields below with doubles.
+    //
+    // Learn more about this here:
+    // https://github.com/facebook/react/issues/14365
+    // https://bugs.chromium.org/p/v8/issues/detail?id=8538
+    this.actualDuration = Number.NaN;
+    this.actualStartTime = Number.NaN;
+    this.selfBaseDuration = Number.NaN;
+    this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
+    // This won't trigger the performance cliff mentioned above,
+    // and it simplifies other profiler code (including DevTools).
 
-          {
-            if ((flags & Insertion) !== NoFlags) {
-              setIsRunningInsertionEffect(true);
-            }
-          }
+    this.actualDuration = 0;
+    this.actualStartTime = -1;
+    this.selfBaseDuration = 0;
+    this.treeBaseDuration = 0;
+  }
 
-          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+  {
+    // This isn't directly used but is handy for debugging internals:
+    this._debugSource = null;
+    this._debugOwner = null;
+    this._debugNeedsRemount = false;
+    this._debugHookTypes = null;
 
-          {
-            if ((flags & Insertion) !== NoFlags) {
-              setIsRunningInsertionEffect(false);
-            }
-          }
+    if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
+      Object.preventExtensions(this);
+    }
+  }
+} // This is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
 
-          if (enableSchedulingProfiler) {
-            if ((flags & Passive) !== NoFlags) {
-              markComponentPassiveEffectUnmountStopped();
-            } else if ((flags & Layout) !== NoFlags) {
-              markComponentLayoutEffectUnmountStopped();
-            }
-          }
-        }
-      }
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
 
-      effect = effect.next;
-    } while (effect !== firstEffect);
+function shouldConstruct(Component) {
+  var prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function isSimpleFunctionComponent(type) {
+  return (
+    typeof type === "function" &&
+    !shouldConstruct(type) &&
+    type.defaultProps === undefined
+  );
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === "function") {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    var $$typeof = Component.$$typeof;
+
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
+    }
+
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
   }
-}
 
-function commitHookEffectListMount(flags, finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
 
-  if (lastEffect !== null) {
-    var firstEffect = lastEffect.next;
-    var effect = firstEffect;
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
 
-    do {
-      if ((effect.tag & flags) === flags) {
-        if (enableSchedulingProfiler) {
-          if ((flags & Passive) !== NoFlags) {
-            markComponentPassiveEffectMountStarted(finishedWork);
-          } else if ((flags & Layout) !== NoFlags) {
-            markComponentLayoutEffectMountStarted(finishedWork);
-          }
-        } // Mount
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(
+      current.tag,
+      pendingProps,
+      current.key,
+      current.mode
+    );
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
 
-        var create = effect.create;
+    {
+      // DEV-only fields
+      workInProgress._debugSource = current._debugSource;
+      workInProgress._debugOwner = current._debugOwner;
+      workInProgress._debugHookTypes = current._debugHookTypes;
+    }
 
-        {
-          if ((flags & Insertion) !== NoFlags) {
-            setIsRunningInsertionEffect(true);
-          }
-        }
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
+  } else {
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
 
-        effect.destroy = create();
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
 
-        {
-          if ((flags & Insertion) !== NoFlags) {
-            setIsRunningInsertionEffect(false);
-          }
-        }
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
 
-        if (enableSchedulingProfiler) {
-          if ((flags & Passive) !== NoFlags) {
-            markComponentPassiveEffectMountStopped();
-          } else if ((flags & Layout) !== NoFlags) {
-            markComponentLayoutEffectMountStopped();
-          }
-        }
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
 
-        {
-          var destroy = effect.destroy;
+    {
+      // We intentionally reset, rather than copy, actualDuration & actualStartTime.
+      // This prevents time from endlessly accumulating in new commits.
+      // This has the downside of resetting values for different priority renders,
+      // But works for yielding (the common case) and should support resuming.
+      workInProgress.actualDuration = 0;
+      workInProgress.actualStartTime = -1;
+    }
+  } // Reset all effects except static ones.
+  // Static effects are not specific to a render.
 
-          if (destroy !== undefined && typeof destroy !== "function") {
-            var hookName = void 0;
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
 
-            if ((effect.tag & Layout) !== NoFlags$1) {
-              hookName = "useLayoutEffect";
-            } else if ((effect.tag & Insertion) !== NoFlags$1) {
-              hookName = "useInsertionEffect";
-            } else {
-              hookName = "useEffect";
-            }
+  var currentDependencies = current.dependencies;
+  workInProgress.dependencies =
+    currentDependencies === null
+      ? null
+      : {
+          lanes: currentDependencies.lanes,
+          firstContext: currentDependencies.firstContext
+        }; // These will be overridden during the parent's reconciliation
 
-            var addendum = void 0;
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
 
-            if (destroy === null) {
-              addendum =
-                " You returned null. If your effect does not require clean " +
-                "up, return undefined (or nothing).";
-            } else if (typeof destroy.then === "function") {
-              addendum =
-                "\n\nIt looks like you wrote " +
-                hookName +
-                "(async () => ...) or returned a Promise. " +
-                "Instead, write the async function inside your effect " +
-                "and call it immediately:\n\n" +
-                hookName +
-                "(() => {\n" +
-                "  async function fetchData() {\n" +
-                "    // You can await here\n" +
-                "    const response = await MyAPI.getData(someId);\n" +
-                "    // ...\n" +
-                "  }\n" +
-                "  fetchData();\n" +
-                "}, [someId]); // Or [] if effect doesn't need props or state\n\n" +
-                "Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching";
-            } else {
-              addendum = " You returned: " + destroy;
-            }
+  {
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
+  }
 
-            error(
-              "%s must not return anything besides a function, " +
-                "which is used for clean-up.%s",
-              hookName,
-              addendum
-            );
-          }
-        }
-      }
+  {
+    workInProgress._debugNeedsRemount = current._debugNeedsRemount;
 
-      effect = effect.next;
-    } while (effect !== firstEffect);
-  }
-}
+    switch (workInProgress.tag) {
+      case IndeterminateComponent:
+      case FunctionComponent:
+      case SimpleMemoComponent:
+        workInProgress.type = resolveFunctionForHotReloading(current.type);
+        break;
 
-function commitUseEffectEventMount(finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  var eventPayloads = updateQueue !== null ? updateQueue.events : null;
+      case ClassComponent:
+        workInProgress.type = resolveClassForHotReloading(current.type);
+        break;
 
-  if (eventPayloads !== null) {
-    for (var ii = 0; ii < eventPayloads.length; ii++) {
-      var _eventPayloads$ii = eventPayloads[ii],
-        ref = _eventPayloads$ii.ref,
-        nextImpl = _eventPayloads$ii.nextImpl;
-      ref.impl = nextImpl;
+      case ForwardRef:
+        workInProgress.type = resolveForwardRefForHotReloading(current.type);
+        break;
     }
   }
-}
-
-function commitPassiveEffectDurations(finishedRoot, finishedWork) {
-  if (getExecutionContext() & CommitContext) {
-    // Only Profilers with work in their subtree will have an Update effect scheduled.
-    if ((finishedWork.flags & Update) !== NoFlags$1) {
-      switch (finishedWork.tag) {
-        case Profiler: {
-          var passiveEffectDuration =
-            finishedWork.stateNode.passiveEffectDuration;
-          var _finishedWork$memoize = finishedWork.memoizedProps,
-            id = _finishedWork$memoize.id,
-            onPostCommit = _finishedWork$memoize.onPostCommit; // This value will still reflect the previous commit phase.
-          // It does not get reset until the start of the next commit phase.
 
-          var commitTime = getCommitTime();
-          var phase = finishedWork.alternate === null ? "mount" : "update";
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
 
-          {
-            if (isCurrentUpdateNested()) {
-              phase = "nested-update";
-            }
-          }
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
 
-          if (typeof onPostCommit === "function") {
-            onPostCommit(id, phase, passiveEffectDuration, commitTime);
-          } // Bubble times to the next nearest ancestor Profiler.
-          // After we process that Profiler, we'll bubble further up.
+  var current = workInProgress.alternate;
 
-          var parentFiber = finishedWork.return;
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
 
-          outer: while (parentFiber !== null) {
-            switch (parentFiber.tag) {
-              case HostRoot:
-                var root = parentFiber.stateNode;
-                root.passiveEffectDuration += passiveEffectDuration;
-                break outer;
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = 0;
+      workInProgress.treeBaseDuration = 0;
+    }
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
 
-              case Profiler:
-                var parentStateNode = parentFiber.stateNode;
-                parentStateNode.passiveEffectDuration += passiveEffectDuration;
-                break outer;
-            }
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
 
-            parentFiber = parentFiber.return;
-          }
+    var currentDependencies = current.dependencies;
+    workInProgress.dependencies =
+      currentDependencies === null
+        ? null
+        : {
+            lanes: currentDependencies.lanes,
+            firstContext: currentDependencies.firstContext
+          };
 
-          break;
-        }
-      }
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = current.selfBaseDuration;
+      workInProgress.treeBaseDuration = current.treeBaseDuration;
     }
   }
-}
-
-function commitHookLayoutEffects(finishedWork, hookFlags) {
-  // At this point layout effects have already been destroyed (during mutation phase).
-  // This is done to prevent sibling component effects from interfering with each other,
-  // e.g. a destroy function in one component should never override a ref set
-  // by a create function in another component during the same commit.
-  if (shouldProfile(finishedWork)) {
-    try {
-      startLayoutEffectTimer();
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
 
-    recordLayoutEffectDuration(finishedWork);
-  } else {
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
-  }
+  return workInProgress;
 }
+function createHostRootFiber(
+  tag,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride
+) {
+  var mode;
 
-function commitClassLayoutLifecycles(finishedWork, current) {
-  var instance = finishedWork.stateNode;
-
-  if (current === null) {
-    // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
-    {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "componentDidMount. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "componentDidMount. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
-      }
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
     }
 
-    if (shouldProfile(finishedWork)) {
-      try {
-        startLayoutEffectTimer();
-        instance.componentDidMount();
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
-
-      recordLayoutEffectDuration(finishedWork);
-    } else {
-      try {
-        instance.componentDidMount();
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
+    if (
+      // Only for internal experiments.
+      concurrentUpdatesByDefaultOverride
+    ) {
+      mode |= ConcurrentUpdatesByDefaultMode;
     }
   } else {
-    var prevProps =
-      finishedWork.elementType === finishedWork.type
-        ? current.memoizedProps
-        : resolveDefaultProps(finishedWork.type, current.memoizedProps);
-    var prevState = current.memoizedState; // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
+    mode = NoMode;
+  }
 
-    {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "componentDidUpdate. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+  if (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;
+  }
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "componentDidUpdate. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
-      }
-    }
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(
+  type, // React$ElementType
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
+) {
+  var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
 
-    if (shouldProfile(finishedWork)) {
-      try {
-        startLayoutEffectTimer();
-        instance.componentDidUpdate(
-          prevProps,
-          prevState,
-          instance.__reactInternalSnapshotBeforeUpdate
-        );
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
+  var resolvedType = type;
 
-      recordLayoutEffectDuration(finishedWork);
+  if (typeof type === "function") {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
+
+      {
+        resolvedType = resolveClassForHotReloading(resolvedType);
+      }
     } else {
-      try {
-        instance.componentDidUpdate(
-          prevProps,
-          prevState,
-          instance.__reactInternalSnapshotBeforeUpdate
-        );
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      {
+        resolvedType = resolveFunctionForHotReloading(resolvedType);
       }
     }
-  }
-}
-
-function commitClassCallbacks(finishedWork) {
-  // TODO: I think this is now always non-null by the time it reaches the
-  // commit phase. Consider removing the type check.
-  var updateQueue = finishedWork.updateQueue;
-
-  if (updateQueue !== null) {
-    var instance = finishedWork.stateNode;
-
+  } else if (typeof type === "string") {
     {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "processing the update queue. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
-
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "processing the update queue. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
-      }
-    } // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
-
-    try {
-      commitCallbacks(updateQueue, instance);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      var hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext)
+        ? HostHoistable
+        : isHostSingletonType(type)
+        ? HostSingleton
+        : HostComponent;
     }
-  }
-}
-
-function commitHostComponentMount(finishedWork) {
-  var type = finishedWork.type;
-  var props = finishedWork.memoizedProps;
-  var instance = finishedWork.stateNode;
-
-  try {
-    commitMount(instance, type, props, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
-  }
-}
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
 
-function commitProfilerUpdate(finishedWork, current) {
-  if (getExecutionContext() & CommitContext) {
-    try {
-      var _finishedWork$memoize2 = finishedWork.memoizedProps,
-        onCommit = _finishedWork$memoize2.onCommit,
-        onRender = _finishedWork$memoize2.onRender;
-      var effectDuration = finishedWork.stateNode.effectDuration;
-      var commitTime = getCommitTime();
-      var phase = current === null ? "mount" : "update";
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
 
-      if (enableProfilerNestedUpdatePhase) {
-        if (isCurrentUpdateNested()) {
-          phase = "nested-update";
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
         }
-      }
-
-      if (typeof onRender === "function") {
-        onRender(
-          finishedWork.memoizedProps.id,
-          phase,
-          finishedWork.actualDuration,
-          finishedWork.treeBaseDuration,
-          finishedWork.actualStartTime,
-          commitTime
-        );
-      }
 
-      if (enableProfilerCommitHooks) {
-        if (typeof onCommit === "function") {
-          onCommit(
-            finishedWork.memoizedProps.id,
-            phase,
-            effectDuration,
-            commitTime
-          );
-        } // Schedule a passive effect for this Profiler to call onPostCommit hooks.
-        // This effect should be scheduled even if there is no onPostCommit callback for this Profiler,
-        // because the effect is also where times bubble to parent Profilers.
+        break;
 
-        enqueuePendingPassiveProfilerEffect(finishedWork); // Propagate layout effect durations to the next nearest Profiler ancestor.
-        // Do not reset these values until the next render so DevTools has a chance to read them first.
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
 
-        var parentFiber = finishedWork.return;
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
 
-        outer: while (parentFiber !== null) {
-          switch (parentFiber.tag) {
-            case HostRoot:
-              var root = parentFiber.stateNode;
-              root.effectDuration += effectDuration;
-              break outer;
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
 
-            case Profiler:
-              var parentStateNode = parentFiber.stateNode;
-              parentStateNode.effectDuration += effectDuration;
-              break outer;
-          }
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
 
-          parentFiber = parentFiber.return;
-        }
+      case REACT_LEGACY_HIDDEN_TYPE: {
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
       }
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
-  }
-}
 
-function commitLayoutEffectOnFiber(
-  finishedRoot,
-  current,
-  finishedWork,
-  committedLanes
-) {
-  // When updating this function, also update reappearLayoutEffects, which does
-  // most of the same things when an offscreen tree goes from hidden -> visible.
-  var flags = finishedWork.flags;
+      // eslint-disable-next-line no-fallthrough
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      case REACT_SCOPE_TYPE: {
+        return createFiberFromScope(type, pendingProps, mode, lanes, key);
+      }
 
-      if (flags & Update) {
-        commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+      // eslint-disable-next-line no-fallthrough
+
+      case REACT_CACHE_TYPE: {
+        return createFiberFromCache(pendingProps, mode, lanes, key);
       }
 
-      break;
-    }
+      // eslint-disable-next-line no-fallthrough
 
-    case ClassComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing) {
+          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
+        }
 
-      if (flags & Update) {
-        commitClassLayoutLifecycles(finishedWork, current);
-      }
+      // eslint-disable-next-line no-fallthrough
 
-      if (flags & Callback) {
-        commitClassCallbacks(finishedWork);
-      }
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = Mode;
+          mode |= DebugTracingMode;
+          break;
+        }
 
-      if (flags & Ref) {
-        safelyAttachRef(finishedWork, finishedWork.return);
-      }
+      // eslint-disable-next-line no-fallthrough
 
-      break;
-    }
+      default: {
+        if (typeof type === "object" && type !== null) {
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = ContextProvider;
+              break getTag;
 
-    case HostRoot: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            case REACT_CONTEXT_TYPE:
+              // This is a consumer
+              fiberTag = ContextConsumer;
+              break getTag;
 
-      if (flags & Callback) {
-        // TODO: I think this is now always non-null by the time it reaches the
-        // commit phase. Consider removing the type check.
-        var updateQueue = finishedWork.updateQueue;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = ForwardRef;
 
-        if (updateQueue !== null) {
-          var instance = null;
+              {
+                resolvedType = resolveForwardRefForHotReloading(resolvedType);
+              }
 
-          if (finishedWork.child !== null) {
-            switch (finishedWork.child.tag) {
-              case HostSingleton:
-              case HostComponent:
-                instance = getPublicInstance(finishedWork.child.stateNode);
-                break;
+              break getTag;
 
-              case ClassComponent:
-                instance = finishedWork.child.stateNode;
-                break;
-            }
-          }
+            case REACT_MEMO_TYPE:
+              fiberTag = MemoComponent;
+              break getTag;
 
-          try {
-            commitCallbacks(updateQueue, instance);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            case REACT_LAZY_TYPE:
+              fiberTag = LazyComponent;
+              resolvedType = null;
+              break getTag;
           }
         }
-      }
 
-      break;
-    }
+        var info = "";
 
-    case HostHoistable: {
-      {
-        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        {
+          if (
+            type === undefined ||
+            (typeof type === "object" &&
+              type !== null &&
+              Object.keys(type).length === 0)
+          ) {
+            info +=
+              " You likely forgot to export your component from the file " +
+              "it's defined in, or you might have mixed up default and " +
+              "named imports.";
+          }
 
-        if (flags & Ref) {
-          safelyAttachRef(finishedWork, finishedWork.return);
+          var ownerName = owner ? getComponentNameFromFiber(owner) : null;
+
+          if (ownerName) {
+            info += "\n\nCheck the render method of `" + ownerName + "`.";
+          }
         }
 
-        break;
+        throw new Error(
+          "Element type is invalid: expected a string (for built-in " +
+            "components) or a class/function (for composite components) " +
+            ("but got: " + (type == null ? type : typeof type) + "." + info)
+        );
       }
     }
-    // eslint-disable-next-line-no-fallthrough
+  }
 
-    case HostSingleton:
-    case HostComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
-      // (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.
+  var fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
 
-      if (current === null && flags & Update) {
-        commitHostComponentMount(finishedWork);
-      }
+  {
+    fiber._debugOwner = owner;
+  }
 
-      if (flags & Ref) {
-        safelyAttachRef(finishedWork, finishedWork.return);
-      }
+  return fiber;
+}
+function createFiberFromElement(element, mode, lanes) {
+  var owner = null;
 
-      break;
-    }
+  {
+    owner = element._owner;
+  }
 
-    case Profiler: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
-      // fire when the tree becomes visible again.
+  var type = element.type;
+  var key = element.key;
+  var pendingProps = element.props;
+  var fiber = createFiberFromTypeAndProps(
+    type,
+    key,
+    pendingProps,
+    owner,
+    mode,
+    lanes
+  );
 
-      if (flags & Update) {
-        commitProfilerUpdate(finishedWork, current);
-      }
+  {
+    fiber._debugSource = element._source;
+    fiber._debugOwner = element._owner;
+  }
 
-      break;
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  var fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromScope(scope, pendingProps, mode, lanes, key) {
+  var fiber = createFiber(ScopeComponent, pendingProps, key, mode);
+  fiber.type = scope;
+  fiber.elementType = scope;
+  fiber.lanes = lanes;
+  return fiber;
+}
+
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+  {
+    if (typeof pendingProps.id !== "string") {
+      error(
+        'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
+        typeof pendingProps.id
+      );
     }
+  }
 
-    case SuspenseComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+  var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
 
-      if (flags & Update) {
-        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
-      }
+  {
+    fiber.stateNode = {
+      effectDuration: 0,
+      passiveEffectDuration: 0
+    };
+  }
 
-      break;
+  return fiber;
+}
+
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
     }
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(LegacyHiddenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  fiber.lanes = lanes; // Adding a stateNode for legacy hidden because it's currently using
+  // the offscreen implementation, which depends on a state node
 
-    case OffscreenComponent: {
-      var isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
+  var instance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
+    }
+  };
+  fiber.stateNode = instance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromTracingMarker(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(TracingMarkerComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_TRACING_MARKER_TYPE;
+  fiber.lanes = lanes;
+  var tracingMarkerInstance = {
+    tag: TransitionTracingMarker,
+    transitions: null,
+    pendingBoundaries: null,
+    aborts: null,
+    name: pendingProps.name
+  };
+  fiber.stateNode = tracingMarkerInstance;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  var fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  var fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = "DELETED";
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  var fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  var pendingProps = portal.children !== null ? portal.children : [];
+  var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
 
-      if (isModernRoot) {
-        var isHidden = finishedWork.memoizedState !== null;
-        var newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+function assignFiberPropertiesInDEV(target, source) {
+  if (target === null) {
+    // This Fiber's initial properties will always be overwritten.
+    // We only use a Fiber to ensure the same hidden class so DEV isn't slow.
+    target = createFiber(IndeterminateComponent, null, null, NoMode);
+  } // This is intentionally written as a list of all properties.
+  // We tried to use Object.assign() instead but this is called in
+  // the hottest path, and Object.assign() was too slow:
+  // https://github.com/facebook/react/issues/12502
+  // This code is DEV-only so size is not a concern.
 
-        if (newOffscreenSubtreeIsHidden);
-        else {
-          // The Offscreen tree is visible.
-          var wasHidden = current !== null && current.memoizedState !== null;
-          var newOffscreenSubtreeWasHidden =
-            wasHidden || offscreenSubtreeWasHidden;
-          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
-          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-          offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+  target.tag = source.tag;
+  target.key = source.key;
+  target.elementType = source.elementType;
+  target.type = source.type;
+  target.stateNode = source.stateNode;
+  target.return = source.return;
+  target.child = source.child;
+  target.sibling = source.sibling;
+  target.index = source.index;
+  target.ref = source.ref;
+  target.refCleanup = source.refCleanup;
+  target.pendingProps = source.pendingProps;
+  target.memoizedProps = source.memoizedProps;
+  target.updateQueue = source.updateQueue;
+  target.memoizedState = source.memoizedState;
+  target.dependencies = source.dependencies;
+  target.mode = source.mode;
+  target.flags = source.flags;
+  target.subtreeFlags = source.subtreeFlags;
+  target.deletions = source.deletions;
+  target.lanes = source.lanes;
+  target.childLanes = source.childLanes;
+  target.alternate = source.alternate;
 
-          if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
-            // This is the root of a reappearing boundary. As we continue
-            // traversing the layout effects, we must also re-mount layout
-            // effects that were unmounted when the Offscreen subtree was
-            // hidden. So this is a superset of the normal commitLayoutEffects.
-            var includeWorkInProgressEffects =
-              (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
-            recursivelyTraverseReappearLayoutEffects(
-              finishedRoot,
-              finishedWork,
-              includeWorkInProgressEffects
-            );
-          } else {
-            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-          }
+  {
+    target.actualDuration = source.actualDuration;
+    target.actualStartTime = source.actualStartTime;
+    target.selfBaseDuration = source.selfBaseDuration;
+    target.treeBaseDuration = source.treeBaseDuration;
+  }
+
+  target._debugSource = source._debugSource;
+  target._debugOwner = source._debugOwner;
+  target._debugNeedsRemount = source._debugNeedsRemount;
+  target._debugHookTypes = source._debugHookTypes;
+  return target;
+}
+
+function FiberRootNode(
+  containerInfo, // $FlowFixMe[missing-local-annot]
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
+) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.context = null;
+  this.pendingContext = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.eventTimes = createLaneMap(NoLanes);
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.mutableReadLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
+  }
 
-          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-        }
-      } else {
-        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      }
+  {
+    this.mutableSourceEagerHydrationData = null;
+  }
 
-      if (flags & Ref) {
-        var props = finishedWork.memoizedProps;
+  {
+    this.hydrationCallbacks = null;
+  }
 
-        if (props.mode === "manual") {
-          safelyAttachRef(finishedWork, finishedWork.return);
-        } else {
-          safelyDetachRef(finishedWork, finishedWork.return);
-        }
-      }
+  this.incompleteTransitions = new Map();
 
-      break;
-    }
+  if (enableTransitionTracing) {
+    this.transitionCallbacks = null;
+    var transitionLanesMap = (this.transitionLanes = []);
 
-    default: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      break;
+    for (var i = 0; i < TotalLanes; i++) {
+      transitionLanesMap.push(null);
     }
   }
-}
-
-function abortRootTransitions(
-  root,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var rootTransitions = root.incompleteTransitions;
-    deletedTransitions.forEach(function (transition) {
-      if (rootTransitions.has(transition)) {
-        var transitionInstance = rootTransitions.get(transition);
 
-        if (transitionInstance.aborts === null) {
-          transitionInstance.aborts = [];
-        }
+  {
+    this.effectDuration = 0;
+    this.passiveEffectDuration = 0;
+  }
 
-        transitionInstance.aborts.push(abort);
+  {
+    this.memoizedUpdaters = new Set();
+    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
 
-        if (deletedOffscreenInstance !== null) {
-          if (
-            transitionInstance.pendingBoundaries !== null &&
-            transitionInstance.pendingBoundaries.has(deletedOffscreenInstance)
-          ) {
-            // $FlowFixMe[incompatible-use] found when upgrading Flow
-            transitionInstance.pendingBoundaries.delete(
-              deletedOffscreenInstance
-            );
-          }
-        }
-      }
-    });
+    for (var _i = 0; _i < TotalLanes; _i++) {
+      pendingUpdatersLaneMap.push(new Set());
+    }
   }
-}
-
-function abortTracingMarkerTransitions(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var markerInstance = abortedFiber.stateNode;
-    var markerTransitions = markerInstance.transitions;
-    var pendingBoundaries = markerInstance.pendingBoundaries;
 
-    if (markerTransitions !== null) {
-      // TODO: Refactor this code. Is there a way to move this code to
-      // the deletions phase instead of calculating it here while making sure
-      // complete is called appropriately?
-      deletedTransitions.forEach(function (transition) {
-        // If one of the transitions on the tracing marker is a transition
-        // that was in an aborted subtree, we will abort that tracing marker
-        if (
-          abortedFiber !== null &&
-          markerTransitions.has(transition) &&
-          (markerInstance.aborts === null ||
-            !markerInstance.aborts.includes(abort))
-        ) {
-          if (markerInstance.transitions !== null) {
-            if (markerInstance.aborts === null) {
-              markerInstance.aborts = [abort];
-              addMarkerIncompleteCallbackToPendingTransition(
-                abortedFiber.memoizedProps.name,
-                markerInstance.transitions,
-                markerInstance.aborts
-              );
-            } else {
-              markerInstance.aborts.push(abort);
-            } // We only want to call onTransitionProgress when the marker hasn't been
-            // deleted
+  {
+    switch (tag) {
+      case ConcurrentRoot:
+        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
+        break;
 
-            if (
-              deletedOffscreenInstance !== null &&
-              !isInDeletedTree &&
-              pendingBoundaries !== null &&
-              pendingBoundaries.has(deletedOffscreenInstance)
-            ) {
-              pendingBoundaries.delete(deletedOffscreenInstance);
-              addMarkerProgressCallbackToPendingTransition(
-                abortedFiber.memoizedProps.name,
-                deletedTransitions,
-                pendingBoundaries
-              );
-            }
-          }
-        }
-      });
+      case LegacyRoot:
+        this._debugRootType = hydrate ? "hydrate()" : "render()";
+        break;
     }
   }
 }
 
-function abortParentMarkerTransitionsForDeletedFiber(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+  // host config, but because they are passed in at runtime, we have to thread
+  // them through the root constructor. Perhaps we should put them all into a
+  // single type, like a DynamicHostConfig that is defined by the renderer.
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
 ) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  var root = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
+  );
+
+  {
+    root.hydrationCallbacks = hydrationCallbacks;
+  }
+
   if (enableTransitionTracing) {
-    // Find all pending markers that are waiting on child suspense boundaries in the
-    // aborted subtree and cancels them
-    var fiber = abortedFiber;
+    root.transitionCallbacks = transitionCallbacks;
+  } // Cyclic construction. This cheats the type system right now because
+  // stateNode is any.
 
-    while (fiber !== null) {
-      switch (fiber.tag) {
-        case TracingMarkerComponent:
-          abortTracingMarkerTransitions(
-            fiber,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance,
-            isInDeletedTree
-          );
-          break;
+  var uninitializedFiber = createHostRootFiber(
+    tag,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride
+  );
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
 
-        case HostRoot:
-          var root = fiber.stateNode;
-          abortRootTransitions(
-            root,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance
-          );
-          break;
-      }
+  {
+    var initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
 
-      fiber = fiber.return;
-    }
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    var initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
   }
-}
 
-function commitTransitionProgress(offscreenFiber) {
-  if (enableTransitionTracing) {
-    // This function adds suspense boundaries to the root
-    // or tracing marker's pendingBoundaries map.
-    // When a suspense boundary goes from a resolved to a fallback
-    // state we add the boundary to the map, and when it goes from
-    // a fallback to a resolved state, we remove the boundary from
-    // the map.
-    // We use stateNode on the Offscreen component as a stable object
-    // that doesnt change from render to render. This way we can
-    // distinguish between different Offscreen instances (vs. the same
-    // Offscreen instance with different fibers)
-    var offscreenInstance = offscreenFiber.stateNode;
-    var prevState = null;
-    var previousFiber = offscreenFiber.alternate;
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
+}
 
-    if (previousFiber !== null && previousFiber.memoizedState !== null) {
-      prevState = previousFiber.memoizedState;
-    }
+var ReactVersion = "18.3.0-www-modern-990522b1";
 
-    var nextState = offscreenFiber.memoizedState;
-    var wasHidden = prevState !== null;
-    var isHidden = nextState !== null;
-    var pendingMarkers = offscreenInstance._pendingMarkers; // If there is a name on the suspense boundary, store that in
-    // the pending boundaries.
+function createPortal$1(
+  children,
+  containerInfo, // TODO: figure out the API for cross-renderer implementation.
+  implementation
+) {
+  var key =
+    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
 
-    var name = null;
-    var parent = offscreenFiber.return;
+  {
+    checkKeyStringCoercion(key);
+  }
 
-    if (
-      parent !== null &&
-      parent.tag === SuspenseComponent &&
-      parent.memoizedProps.unstable_name
-    ) {
-      name = parent.memoizedProps.unstable_name;
-    }
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
+}
 
-    if (!wasHidden && isHidden) {
-      // The suspense boundaries was just hidden. Add the boundary
-      // to the pending boundary set if it's there
-      if (pendingMarkers !== null) {
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries;
-          var transitions = markerInstance.transitions;
-          var markerName = markerInstance.name;
+// Might add PROFILE later.
 
-          if (
-            pendingBoundaries !== null &&
-            !pendingBoundaries.has(offscreenInstance)
-          ) {
-            pendingBoundaries.set(offscreenInstance, {
-              name: name
-            });
+var didWarnAboutNestedUpdates;
 
-            if (transitions !== null) {
-              if (
-                markerInstance.tag === TransitionTracingMarker &&
-                markerName !== null
-              ) {
-                addMarkerProgressCallbackToPendingTransition(
-                  markerName,
-                  transitions,
-                  pendingBoundaries
-                );
-              } else if (markerInstance.tag === TransitionRoot) {
-                transitions.forEach(function (transition) {
-                  addTransitionProgressCallbackToPendingTransition(
-                    transition,
-                    pendingBoundaries
-                  );
-                });
-              }
-            }
-          }
-        });
-      }
-    } else if (wasHidden && !isHidden) {
-      // The suspense boundary went from hidden to visible. Remove
-      // the boundary from the pending suspense boundaries set
-      // if it's there
-      if (pendingMarkers !== null) {
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries;
-          var transitions = markerInstance.transitions;
-          var markerName = markerInstance.name;
+{
+  didWarnAboutNestedUpdates = false;
+}
 
-          if (
-            pendingBoundaries !== null &&
-            pendingBoundaries.has(offscreenInstance)
-          ) {
-            pendingBoundaries.delete(offscreenInstance);
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
+  }
 
-            if (transitions !== null) {
-              if (
-                markerInstance.tag === TransitionTracingMarker &&
-                markerName !== null
-              ) {
-                addMarkerProgressCallbackToPendingTransition(
-                  markerName,
-                  transitions,
-                  pendingBoundaries
-                ); // If there are no more unresolved suspense boundaries, the interaction
-                // is considered finished
+  var fiber = get(parentComponent);
+  var parentContext = findCurrentUnmaskedContext();
 
-                if (pendingBoundaries.size === 0) {
-                  if (markerInstance.aborts === null) {
-                    addMarkerCompleteCallbackToPendingTransition(
-                      markerName,
-                      transitions
-                    );
-                  }
+  if (fiber.tag === ClassComponent) {
+    var Component = fiber.type;
 
-                  markerInstance.transitions = null;
-                  markerInstance.pendingBoundaries = null;
-                  markerInstance.aborts = null;
-                }
-              } else if (markerInstance.tag === TransitionRoot) {
-                transitions.forEach(function (transition) {
-                  addTransitionProgressCallbackToPendingTransition(
-                    transition,
-                    pendingBoundaries
-                  );
-                });
-              }
-            }
-          }
-        });
-      }
+    if (isContextProvider()) {
+      return processChildContext(fiber, Component, parentContext);
     }
   }
+
+  return parentContext;
 }
 
-function hideOrUnhideAllChildren(finishedWork, isHidden) {
-  // Only hide or unhide the top-most host nodes.
-  var hostSubtreeRoot = null;
+function createContainer(
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  var hydrate = false;
+  var initialChildren = null;
+  return createFiberRoot(
+    containerInfo,
+    tag,
+    hydrate,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
+  );
+}
+function createHydrationContainer(
+  initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+  callback,
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  var hydrate = true;
+  var root = createFiberRoot(
+    containerInfo,
+    tag,
+    hydrate,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
+  ); // TODO: Move this to FiberRoot constructor
 
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
+
+  var current = root.current;
+  var lane = requestUpdateLane(current);
+  var update = createUpdate(lane);
+  update.callback =
+    callback !== undefined && callback !== null ? callback : null;
+  var eventTime = requestEventTime();
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane, eventTime);
+  return root;
+}
+function updateContainer(element, container, parentComponent, callback) {
   {
-    // We only have the top Fiber that was inserted but we need to recurse down its
-    // children to find all the terminal nodes.
-    var node = finishedWork;
+    onScheduleRoot(container, element);
+  }
 
-    while (true) {
-      if (
-        node.tag === HostComponent ||
-        node.tag === HostHoistable ||
-        node.tag === HostSingleton
-      ) {
-        if (hostSubtreeRoot === null) {
-          hostSubtreeRoot = node;
+  var current$1 = container.current;
+  var lane = requestUpdateLane(current$1);
 
-          try {
-            var instance = node.stateNode;
+  if (enableSchedulingProfiler) {
+    markRenderScheduled(lane);
+  }
 
-            if (isHidden) {
-              hideInstance(instance);
-            } else {
-              unhideInstance(node.stateNode, node.memoizedProps);
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      } else if (node.tag === HostText) {
-        if (hostSubtreeRoot === null) {
-          try {
-            var _instance = node.stateNode;
+  var context = getContextForSubtree(parentComponent);
 
-            if (isHidden) {
-              hideTextInstance(_instance);
-            } else {
-              unhideTextInstance(_instance, node.memoizedProps);
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      } else if (
-        (node.tag === OffscreenComponent ||
-          node.tag === LegacyHiddenComponent) &&
-        node.memoizedState !== null &&
-        node !== finishedWork
-      );
-      else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
+  if (container.context === null) {
+    container.context = context;
+  } else {
+    container.pendingContext = context;
+  }
 
-      if (node === finishedWork) {
-        return;
-      }
+  {
+    if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
+      didWarnAboutNestedUpdates = true;
 
-      while (node.sibling === null) {
-        if (node.return === null || node.return === finishedWork) {
-          return;
-        }
+      error(
+        "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.",
+        getComponentNameFromFiber(current) || "Unknown"
+      );
+    }
+  }
 
-        if (hostSubtreeRoot === node) {
-          hostSubtreeRoot = null;
-        }
+  var update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-        node = node.return;
-      }
+  update.payload = {
+    element: element
+  };
+  callback = callback === undefined ? null : callback;
 
-      if (hostSubtreeRoot === node) {
-        hostSubtreeRoot = null;
+  if (callback !== null) {
+    {
+      if (typeof callback !== "function") {
+        error(
+          "render(...): Expected the last optional `callback` argument to be a " +
+            "function. Instead received: %s.",
+          callback
+        );
       }
-
-      node.sibling.return = node.return;
-      node = node.sibling;
     }
+
+    update.callback = callback;
   }
-}
 
-function commitAttachRef(finishedWork) {
-  var ref = finishedWork.ref;
+  var root = enqueueUpdate(current$1, update, lane);
 
-  if (ref !== null) {
-    var instance = finishedWork.stateNode;
-    var instanceToUse;
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, current$1, lane, eventTime);
+    entangleTransitions(root, current$1, lane);
+  }
 
-    switch (finishedWork.tag) {
-      case HostHoistable:
-      case HostSingleton:
-      case HostComponent:
-        instanceToUse = getPublicInstance(instance);
-        break;
+  return lane;
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot: {
+      var root = fiber.stateNode;
 
-      default:
-        instanceToUse = instance;
-    } // Moved outside to ensure DCE works with this flag
+      if (isRootDehydrated(root)) {
+        // Flush the first scheduled "update".
+        var lanes = getHighestPriorityPendingLanes(root);
+        flushRoot(root, lanes);
+      }
 
-    if (finishedWork.tag === ScopeComponent) {
-      instanceToUse = instance;
+      break;
     }
 
-    if (typeof ref === "function") {
-      if (shouldProfile(finishedWork)) {
-        try {
-          startLayoutEffectTimer();
-          finishedWork.refCleanup = ref(instanceToUse);
-        } finally {
-          recordLayoutEffectDuration(finishedWork);
-        }
-      } else {
-        finishedWork.refCleanup = ref(instanceToUse);
-      }
-    } else {
-      {
-        if (!ref.hasOwnProperty("current")) {
-          error(
-            "Unexpected ref object provided for %s. " +
-              "Use either a ref-setter function or React.createRef().",
-            getComponentNameFromFiber(finishedWork)
-          );
+    case SuspenseComponent: {
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+        if (root !== null) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);
         }
-      } // $FlowFixMe unable to narrow type to the non-function case
+      }); // If we're still blocked after this, we need to increase
+      // the priority of any promises resolving within this
+      // boundary so that they next attempt also has higher pri.
 
-      ref.current = instanceToUse;
+      var retryLane = SyncLane;
+      markRetryLaneIfNotHydrated(fiber, retryLane);
+      break;
     }
   }
 }
 
-function detachFiberMutation(fiber) {
-  // Cut off the return pointer to disconnect it from the tree.
-  // This enables us to detect and warn against state updates on an unmounted component.
-  // It also prevents events from bubbling from within disconnected components.
-  //
-  // Ideally, we should also 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.
-  //
-  // Note that we can't clear child or sibling pointers yet.
-  // They're needed for passive effects and for findDOMNode.
-  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
-  //
-  // Don't reset the alternate yet, either. We need that so we can detach the
-  // alternate's fields in the passive phase. Clearing the return pointer is
-  // sufficient for findDOMNode semantics.
-  var alternate = fiber.alternate;
+function markRetryLaneImpl(fiber, retryLane) {
+  var suspenseState = fiber.memoizedState;
 
-  if (alternate !== null) {
-    alternate.return = null;
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(
+      suspenseState.retryLane,
+      retryLane
+    );
   }
+} // Increases the priority of thenables when they resolve within this boundary.
 
-  fiber.return = null;
-}
-
-function detachFiberAfterEffects(fiber) {
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
   var alternate = fiber.alternate;
 
-  if (alternate !== null) {
-    fiber.alternate = null;
-    detachFiberAfterEffects(alternate);
-  } // Clear cyclical Fiber fields. This level alone is designed to roughly
-  // approximate the planned Fiber refactor. In that world, `setState` will be
-  // bound to a special "instance" object instead of a Fiber. The Instance
-  // object will not have any of these fields. It will only be connected to
-  // the fiber tree via a single link at the root. So if this level alone is
-  // sufficient to fix memory issues, that bodes well for our plans.
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
+  }
+}
 
-  fiber.child = null;
-  fiber.deletions = null;
-  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
-  // tree, which has its own pointers to children, parents, and siblings.
-  // The other host nodes also point back to fibers, so we should detach that
-  // one, too.
+function attemptDiscreteHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
 
-  if (fiber.tag === HostComponent) {
-    var hostInstance = fiber.stateNode;
+  var lane = SyncLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
 
-    if (hostInstance !== null) {
-      detachDeletedInstance(hostInstance);
-    }
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
   }
 
-  fiber.stateNode = null;
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
 
-  {
-    fiber._debugOwner = null;
-  } // Theoretically, nothing in here should be necessary, because we already
-  // disconnected the fiber from the tree. So even if something leaks this
-  // particular fiber, it won't leak anything else.
+  var lane = SelectiveHydrationLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
 
-  fiber.return = null;
-  fiber.dependencies = null;
-  fiber.memoizedProps = null;
-  fiber.memoizedState = null;
-  fiber.pendingProps = null;
-  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+  }
 
-  fiber.updateQueue = null;
+  markRetryLaneIfNotHydrated(fiber, lane);
 }
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
+  }
 
-function getHostParentFiber(fiber) {
-  var parent = fiber.return;
-
-  while (parent !== null) {
-    if (isHostParent(parent)) {
-      return parent;
-    }
+  var lane = requestUpdateLane(fiber);
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
 
-    parent = parent.return;
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
   }
 
-  throw new Error(
-    "Expected to find a host parent. This error is likely caused by a bug " +
-      "in React. Please file an issue."
-  );
+  markRetryLaneIfNotHydrated(fiber, lane);
 }
 
-function isHostParent(fiber) {
-  return (
-    fiber.tag === HostComponent ||
-    fiber.tag === HostRoot ||
-    fiber.tag === HostHoistable ||
-    fiber.tag === HostSingleton ||
-    fiber.tag === HostPortal
-  );
+var shouldErrorImpl = function (fiber) {
+  return null;
+};
+
+function shouldError(fiber) {
+  return shouldErrorImpl(fiber);
 }
 
-function getHostSibling(fiber) {
-  // We're going to search forward into the tree until we find a sibling host
-  // node. Unfortunately, if multiple insertions are done in a row we have to
-  // search past them. This leads to exponential search for the next sibling.
-  // TODO: Find a more efficient way to do this.
-  var node = fiber;
+var shouldSuspendImpl = function (fiber) {
+  return false;
+};
 
-  siblings: while (true) {
-    // If we didn't find anything, let's try the next sibling.
-    while (node.sibling === null) {
-      if (node.return === null || isHostParent(node.return)) {
-        // If we pop out of the root or hit the parent the fiber we are the
-        // last sibling.
-        return null;
-      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+function shouldSuspend(fiber) {
+  return shouldSuspendImpl(fiber);
+}
+var overrideHookState = null;
+var overrideHookStateDeletePath = null;
+var overrideHookStateRenamePath = null;
+var overrideProps = null;
+var overridePropsDeletePath = null;
+var overridePropsRenamePath = null;
+var scheduleUpdate = null;
+var setErrorHandler = null;
+var setSuspenseHandler = null;
 
-      node = node.return;
-    }
+{
+  var copyWithDeleteImpl = function (obj, path, index) {
+    var key = path[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
 
-    node.sibling.return = node.return;
-    node = node.sibling;
+    if (index + 1 === path.length) {
+      if (isArray(updated)) {
+        updated.splice(key, 1);
+      } else {
+        delete updated[key];
+      }
 
-    while (
-      node.tag !== HostComponent &&
-      node.tag !== HostText &&
-      node.tag !== HostSingleton &&
-      node.tag !== DehydratedFragment
-    ) {
-      // If it is not host node and, we might have a host node inside it.
-      // Try to search down until we find one.
-      if (node.flags & Placement) {
-        // If we don't have a child, try the siblings instead.
-        continue siblings;
-      } // If we don't have a child, try the siblings instead.
-      // We also skip portals because they are not part of this host tree.
+      return updated;
+    } // $FlowFixMe number or string is fine here
 
-      if (node.child === null || node.tag === HostPortal) {
-        continue siblings;
+    updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
+    return updated;
+  };
+
+  var copyWithDelete = function (obj, path) {
+    return copyWithDeleteImpl(obj, path, 0);
+  };
+
+  var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
+    var oldKey = oldPath[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+
+    if (index + 1 === oldPath.length) {
+      var newKey = newPath[index]; // $FlowFixMe number or string is fine here
+
+      updated[newKey] = updated[oldKey];
+
+      if (isArray(updated)) {
+        updated.splice(oldKey, 1);
       } else {
-        node.child.return = node;
-        node = node.child;
+        delete updated[oldKey];
       }
-    } // Check if this host node is stable or about to be placed.
-
-    if (!(node.flags & Placement)) {
-      // Found it!
-      return node.stateNode;
+    } else {
+      // $FlowFixMe number or string is fine here
+      updated[oldKey] = copyWithRenameImpl(
+        // $FlowFixMe number or string is fine here
+        obj[oldKey],
+        oldPath,
+        newPath,
+        index + 1
+      );
     }
-  }
-}
 
-function commitPlacement(finishedWork) {
-  {
-    if (finishedWork.tag === HostSingleton) {
-      // Singletons are already in the Host and don't need to be placed
-      // Since they operate somewhat like Portals though their children will
-      // have Placement and will get placed inside them
-      return;
-    }
-  } // Recursively insert all host nodes into the parent.
+    return updated;
+  };
 
-  var parentFiber = getHostParentFiber(finishedWork);
+  var copyWithRename = function (obj, oldPath, newPath) {
+    if (oldPath.length !== newPath.length) {
+      warn("copyWithRename() expects paths of the same length");
 
-  switch (parentFiber.tag) {
-    case HostSingleton: {
-      {
-        var parent = parentFiber.stateNode;
-        var before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
-        // children to find all the terminal nodes.
+      return;
+    } else {
+      for (var i = 0; i < newPath.length - 1; i++) {
+        if (oldPath[i] !== newPath[i]) {
+          warn(
+            "copyWithRename() expects paths to be the same except for the deepest key"
+          );
 
-        insertOrAppendPlacementNode(finishedWork, before, parent);
-        break;
+          return;
+        }
       }
     }
-    // eslint-disable-next-line no-fallthrough
 
-    case HostComponent: {
-      var _parent = parentFiber.stateNode;
+    return copyWithRenameImpl(obj, oldPath, newPath, 0);
+  };
 
-      if (parentFiber.flags & ContentReset) {
-        // Reset the text content of the parent before doing any insertions
-        resetTextContent(_parent); // Clear ContentReset from the effect tag
+  var copyWithSetImpl = function (obj, path, index, value) {
+    if (index >= path.length) {
+      return value;
+    }
 
-        parentFiber.flags &= ~ContentReset;
-      }
+    var key = path[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj); // $FlowFixMe number or string is fine here
 
-      var _before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
-      // children to find all the terminal nodes.
+    updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
+    return updated;
+  };
 
-      insertOrAppendPlacementNode(finishedWork, _before, _parent);
-      break;
+  var copyWithSet = function (obj, path, value) {
+    return copyWithSetImpl(obj, path, 0, value);
+  };
+
+  var findHook = function (fiber, id) {
+    // For now, the "id" of stateful hooks is just the stateful hook index.
+    // This may change in the future with e.g. nested hooks.
+    var currentHook = fiber.memoizedState;
+
+    while (currentHook !== null && id > 0) {
+      currentHook = currentHook.next;
+      id--;
     }
 
-    case HostRoot:
-    case HostPortal: {
-      var _parent2 = parentFiber.stateNode.containerInfo;
+    return currentHook;
+  }; // Support DevTools editable values for useState and useReducer.
 
-      var _before2 = getHostSibling(finishedWork);
+  overrideHookState = function (fiber, id, path, value) {
+    var hook = findHook(fiber, id);
 
-      insertOrAppendPlacementNodeIntoContainer(
-        finishedWork,
-        _before2,
-        _parent2
-      );
-      break;
+    if (hook !== null) {
+      var newState = copyWithSet(hook.memoizedState, path, value);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
     }
-    // eslint-disable-next-line-no-fallthrough
+  };
 
-    default:
-      throw new Error(
-        "Invalid host parent fiber. This error is likely caused by a bug " +
-          "in React. Please file an issue."
-      );
-  }
-}
+  overrideHookStateDeletePath = function (fiber, id, path) {
+    var hook = findHook(fiber, id);
 
-function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
-  var tag = node.tag;
-  var isHost = tag === HostComponent || tag === HostText;
+    if (hook !== null) {
+      var newState = copyWithDelete(hook.memoizedState, path);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
 
-  if (isHost) {
-    var stateNode = node.stateNode;
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-    if (before) {
-      insertInContainerBefore(parent, stateNode, before);
-    } else {
-      appendChildToContainer(parent, stateNode);
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
     }
-  } else if (tag === HostPortal || tag === HostSingleton);
-  else {
-    var child = node.child;
+  };
 
-    if (child !== null) {
-      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
-      var sibling = child.sibling;
+  overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
+    var hook = findHook(fiber, id);
 
-      while (sibling !== null) {
-        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
-        sibling = sibling.sibling;
+    if (hook !== null) {
+      var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
       }
     }
-  }
-}
+  }; // Support DevTools props for function components, forwardRef, memo, host components, etc.
 
-function insertOrAppendPlacementNode(node, before, parent) {
-  var tag = node.tag;
-  var isHost = tag === HostComponent || tag === HostText;
+  overrideProps = function (fiber, path, value) {
+    fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
+    }
 
-  if (isHost) {
-    var stateNode = node.stateNode;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-    if (before) {
-      insertBefore(parent, stateNode, before);
-    } else {
-      appendChild(parent, stateNode);
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
     }
-  } else if (tag === HostPortal || tag === HostSingleton);
-  else {
-    var child = node.child;
+  };
 
-    if (child !== null) {
-      insertOrAppendPlacementNode(child, before, parent);
-      var sibling = child.sibling;
+  overridePropsDeletePath = function (fiber, path) {
+    fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
 
-      while (sibling !== null) {
-        insertOrAppendPlacementNode(sibling, before, parent);
-        sibling = sibling.sibling;
-      }
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
     }
-  }
-} // These are tracked on the stack as we recursively traverse a
-// deleted subtree.
-// TODO: Update these during the whole mutation phase, not just during
-// a deletion.
 
-var hostParent = null;
-var hostParentIsContainer = false;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-function commitDeletionEffects(root, returnFiber, deletedFiber) {
-  {
-    // We only have the top Fiber that was deleted but we need to recurse down its
-    // children to find all the terminal nodes.
-    // Recursively delete all host nodes from the parent, detach refs, clean
-    // up mounted layout effects, and call componentWillUnmount.
-    // We only need to remove the topmost host child in each branch. But then we
-    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
-    // could split this into two separate traversals functions, where the second
-    // one doesn't include any removeChild logic. This is maybe the same
-    // function as "disappearLayoutEffects" (or whatever that turns into after
-    // the layout phase is refactored to use recursion).
-    // Before starting, find the nearest host parent on the stack so we know
-    // which instance/container to remove the children from.
-    // TODO: Instead of searching up the fiber return path on every deletion, we
-    // can track the nearest host component on the JS stack as we traverse the
-    // tree during the commit phase. This would make insertions faster, too.
-    var parent = returnFiber;
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    }
+  };
 
-    findParent: while (parent !== null) {
-      switch (parent.tag) {
-        case HostSingleton:
-        case HostComponent: {
-          hostParent = parent.stateNode;
-          hostParentIsContainer = false;
-          break findParent;
-        }
+  overridePropsRenamePath = function (fiber, oldPath, newPath) {
+    fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
 
-        case HostRoot: {
-          hostParent = parent.stateNode.containerInfo;
-          hostParentIsContainer = true;
-          break findParent;
-        }
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
+    }
 
-        case HostPortal: {
-          hostParent = parent.stateNode.containerInfo;
-          hostParentIsContainer = true;
-          break findParent;
-        }
-      }
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-      parent = parent.return;
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
     }
+  };
 
-    if (hostParent === null) {
-      throw new Error(
-        "Expected to find a host parent. This error is likely caused by " +
-          "a bug in React. Please file an issue."
-      );
+  scheduleUpdate = function (fiber) {
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
     }
+  };
 
-    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
-    hostParent = null;
-    hostParentIsContainer = false;
+  setErrorHandler = function (newShouldErrorImpl) {
+    shouldErrorImpl = newShouldErrorImpl;
+  };
+
+  setSuspenseHandler = function (newShouldSuspendImpl) {
+    shouldSuspendImpl = newShouldSuspendImpl;
+  };
+}
+
+function findHostInstanceByFiber(fiber) {
+  var hostFiber = findCurrentHostFiber(fiber);
+
+  if (hostFiber === null) {
+    return null;
   }
 
-  detachFiberMutation(deletedFiber);
+  return hostFiber.stateNode;
 }
 
-function recursivelyTraverseDeletionEffects(
-  finishedRoot,
-  nearestMountedAncestor,
-  parent
-) {
-  // TODO: Use a static flag to skip trees that don't have unmount effects
-  var child = parent.child;
+function emptyFindFiberByHostInstance(instance) {
+  return null;
+}
 
-  while (child !== null) {
-    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
-    child = child.sibling;
+function getCurrentFiberForDevTools() {
+  return current;
+}
+
+function injectIntoDevTools(devToolsConfig) {
+  var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState: overrideHookState,
+    overrideHookStateDeletePath: overrideHookStateDeletePath,
+    overrideHookStateRenamePath: overrideHookStateRenamePath,
+    overrideProps: overrideProps,
+    overridePropsDeletePath: overridePropsDeletePath,
+    overridePropsRenamePath: overridePropsRenamePath,
+    setErrorHandler: setErrorHandler,
+    setSuspenseHandler: setSuspenseHandler,
+    scheduleUpdate: scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber: findHostInstanceByFiber,
+    findFiberByHostInstance:
+      findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: findHostInstancesForRefresh,
+    scheduleRefresh: scheduleRefresh,
+    scheduleRoot: scheduleRoot,
+    setRefreshHandler: setRefreshHandler,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: getCurrentFiberForDevTools,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
+
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
+
+var isInsideEventHandler = false;
+
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  var controlledComponentsHavePendingUpdates = needsStateRestore();
+
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
   }
 }
 
-function commitDeletionEffectsOnFiber(
-  finishedRoot,
-  nearestMountedAncestor,
-  deletedFiber
-) {
-  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
-  // into their subtree. There are simpler cases in the inner switch
-  // that don't modify the stack.
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
 
-  switch (deletedFiber.tag) {
-    case HostHoistable: {
-      {
-        if (!offscreenSubtreeWasHidden) {
-          safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        }
+  isInsideEventHandler = true;
 
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
 
-        if (deletedFiber.memoizedState) {
-          releaseResource(deletedFiber.memoizedState);
-        } else if (deletedFiber.stateNode) {
-          unmountHoistable(deletedFiber.stateNode);
-        }
+function isInteractive(tag) {
+  return (
+    tag === "button" ||
+    tag === "input" ||
+    tag === "select" ||
+    tag === "textarea"
+  );
+}
 
-        return;
-      }
-    }
-    // eslint-disable-next-line no-fallthrough
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      return !!(props.disabled && isInteractive(type));
 
-    case HostSingleton: {
-      {
-        if (!offscreenSubtreeWasHidden) {
-          safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        }
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
 
-        var prevHostParent = hostParent;
-        var prevHostParentIsContainer = hostParentIsContainer;
-        hostParent = deletedFiber.stateNode;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        ); // Normally this is called in passive unmount effect phase however with
-        // HostSingleton we warn if you acquire one that is already associated to
-        // a different fiber. To increase our chances of avoiding this, specifically
-        // if you keyed a HostSingleton so there will be a delete followed by a Placement
-        // we treat detach eagerly here
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
 
-        releaseSingletonInstance(deletedFiber.stateNode);
-        hostParent = prevHostParent;
-        hostParentIsContainer = prevHostParentIsContainer;
-        return;
-      }
-    }
-    // eslint-disable-next-line no-fallthrough
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
 
-    case HostComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      } // Intentional fallthrough to next branch
-    }
-    // eslint-disable-next-line-no-fallthrough
+  var props = getFiberCurrentPropsFromNode(stateNode);
 
-    case HostText: {
-      // We only need to remove the nearest host child. Set the host parent
-      // to `null` on the stack to indicate that nested children don't
-      // need to be removed.
-      {
-        var _prevHostParent = hostParent;
-        var _prevHostParentIsContainer = hostParentIsContainer;
-        hostParent = null;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        hostParent = _prevHostParent;
-        hostParentIsContainer = _prevHostParentIsContainer;
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
 
-        if (hostParent !== null) {
-          // Now that all the child effects have unmounted, we can remove the
-          // node from the tree.
-          if (hostParentIsContainer) {
-            removeChildFromContainer(hostParent, deletedFiber.stateNode);
-          } else {
-            removeChild(hostParent, deletedFiber.stateNode);
-          }
-        }
-      }
+  var listener = props[registrationName];
 
-      return;
-    }
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
+  }
 
-    case DehydratedFragment: {
-      {
-        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+  if (listener && typeof listener !== "function") {
+    throw new Error(
+      "Expected `" +
+        registrationName +
+        "` listener to be a function, instead got a value of `" +
+        typeof listener +
+        "` type."
+    );
+  }
 
-        if (hydrationCallbacks !== null) {
-          var onDeleted = hydrationCallbacks.onDeleted;
+  return listener;
+}
 
-          if (onDeleted) {
-            onDeleted(deletedFiber.stateNode);
-          }
-        }
-      } // Dehydrated fragments don't have any children
-      // Delete the dehydrated suspense boundary and all of its content.
+var passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
 
-      {
-        if (hostParent !== null) {
-          if (hostParentIsContainer) {
-            clearSuspenseBoundaryFromContainer(
-              hostParent,
-              deletedFiber.stateNode
-            );
-          } else {
-            clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
-          }
-        }
+if (canUseDOM) {
+  try {
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = true;
       }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
+  }
+}
 
-      return;
-    }
+// has this definition built-in.
 
-    case HostPortal: {
-      {
-        // When we go into a portal, it becomes the parent to remove from.
-        var _prevHostParent2 = hostParent;
-        var _prevHostParentIsContainer2 = hostParentIsContainer;
-        hostParent = deletedFiber.stateNode.containerInfo;
-        hostParentIsContainer = true;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        hostParent = _prevHostParent2;
-        hostParentIsContainer = _prevHostParentIsContainer2;
-      }
+var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
 
-      return;
-    }
+var queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.
+// if the last target was dehydrated.
 
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        var updateQueue = deletedFiber.updateQueue;
+var queuedFocus = null;
+var queuedDrag = null;
+var queuedMouse = null; // For pointer events there can be one latest event per pointerId.
 
-        if (updateQueue !== null) {
-          var lastEffect = updateQueue.lastEffect;
+var queuedPointers = new Map();
+var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
 
-          if (lastEffect !== null) {
-            var firstEffect = lastEffect.next;
-            var effect = firstEffect;
+var queuedExplicitHydrationTargets = [];
+function hasQueuedDiscreteEvents() {
+  return queuedDiscreteEvents.length > 0;
+}
+var discreteReplayableEvents = [
+  "mousedown",
+  "mouseup",
+  "touchcancel",
+  "touchend",
+  "touchstart",
+  "auxclick",
+  "dblclick",
+  "pointercancel",
+  "pointerdown",
+  "pointerup",
+  "dragend",
+  "dragstart",
+  "drop",
+  "compositionend",
+  "compositionstart",
+  "keydown",
+  "keypress",
+  "keyup",
+  "input",
+  "textInput", // Intentionally camelCase
+  "copy",
+  "cut",
+  "paste",
+  "click",
+  "change",
+  "contextmenu",
+  "reset",
+  "submit"
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
 
-            do {
-              var _effect = effect,
-                destroy = _effect.destroy,
-                tag = _effect.tag;
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return {
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
+  };
+}
 
-              if (destroy !== undefined) {
-                if ((tag & Insertion) !== NoFlags) {
-                  safelyCallDestroy(
-                    deletedFiber,
-                    nearestMountedAncestor,
-                    destroy
-                  );
-                } else if ((tag & Layout) !== NoFlags) {
-                  if (enableSchedulingProfiler) {
-                    markComponentLayoutEffectUnmountStarted(deletedFiber);
-                  }
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    return;
+  }
 
-                  if (shouldProfile(deletedFiber)) {
-                    startLayoutEffectTimer();
-                    safelyCallDestroy(
-                      deletedFiber,
-                      nearestMountedAncestor,
-                      destroy
-                    );
-                    recordLayoutEffectDuration(deletedFiber);
-                  } else {
-                    safelyCallDestroy(
-                      deletedFiber,
-                      nearestMountedAncestor,
-                      destroy
-                    );
-                  }
+  var queuedEvent = createQueuedReplayableEvent(
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
+  queuedDiscreteEvents.push(queuedEvent);
 
-                  if (enableSchedulingProfiler) {
-                    markComponentLayoutEffectUnmountStopped();
-                  }
-                }
-              }
+  if (queuedDiscreteEvents.length === 1) {
+    // If this was the first discrete event, we might be able to
+    // synchronously unblock it so that preventDefault still works.
+    while (queuedEvent.blockedOn !== null) {
+      var fiber = getInstanceFromNode$1(queuedEvent.blockedOn);
 
-              effect = effect.next;
-            } while (effect !== firstEffect);
-          }
-        }
+      if (fiber === null) {
+        break;
       }
 
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
-    }
+      attemptSynchronousHydration(fiber);
 
-    case ClassComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        var instance = deletedFiber.stateNode;
+      if (queuedEvent.blockedOn === null) {
+        // We got unblocked by hydration. Let's try again.
+        replayUnblockedEvents(); // If we're reblocked, on an inner boundary, we might need
+        // to attempt hydrating that one.
 
-        if (typeof instance.componentWillUnmount === "function") {
-          safelyCallComponentWillUnmount(
-            deletedFiber,
-            nearestMountedAncestor,
-            instance
-          );
-        }
+        continue;
+      } else {
+        // We're still blocked from hydration, we have to give up
+        // and replay later.
+        break;
       }
-
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
     }
+  }
+} // Resets the replaying for this type of continuous event to no event.
 
-    case ScopeComponent: {
-      {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      }
-
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
-    }
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
 
-    case OffscreenComponent: {
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
 
-      if (deletedFiber.mode & ConcurrentMode) {
-        // If this offscreen component is hidden, we already unmounted it. Before
-        // deleting the children, track that it's already unmounted so that we
-        // don't attempt to unmount the effects again.
-        // TODO: If the tree is hidden, in most cases we should be able to skip
-        // over the nested children entirely. An exception is we haven't yet found
-        // the topmost host node to delete, which we already track on the stack.
-        // But the other case is portals, which need to be detached no matter how
-        // deeply they are nested. We should use a subtree flag to track whether a
-        // subtree includes a nested portal.
-        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-        offscreenSubtreeWasHidden =
-          prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-      } else {
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-      }
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
 
+    case "pointerover":
+    case "pointerout": {
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.delete(pointerId);
       break;
     }
 
-    default: {
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
+    case "gotpointercapture":
+    case "lostpointercapture": {
+      var _pointerId = nativeEvent.pointerId;
+      queuedPointerCaptures.delete(_pointerId);
+      break;
     }
   }
 }
 
-function commitSuspenseCallback(finishedWork) {
-  // TODO: Move this to passive phase
-  var newState = finishedWork.memoizedState;
-
-  if (newState !== null) {
-    var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    existingQueuedEvent === null ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
+  ) {
+    var queuedEvent = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
 
-    if (typeof suspenseCallback === "function") {
-      var wakeables = finishedWork.updateQueue;
+    if (blockedOn !== null) {
+      var fiber = getInstanceFromNode$1(blockedOn);
 
-      if (wakeables !== null) {
-        suspenseCallback(new Set(wakeables));
-      }
-    } else {
-      if (suspenseCallback !== undefined) {
-        error("Unexpected type for suspenseCallback.");
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
       }
     }
-  }
-}
 
-function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
-  var newState = finishedWork.memoizedState;
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
 
-  if (newState === null) {
-    var current = finishedWork.alternate;
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  var targetContainers = existingQueuedEvent.targetContainers;
 
-    if (current !== null) {
-      var prevState = current.memoizedState;
+  if (
+    targetContainer !== null &&
+    targetContainers.indexOf(targetContainer) === -1
+  ) {
+    targetContainers.push(targetContainer);
+  }
 
-      if (prevState !== null) {
-        var suspenseInstance = prevState.dehydrated;
+  return existingQueuedEvent;
+}
 
-        if (suspenseInstance !== null) {
-          try {
-            commitHydratedSuspenseInstance(suspenseInstance);
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case "focusin": {
+      var focusEvent = nativeEvent;
+      queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedFocus,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        focusEvent
+      );
+      return true;
+    }
 
-            if (enableSuspenseCallback) {
-              var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+    case "dragenter": {
+      var dragEvent = nativeEvent;
+      queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedDrag,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        dragEvent
+      );
+      return true;
+    }
 
-              if (hydrationCallbacks !== null) {
-                var onHydrated = hydrationCallbacks.onHydrated;
+    case "mouseover": {
+      var mouseEvent = nativeEvent;
+      queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedMouse,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        mouseEvent
+      );
+      return true;
+    }
 
-                if (onHydrated) {
-                  onHydrated(suspenseInstance);
-                }
-              }
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
+    case "pointerover": {
+      var pointerEvent = nativeEvent;
+      var pointerId = pointerEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          pointerEvent
+        )
+      );
+      return true;
+    }
+
+    case "gotpointercapture": {
+      var _pointerEvent = nativeEvent;
+      var _pointerId2 = _pointerEvent.pointerId;
+      queuedPointerCaptures.set(
+        _pointerId2,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointerCaptures.get(_pointerId2) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          _pointerEvent
+        )
+      );
+      return true;
     }
   }
-}
 
-function getRetryCache(finishedWork) {
-  // TODO: Unify the interface for the retry cache so we don't have to switch
-  // on the tag like this.
-  switch (finishedWork.tag) {
-    case SuspenseComponent:
-    case SuspenseListComponent: {
-      var retryCache = finishedWork.stateNode;
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
 
-      if (retryCache === null) {
-        retryCache = finishedWork.stateNode = new PossiblyWeakSet();
-      }
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
 
-      return retryCache;
-    }
+  if (targetInst !== null) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-      var _retryCache = instance._retryCache;
+    if (nearestMounted !== null) {
+      var tag = nearestMounted.tag;
 
-      if (_retryCache === null) {
-        _retryCache = instance._retryCache = new PossiblyWeakSet();
-      }
+      if (tag === SuspenseComponent) {
+        var instance = getSuspenseInstanceFromFiber(nearestMounted);
 
-      return _retryCache;
-    }
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, function () {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
+        }
+      } else if (tag === HostRoot) {
+        var root = nearestMounted.stateNode;
 
-    default: {
-      throw new Error(
-        "Unexpected Suspense handler tag (" +
-          finishedWork.tag +
-          "). This is a " +
-          "bug in React."
-      );
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
+
+          return;
+        }
+      }
     }
   }
+
+  queuedTarget.blockedOn = null;
 }
 
-function detachOffscreenInstance(instance) {
-  var fiber = instance._current;
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  var updatePriority = getCurrentUpdatePriority();
+  var queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
+  };
+  var i = 0;
 
-  if (fiber === null) {
-    throw new Error(
-      "Calling Offscreen.detach before instance handle has been set."
-    );
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (
+      !isHigherEventPriority(
+        updatePriority,
+        queuedExplicitHydrationTargets[i].priority
+      )
+    ) {
+      break;
+    }
   }
 
-  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
-    // The instance is already detached, this is a noop.
-    return;
-  } // TODO: There is an opportunity to optimise this by not entering commit phase
-  // and unmounting effects directly.
-
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
 
-  if (root !== null) {
-    instance._pendingVisibility |= OffscreenDetached;
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
   }
 }
-function attachOffscreenInstance(instance) {
-  var fiber = instance._current;
 
-  if (fiber === null) {
-    throw new Error(
-      "Calling Offscreen.detach before instance handle has been set."
-    );
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
   }
 
-  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
-    // The instance is already attached, this is a noop.
-    return;
+  var targetContainers = queuedEvent.targetContainers;
+
+  while (targetContainers.length > 0) {
+    var targetContainer = targetContainers[0];
+    var nextBlockedOn = findInstanceBlockingEvent(
+      queuedEvent.domEventName,
+      queuedEvent.eventSystemFlags,
+      targetContainer,
+      queuedEvent.nativeEvent
+    );
+
+    if (nextBlockedOn === null) {
+      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+        var nativeEvent = queuedEvent.nativeEvent;
+        var nativeEventClone = new nativeEvent.constructor(
+          nativeEvent.type,
+          nativeEvent
+        );
+        setReplayingEvent(nativeEventClone);
+        nativeEvent.target.dispatchEvent(nativeEventClone);
+        resetReplayingEvent();
+      } else {
+        setReplayingEvent(queuedEvent.nativeEvent);
+        dispatchEventForPluginEventSystem(
+          queuedEvent.domEventName,
+          queuedEvent.eventSystemFlags,
+          queuedEvent.nativeEvent,
+          return_targetInst,
+          targetContainer
+        );
+        resetReplayingEvent();
+      }
+    } else {
+      // We're still blocked. Try again later.
+      var fiber = getInstanceFromNode$1(nextBlockedOn);
+
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
+
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
+
+    targetContainers.shift();
   }
 
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  return true;
+}
 
-  if (root !== null) {
-    instance._pendingVisibility &= ~OffscreenDetached;
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
   }
 }
 
-function attachSuspenseRetryListeners(finishedWork, wakeables) {
-  // If this boundary just timed out, then it will have a set of wakeables.
-  // For each wakeable, attach a listener so that when it resolves, React
-  // attempts to re-render the boundary in the primary (pre-timeout) state.
-  var retryCache = getRetryCache(finishedWork);
-  wakeables.forEach(function (wakeable) {
-    // Memoize using the boundary fiber to prevent redundant listeners.
-    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false;
 
-    if (!retryCache.has(wakeable)) {
-      retryCache.add(wakeable);
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    // First replay discrete events.
+    while (queuedDiscreteEvents.length > 0) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
 
-      {
-        if (isDevToolsPresent) {
-          if (inProgressLanes !== null && inProgressRoot !== null) {
-            // If we have pending work still, associate the original updaters with it.
-            restorePendingUpdaters(inProgressRoot, inProgressLanes);
-          } else {
-            throw Error(
-              "Expected finished root and lanes to be set. This is a bug in React."
-            );
-          }
+      if (nextDiscreteEvent.blockedOn !== null) {
+        // We're still blocked.
+        // Increase the priority of this boundary to unblock
+        // the next discrete event.
+        var fiber = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
+
+        if (fiber !== null) {
+          attemptDiscreteHydration(fiber);
         }
+
+        break;
+      }
+
+      var targetContainers = nextDiscreteEvent.targetContainers;
+
+      while (targetContainers.length > 0) {
+        var targetContainer = targetContainers[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          targetContainer,
+          nextDiscreteEvent.nativeEvent
+        );
+
+        if (nextBlockedOn === null) {
+          // This whole function is in !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
+          // so we don't need the new replay behavior code branch.
+          setReplayingEvent(nextDiscreteEvent.nativeEvent);
+          dispatchEventForPluginEventSystem(
+            nextDiscreteEvent.domEventName,
+            nextDiscreteEvent.eventSystemFlags,
+            nextDiscreteEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          );
+          resetReplayingEvent();
+        } else {
+          // We're still blocked. Try again later.
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
+          break;
+        } // This target container was successfully dispatched. Try the next.
+
+        targetContainers.shift();
       }
 
-      wakeable.then(retry, retry);
+      if (nextDiscreteEvent.blockedOn === null) {
+        // We've successfully replayed the first event. Let's try the next one.
+        queuedDiscreteEvents.shift();
+      }
     }
-  });
-} // This function detects when a Suspense boundary goes from visible to hidden.
-// It returns false if the boundary is already hidden.
-// TODO: Use an effect tag.
+  } // Next replay any continuous events.
 
-function isSuspenseBoundaryBeingHidden(current, finishedWork) {
-  if (current !== null) {
-    var oldState = current.memoizedState;
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
+  }
 
-    if (oldState === null || oldState.dehydrated !== null) {
-      var newState = finishedWork.memoizedState;
-      return newState !== null && newState.dehydrated === null;
-    }
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
   }
 
-  return false;
-}
-function commitMutationEffects(root, finishedWork, committedLanes) {
-  inProgressLanes = committedLanes;
-  inProgressRoot = root;
-  setCurrentFiber(finishedWork);
-  commitMutationEffectsOnFiber(finishedWork, root);
-  setCurrentFiber(finishedWork);
-  inProgressLanes = null;
-  inProgressRoot = null;
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
+  }
+
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
 }
 
-function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects hae fired.
-  var deletions = parentFiber.deletions;
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
 
-  if (deletions !== null) {
-    for (var i = 0; i < deletions.length; i++) {
-      var childToDelete = deletions[i];
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
 
-      try {
-        commitDeletionEffects(root, parentFiber, childToDelete);
-      } catch (error) {
-        captureCommitPhaseError(childToDelete, parentFiber, error);
-      }
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      );
     }
   }
+}
 
-  var prevDebugFiber = getCurrentFiber();
+function retryIfBlockedOn(unblocked) {
+  // Mark anything that was blocked on this as no longer blocked
+  // and eligible for a replay.
+  if (queuedDiscreteEvents.length > 0) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
+    // worth it because we expect very few discrete events to queue up and once
+    // we are actually fully unblocked it will be fast to replay them.
 
-  if (parentFiber.subtreeFlags & MutationMask) {
-    var child = parentFiber.child;
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent = queuedDiscreteEvents[i];
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitMutationEffectsOnFiber(child, root);
-      child = child.sibling;
+      if (queuedEvent.blockedOn === unblocked) {
+        queuedEvent.blockedOn = null;
+      }
     }
   }
 
-  setCurrentFiber(prevDebugFiber);
-}
-
-var currentHoistableRoot = null;
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  }
 
-function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
-  var current = finishedWork.alternate;
-  var flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
-  // because the fiber tag is more specific. An exception is any flag related
-  // to reconciliation, because those can be set on all fiber types.
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  }
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  }
 
-      if (flags & Update) {
-        try {
-          commitHookEffectListUnmount(
-            Insertion | HasEffect,
-            finishedWork,
-            finishedWork.return
-          );
-          commitHookEffectListMount(Insertion | HasEffect, finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        } // Layout effects are destroyed during the mutation phase so that all
-        // destroy functions for all fibers are called before any create functions.
-        // This prevents sibling component effects from interfering with each other,
-        // e.g. a destroy function in one component should never override a ref set
-        // by a create function in another component during the same commit.
+  var unblock = function (queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  };
 
-        if (shouldProfile(finishedWork)) {
-          try {
-            startLayoutEffectTimer();
-            commitHookEffectListUnmount(
-              Layout | HasEffect,
-              finishedWork,
-              finishedWork.return
-            );
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
 
-          recordLayoutEffectDuration(finishedWork);
-        } else {
-          try {
-            commitHookEffectListUnmount(
-              Layout | HasEffect,
-              finishedWork,
-              finishedWork.return
-            );
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
+  for (var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++) {
+    var queuedTarget = queuedExplicitHydrationTargets[_i];
 
-      return;
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
     }
+  }
 
-    case ClassComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
-      }
+  while (queuedExplicitHydrationTargets.length > 0) {
+    var nextExplicitTarget = queuedExplicitHydrationTargets[0];
 
-      if (flags & Callback && offscreenSubtreeIsHidden) {
-        var updateQueue = finishedWork.updateQueue;
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
 
-        if (updateQueue !== null) {
-          deferHiddenCallbacks(updateQueue);
-        }
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
       }
-
-      return;
     }
+  }
+}
 
-    case HostHoistable: {
-      {
-        // We cast because we always set the root at the React root and so it cannot be
-        // null while we are processing mutation effects
-        var hoistableRoot = currentHoistableRoot;
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork);
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
 
-        if (flags & Ref) {
-          if (current !== null) {
-            safelyDetachRef(current, current.return);
-          }
-        }
+var _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
 
-        if (flags & Update) {
-          var currentResource = current !== null ? current.memoizedState : null;
-          var newResource = finishedWork.memoizedState;
+function setEnabled(enabled) {
+  _enabled = !!enabled;
+}
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
+) {
+  var eventPriority = getEventPriority(domEventName);
+  var listenerWrapper;
 
-          if (current === null) {
-            // We are mounting a new HostHoistable Fiber. We fork the mount
-            // behavior based on whether this instance is a Hoistable Instance
-            // or a Hoistable Resource
-            if (newResource === null) {
-              if (finishedWork.stateNode === null) {
-                finishedWork.stateNode = hydrateHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.memoizedProps,
-                  finishedWork
-                );
-              } else {
-                mountHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.stateNode
-                );
-              }
-            } else {
-              finishedWork.stateNode = acquireResource(
-                hoistableRoot,
-                newResource,
-                finishedWork.memoizedProps
-              );
-            }
-          } else if (currentResource !== newResource) {
-            // We are moving to or from Hoistable Resource, or between different Hoistable Resources
-            if (currentResource === null) {
-              if (current.stateNode !== null) {
-                unmountHoistable(current.stateNode);
-              }
-            } else {
-              releaseResource(currentResource);
-            }
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
 
-            if (newResource === null) {
-              mountHoistable(
-                hoistableRoot,
-                finishedWork.type,
-                finishedWork.stateNode
-              );
-            } else {
-              acquireResource(
-                hoistableRoot,
-                newResource,
-                finishedWork.memoizedProps
-              );
-            }
-          } else if (newResource === null && finishedWork.stateNode !== null) {
-            // We may have an update on a Hoistable element
-            var updatePayload = finishedWork.updateQueue;
-            finishedWork.updateQueue = null;
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
 
-            if (updatePayload !== null) {
-              try {
-                commitUpdate(
-                  finishedWork.stateNode,
-                  updatePayload,
-                  finishedWork.type,
-                  current.memoizedProps,
-                  finishedWork.memoizedProps,
-                  finishedWork
-                );
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
 
-        return;
-      }
-    }
-    // eslint-disable-next-line-no-fallthrough
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
+  );
+}
 
-    case HostSingleton: {
-      {
-        if (flags & Update) {
-          var previousWork = finishedWork.alternate;
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
 
-          if (previousWork === null) {
-            var singleton = finishedWork.stateNode;
-            var props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
 
-            clearSingleton(singleton);
-            acquireSingletonInstance(
-              finishedWork.type,
-              props,
-              singleton,
-              finishedWork
-            );
-          }
-        }
-      }
-    }
-    // eslint-disable-next-line-no-fallthrough
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
 
-    case HostComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
 
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
-      }
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (!_enabled) {
+    return;
+  }
 
-      {
-        // TODO: ContentReset gets cleared by the children during the commit
-        // phase. This is a refactor hazard because it means we must read
-        // flags the flags after `commitReconciliationEffects` has already run;
-        // the order matters. We should refactor so that ContentReset does not
-        // rely on mutating the flag during commit. Like by setting a flag
-        // during the render phase instead.
-        if (finishedWork.flags & ContentReset) {
-          var instance = finishedWork.stateNode;
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+  } else {
+    dispatchEventOriginal(
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+  }
+}
 
-          try {
-            resetTextContent(instance);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
+function dispatchEventOriginal(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // TODO: replaying capture phase events is currently broken
+  // because we used to do it during top-level native bubble handlers
+  // but now we use different bubble and capture handlers.
+  // In eager mode, we attach capture listeners early, so we need
+  // to filter them out until we fix the logic to handle them correctly.
+  var allowReplay = (eventSystemFlags & IS_CAPTURE_PHASE) === 0;
 
-        if (flags & Update) {
-          var _instance2 = finishedWork.stateNode;
+  if (
+    allowReplay &&
+    hasQueuedDiscreteEvents() &&
+    isDiscreteEventThatRequiresHydration(domEventName)
+  ) {
+    // If we already have a queue of discrete events, and this is another discrete
+    // event, then we can't dispatch it regardless of its target, since they
+    // need to dispatch in order.
+    queueDiscreteEvent(
+      null, // Flags that we're not actually blocked on anything as far as we know.
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+    return;
+  }
 
-          if (_instance2 != null) {
-            // Commit the work prepared earlier.
-            var newProps = finishedWork.memoizedProps; // 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 blockedOn = findInstanceBlockingEvent(
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
 
-            var oldProps = current !== null ? current.memoizedProps : newProps;
-            var type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      return_targetInst,
+      targetContainer
+    );
 
-            var _updatePayload = finishedWork.updateQueue;
-            finishedWork.updateQueue = null;
+    if (allowReplay) {
+      clearIfContinuousEvent(domEventName, nativeEvent);
+    }
 
-            if (_updatePayload !== null) {
-              try {
-                commitUpdate(
-                  _instance2,
-                  _updatePayload,
-                  type,
-                  oldProps,
-                  newProps,
-                  finishedWork
-                );
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
-      }
+    return;
+  }
+
+  if (allowReplay) {
+    if (isDiscreteEventThatRequiresHydration(domEventName)) {
+      // This to be replayed later once the target is available.
+      queueDiscreteEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
+      return;
+    }
 
+    if (
+      queueIfContinuousEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )
+    ) {
       return;
-    }
-
-    case HostText: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+    } // We need to clear only if we didn't queue because
+    // queueing is accumulative.
 
-      if (flags & Update) {
-        {
-          if (finishedWork.stateNode === null) {
-            throw new Error(
-              "This should have a text node initialized. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          }
+    clearIfContinuousEvent(domEventName, nativeEvent);
+  } // This is not replayable so we'll invoke it but without a target,
+  // in case the event system needs to trace it.
 
-          var textInstance = finishedWork.stateNode;
-          var newText = finishedWork.memoizedProps; // 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.
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
 
-          var oldText = current !== null ? current.memoizedProps : newText;
+function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  var blockedOn = findInstanceBlockingEvent(
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
 
-          try {
-            commitTextUpdate(textInstance, oldText, newText);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      return_targetInst,
+      targetContainer
+    );
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
 
-      return;
-    }
+  if (
+    queueIfContinuousEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )
+  ) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
 
-    case HostRoot: {
-      {
-        prepareToCommitHoistables();
-        var previousHoistableRoot = currentHoistableRoot;
-        currentHoistableRoot = getHoistableRoot(root.containerInfo);
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        currentHoistableRoot = previousHoistableRoot;
-        commitReconciliationEffects(finishedWork);
-      }
+  clearIfContinuousEvent(domEventName, nativeEvent);
 
-      if (flags & Update) {
-        {
-          if (current !== null) {
-            var prevRootState = current.memoizedState;
+  if (
+    eventSystemFlags & IS_CAPTURE_PHASE &&
+    isDiscreteEventThatRequiresHydration(domEventName)
+  ) {
+    while (blockedOn !== null) {
+      var fiber = getInstanceFromNode$1(blockedOn);
 
-            if (prevRootState.isDehydrated) {
-              try {
-                commitHydratedContainer(root.containerInfo);
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
       }
 
-      return;
-    }
+      var nextBlockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
 
-    case HostPortal: {
-      {
-        var _previousHoistableRoot = currentHoistableRoot;
-        currentHoistableRoot = getHoistableRoot(
-          finishedWork.stateNode.containerInfo
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
         );
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork);
-        currentHoistableRoot = _previousHoistableRoot;
       }
 
-      return;
-    }
+      if (nextBlockedOn === blockedOn) {
+        break;
+      }
 
-    case SuspenseComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      var offscreenFiber = finishedWork.child;
+      blockedOn = nextBlockedOn;
+    }
 
-      if (offscreenFiber.flags & Visibility) {
-        var newState = offscreenFiber.memoizedState;
-        var isHidden = newState !== null;
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
 
-        if (isHidden) {
-          var wasHidden =
-            offscreenFiber.alternate !== null &&
-            offscreenFiber.alternate.memoizedState !== null;
+    return;
+  } // This is not replayable so we'll invoke it but without a target,
+  // in case the event system needs to trace it.
 
-          if (!wasHidden) {
-            // TODO: Move to passive phase
-            markCommitTimeOfFallback();
-          }
-        }
-      }
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
 
-      if (flags & Update) {
-        try {
-          commitSuspenseCallback(finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
+var return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
 
-        var wakeables = finishedWork.updateQueue;
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  var nativeEventTarget = getEventTarget(nativeEvent);
+  var targetInst = getClosestInstanceFromNode(nativeEventTarget);
 
-        if (wakeables !== null) {
-          finishedWork.updateQueue = null;
-          attachSuspenseRetryListeners(finishedWork, wakeables);
-        }
-      }
+  if (targetInst !== null) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
 
-      return;
-    }
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      var tag = nearestMounted.tag;
 
-    case OffscreenComponent: {
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
-      }
+      if (tag === SuspenseComponent) {
+        var instance = getSuspenseInstanceFromFiber(nearestMounted);
 
-      var _newState = finishedWork.memoizedState;
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
 
-      var _isHidden = _newState !== null;
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        var root = nearestMounted.stateNode;
 
-      var _wasHidden = current !== null && current.memoizedState !== null;
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
+        }
 
-      if (finishedWork.mode & ConcurrentMode) {
-        // Before committing the children, track on the stack whether this
-        // offscreen subtree was already hidden, so that we don't unmount the
-        // effects again.
-        var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
-        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || _isHidden;
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || _wasHidden;
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-      } else {
-        recursivelyTraverseMutationEffects(root, finishedWork);
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
       }
+    }
+  }
 
-      commitReconciliationEffects(finishedWork);
-      var offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
-
-      offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
-      // to support batching of `attach` and `detach` calls.
+  return_targetInst = targetInst; // We're not blocked on anything.
 
-      offscreenInstance._visibility &= ~OffscreenDetached;
-      offscreenInstance._visibility |=
-        offscreenInstance._pendingVisibility & OffscreenDetached;
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange": // Used by polyfills:
+    // eslint-disable-next-line no-fallthrough
 
-      if (flags & Visibility) {
-        // Track the current state on the Offscreen instance so we can
-        // read it during an event
-        if (_isHidden) {
-          offscreenInstance._visibility &= ~OffscreenVisible;
-        } else {
-          offscreenInstance._visibility |= OffscreenVisible;
-        }
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate": // Only enableCreateEventHandleAPI:
+    // eslint-disable-next-line no-fallthrough
 
-        if (_isHidden) {
-          var isUpdate = current !== null;
-          var wasHiddenByAncestorOffscreen =
-            offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
-          //   - This is an update, not first mount.
-          //   - This Offscreen was not hidden before.
-          //   - Ancestor Offscreen was not hidden in previous commit.
+    case "beforeblur":
+    case "afterblur": // Not used by React but could be by user code:
+    // eslint-disable-next-line no-fallthrough
 
-          if (isUpdate && !_wasHidden && !wasHiddenByAncestorOffscreen) {
-            if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
-              // Disappear the layout effects of all the children
-              recursivelyTraverseDisappearLayoutEffects(finishedWork);
-            }
-          }
-        } // Offscreen with manual mode manages visibility manually.
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return DiscreteEventPriority;
 
-        if (!isOffscreenManual(finishedWork)) {
-          // TODO: This needs to run whenever there's an insertion or update
-          // inside a hidden Offscreen tree.
-          hideOrUnhideAllChildren(finishedWork, _isHidden);
-        }
-      } // TODO: Move to passive phase
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel": // Not used by React but could be by user code:
+    // eslint-disable-next-line no-fallthrough
 
-      if (flags & Update) {
-        var offscreenQueue = finishedWork.updateQueue;
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return ContinuousEventPriority;
 
-        if (offscreenQueue !== null) {
-          var _wakeables = offscreenQueue.wakeables;
+    case "message": {
+      // We might be in the Scheduler callback.
+      // Eventually this mechanism will be replaced by a check
+      // of the current priority on the native scheduler.
+      var schedulerPriority = getCurrentPriorityLevel();
 
-          if (_wakeables !== null) {
-            offscreenQueue.wakeables = null;
-            attachSuspenseRetryListeners(finishedWork, _wakeables);
-          }
-        }
-      }
+      switch (schedulerPriority) {
+        case ImmediatePriority:
+          return DiscreteEventPriority;
 
-      return;
-    }
+        case UserBlockingPriority:
+          return ContinuousEventPriority;
 
-    case SuspenseListComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+        case NormalPriority$1:
+        case LowPriority:
+          // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+          return DefaultEventPriority;
 
-      if (flags & Update) {
-        var _wakeables2 = finishedWork.updateQueue;
+        case IdlePriority:
+          return IdleEventPriority;
 
-        if (_wakeables2 !== null) {
-          finishedWork.updateQueue = null;
-          attachSuspenseRetryListeners(finishedWork, _wakeables2);
-        }
+        default:
+          return DefaultEventPriority;
       }
-
-      return;
     }
 
-    case ScopeComponent: {
-      {
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork); // TODO: This is a temporary solution that allowed us to transition away
-        // from React Flare on www.
-
-        if (flags & Ref) {
-          if (current !== null) {
-            safelyDetachRef(finishedWork, finishedWork.return);
-          }
+    default:
+      return DefaultEventPriority;
+  }
+}
 
-          safelyAttachRef(finishedWork, finishedWork.return);
-        }
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, false);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, {
+    capture: true,
+    passive: passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, {
+    passive: passive
+  });
+  return listener;
+}
+function removeEventListener(target, eventType, listener, capture) {
+  target.removeEventListener(eventType, listener, capture);
+}
 
-        if (flags & Update) {
-          var scopeInstance = finishedWork.stateNode;
-          prepareScopeUpdate(scopeInstance, finishedWork);
-        }
-      }
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+var root = null;
+var startText = null;
+var fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
 
-      return;
-    }
+  var start;
+  var startValue = startText;
+  var startLength = startValue.length;
+  var end;
+  var endValue = getText();
+  var endLength = endValue.length;
 
-    default: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      return;
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
+      break;
     }
   }
-}
-
-function commitReconciliationEffects(finishedWork) {
-  // Placement effects (insertions, reorders) can be scheduled on any fiber
-  // type. They needs to happen after the children effects have fired, but
-  // before the effects on this fiber have fired.
-  var flags = finishedWork.flags;
 
-  if (flags & Placement) {
-    try {
-      commitPlacement(finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    } // Clear the "placement" from effect tag so that we know that this is
-    // inserted, before any life-cycles like componentDidMount gets called.
-    // TODO: findDOMNode doesn't rely on this any more but isMounted does
-    // and isMounted is deprecated anyway so we should be able to kill this.
+  var minEnd = startLength - start;
 
-    finishedWork.flags &= ~Placement;
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
+      break;
+    }
   }
 
-  if (flags & Hydrating) {
-    finishedWork.flags &= ~Hydrating;
-  }
+  var sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
 }
+function getText() {
+  if ("value" in root) {
+    return root.value;
+  }
 
-function commitLayoutEffects(finishedWork, root, committedLanes) {
-  inProgressLanes = committedLanes;
-  inProgressRoot = root;
-  var current = finishedWork.alternate;
-  commitLayoutEffectOnFiber(root, current, finishedWork);
-  inProgressLanes = null;
-  inProgressRoot = null;
+  return root.textContent;
 }
 
-function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
-  var prevDebugFiber = getCurrentFiber();
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  var charCode;
+  var keyCode = nativeEvent.keyCode;
 
-  if (parentFiber.subtreeFlags & LayoutMask) {
-    var child = parentFiber.child;
+  if ("charCode" in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      var current = child.alternate;
-      commitLayoutEffectOnFiber(root, current, child);
-      child = child.sibling;
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
     }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
+
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
   }
 
-  setCurrentFiber(prevDebugFiber);
+  return 0;
 }
 
-function disappearLayoutEffects(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      // TODO (Offscreen) Check: flags & LayoutStatic
-      if (shouldProfile(finishedWork)) {
-        try {
-          startLayoutEffectTimer();
-          commitHookEffectListUnmount(
-            Layout,
-            finishedWork,
-            finishedWork.return
-          );
-        } finally {
-          recordLayoutEffectDuration(finishedWork);
-        }
+function functionThatReturnsTrue() {
+  return true;
+}
+
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
+
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  ) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+
+    for (var propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
+
+      var normalize = Interface[propName];
+
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
       } else {
-        commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+        this[propName] = nativeEvent[propName];
       }
+    }
 
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
+    var defaultPrevented =
+      nativeEvent.defaultPrevented != null
+        ? nativeEvent.defaultPrevented
+        : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
     }
 
-    case ClassComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      var instance = finishedWork.stateNode;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
 
-      if (typeof instance.componentWillUnmount === "function") {
-        safelyCallComponentWillUnmount(
-          finishedWork,
-          finishedWork.return,
-          instance
-        );
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      var event = this.nativeEvent;
+
+      if (!event) {
+        return;
       }
 
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
-    }
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== "unknown") {
+        event.returnValue = false;
+      }
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
-    }
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      var event = this.nativeEvent;
 
-    case OffscreenComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      var isHidden = finishedWork.memoizedState !== null;
+      if (!event) {
+        return;
+      }
 
-      if (isHidden);
-      else {
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== "unknown") {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
       }
 
-      break;
-    }
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
 
-    default: {
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
-    }
-  }
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {
+      // Modern event system doesn't use pooling.
+    },
+
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
 }
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
-  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
-  var child = parentFiber.child;
+var EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+var SyntheticEvent = createSyntheticEvent(EventInterface);
 
-  while (child !== null) {
-    disappearLayoutEffects(child);
-    child = child.sibling;
+var UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
+
+var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+var lastMovementX;
+var lastMovementY;
+var lastMouseEvent;
+
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === "mousemove") {
+      // $FlowFixMe assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe assuming this is a number
+
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
+    }
+
+    lastMouseEvent = event;
   }
 }
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-function reappearLayoutEffects(
-  finishedRoot,
-  current,
-  finishedWork, // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  includeWorkInProgressEffects
-) {
-  // Turn on layout effects in a tree that previously disappeared.
-  var flags = finishedWork.flags;
+var MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined)
+      return event.fromElement === event.srcElement
+        ? event.toElement
+        : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ("movementX" in event) {
+      return event.movementX;
+    }
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Check flags & LayoutStatic
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ("movementY" in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
 
-      commitHookLayoutEffects(finishedWork, Layout);
-      break;
-    }
+    return lastMovementY;
+  }
+});
 
-    case ClassComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Check for LayoutStatic flag
+var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-      var instance = finishedWork.stateNode;
+var DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
 
-      if (typeof instance.componentDidMount === "function") {
-        try {
-          instance.componentDidMount();
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
-      } // Commit any callbacks that would have fired while the component
-      // was hidden.
+var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-      var updateQueue = finishedWork.updateQueue;
+var FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
 
-      if (updateQueue !== null) {
-        commitHiddenCallbacks(updateQueue, instance);
-      } // If this is newly finished work, check for setState callbacks
+var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
 
-      if (includeWorkInProgressEffects && flags & Callback) {
-        commitClassCallbacks(finishedWork);
-      } // TODO: Check flags & RefStatic
+var AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    }
-    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
-    // because this function only visits nodes that are inside an
-    // Offscreen fiber.
-    // case HostRoot: {
-    //  ...
-    // }
+var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // Renderers may schedule work to be done after host components are mounted
-      // (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.
+var ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return "clipboardData" in event
+      ? event.clipboardData
+      : window.clipboardData;
+  }
+});
 
-      if (includeWorkInProgressEffects && current === null && flags & Update) {
-        commitHostComponentMount(finishedWork);
-      } // TODO: Check flags & Ref
+var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    }
+var CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
 
-    case Profiler: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Figure out how Profiler updates should work with Offscreen
+var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
 
-      if (includeWorkInProgressEffects && flags & Update) {
-        commitProfilerUpdate(finishedWork, current);
-      }
+var SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
 
-      break;
-    }
+var normalizeKey = {
+  Esc: "Escape",
+  Spacebar: " ",
+  Left: "ArrowLeft",
+  Up: "ArrowUp",
+  Right: "ArrowRight",
+  Down: "ArrowDown",
+  Del: "Delete",
+  Win: "OS",
+  Menu: "ContextMenu",
+  Apps: "ContextMenu",
+  Scroll: "ScrollLock",
+  MozPrintableKey: "Unidentified"
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
 
-    case SuspenseComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Figure out how Suspense hydration callbacks should work
-      // with Offscreen.
+var translateToKey = {
+  "8": "Backspace",
+  "9": "Tab",
+  "12": "Clear",
+  "13": "Enter",
+  "16": "Shift",
+  "17": "Control",
+  "18": "Alt",
+  "19": "Pause",
+  "20": "CapsLock",
+  "27": "Escape",
+  "32": " ",
+  "33": "PageUp",
+  "34": "PageDown",
+  "35": "End",
+  "36": "Home",
+  "37": "ArrowLeft",
+  "38": "ArrowUp",
+  "39": "ArrowRight",
+  "40": "ArrowDown",
+  "45": "Insert",
+  "46": "Delete",
+  "112": "F1",
+  "113": "F2",
+  "114": "F3",
+  "115": "F4",
+  "116": "F5",
+  "117": "F6",
+  "118": "F7",
+  "119": "F8",
+  "120": "F9",
+  "121": "F10",
+  "122": "F11",
+  "123": "F12",
+  "144": "NumLock",
+  "145": "ScrollLock",
+  "224": "Meta"
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
 
-      if (includeWorkInProgressEffects && flags & Update) {
-        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
-      }
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    var key = normalizeKey[nativeEvent.key] || nativeEvent.key; // $FlowFixMe unable to index with a `mixed` value
 
-      break;
+    if (key !== "Unidentified") {
+      return key;
     }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
 
-    case OffscreenComponent: {
-      var offscreenState = finishedWork.memoizedState;
-      var isHidden = offscreenState !== null;
-
-      if (isHidden);
-      else {
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-      } // TODO: Check flags & Ref
+  if (nativeEvent.type === "keypress") {
+    var charCode = getEventCharCode(
+      // $FlowFixMe unable to narrow to `KeyboardEvent`
+      nativeEvent
+    ); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    }
+    return charCode === 13 ? "Enter" : String.fromCharCode(charCode);
+  }
 
-    default: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      );
-      break;
-    }
+  if (nativeEvent.type === "keydown" || nativeEvent.type === "keyup") {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || "Unidentified";
   }
+
+  return "";
 }
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
 
-function recursivelyTraverseReappearLayoutEffects(
-  finishedRoot,
-  parentFiber,
-  includeWorkInProgressEffects
-) {
-  // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  var childShouldIncludeWorkInProgressEffects =
-    includeWorkInProgressEffects &&
-    (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+var modifierKeyToProp = {
+  Alt: "altKey",
+  Control: "ctrlKey",
+  Meta: "metaKey",
+  Shift: "shiftKey"
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
 
-  var prevDebugFiber = getCurrentFiber();
-  var child = parentFiber.child;
+function modifierStateGetter(keyArg) {
+  var syntheticEvent = this;
+  var nativeEvent = syntheticEvent.nativeEvent;
 
-  while (child !== null) {
-    var current = child.alternate;
-    reappearLayoutEffects(
-      finishedRoot,
-      current,
-      child,
-      childShouldIncludeWorkInProgressEffects
-    );
-    child = child.sibling;
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
   }
 
-  setCurrentFiber(prevDebugFiber);
+  var keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
 }
 
-function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  if (shouldProfile(finishedWork)) {
-    startPassiveEffectTimer();
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === "keypress") {
+      return getEventCharCode(
+        // $FlowFixMe unable to narrow to `KeyboardEvent`
+        event
+      );
     }
 
-    recordPassiveEffectDuration(finishedWork);
-  } else {
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === "keydown" || event.type === "keyup") {
+      return event.keyCode;
     }
-  }
-}
-
-function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
-  {
-    var previousCache = null;
 
-    if (
-      current !== null &&
-      current.memoizedState !== null &&
-      current.memoizedState.cachePool !== null
-    ) {
-      previousCache = current.memoizedState.cachePool.pool;
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === "keypress") {
+      return getEventCharCode(
+        // $FlowFixMe unable to narrow to `KeyboardEvent`
+        event
+      );
     }
 
-    var nextCache = null;
-
-    if (
-      finishedWork.memoizedState !== null &&
-      finishedWork.memoizedState.cachePool !== null
-    ) {
-      nextCache = finishedWork.memoizedState.cachePool.pool;
-    } // Retain/release the cache used for pending (suspended) nodes.
-    // Note that this is only reached in the non-suspended/visible case:
-    // when the content is suspended/hidden, the retain/release occurs
-    // via the parent Suspense component (see case above).
-
-    if (nextCache !== previousCache) {
-      if (nextCache != null) {
-        retainCache(nextCache);
-      }
-
-      if (previousCache != null) {
-        releaseCache(previousCache);
-      }
+    if (event.type === "keydown" || event.type === "keyup") {
+      return event.keyCode;
     }
-  }
-
-  if (enableTransitionTracing) {
-    // TODO: Pre-rendering should not be counted as part of a transition. We
-    // may add separate logs for pre-rendering, but it's not part of the
-    // primary metrics.
-    var offscreenState = finishedWork.memoizedState;
-    var queue = finishedWork.updateQueue;
-    var isHidden = offscreenState !== null;
-
-    if (queue !== null) {
-      if (isHidden) {
-        var transitions = queue.transitions;
 
-        if (transitions !== null) {
-          transitions.forEach(function (transition) {
-            // Add all the transitions saved in the update queue during
-            // the render phase (ie the transitions associated with this boundary)
-            // into the transitions set.
-            if (instance._transitions === null) {
-              instance._transitions = new Set();
-            }
+    return 0;
+  }
+});
 
-            instance._transitions.add(transition);
-          });
-        }
+var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
 
-        var markerInstances = queue.markerInstances;
+var PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
 
-        if (markerInstances !== null) {
-          markerInstances.forEach(function (markerInstance) {
-            var markerTransitions = markerInstance.transitions; // There should only be a few tracing marker transitions because
-            // they should be only associated with the transition that
-            // caused them
+var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
 
-            if (markerTransitions !== null) {
-              markerTransitions.forEach(function (transition) {
-                if (instance._transitions === null) {
-                  instance._transitions = new Set();
-                } else if (instance._transitions.has(transition)) {
-                  if (markerInstance.pendingBoundaries === null) {
-                    markerInstance.pendingBoundaries = new Map();
-                  }
+var TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
 
-                  if (instance._pendingMarkers === null) {
-                    instance._pendingMarkers = new Set();
-                  }
+var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
 
-                  instance._pendingMarkers.add(markerInstance);
-                }
-              });
-            }
-          });
-        }
-      }
+var TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
 
-      finishedWork.updateQueue = null;
-    }
+var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
+var WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX: function (event) {
+    return "deltaX" in event
+      ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+      : "wheelDeltaX" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDeltaX
+      : 0;
+  },
+  deltaY: function (event) {
+    return "deltaY" in event
+      ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+      : "wheelDeltaY" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+      : "wheelDelta" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDelta
+      : 0;
+  },
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
 
-    if (!isHidden) {
-      instance._transitions = null;
-      instance._pendingMarkers = null;
-    }
-  }
-}
+var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
 
-function commitCachePassiveMountEffect(current, finishedWork) {
-  {
-    var previousCache = null;
+var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
 
-    if (finishedWork.alternate !== null) {
-      previousCache = finishedWork.alternate.memoizedState.cache;
-    }
+var START_KEYCODE = 229;
+var canUseCompositionEvent = canUseDOM && "CompositionEvent" in window;
+var documentMode = null;
 
-    var nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
-    // could be "borrowing" a cache instance owned by some parent,
-    // in which case we could avoid retaining/releasing. But it
-    // is non-trivial to determine when that is the case, so we
-    // always retain/release.
+if (canUseDOM && "documentMode" in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
 
-    if (nextCache !== previousCache) {
-      retainCache(nextCache);
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
 
-      if (previousCache != null) {
-        releaseCache(previousCache);
-      }
-    }
-  }
-}
+var useFallbackCompositionData =
+  canUseDOM &&
+  (!canUseCompositionEvent ||
+    (documentMode && documentMode > 8 && documentMode <= 11));
+var SPACEBAR_CODE = 32;
+var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
 
-function commitTracingMarkerPassiveMountEffect(finishedWork) {
-  // Get the transitions that were initiatized during the render
-  // and add a start transition callback for each of them
-  // We will only call this on initial mount of the tracing marker
-  // only if there are no suspense children
-  var instance = finishedWork.stateNode;
+function registerEvents$3() {
+  registerTwoPhaseEvent("onBeforeInput", [
+    "compositionend",
+    "keypress",
+    "textInput",
+    "paste"
+  ]);
+  registerTwoPhaseEvent("onCompositionEnd", [
+    "compositionend",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+  registerTwoPhaseEvent("onCompositionStart", [
+    "compositionstart",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+  registerTwoPhaseEvent("onCompositionUpdate", [
+    "compositionupdate",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+} // Track whether we've ever handled a keypress on the space key.
 
-  if (instance.transitions !== null && instance.pendingBoundaries === null) {
-    addMarkerCompleteCallbackToPendingTransition(
-      finishedWork.memoizedProps.name,
-      instance.transitions
-    );
-    instance.transitions = null;
-    instance.pendingBoundaries = null;
-    instance.aborts = null;
-    instance.name = null;
-  }
-}
+var hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
 
-function commitPassiveMountEffects(
-  root,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  setCurrentFiber(finishedWork);
-  commitPassiveMountOnFiber(
-    root,
-    finishedWork,
-    committedLanes,
-    committedTransitions
+function isKeypressCommand(nativeEvent) {
+  return (
+    (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+    !(nativeEvent.ctrlKey && nativeEvent.altKey)
   );
-  resetCurrentFiber();
-}
-
-function recursivelyTraversePassiveMountEffects(
-  root,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  var prevDebugFiber = getCurrentFiber();
-
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
-
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitPassiveMountOnFiber(
-        root,
-        child,
-        committedLanes,
-        committedTransitions
-      );
-      child = child.sibling;
-    }
-  }
-
-  setCurrentFiber(prevDebugFiber);
 }
+/**
+ * Translate native top level events into event types.
+ */
 
-function commitPassiveMountOnFiber(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  // When updating this function, also update reconnectPassiveEffects, which does
-  // most of the same things when an offscreen tree goes from hidden -> visible,
-  // or when toggling effects inside a hidden tree.
-  var flags = finishedWork.flags;
-
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-
-      if (flags & Passive$1) {
-        commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
-      }
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case "compositionstart":
+      return "onCompositionStart";
 
-      break;
-    }
+    case "compositionend":
+      return "onCompositionEnd";
 
-    case HostRoot: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
+    case "compositionupdate":
+      return "onCompositionUpdate";
+  }
+}
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
 
-      if (flags & Passive$1) {
-        {
-          var previousCache = null;
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === "keydown" && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
 
-          if (finishedWork.alternate !== null) {
-            previousCache = finishedWork.alternate.memoizedState.cache;
-          }
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
 
-          var nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
-          // Note that on initial mount, previousCache and nextCache will be the same
-          // and this retain won't occur. To counter this, we instead retain the HostRoot's
-          // initial cache when creating the root itself (see createFiberRoot() in
-          // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
-          // here, such that previous/next caches are retained correctly.
+    case "keydown":
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
 
-          if (nextCache !== previousCache) {
-            retainCache(nextCache);
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      // Events are not possible without cancelling IME.
+      return true;
 
-            if (previousCache != null) {
-              releaseCache(previousCache);
-            }
-          }
-        }
+    default:
+      return false;
+  }
+}
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
 
-        if (enableTransitionTracing) {
-          // Get the transitions that were initiatized during the render
-          // and add a start transition callback for each of them
-          var root = finishedWork.stateNode;
-          var incompleteTransitions = root.incompleteTransitions; // Initial render
+function getDataFromCustomEvent(nativeEvent) {
+  var detail = nativeEvent.detail;
 
-          if (committedTransitions !== null) {
-            committedTransitions.forEach(function (transition) {
-              addTransitionStartCallbackToPendingTransition(transition);
-            });
-            clearTransitionsForLanes(finishedRoot, committedLanes);
-          }
+  if (typeof detail === "object" && "data" in detail) {
+    return detail.data;
+  }
 
-          incompleteTransitions.forEach(function (markerInstance, transition) {
-            var pendingBoundaries = markerInstance.pendingBoundaries;
+  return null;
+}
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
 
-            if (pendingBoundaries === null || pendingBoundaries.size === 0) {
-              if (markerInstance.aborts === null) {
-                addTransitionCompleteCallbackToPendingTransition(transition);
-              }
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === "ko";
+} // Track the current IME composition status, if any.
 
-              incompleteTransitions.delete(transition);
-            }
-          });
-          clearTransitionsForLanes(finishedRoot, committedLanes);
-        }
-      }
+var isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
 
-      break;
+function extractCompositionEvent(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget
+) {
+  var eventType;
+  var fallbackData;
+
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = "onCompositionStart";
     }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = "onCompositionEnd";
+  }
 
-    case LegacyHiddenComponent: {
-      {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
-        );
+  if (!eventType) {
+    return null;
+  }
 
-        if (flags & Passive$1) {
-          var current = finishedWork.alternate;
-          var instance = finishedWork.stateNode;
-          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-        }
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === "onCompositionStart") {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === "onCompositionEnd") {
+      if (isComposing) {
+        fallbackData = getData();
       }
-
-      break;
     }
+  }
 
-    case OffscreenComponent: {
-      // TODO: Pass `current` as argument to this function
-      var _instance3 = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+  var listeners = accumulateTwoPhaseListeners(targetInst, eventType);
 
-      if (isHidden) {
-        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          );
-        } else {
-          if (finishedWork.mode & ConcurrentMode) {
-            // The effects are currently disconnected. Since the tree is hidden,
-            // don't connect them. This also applies to the initial render.
-            {
-              // "Atomic" effects are ones that need to fire on every commit,
-              // even during pre-rendering. An example is updating the reference
-              // count on cache instances.
-              recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              );
-            }
-          } else {
-            // Legacy Mode: Fire the effects even if the tree is hidden.
-            _instance3._visibility |= OffscreenPassiveEffectsConnected;
-            recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            );
-          }
-        }
-      } else {
-        // Tree is visible
-        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          );
-        } else {
-          // The effects are currently disconnected. Reconnect them, while also
-          // firing effects inside newly mounted trees. This also applies to
-          // the initial render.
-          _instance3._visibility |= OffscreenPassiveEffectsConnected;
-          var includeWorkInProgressEffects =
-            (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
-          );
-        }
+  if (listeners.length > 0) {
+    var event = new SyntheticCompositionEvent(
+      eventType,
+      domEventName,
+      null,
+      nativeEvent,
+      nativeEventTarget
+    );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
+
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      var customData = getDataFromCustomEvent(nativeEvent);
+
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
       }
+    }
+  }
+}
 
-      if (flags & Passive$1) {
-        var _current = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
+
+    case "keypress":
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      var which = nativeEvent.which;
+
+      if (which !== SPACEBAR_CODE) {
+        return null;
       }
 
-      break;
-    }
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
 
-    case CacheComponent: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
+    case "textInput":
+      // Record the characters to be added to the DOM.
+      var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current2 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current2, finishedWork);
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
       }
 
-      break;
+      return chars;
+
+    default:
+      // For other native event types, do nothing.
+      return null;
+  }
+}
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
+
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (
+      domEventName === "compositionend" ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+    ) {
+      var chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
     }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
-        );
+    return null;
+  }
 
-        if (flags & Passive$1) {
-          commitTracingMarkerPassiveMountEffect(finishedWork);
+  switch (domEventName) {
+    case "paste":
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
+
+    case "keypress":
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
         }
+      }
 
-        break;
-      } // Intentional fallthrough to next branch
-    }
-    // eslint-disable-next-line-no-fallthrough
+      return null;
 
-    default: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-      break;
-    }
+    case "compositionend":
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)
+        ? null
+        : nativeEvent.data;
+
+    default:
+      return null;
   }
 }
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
 
-function recursivelyTraverseReconnectPassiveEffects(
-  finishedRoot,
-  parentFiber,
-  committedLanes,
-  committedTransitions,
-  includeWorkInProgressEffects
+function extractBeforeInputEvent(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget
 ) {
-  // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  var childShouldIncludeWorkInProgressEffects =
-    includeWorkInProgressEffects &&
-    (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  var chars;
 
-  var prevDebugFiber = getCurrentFiber();
-  var child = parentFiber.child;
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
+  } else {
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
 
-  while (child !== null) {
-    reconnectPassiveEffects(
-      finishedRoot,
-      child,
-      committedLanes,
-      committedTransitions,
-      childShouldIncludeWorkInProgressEffects
+  if (!chars) {
+    return null;
+  }
+
+  var listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
+
+  if (listeners.length > 0) {
+    var event = new SyntheticInputEvent(
+      "onBeforeInput",
+      "beforeinput",
+      null,
+      nativeEvent,
+      nativeEventTarget
     );
-    child = child.sibling;
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    }); // $FlowFixMe[incompatible-use]
+
+    event.data = chars;
   }
+}
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
 
-  setCurrentFiber(prevDebugFiber);
+function extractEvents$5(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  extractCompositionEvent(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  );
+  extractBeforeInputEvent(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  );
 }
 
-function reconnectPassiveEffects(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions, // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  includeWorkInProgressEffects
-) {
-  var flags = finishedWork.flags;
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+var supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  "datetime-local": true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      ); // TODO: Check for PassiveStatic flag
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
 
-      commitHookPassiveMountEffects(finishedWork, Passive);
-      break;
-    }
-    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
-    // because this function only visits nodes that are inside an
-    // Offscreen fiber.
-    // case HostRoot: {
-    //  ...
-    // }
+  if (nodeName === "input") {
+    return !!supportedInputTypes[elem.type];
+  }
 
-    case LegacyHiddenComponent: {
-      {
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
+  if (nodeName === "textarea") {
+    return true;
+  }
 
-        if (includeWorkInProgressEffects && flags & Passive$1) {
-          // TODO: Pass `current` as argument to this function
-          var current = finishedWork.alternate;
-          var instance = finishedWork.stateNode;
-          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-        }
-      }
+  return false;
+}
 
-      break;
-    }
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
 
-    case OffscreenComponent: {
-      var _instance4 = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
+  }
 
-      if (isHidden) {
-        if (_instance4._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
-          );
-        } else {
-          if (finishedWork.mode & ConcurrentMode) {
-            // The effects are currently disconnected. Since the tree is hidden,
-            // don't connect them. This also applies to the initial render.
-            {
-              // "Atomic" effects are ones that need to fire on every commit,
-              // even during pre-rendering. An example is updating the reference
-              // count on cache instances.
-              recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              );
-            }
-          } else {
-            // Legacy Mode: Fire the effects even if the tree is hidden.
-            _instance4._visibility |= OffscreenPassiveEffectsConnected;
-            recursivelyTraverseReconnectPassiveEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions,
-              includeWorkInProgressEffects
-            );
-          }
-        }
-      } else {
-        // Tree is visible
-        // Since we're already inside a reconnecting tree, it doesn't matter
-        // whether the effects are currently connected. In either case, we'll
-        // continue traversing the tree and firing all the effects.
-        //
-        // We do need to set the "connected" flag on the instance, though.
-        _instance4._visibility |= OffscreenPassiveEffectsConnected;
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
-      }
+  var eventName = "on" + eventNameSuffix;
+  var isSupported = eventName in document;
 
-      if (includeWorkInProgressEffects && flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current3 = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
-      }
+  if (!isSupported) {
+    var element = document.createElement("div");
+    element.setAttribute(eventName, "return;");
+    isSupported = typeof element[eventName] === "function";
+  }
 
-      break;
-    }
+  return isSupported;
+}
 
-    case CacheComponent: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      );
+function registerEvents$2() {
+  registerTwoPhaseEvent("onChange", [
+    "change",
+    "click",
+    "focusin",
+    "focusout",
+    "input",
+    "keydown",
+    "keyup",
+    "selectionchange"
+  ]);
+}
 
-      if (includeWorkInProgressEffects && flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current4 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current4, finishedWork);
-      }
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
+) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  var listeners = accumulateTwoPhaseListeners(inst, "onChange");
 
-      break;
-    }
+  if (listeners.length > 0) {
+    var event = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
+  }
+}
+/**
+ * For IE shims
+ */
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
+var activeElement$1 = null;
+var activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
 
-        if (includeWorkInProgressEffects && flags & Passive$1) {
-          commitTracingMarkerPassiveMountEffect(finishedWork);
-        }
+function shouldUseChangeEvent(elem) {
+  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName === "select" || (nodeName === "input" && elem.type === "file")
+  );
+}
 
-        break;
-      } // Intentional fallthrough to next branch
-    }
-    // eslint-disable-next-line-no-fallthrough
+function manualDispatchChangeEvent(nativeEvent) {
+  var dispatchQueue = [];
+  createAndAccumulateChangeEvent(
+    dispatchQueue,
+    activeElementInst$1,
+    nativeEvent,
+    getEventTarget(nativeEvent)
+  ); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
 
-    default: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      );
-      break;
-    }
-  }
+  batchedUpdates(runEventInBatch, dispatchQueue);
 }
 
-function recursivelyTraverseAtomicPassiveEffects(
-  finishedRoot,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  // "Atomic" effects are ones that need to fire on every commit, even during
-  // pre-rendering. We call this function when traversing a hidden tree whose
-  // regular effects are currently disconnected.
-  var prevDebugFiber = getCurrentFiber(); // TODO: Add special flag for atomic effects
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
 
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitAtomicPassiveEffects(finishedRoot, child);
-      child = child.sibling;
-    }
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
   }
-
-  setCurrentFiber(prevDebugFiber);
 }
 
-function commitAtomicPassiveEffects(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  // "Atomic" effects are ones that need to fire on every commit, even during
-  // pre-rendering. We call this function when traversing a hidden tree whose
-  // regular effects are currently disconnected.
-  var flags = finishedWork.flags;
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === "change") {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
 
-  switch (finishedWork.tag) {
-    case OffscreenComponent: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+var isInputEventSupported = false;
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var current = finishedWork.alternate;
-        var instance = finishedWork.stateNode;
-        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-      }
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported =
+    isEventSupported("input") &&
+    (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
 
-      break;
-    }
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent("onpropertychange", handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
 
-    case CacheComponent: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
+  }
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current5 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current5, finishedWork);
-      }
+  activeElement$1.detachEvent("onpropertychange", handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
 
-      break;
-    }
-    // eslint-disable-next-line-no-fallthrough
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== "value") {
+    return;
+  }
 
-    default: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-      break;
-    }
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
   }
 }
 
-function commitPassiveUnmountEffects(finishedWork) {
-  setCurrentFiber(finishedWork);
-  commitPassiveUnmountOnFiber(finishedWork);
-  resetCurrentFiber();
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === "focusin") {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === "focusout") {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
+
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (
+    domEventName === "selectionchange" ||
+    domEventName === "keyup" ||
+    domEventName === "keydown"
+  ) {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
+  }
 }
+/**
+ * SECTION: handle `click` event
+ */
 
-function detachAlternateSiblings(parentFiber) {
-  // A fiber was deleted from this parent fiber, but it's still part of the
-  // previous (alternate) parent fiber's list of children. Because children
-  // are a linked list, an earlier sibling that's still alive will be
-  // connected to the deleted fiber via its `alternate`:
-  //
-  //   live fiber --alternate--> previous live fiber --sibling--> deleted
-  //   fiber
-  //
-  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
-  // but we can disconnect the `sibling` and `child` pointers.
-  var previousFiber = parentFiber.alternate;
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  var nodeName = elem.nodeName;
+  return (
+    nodeName &&
+    nodeName.toLowerCase() === "input" &&
+    (elem.type === "checkbox" || elem.type === "radio")
+  );
+}
 
-  if (previousFiber !== null) {
-    var detachedChild = previousFiber.child;
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === "click") {
+    return getInstIfValueChanged(targetInst);
+  }
+}
 
-    if (detachedChild !== null) {
-      previousFiber.child = null;
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === "input" || domEventName === "change") {
+    return getInstIfValueChanged(targetInst);
+  }
+}
 
-      do {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        var detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+function handleControlledInputBlur(node) {
+  var state = node._wrapperState;
 
-        detachedChild.sibling = null;
-        detachedChild = detachedSibling;
-      } while (detachedChild !== null);
-    }
+  if (!state || !state.controlled || node.type !== "number") {
+    return;
   }
-}
 
-function commitHookPassiveUnmountEffects(
-  finishedWork,
-  nearestMountedAncestor,
-  hookFlags
-) {
-  if (shouldProfile(finishedWork)) {
-    startPassiveEffectTimer();
-    commitHookEffectListUnmount(
-      hookFlags,
-      finishedWork,
-      nearestMountedAncestor
-    );
-    recordPassiveEffectDuration(finishedWork);
-  } else {
-    commitHookEffectListUnmount(
-      hookFlags,
-      finishedWork,
-      nearestMountedAncestor
-    );
+  if (!disableInputAttributeSyncing) {
+    // If controlled, assign the value attribute to the current value on blur
+    setDefaultValue(node, "number", node.value);
   }
 }
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
 
-function recursivelyTraversePassiveUnmountEffects(parentFiber) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects have fired.
-  var deletions = parentFiber.deletions;
-
-  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
-    if (deletions !== null) {
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
+function extractEvents$4(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  var getTargetInstFunc, handleEventFunc;
 
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+    } else {
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
     }
-
-    detachAlternateSiblings(parentFiber);
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else if (
+    enableCustomElementPropertySupport &&
+    targetInst &&
+    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
+  ) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
   }
 
-  var prevDebugFiber = getCurrentFiber(); // TODO: Split PassiveMask into separate masks for mount and unmount?
-
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+  if (getTargetInstFunc) {
+    var inst = getTargetInstFunc(domEventName, targetInst);
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitPassiveUnmountOnFiber(child);
-      child = child.sibling;
+    if (inst) {
+      createAndAccumulateChangeEvent(
+        dispatchQueue,
+        inst,
+        nativeEvent,
+        nativeEventTarget
+      );
+      return;
     }
   }
 
-  setCurrentFiber(prevDebugFiber);
-}
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
 
-function commitPassiveUnmountOnFiber(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
+  if (domEventName === "focusout") {
+    handleControlledInputBlur(targetNode);
+  }
+}
 
-      if (finishedWork.flags & Passive$1) {
-        commitHookPassiveUnmountEffects(
-          finishedWork,
-          finishedWork.return,
-          Passive | HasEffect
-        );
-      }
+function registerEvents$1() {
+  registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+  registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+  registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+  registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
 
-      break;
-    }
+function extractEvents$3(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var isOverEvent =
+    domEventName === "mouseover" || domEventName === "pointerover";
+  var isOutEvent = domEventName === "mouseout" || domEventName === "pointerout";
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
 
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
       if (
-        isHidden &&
-        instance._visibility & OffscreenPassiveEffectsConnected && // For backwards compatibility, don't unmount when a tree suspends. In
-        // the future we may change this to unmount after a delay.
-        (finishedWork.return === null ||
-          finishedWork.return.tag !== SuspenseComponent)
+        getClosestInstanceFromNode(related) ||
+        isContainerMarkedAsRoot(related)
       ) {
-        // The effects are currently connected. Disconnect them.
-        // TODO: Add option or heuristic to delay before disconnecting the
-        // effects. Then if the tree reappears before the delay has elapsed, we
-        // can skip toggling the effects entirely.
-        instance._visibility &= ~OffscreenPassiveEffectsConnected;
-        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      } else {
-        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        return;
       }
-
-      break;
     }
+  }
 
-    default: {
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-      break;
-    }
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
   }
-}
 
-function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects have fired.
-  var deletions = parentFiber.deletions;
+  var win; // TODO: why is this nullable in the types but we read from it?
 
-  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
-    if (deletions !== null) {
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    var doc = nativeEventTarget.ownerDocument;
 
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
+    } else {
+      win = window;
     }
-
-    detachAlternateSiblings(parentFiber);
   }
 
-  var prevDebugFiber = getCurrentFiber(); // TODO: Check PassiveStatic flag
-
-  var child = parentFiber.child;
+  var from;
+  var to;
 
-  while (child !== null) {
-    setCurrentFiber(child);
-    disconnectPassiveEffect(child);
-    child = child.sibling;
-  }
+  if (isOutEvent) {
+    var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
 
-  setCurrentFiber(prevDebugFiber);
-}
+    from = targetInst;
+    to = _related ? getClosestInstanceFromNode(_related) : null;
 
-function disconnectPassiveEffect(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      // TODO: Check PassiveStatic flag
-      commitHookPassiveUnmountEffects(
-        finishedWork,
-        finishedWork.return,
-        Passive
-      ); // When disconnecting passive effects, we fire the effects in the same
-      // order as during a deletiong: parent before child
+    if (to !== null) {
+      var nearestMounted = getNearestMountedFiber(to);
+      var tag = to.tag;
 
-      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      break;
+      if (
+        to !== nearestMounted ||
+        (tag !== HostComponent && tag !== HostSingleton && tag !== HostText)
+      ) {
+        to = null;
+      }
     }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
+  }
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-
-      if (instance._visibility & OffscreenPassiveEffectsConnected) {
-        instance._visibility &= ~OffscreenPassiveEffectsConnected;
-        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      }
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
+  }
 
-      break;
-    }
+  var SyntheticEventCtor = SyntheticMouseEvent;
+  var leaveEventType = "onMouseLeave";
+  var enterEventType = "onMouseEnter";
+  var eventTypePrefix = "mouse";
 
-    default: {
-      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      break;
-    }
+  if (domEventName === "pointerout" || domEventName === "pointerover") {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = "onPointerLeave";
+    enterEventType = "onPointerEnter";
+    eventTypePrefix = "pointer";
   }
-}
 
-function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-  deletedSubtreeRoot,
-  nearestMountedAncestor
-) {
-  while (nextEffect !== null) {
-    var fiber = nextEffect; // Deletion effects fire in parent -> child order
-    // TODO: Check if fiber has a PassiveStatic flag
+  var fromNode = from == null ? win : getNodeFromInstance(from);
+  var toNode = to == null ? win : getNodeFromInstance(to);
+  var leave = new SyntheticEventCtor(
+    leaveEventType,
+    eventTypePrefix + "leave",
+    from,
+    nativeEvent,
+    nativeEventTarget
+  );
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  var enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
 
-    setCurrentFiber(fiber);
-    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
-    resetCurrentFiber();
-    var child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+  var nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
 
-    if (child !== null) {
-      child.return = fiber;
-      nextEffect = child;
-    } else {
-      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
-        deletedSubtreeRoot
-      );
-    }
+  if (nativeTargetInst === targetInst) {
+    var enterEvent = new SyntheticEventCtor(
+      enterEventType,
+      eventTypePrefix + "enter",
+      to,
+      nativeEvent,
+      nativeEventTarget
+    );
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
   }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
 }
 
-function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
-  deletedSubtreeRoot
-) {
-  while (nextEffect !== null) {
-    var fiber = nextEffect;
-    var sibling = fiber.sibling;
-    var returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
-    // This is more aggressive than ideal, and the long term goal is to only
-    // have to detach the deleted tree at the root.
+/**
+ * Given any node return the first leaf node without children.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {DOMElement|DOMTextNode}
+ */
 
-    detachFiberAfterEffects(fiber);
+function getLeafNode(node) {
+  while (node && node.firstChild) {
+    node = node.firstChild;
+  }
 
-    if (fiber === deletedSubtreeRoot) {
-      nextEffect = null;
-      return;
-    }
+  return node;
+}
+/**
+ * Get the next sibling within a container. This will walk up the
+ * DOM if a node's siblings have been exhausted.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {?DOMElement|DOMTextNode}
+ */
 
-    if (sibling !== null) {
-      sibling.return = returnFiber;
-      nextEffect = sibling;
-      return;
+function getSiblingNode(node) {
+  while (node) {
+    if (node.nextSibling) {
+      return node.nextSibling;
     }
 
-    nextEffect = returnFiber;
+    node = node.parentNode;
   }
 }
+/**
+ * Get object describing the nodes which contain characters at offset.
+ *
+ * @param {DOMElement|DOMTextNode} root
+ * @param {number} offset
+ * @return {?object}
+ */
 
-function commitPassiveUnmountInsideDeletedTreeOnFiber(
-  current,
-  nearestMountedAncestor
-) {
-  switch (current.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
-      break;
-    }
-    // TODO: run passive unmount effects when unmounting a root.
-    // Because passive unmount effects are not currently run,
-    // the cache instance owned by the root will never be freed.
-    // When effects are run, the cache should be freed here:
-    // case HostRoot: {
-    //   if (enableCache) {
-    //     const cache = current.memoizedState.cache;
-    //     releaseCache(cache);
-    //   }
-    //   break;
-    // }
+function getNodeForCharacterOffset(root, offset) {
+  var node = getLeafNode(root);
+  var nodeStart = 0;
+  var nodeEnd = 0;
 
-    case LegacyHiddenComponent:
-    case OffscreenComponent: {
-      {
-        if (
-          current.memoizedState !== null &&
-          current.memoizedState.cachePool !== null
-        ) {
-          var cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
-          // Note that this is only reached in the non-suspended/visible case:
-          // when the content is suspended/hidden, the retain/release occurs
-          // via the parent Suspense component (see case above).
+  while (node) {
+    if (node.nodeType === TEXT_NODE) {
+      nodeEnd = nodeStart + node.textContent.length;
 
-          if (cache != null) {
-            retainCache(cache);
-          }
-        }
+      if (nodeStart <= offset && nodeEnd >= offset) {
+        return {
+          node: node,
+          offset: offset - nodeStart
+        };
       }
 
-      break;
+      nodeStart = nodeEnd;
     }
 
-    case SuspenseComponent: {
-      if (enableTransitionTracing) {
-        // We need to mark this fiber's parents as deleted
-        var offscreenFiber = current.child;
-        var instance = offscreenFiber.stateNode;
-        var transitions = instance._transitions;
-
-        if (transitions !== null) {
-          var abortReason = {
-            reason: "suspense",
-            name: current.memoizedProps.unstable_name || null
-          };
-
-          if (
-            current.memoizedState === null ||
-            current.memoizedState.dehydrated === null
-          ) {
-            abortParentMarkerTransitionsForDeletedFiber(
-              offscreenFiber,
-              abortReason,
-              transitions,
-              instance,
-              true
-            );
-
-            if (nearestMountedAncestor !== null) {
-              abortParentMarkerTransitionsForDeletedFiber(
-                nearestMountedAncestor,
-                abortReason,
-                transitions,
-                instance,
-                false
-              );
-            }
-          }
-        }
-      }
+    node = getLeafNode(getSiblingNode(node));
+  }
+}
 
-      break;
-    }
+/**
+ * @param {DOMElement} outerNode
+ * @return {?object}
+ */
 
-    case CacheComponent: {
-      {
-        var _cache = current.memoizedState.cache;
-        releaseCache(_cache);
-      }
+function getOffsets(outerNode) {
+  var ownerDocument = outerNode.ownerDocument;
+  var win = (ownerDocument && ownerDocument.defaultView) || window;
+  var selection = win.getSelection && win.getSelection();
 
-      break;
-    }
+  if (!selection || selection.rangeCount === 0) {
+    return null;
+  }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        // We need to mark this fiber's parents as deleted
-        var _instance5 = current.stateNode;
-        var _transitions = _instance5.transitions;
+  var anchorNode = selection.anchorNode,
+    anchorOffset = selection.anchorOffset,
+    focusNode = selection.focusNode,
+    focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
+  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
+  // expose properties, triggering a "Permission denied error" if any of its
+  // properties are accessed. The only seemingly possible way to avoid erroring
+  // is to access a property that typically works for non-anonymous divs and
+  // catch any error that may otherwise arise. See
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
 
-        if (_transitions !== null) {
-          var _abortReason = {
-            reason: "marker",
-            name: current.memoizedProps.name
-          };
-          abortParentMarkerTransitionsForDeletedFiber(
-            current,
-            _abortReason,
-            _transitions,
-            null,
-            true
-          );
+  try {
+    /* eslint-disable ft-flow/no-unused-expressions */
+    anchorNode.nodeType;
+    focusNode.nodeType;
+    /* eslint-enable ft-flow/no-unused-expressions */
+  } catch (e) {
+    return null;
+  }
 
-          if (nearestMountedAncestor !== null) {
-            abortParentMarkerTransitionsForDeletedFiber(
-              nearestMountedAncestor,
-              _abortReason,
-              _transitions,
-              null,
-              false
-            );
-          }
-        }
-      }
+  return getModernOffsetsFromPoints(
+    outerNode,
+    anchorNode,
+    anchorOffset,
+    focusNode,
+    focusOffset
+  );
+}
+/**
+ * Returns {start, end} where `start` is the character/codepoint index of
+ * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
+ * `end` is the index of (focusNode, focusOffset).
+ *
+ * Returns null if you pass in garbage input but we should probably just crash.
+ *
+ * Exported only for testing.
+ */
 
-      break;
-    }
-  }
-}
+function getModernOffsetsFromPoints(
+  outerNode,
+  anchorNode,
+  anchorOffset,
+  focusNode,
+  focusOffset
+) {
+  var length = 0;
+  var start = -1;
+  var end = -1;
+  var indexWithinAnchor = 0;
+  var indexWithinFocus = 0;
+  var node = outerNode;
+  var parentNode = null;
 
-function invokeLayoutEffectMountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListMount(Layout | HasEffect, fiber);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
+  outer: while (true) {
+    var next = null;
 
-        break;
+    while (true) {
+      if (
+        node === anchorNode &&
+        (anchorOffset === 0 || node.nodeType === TEXT_NODE)
+      ) {
+        start = length + anchorOffset;
       }
 
-      case ClassComponent: {
-        var instance = fiber.stateNode;
+      if (
+        node === focusNode &&
+        (focusOffset === 0 || node.nodeType === TEXT_NODE)
+      ) {
+        end = length + focusOffset;
+      }
 
-        try {
-          instance.componentDidMount();
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
+      if (node.nodeType === TEXT_NODE) {
+        length += node.nodeValue.length;
+      }
 
+      if ((next = node.firstChild) === null) {
         break;
-      }
+      } // Moving from `node` to its first child `next`.
+
+      parentNode = node;
+      node = next;
     }
-  }
-}
 
-function invokePassiveEffectMountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListMount(Passive | HasEffect, fiber);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
+    while (true) {
+      if (node === outerNode) {
+        // If `outerNode` has children, this is always the second time visiting
+        // it. If it has no children, this is still the first loop, and the only
+        // valid selection is anchorNode and focusNode both equal to this node
+        // and both offsets 0, in which case we will have handled above.
+        break outer;
+      }
 
-        break;
+      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
+        start = length;
       }
-    }
-  }
-}
 
-function invokeLayoutEffectUnmountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
+      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
+        end = length;
+      }
 
+      if ((next = node.nextSibling) !== null) {
         break;
       }
 
-      case ClassComponent: {
-        var instance = fiber.stateNode;
-
-        if (typeof instance.componentWillUnmount === "function") {
-          safelyCallComponentWillUnmount(fiber, fiber.return, instance);
-        }
+      node = parentNode;
+      parentNode = node.parentNode;
+    } // Moving from `node` to its next sibling `next`.
 
-        break;
-      }
-    }
+    node = next;
   }
-}
 
-function invokePassiveEffectUnmountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
-      }
-    }
+  if (start === -1 || end === -1) {
+    // This should never happen. (Would happen if the anchor/focus nodes aren't
+    // actually inside the passed-in node.)
+    return null;
   }
-}
 
-function getCacheSignal() {
-  var cache = readContext(CacheContext);
-  return cache.controller.signal;
+  return {
+    start: start,
+    end: end
+  };
 }
+/**
+ * In modern non-IE browsers, we can support both forward and backward
+ * selections.
+ *
+ * Note: IE10+ supports the Selection object, but it does not support
+ * the `extend` method, which means that even in modern IE, it's not possible
+ * to programmatically create a backward selection. Thus, for all IE
+ * versions, we use the old IE API to create our selections.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @param {object} offsets
+ */
 
-function getCacheForType(resourceType) {
-  var cache = readContext(CacheContext);
-  var cacheForType = cache.data.get(resourceType);
+function setOffsets(node, offsets) {
+  var doc = node.ownerDocument || document;
+  var win = (doc && doc.defaultView) || window; // Edge fails with "Object expected" in some scenarios.
+  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
+  // fails when pasting 100+ items)
 
-  if (cacheForType === undefined) {
-    cacheForType = resourceType();
-    cache.data.set(resourceType, cacheForType);
+  if (!win.getSelection) {
+    return;
   }
 
-  return cacheForType;
-}
-
-var DefaultCacheDispatcher = {
-  getCacheSignal: getCacheSignal,
-  getCacheForType: getCacheForType
-};
+  var selection = win.getSelection();
+  var length = node.textContent.length;
+  var start = Math.min(offsets.start, length);
+  var end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
+  // Flip backward selections, so we can set with a single range.
 
-if (typeof Symbol === "function" && Symbol.for) {
-  var symbolFor = Symbol.for;
-  symbolFor("selector.component");
-  symbolFor("selector.has_pseudo_class");
-  symbolFor("selector.role");
-  symbolFor("selector.test_id");
-  symbolFor("selector.text");
-}
-var commitHooks = [];
-function onCommitRoot() {
-  {
-    commitHooks.forEach(function (commitHook) {
-      return commitHook();
-    });
+  if (!selection.extend && start > end) {
+    var temp = end;
+    end = start;
+    start = temp;
   }
-}
-
-var ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;
-function isLegacyActEnvironment(fiber) {
-  {
-    // Legacy mode. We preserve the behavior of React 17's act. It assumes an
-    // act environment whenever `jest` is defined, but you can still turn off
-    // spurious warnings by setting IS_REACT_ACT_ENVIRONMENT explicitly
-    // to false.
-    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
-      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
-        ? IS_REACT_ACT_ENVIRONMENT
-        : undefined; // $FlowFixMe - Flow doesn't know about jest
 
-    var jestIsDefined = typeof jest !== "undefined";
-    return jestIsDefined && isReactActEnvironmentGlobal !== false;
-  }
-}
-function isConcurrentActEnvironment() {
-  {
-    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
-      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
-        ? IS_REACT_ACT_ENVIRONMENT
-        : undefined;
+  var startMarker = getNodeForCharacterOffset(node, start);
+  var endMarker = getNodeForCharacterOffset(node, end);
 
+  if (startMarker && endMarker) {
     if (
-      !isReactActEnvironmentGlobal &&
-      ReactCurrentActQueue$1.current !== null
+      selection.rangeCount === 1 &&
+      selection.anchorNode === startMarker.node &&
+      selection.anchorOffset === startMarker.offset &&
+      selection.focusNode === endMarker.node &&
+      selection.focusOffset === endMarker.offset
     ) {
-      // TODO: Include link to relevant documentation page.
-      error(
-        "The current testing environment is not configured to support " +
-          "act(...)"
-      );
+      return;
     }
 
-    return isReactActEnvironmentGlobal;
+    var range = doc.createRange();
+    range.setStart(startMarker.node, startMarker.offset);
+    selection.removeAllRanges();
+
+    if (start > end) {
+      selection.addRange(range);
+      selection.extend(endMarker.node, endMarker.offset);
+    } else {
+      range.setEnd(endMarker.node, endMarker.offset);
+      selection.addRange(range);
+    }
   }
 }
 
-var postPaintCallbackScheduled = false;
-var callbacks = [];
-function schedulePostPaintCallback(callback) {
-  callbacks.push(callback);
-
-  if (!postPaintCallbackScheduled) {
-    postPaintCallbackScheduled = true;
-    requestPostPaintCallback(function (endTime) {
-      for (var i = 0; i < callbacks.length; i++) {
-        callbacks[i](endTime);
-      }
+function isTextNode(node) {
+  return node && node.nodeType === TEXT_NODE;
+}
 
-      postPaintCallbackScheduled = false;
-      callbacks = [];
-    });
+function containsNode(outerNode, innerNode) {
+  if (!outerNode || !innerNode) {
+    return false;
+  } else if (outerNode === innerNode) {
+    return true;
+  } else if (isTextNode(outerNode)) {
+    return false;
+  } else if (isTextNode(innerNode)) {
+    return containsNode(outerNode, innerNode.parentNode);
+  } else if ("contains" in outerNode) {
+    return outerNode.contains(innerNode);
+  } else if (outerNode.compareDocumentPosition) {
+    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+  } else {
+    return false;
   }
 }
 
-var ceil = Math.ceil;
-var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
-var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
-  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
-  ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
-var NoContext =
-  /*             */
-  0;
-var BatchedContext =
-  /*               */
-  1;
-var RenderContext =
-  /*         */
-  2;
-var CommitContext =
-  /*         */
-  4;
-var RootInProgress = 0;
-var RootFatalErrored = 1;
-var RootErrored = 2;
-var RootSuspended = 3;
-var RootSuspendedWithDelay = 4;
-var RootCompleted = 5;
-var RootDidNotComplete = 6; // Describes where we are in the React execution stack
-
-var executionContext = NoContext; // The root we're working on
-
-var workInProgressRoot = null; // The fiber we're working on
-
-var workInProgress = null; // The lanes we're rendering
-
-var workInProgressRootRenderLanes = NoLanes;
-var NotSuspended = 0;
-var SuspendedOnError = 1;
-var SuspendedOnData = 2;
-var SuspendedOnImmediate = 3;
-var SuspendedOnDeprecatedThrowPromise = 4;
-var SuspendedAndReadyToContinue = 5;
-var SuspendedOnHydration = 6; // When this is true, the work-in-progress fiber just suspended (or errored) and
-// we've yet to unwind the stack. In some cases, we may yield to the main thread
-// after this happens. If the fiber is pinged before we resume, we can retry
-// immediately instead of unwinding the stack.
-
-var workInProgressSuspendedReason = NotSuspended;
-var workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
-// different that whether something suspended, because we don't add multiple
-// listeners to a promise we've already seen (per root and lane).
-
-var workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
-// the lanes that we started working on at the root. When we enter a subtree
-// that is currently hidden, we add the lanes that would have committed if
-// the hidden tree hadn't been deferred. This is modified by the
-// HiddenContext module.
-//
-// Most things in the work loop should deal with workInProgressRootRenderLanes.
-// Most things in begin/complete phases should deal with renderLanes.
-
-var renderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
-
-var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
-
-var workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
-// includes unprocessed updates, not work in bailed out children.
-
-var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
-
-var workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
-
-var workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.
+function isInDocument(node) {
+  return (
+    node &&
+    node.ownerDocument &&
+    containsNode(node.ownerDocument.documentElement, node)
+  );
+}
 
-var workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
-// We will log them once the tree commits.
+function isSameOriginFrame(iframe) {
+  try {
+    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
+    // to throw, e.g. if it has a cross-origin src attribute.
+    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
+    // iframe.contentDocument.defaultView;
+    // A safety way is to access one of the cross origin properties: Window or Location
+    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
+    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
+    return typeof iframe.contentWindow.location.href === "string";
+  } catch (err) {
+    return false;
+  }
+}
 
-var workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train
-// model where we don't commit new loading states in too quick succession.
+function getActiveElementDeep() {
+  var win = window;
+  var element = getActiveElement();
 
-var globalMostRecentFallbackTime = 0;
-var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
-// more and prefer CPU suspense heuristics instead.
+  while (element instanceof win.HTMLIFrameElement) {
+    if (isSameOriginFrame(element)) {
+      win = element.contentWindow;
+    } else {
+      return element;
+    }
 
-var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
-// suspense heuristics and opt out of rendering more content.
+    element = getActiveElement(win.document);
+  }
 
-var RENDER_TIMEOUT_MS = 500;
-var workInProgressTransitions = null;
-function getWorkInProgressTransitions() {
-  return workInProgressTransitions;
+  return element;
 }
-var currentPendingTransitionCallbacks = null;
-var currentEndTime = null;
-function addTransitionStartCallbackToPendingTransition(transition) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: [],
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
+/**
+ * @ReactInputSelection: React input selection module. Based on Selection.js,
+ * but modified to be suitable for react and has a couple of bug fixes (doesn't
+ * assume buttons have range selections allowed).
+ * Input selection module for React.
+ */
 
-    if (currentPendingTransitionCallbacks.transitionStart === null) {
-      currentPendingTransitionCallbacks.transitionStart = [];
-    }
+/**
+ * @hasSelectionCapabilities: we get the element types that support selection
+ * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
+ * and `selectionEnd` rows.
+ */
 
-    currentPendingTransitionCallbacks.transitionStart.push(transition);
-  }
+function hasSelectionCapabilities(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName &&
+    ((nodeName === "input" &&
+      (elem.type === "text" ||
+        elem.type === "search" ||
+        elem.type === "tel" ||
+        elem.type === "url" ||
+        elem.type === "password")) ||
+      nodeName === "textarea" ||
+      elem.contentEditable === "true")
+  );
 }
-function addMarkerProgressCallbackToPendingTransition(
-  markerName,
-  transitions,
-  pendingBoundaries
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: new Map(),
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
+function getSelectionInformation() {
+  var focusedElem = getActiveElementDeep();
+  return {
+    focusedElem: focusedElem,
+    selectionRange: hasSelectionCapabilities(focusedElem)
+      ? getSelection$1(focusedElem)
+      : null
+  };
+}
+/**
+ * @restoreSelection: If any selection information was potentially lost,
+ * restore it. This is useful when performing operations that could remove dom
+ * nodes and place them back in, resulting in focus being lost.
+ */
 
-    if (currentPendingTransitionCallbacks.markerProgress === null) {
-      currentPendingTransitionCallbacks.markerProgress = new Map();
-    }
+function restoreSelection(priorSelectionInformation) {
+  var curFocusedElem = getActiveElementDeep();
+  var priorFocusedElem = priorSelectionInformation.focusedElem;
+  var priorSelectionRange = priorSelectionInformation.selectionRange;
 
-    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
-      pendingBoundaries: pendingBoundaries,
-      transitions: transitions
-    });
-  }
-}
-function addMarkerIncompleteCallbackToPendingTransition(
-  markerName,
-  transitions,
-  aborts
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: new Map(),
-        markerComplete: null
-      };
+  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
+    if (
+      priorSelectionRange !== null &&
+      hasSelectionCapabilities(priorFocusedElem)
+    ) {
+      setSelection(priorFocusedElem, priorSelectionRange);
+    } // Focusing a node can change the scroll position, which is undesirable
+
+    var ancestors = [];
+    var ancestor = priorFocusedElem;
+
+    while ((ancestor = ancestor.parentNode)) {
+      if (ancestor.nodeType === ELEMENT_NODE) {
+        ancestors.push({
+          element: ancestor,
+          left: ancestor.scrollLeft,
+          top: ancestor.scrollTop
+        });
+      }
     }
 
-    if (currentPendingTransitionCallbacks.markerIncomplete === null) {
-      currentPendingTransitionCallbacks.markerIncomplete = new Map();
+    if (typeof priorFocusedElem.focus === "function") {
+      priorFocusedElem.focus();
     }
 
-    currentPendingTransitionCallbacks.markerIncomplete.set(markerName, {
-      transitions: transitions,
-      aborts: aborts
-    });
+    for (var i = 0; i < ancestors.length; i++) {
+      var info = ancestors[i];
+      info.element.scrollLeft = info.left;
+      info.element.scrollTop = info.top;
+    }
   }
 }
-function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: new Map()
-      };
-    }
+/**
+ * @getSelection: Gets the selection bounds of a focused textarea, input or
+ * contentEditable node.
+ * -@input: Look up selection bounds of this input
+ * -@return {start: selectionStart, end: selectionEnd}
+ */
 
-    if (currentPendingTransitionCallbacks.markerComplete === null) {
-      currentPendingTransitionCallbacks.markerComplete = new Map();
-    }
+function getSelection$1(input) {
+  var selection;
 
-    currentPendingTransitionCallbacks.markerComplete.set(
-      markerName,
-      transitions
-    );
+  if ("selectionStart" in input) {
+    // Modern browser with input or textarea.
+    selection = {
+      start: input.selectionStart,
+      end: input.selectionEnd
+    };
+  } else {
+    // Content editable or old IE textarea.
+    selection = getOffsets(input);
   }
-}
-function addTransitionProgressCallbackToPendingTransition(
-  transition,
-  boundaries
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: new Map(),
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
 
-    if (currentPendingTransitionCallbacks.transitionProgress === null) {
-      currentPendingTransitionCallbacks.transitionProgress = new Map();
+  return (
+    selection || {
+      start: 0,
+      end: 0
     }
+  );
+}
+/**
+ * @setSelection: Sets the selection bounds of a textarea or input and focuses
+ * the input.
+ * -@input     Set selection bounds of this input or textarea
+ * -@offsets   Object of same form that is returned from get*
+ */
 
-    currentPendingTransitionCallbacks.transitionProgress.set(
-      transition,
-      boundaries
-    );
+function setSelection(input, offsets) {
+  var start = offsets.start;
+  var end = offsets.end;
+
+  if (end === undefined) {
+    end = start;
+  }
+
+  if ("selectionStart" in input) {
+    input.selectionStart = start;
+    input.selectionEnd = Math.min(end, input.value.length);
+  } else {
+    setOffsets(input, offsets);
   }
 }
-function addTransitionCompleteCallbackToPendingTransition(transition) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: [],
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
 
-    if (currentPendingTransitionCallbacks.transitionComplete === null) {
-      currentPendingTransitionCallbacks.transitionComplete = [];
-    }
+var skipSelectionChangeEvent =
+  canUseDOM && "documentMode" in document && document.documentMode <= 11;
 
-    currentPendingTransitionCallbacks.transitionComplete.push(transition);
-  }
+function registerEvents() {
+  registerTwoPhaseEvent("onSelect", [
+    "focusout",
+    "contextmenu",
+    "dragend",
+    "focusin",
+    "keydown",
+    "keyup",
+    "mousedown",
+    "mouseup",
+    "selectionchange"
+  ]);
 }
 
-function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+var activeElement = null;
+var activeElementInst = null;
+var lastSelection = null;
+var mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
+
+function getSelection(node) {
+  if ("selectionStart" in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    var win = (node.ownerDocument && node.ownerDocument.defaultView) || window;
+    var selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
+  }
 }
+/**
+ * Get document associated with the event target.
+ */
 
-function getRenderTargetTime() {
-  return workInProgressRootRenderTargetTime;
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget
+    ? eventTarget.document
+    : eventTarget.nodeType === DOCUMENT_NODE
+    ? eventTarget
+    : eventTarget.ownerDocument;
 }
-var hasUncaughtError = false;
-var firstUncaughtError = null;
-var legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
-// to track which root is currently committing layout effects.
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
 
-var rootCommittingMutationOrLayoutEffects = null;
-var rootDoesHavePassiveEffects = false;
-var rootWithPendingPassiveEffects = null;
-var pendingPassiveEffectsLanes = NoLanes;
-var pendingPassiveProfilerEffects = [];
-var pendingPassiveEffectsRemainingLanes = NoLanes;
-var pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  var doc = getEventTargetDocument(nativeEventTarget);
 
-var NESTED_UPDATE_LIMIT = 50;
-var nestedUpdateCount = 0;
-var rootWithNestedUpdates = null;
-var isFlushingPassiveEffects = false;
-var didScheduleUpdateDuringPassiveEffects = false;
-var NESTED_PASSIVE_UPDATE_LIMIT = 50;
-var nestedPassiveUpdateCount = 0;
-var rootWithPassiveNestedUpdates = null; // If two updates are scheduled within the same event, we should treat their
-// event times as simultaneous, even if the actual clock time has advanced
-// between the first and second call.
+  if (
+    mouseDown ||
+    activeElement == null ||
+    activeElement !== getActiveElement(doc)
+  ) {
+    return;
+  } // Only fire when selection has actually changed.
 
-var currentEventTime = NoTimestamp;
-var currentEventTransitionLane = NoLanes;
-var isRunningInsertionEffect = false;
-function getWorkInProgressRoot() {
-  return workInProgressRoot;
-}
-function getWorkInProgressRootRenderLanes() {
-  return workInProgressRootRenderLanes;
-}
-function requestEventTime() {
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    // We're inside React, so it's fine to read the actual time.
-    return now$1();
-  } // We're not inside React, so we may be in the middle of a browser event.
+  var currentSelection = getSelection(activeElement);
 
-  if (currentEventTime !== NoTimestamp) {
-    // Use the same start time for all updates until we enter React again.
-    return currentEventTime;
-  } // This is the first update since React yielded. Compute a new start time.
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    var listeners = accumulateTwoPhaseListeners(activeElementInst, "onSelect");
 
-  currentEventTime = now$1();
-  return currentEventTime;
+    if (listeners.length > 0) {
+      var event = new SyntheticEvent(
+        "onSelect",
+        "select",
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
+      dispatchQueue.push({
+        event: event,
+        listeners: listeners
+      });
+      event.target = activeElement;
+    }
+  }
 }
-function requestUpdateLane(fiber) {
-  // Special cases
-  var mode = fiber.mode;
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
 
-  if ((mode & ConcurrentMode) === NoMode) {
-    return SyncLane;
-  } else if (
-    !deferRenderPhaseUpdateToNextBatch &&
-    (executionContext & RenderContext) !== NoContext &&
-    workInProgressRootRenderLanes !== NoLanes
-  ) {
-    // This is a render phase update. These are not officially supported. The
-    // old behavior is to give this the same "thread" (lanes) as
-    // whatever is currently rendering. So if you call `setState` on a component
-    // that happens later in the same render, it will flush. Ideally, we want to
-    // remove the special case and treat them as if they came from an
-    // interleaved event. Regardless, this pattern is not officially supported.
-    // This behavior is only a fallback. The flag only exists until we can roll
-    // out the setState warning, since existing code might accidentally rely on
-    // the current behavior.
-    return pickArbitraryLane(workInProgressRootRenderLanes);
-  }
+function extractEvents$2(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
 
-  var isTransition = requestCurrentTransition() !== NoTransition;
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case "focusin":
+      if (
+        isTextInputElement(targetNode) ||
+        targetNode.contentEditable === "true"
+      ) {
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
+      }
 
-  if (isTransition) {
-    if (ReactCurrentBatchConfig.transition !== null) {
-      var transition = ReactCurrentBatchConfig.transition;
+      break;
 
-      if (!transition._updatedFibers) {
-        transition._updatedFibers = new Set();
-      }
+    case "focusout":
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
 
-      transition._updatedFibers.add(fiber);
-    } // The algorithm for assigning an update to a lane should be stable for all
-    // updates at the same priority within the same event. To do this, the
-    // inputs to the algorithm must be the same.
+    case "mousedown":
+      mouseDown = true;
+      break;
+
+    case "contextmenu":
+    case "mouseup":
+    case "dragend":
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
     //
-    // The trick we use is to cache the first of each of these inputs within an
-    // event. Then reset the cached values once we can be sure the event is
-    // over. Our heuristic for that is whenever we enter a concurrent work loop.
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
 
-    if (currentEventTransitionLane === NoLane) {
-      // All transitions within the same event are assigned the same lane.
-      currentEventTransitionLane = claimNextTransitionLane();
-    }
+    case "selectionchange":
+      if (skipSelectionChangeEvent) {
+        break;
+      }
 
-    return currentEventTransitionLane;
-  } // Updates originating inside certain React methods, like flushSync, have
-  // their priority set by tracking it with a context variable.
-  //
-  // The opaque type returned by the host config is internally a lane, so we can
-  // use that directly.
-  // TODO: Move this type conversion to the event priority module.
+    // falls through
 
-  var updateLane = getCurrentUpdatePriority$1();
+    case "keydown":
+    case "keyup":
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
+}
 
-  if (updateLane !== NoLane) {
-    return updateLane;
-  } // This update originated outside React. Ask the host environment for an
-  // appropriate priority, based on the type of event.
-  //
-  // The opaque type returned by the host config is internally a lane, so we can
-  // use that directly.
-  // TODO: Move this type conversion to the event priority module.
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
 
-  var eventLane = getCurrentEventPriority();
-  return eventLane;
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
 }
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
 
-function requestRetryLane(fiber) {
-  // This is a fork of `requestUpdateLane` designed specifically for Suspense
-  // "retries" — a special update that attempts to flip a Suspense boundary
-  // from its placeholder state to its primary/resolved state.
-  // Special cases
-  var mode = fiber.mode;
+var vendorPrefixes = {
+  animationend: makePrefixMap("Animation", "AnimationEnd"),
+  animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+  animationstart: makePrefixMap("Animation", "AnimationStart"),
+  transitionend: makePrefixMap("Transition", "TransitionEnd")
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
 
-  if ((mode & ConcurrentMode) === NoMode) {
-    return SyncLane;
-  }
+var prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
 
-  return claimNextRetryLane();
+var style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
+
+if (canUseDOM) {
+  style = document.createElement("div").style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
+
+  if (!("AnimationEvent" in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
+
+  if (!("TransitionEvent" in window)) {
+    delete vendorPrefixes.transitionend.transition;
+  }
 }
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
 
-function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
-  {
-    if (isRunningInsertionEffect) {
-      error("useInsertionEffect must not schedule updates.");
-    }
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
   }
 
-  {
-    if (isFlushingPassiveEffects) {
-      didScheduleUpdateDuringPassiveEffects = true;
+  var prefixMap = vendorPrefixes[eventName];
+
+  for (var styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
     }
-  } // Check if the work loop is currently suspended and waiting for data to
-  // finish loading.
+  }
 
-  if (
-    workInProgressSuspendedReason === SuspendedOnData &&
-    root === workInProgressRoot
-  ) {
-    // The incoming update might unblock the current render. Interrupt the
-    // current attempt and restart from the top.
-    prepareFreshStack(root, NoLanes);
-    markRootSuspended(root, workInProgressRootRenderLanes);
-  } // Mark that the root has a pending update.
+  return eventName;
+}
 
-  markRootUpdated(root, lane, eventTime);
+var ANIMATION_END = getVendorPrefixedEventName("animationend");
+var ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration");
+var ANIMATION_START = getVendorPrefixedEventName("animationstart");
+var TRANSITION_END = getVendorPrefixedEventName("transitionend");
 
-  if (
-    (executionContext & RenderContext) !== NoLanes &&
-    root === workInProgressRoot
-  ) {
-    // This update was dispatched during the render phase. This is a mistake
-    // if the update originates from user space (with the exception of local
-    // hook updates, which are handled differently and don't reach this
-    // function), but there are some internal React features that use this as
-    // an implementation detail, like selective hydration.
-    warnAboutRenderPhaseUpdatesInDEV(fiber); // Track lanes that were updated during the render phase
-  } else {
-    // This is a normal update, scheduled from outside the render phase. For
-    // example, during an input event.
-    {
-      if (isDevToolsPresent) {
-        addFiberToLanesMap(root, fiber, lane);
-      }
-    }
+var topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
 
-    warnIfUpdatesNotWrappedWithActDEV(fiber);
+var simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'toggle', 'touchMove', 'waiting', 'wheel'];
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      if (
-        (executionContext & CommitContext) !== NoContext &&
-        root === rootCommittingMutationOrLayoutEffects
-      ) {
-        if (fiber.mode & ProfileMode) {
-          var current = fiber;
+{
+  // Special case: these two events don't have on* React handler
+  // and are only accessible via the createEventHandle API.
+  topLevelEventsToReactNames.set("beforeblur", null);
+  topLevelEventsToReactNames.set("afterblur", null);
+}
 
-          while (current !== null) {
-            if (current.tag === Profiler) {
-              var _current$memoizedProp = current.memoizedProps,
-                id = _current$memoizedProp.id,
-                onNestedUpdateScheduled =
-                  _current$memoizedProp.onNestedUpdateScheduled;
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
 
-              if (typeof onNestedUpdateScheduled === "function") {
-                onNestedUpdateScheduled(id);
-              }
-            }
+function registerSimpleEvents() {
+  for (var i = 0; i < simpleEventPluginEvents.length; i++) {
+    var eventName = simpleEventPluginEvents[i];
+    var domEventName = eventName.toLowerCase();
+    var capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, "on" + capitalizedEvent);
+  } // Special cases where event names don't match.
 
-            current = current.return;
-          }
-        }
-      }
-    }
+  registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+  registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+  registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+  registerSimpleEvent("dblclick", "onDoubleClick");
+  registerSimpleEvent("focusin", "onFocus");
+  registerSimpleEvent("focusout", "onBlur");
+  registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+}
 
-    if (enableTransitionTracing) {
-      var transition = ReactCurrentBatchConfig.transition;
+function extractEvents$1(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var reactName = topLevelEventsToReactNames.get(domEventName);
 
-      if (transition !== null && transition.name != null) {
-        if (transition.startTime === -1) {
-          transition.startTime = now$1();
-        }
+  if (reactName === undefined) {
+    return;
+  }
 
-        addTransitionToLanesMap(root, transition, lane);
-      }
-    }
+  var SyntheticEventCtor = SyntheticEvent;
+  var reactEventType = domEventName;
 
-    if (root === workInProgressRoot) {
-      // Received an update to a tree that's in the middle of rendering. Mark
-      // that there was an interleaved update work on this root. Unless the
-      // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
-      // phase update. In that case, we don't treat render phase updates as if
-      // they were interleaved, for backwards compat reasons.
-      if (
-        deferRenderPhaseUpdateToNextBatch ||
-        (executionContext & RenderContext) === NoContext
-      ) {
-        workInProgressRootInterleavedUpdatedLanes = mergeLanes(
-          workInProgressRootInterleavedUpdatedLanes,
-          lane
-        );
+  switch (domEventName) {
+    case "keypress":
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
       }
 
-      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
-        // The root already suspended with a delay, which means this render
-        // definitely won't finish. Since we have a new update, let's mark it as
-        // suspended now, right before marking the incoming update. This has the
-        // effect of interrupting the current render and switching to the update.
-        // TODO: Make sure this doesn't override pings that happen while we've
-        // already started rendering.
-        markRootSuspended(root, workInProgressRootRenderLanes);
-      }
-    }
+    /* falls through */
 
-    ensureRootIsScheduled(root, eventTime);
+    case "keydown":
+    case "keyup":
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
 
-    if (
-      lane === SyncLane &&
-      executionContext === NoContext &&
-      (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
-      !ReactCurrentActQueue.isBatchingLegacy
-    ) {
-      // Flush the synchronous work now, unless we're already working or inside
-      // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
-      // scheduleCallbackForFiber to preserve the ability to schedule a callback
-      // without immediately flushing it. We only do this for user-initiated
-      // updates, to preserve historical behavior of legacy mode.
-      resetRenderTimer();
-      flushSyncCallbacksOnlyInLegacyMode();
-    }
-  }
-}
-function scheduleInitialHydrationOnRoot(root, lane, eventTime) {
-  // This is a special fork of scheduleUpdateOnFiber that is only used to
-  // schedule the initial hydration of a root that has just been created. Most
-  // of the stuff in scheduleUpdateOnFiber can be skipped.
-  //
-  // The main reason for this separate path, though, is to distinguish the
-  // initial children from subsequent updates. In fully client-rendered roots
-  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
-  // updates, but hydration roots are special because the initial render must
-  // match what was rendered on the server.
-  var current = root.current;
-  current.lanes = lane;
-  markRootUpdated(root, lane, eventTime);
-  ensureRootIsScheduled(root, eventTime);
-}
-function isUnsafeClassRenderPhaseUpdate(fiber) {
-  // Check if this is a render phase update. Only called by class components,
-  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
-  return (
-    // TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We
-    // decided not to enable it.
-    (!deferRenderPhaseUpdateToNextBatch ||
-      (fiber.mode & ConcurrentMode) === NoMode) &&
-    (executionContext & RenderContext) !== NoContext
-  );
-} // Use this function to schedule a task for a root. There's only one task per
-// root; if a task was already scheduled, we'll check to make sure the priority
-// of the existing task is the same as the priority of the next level that the
-// root has work on. This function is called on every update, and right before
-// exiting a task.
+    case "focusin":
+      reactEventType = "focus";
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-function ensureRootIsScheduled(root, currentTime) {
-  var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
-  // expired so we know to work on those next.
+    case "focusout":
+      reactEventType = "blur";
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+    case "beforeblur":
+    case "afterblur":
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-  var nextLanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
-  );
+    case "click":
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      if (nativeEvent.button === 2) {
+        return;
+      }
 
-  if (nextLanes === NoLanes) {
-    // Special case: There's nothing to work on.
-    if (existingCallbackNode !== null) {
-      cancelCallback(existingCallbackNode);
-    }
+    /* falls through */
 
-    root.callbackNode = null;
-    root.callbackPriority = NoLane;
-    return;
-  } // If this root is currently suspended and waiting for data to resolve, don't
-  // schedule a task to render it. We'll either wait for a ping, or wait to
-  // receive an update.
+    case "auxclick":
+    case "dblclick":
+    case "mousedown":
+    case "mousemove":
+    case "mouseup": // TODO: Disabled elements should not respond to mouse events
 
-  if (
-    workInProgressSuspendedReason === SuspendedOnData &&
-    workInProgressRoot === root
-  ) {
-    root.callbackPriority = NoLane;
-    root.callbackNode = null;
-    return;
-  } // We use the highest priority lane to represent the priority of the callback.
+    /* falls through */
 
-  var newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.
+    case "mouseout":
+    case "mouseover":
+    case "contextmenu":
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
 
-  var existingCallbackPriority = root.callbackPriority;
+    case "drag":
+    case "dragend":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "dragstart":
+    case "drop":
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
 
-  if (
-    existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
-    // Scheduler task, rather than an `act` task, cancel it and re-scheduled
-    // on the `act` queue.
-    !(
-      ReactCurrentActQueue.current !== null &&
-      existingCallbackNode !== fakeActCallbackNode
-    )
-  ) {
-    {
-      // If we're going to re-use an existing task, it needs to exist.
-      // Assume that discrete update microtasks are non-cancellable and null.
-      // TODO: Temporary until we confirm this warning is not fired.
-      if (
-        existingCallbackNode == null &&
-        !includesSyncLane(existingCallbackPriority)
-      ) {
-        error(
-          "Expected scheduled callback to exist. This error is likely caused by a bug in React. Please file an issue."
-        );
-      }
-    } // The priority hasn't changed. We can reuse the existing task. Exit.
+    case "touchcancel":
+    case "touchend":
+    case "touchmove":
+    case "touchstart":
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
 
-    return;
-  }
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
 
-  if (existingCallbackNode != null) {
-    // Cancel the existing callback. We'll schedule a new one below.
-    cancelCallback(existingCallbackNode);
-  } // Schedule a new callback.
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
 
-  var newCallbackNode;
+    case "scroll":
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
 
-  if (includesSyncLane(newCallbackPriority)) {
-    // Special case: Sync React callbacks are scheduled on a special
-    // internal queue
-    if (root.tag === LegacyRoot) {
-      if (ReactCurrentActQueue.isBatchingLegacy !== null) {
-        ReactCurrentActQueue.didScheduleLegacyUpdate = true;
-      }
+    case "wheel":
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
 
-      scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));
-    } else {
-      scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
-    }
+    case "copy":
+    case "cut":
+    case "paste":
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
 
-    {
-      // Flush the queue in a microtask.
-      if (ReactCurrentActQueue.current !== null) {
-        // Inside `act`, use our internal `act` queue so that these get flushed
-        // at the end of the current scope even when using the sync version
-        // of `act`.
-        ReactCurrentActQueue.current.push(flushSyncCallbacks);
-      } else {
-        scheduleMicrotask(function () {
-          // In Safari, appending an iframe forces microtasks to run.
-          // https://github.com/facebook/react/issues/22459
-          // We don't support running callbacks in the middle of render
-          // or commit so we need to check against that.
-          if (
-            (executionContext & (RenderContext | CommitContext)) ===
-            NoContext
-          ) {
-            // Note that this would still prematurely flush the callbacks
-            // if this happens outside render or commit phase (e.g. in an event).
-            flushSyncCallbacks();
-          }
-        });
-      }
-    }
+    case "gotpointercapture":
+    case "lostpointercapture":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "pointerup":
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
+  }
 
-    newCallbackNode = null;
-  } else {
-    var schedulerPriorityLevel;
+  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
 
-    switch (lanesToEventPriority(nextLanes)) {
-      case DiscreteEventPriority:
-        schedulerPriorityLevel = ImmediatePriority;
-        break;
+  if (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) {
+    var listeners = accumulateEventHandleNonManagedNodeListeners(
+      // TODO: this cast may not make sense for events like
+      // "focus" where React listens to e.g. "focusin".
+      reactEventType,
+      targetContainer,
+      inCapturePhase
+    );
 
-      case ContinuousEventPriority:
-        schedulerPriorityLevel = UserBlockingPriority;
-        break;
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      var event = new SyntheticEventCtor(
+        reactName,
+        reactEventType,
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
+      dispatchQueue.push({
+        event: event,
+        listeners: listeners
+      });
+    }
+  } else {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    var accumulateTargetOnly =
+      !inCapturePhase && // TODO: ideally, we'd eventually add all events from
+      // nonDelegatedEvents list in DOMPluginEventSystem.
+      // Then we can remove this special list.
+      // This is a breaking change that can wait until React 18.
+      domEventName === "scroll";
 
-      case DefaultEventPriority:
-        schedulerPriorityLevel = NormalPriority$1;
-        break;
+    var _listeners = accumulateSinglePhaseListeners(
+      targetInst,
+      reactName,
+      nativeEvent.type,
+      inCapturePhase,
+      accumulateTargetOnly,
+      nativeEvent
+    );
 
-      case IdleEventPriority:
-        schedulerPriorityLevel = IdlePriority;
-        break;
+    if (_listeners.length > 0) {
+      // Intentionally create event lazily.
+      var _event = new SyntheticEventCtor(
+        reactName,
+        reactEventType,
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
 
-      default:
-        schedulerPriorityLevel = NormalPriority$1;
-        break;
+      dispatchQueue.push({
+        event: _event,
+        listeners: _listeners
+      });
     }
+  }
+}
 
-    newCallbackNode = scheduleCallback(
-      schedulerPriorityLevel,
-      performConcurrentWorkOnRoot.bind(null, root)
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
+
+function extractEvents(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget,
+    eventSystemFlags,
+    targetContainer
+  );
+  var shouldProcessPolyfillPlugins =
+    (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
+
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$4(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$2(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$5(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
     );
   }
+} // List of events that need to be individually attached to media elements.
+
+var mediaEventTypes = [
+  "abort",
+  "canplay",
+  "canplaythrough",
+  "durationchange",
+  "emptied",
+  "encrypted",
+  "ended",
+  "error",
+  "loadeddata",
+  "loadedmetadata",
+  "loadstart",
+  "pause",
+  "play",
+  "playing",
+  "progress",
+  "ratechange",
+  "resize",
+  "seeked",
+  "seeking",
+  "stalled",
+  "suspend",
+  "timeupdate",
+  "volumechange",
+  "waiting"
+]; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
 
-  root.callbackPriority = newCallbackPriority;
-  root.callbackNode = newCallbackNode;
-} // This is the entry point for every concurrent task, i.e. anything that
-// goes through Scheduler.
+var nonDelegatedEvents = new Set(
+  ["cancel", "close", "invalid", "load", "scroll", "toggle"].concat(
+    mediaEventTypes
+  )
+);
 
-function performConcurrentWorkOnRoot(root, didTimeout) {
-  {
-    resetNestedUpdateFlag();
-  } // Since we know we're in a React event, we can clear the current
-  // event time. The next update will compute a new event time.
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
+}
 
-  currentEventTime = NoTimestamp;
-  currentEventTransitionLane = NoLanes;
+function processDispatchQueueItemsInOrder(
+  event,
+  dispatchListeners,
+  inCapturePhase
+) {
+  var previousInstance;
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
-  } // Flush any pending passive effects before deciding which lanes to work on,
-  // in case they schedule additional work.
+  if (inCapturePhase) {
+    for (var i = dispatchListeners.length - 1; i >= 0; i--) {
+      var _dispatchListeners$i = dispatchListeners[i],
+        instance = _dispatchListeners$i.instance,
+        currentTarget = _dispatchListeners$i.currentTarget,
+        listener = _dispatchListeners$i.listener;
 
-  var originalCallbackNode = root.callbackNode;
-  var didFlushPassiveEffects = flushPassiveEffects();
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
 
-  if (didFlushPassiveEffects) {
-    // Something in the passive effect phase may have canceled the current task.
-    // Check if the task node for this root was changed.
-    if (root.callbackNode !== originalCallbackNode) {
-      // The current task was canceled. Exit. We don't need to call
-      // `ensureRootIsScheduled` because the check above implies either that
-      // there's a new task, or that there's no remaining work on this root.
-      return null;
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
     }
-  } // Determine the next lanes to work on, using the fields stored
-  // on the root.
-
-  var lanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
-  );
-
-  if (lanes === NoLanes) {
-    // Defensive coding. This is never expected to happen.
-    return null;
-  } // We disable time-slicing in some cases: if the work has been CPU-bound
-  // for too long ("expired" work, to prevent starvation), or we're in
-  // sync-updates-by-default mode.
-  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
-  // bug we're still investigating. Once the bug in Scheduler is fixed,
-  // we can remove this, since we track expiration ourselves.
-
-  var shouldTimeSlice =
-    !includesBlockingLane(root, lanes) &&
-    !includesExpiredLane(root, lanes) &&
-    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
-  var exitStatus = shouldTimeSlice
-    ? renderRootConcurrent(root, lanes)
-    : renderRootSync(root, lanes);
-
-  if (exitStatus !== RootInProgress) {
-    if (exitStatus === RootErrored) {
-      // If something threw an error, try rendering one more time. We'll
-      // render synchronously to block concurrent data mutations, and we'll
-      // includes all pending updates are included. If it still fails after
-      // the second attempt, we'll give up and commit the resulting tree.
-      var originallyAttemptedLanes = lanes;
-      var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-        root,
-        originallyAttemptedLanes
-      );
+  } else {
+    for (var _i = 0; _i < dispatchListeners.length; _i++) {
+      var _dispatchListeners$_i = dispatchListeners[_i],
+        _instance = _dispatchListeners$_i.instance,
+        _currentTarget = _dispatchListeners$_i.currentTarget,
+        _listener = _dispatchListeners$_i.listener;
 
-      if (errorRetryLanes !== NoLanes) {
-        lanes = errorRetryLanes;
-        exitStatus = recoverFromConcurrentError(
-          root,
-          originallyAttemptedLanes,
-          errorRetryLanes
-        );
+      if (_instance !== previousInstance && event.isPropagationStopped()) {
+        return;
       }
-    }
 
-    if (exitStatus === RootFatalErrored) {
-      var fatalError = workInProgressRootFatalError;
-      prepareFreshStack(root, NoLanes);
-      markRootSuspended(root, lanes);
-      ensureRootIsScheduled(root, now$1());
-      throw fatalError;
+      executeDispatch(event, _listener, _currentTarget);
+      previousInstance = _instance;
     }
+  }
+}
 
-    if (exitStatus === RootDidNotComplete) {
-      // The render unwound without completing the tree. This happens in special
-      // cases where need to exit the current render without producing a
-      // consistent tree or committing.
-      markRootSuspended(root, lanes);
-    } else {
-      // The render completed.
-      // Check if this render may have yielded to a concurrent event, and if so,
-      // confirm that any newly rendered stores are consistent.
-      // TODO: It's possible that even a concurrent render may never have yielded
-      // to the main thread, if it was fast enough, or if it expired. We could
-      // skip the consistency check in that case, too.
-      var renderWasConcurrent = !includesBlockingLane(root, lanes);
-      var finishedWork = root.current.alternate;
-
-      if (
-        renderWasConcurrent &&
-        !isRenderConsistentWithExternalStores(finishedWork)
-      ) {
-        // A store was mutated in an interleaved event. Render again,
-        // synchronously, to block further mutations.
-        exitStatus = renderRootSync(root, lanes); // We need to check again if something threw
-
-        if (exitStatus === RootErrored) {
-          var _originallyAttemptedLanes = lanes;
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
 
-          var _errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-            root,
-            _originallyAttemptedLanes
-          );
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event,
+      listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
 
-          if (_errorRetryLanes !== NoLanes) {
-            lanes = _errorRetryLanes;
-            exitStatus = recoverFromConcurrentError(
-              root,
-              _originallyAttemptedLanes,
-              _errorRetryLanes
-            ); // We assume the tree is now consistent because we didn't yield to any
-            // concurrent events.
-          }
-        }
+  rethrowCaughtError();
+}
 
-        if (exitStatus === RootFatalErrored) {
-          var _fatalError = workInProgressRootFatalError;
-          prepareFreshStack(root, NoLanes);
-          markRootSuspended(root, lanes);
-          ensureRootIsScheduled(root, now$1());
-          throw _fatalError;
-        } // FIXME: Need to check for RootDidNotComplete again. The factoring here
-        // isn't ideal.
-      } // We now have a consistent tree. The next step is either to commit it,
-      // or, if something suspended, wait to commit it after a timeout.
+function dispatchEventsForPlugins(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst,
+  targetContainer
+) {
+  var nativeEventTarget = getEventTarget(nativeEvent);
+  var dispatchQueue = [];
+  extractEvents(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget,
+    eventSystemFlags,
+    targetContainer
+  );
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
+}
 
-      root.finishedWork = finishedWork;
-      root.finishedLanes = lanes;
-      finishConcurrentRender(root, exitStatus, lanes);
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+  {
+    if (!nonDelegatedEvents.has(domEventName)) {
+      error(
+        'Did not expect a listenToNonDelegatedEvent() call for "%s". ' +
+          "This is a bug in React. Please file an issue.",
+        domEventName
+      );
     }
   }
 
-  ensureRootIsScheduled(root, now$1());
+  var isCapturePhaseListener = false;
+  var listenerSet = getEventListenerSet(targetElement);
+  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
 
-  if (root.callbackNode === originalCallbackNode) {
-    // The task node scheduled for this root is the same one that's
-    // currently executed. Need to return a continuation.
-    return performConcurrentWorkOnRoot.bind(null, root);
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(
+      targetElement,
+      domEventName,
+      IS_NON_DELEGATED,
+      isCapturePhaseListener
+    );
+    listenerSet.add(listenerSetKey);
   }
-
-  return null;
 }
-
-function recoverFromConcurrentError(
-  root,
-  originallyAttemptedLanes,
-  errorRetryLanes
-) {
-  // If an error occurred during hydration, discard server response and fall
-  // back to client side render.
-  // Before rendering again, save the errors from the previous attempt.
-  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
-  var wasRootDehydrated = isRootDehydrated(root);
-
-  if (wasRootDehydrated) {
-    // The shell failed to hydrate. Set a flag to force a client rendering
-    // during the next attempt. To do this, we call prepareFreshStack now
-    // to create the root work-in-progress fiber. This is a bit weird in terms
-    // of factoring, because it relies on renderRootSync not calling
-    // prepareFreshStack again in the call below, which happens because the
-    // root and lanes haven't changed.
-    //
-    // TODO: I think what we should do is set ForceClientRender inside
-    // throwException, like we do for nested Suspense boundaries. The reason
-    // it's here instead is so we can switch to the synchronous work loop, too.
-    // Something to consider for a future refactor.
-    var rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
-    rootWorkInProgress.flags |= ForceClientRender;
-
-    {
-      errorHydratingContainer(root.containerInfo);
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+  {
+    if (nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener) {
+      error(
+        'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. ' +
+          "This is a bug in React. Please file an issue.",
+        domEventName
+      );
     }
   }
 
-  var exitStatus = renderRootSync(root, errorRetryLanes);
+  var eventSystemFlags = 0;
 
-  if (exitStatus !== RootErrored) {
-    // Successfully finished rendering on retry
-    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
-      // During the synchronous render, we attached additional ping listeners.
-      // This is highly suggestive of an uncached promise (though it's not the
-      // only reason this would happen). If it was an uncached promise, then
-      // it may have masked a downstream error from ocurring without actually
-      // fixing it. Example:
-      //
-      //    use(Promise.resolve('uncached'))
-      //    throw new Error('Oops!')
-      //
-      // When this happens, there's a conflict between blocking potential
-      // concurrent data races and unwrapping uncached promise values. We
-      // have to choose one or the other. Because the data race recovery is
-      // a last ditch effort, we'll disable it.
-      root.errorRecoveryDisabledLanes = mergeLanes(
-        root.errorRecoveryDisabledLanes,
-        originallyAttemptedLanes
-      ); // Mark the current render as suspended and force it to restart. Once
-      // these lanes finish successfully, we'll re-enable the error recovery
-      // mechanism for subsequent updates.
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
 
-      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
-      return RootSuspendedWithDelay;
-    } // The errors from the failed first attempt have been recovered. Add
-    // them to the collection of recoverable errors. We'll log them in the
-    // commit phase.
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
+} // This is only used by createEventHandle when the
+// target is not a DOM element. E.g. window.
 
-    var errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
-    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
-    // from the first attempt, to preserve the causal sequence.
+function listenToNativeEventForNonManagedEventTarget(
+  domEventName,
+  isCapturePhaseListener,
+  target
+) {
+  var eventSystemFlags = IS_EVENT_HANDLE_NON_MANAGED_NODE;
+  var listenerSet = getEventListenerSet(target);
+  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
 
-    if (errorsFromSecondAttempt !== null) {
-      queueRecoverableErrors(errorsFromSecondAttempt);
+  if (!listenerSet.has(listenerSetKey)) {
+    if (isCapturePhaseListener) {
+      eventSystemFlags |= IS_CAPTURE_PHASE;
     }
-  }
-
-  return exitStatus;
-}
 
-function queueRecoverableErrors(errors) {
-  if (workInProgressRootRecoverableErrors === null) {
-    workInProgressRootRecoverableErrors = errors;
-  } else {
-    // $FlowFixMe[method-unbinding]
-    workInProgressRootRecoverableErrors.push.apply(
-      workInProgressRootRecoverableErrors,
-      errors
+    addTrappedEventListener(
+      target,
+      domEventName,
+      eventSystemFlags,
+      isCapturePhaseListener
     );
+    listenerSet.add(listenerSetKey);
   }
 }
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(function (domEventName) {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== "selectionchange") {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
 
-function finishConcurrentRender(root, exitStatus, lanes) {
-  switch (exitStatus) {
-    case RootInProgress:
-    case RootFatalErrored: {
-      throw new Error("Root did not complete. This is a bug in React.");
-    }
-    // Flow knows about invariant, so it complains if I add a break
-    // statement, but eslint doesn't know about invariant, so it complains
-    // if I do. eslint-disable-next-line no-fallthrough
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    var ownerDocument =
+      rootContainerElement.nodeType === DOCUMENT_NODE
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
 
-    case RootErrored: {
-      // We should have already attempted to retry this tree. If we reached
-      // this point, it errored again. Commit it.
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent("selectionchange", false, ownerDocument);
+      }
     }
+  }
+}
 
-    case RootSuspended: {
-      markRootSuspended(root, lanes); // We have an acceptable loading state. We need to figure out if we
-      // should immediately commit it or wait a bit.
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  var listener = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  ); // If passive option is not supported, then the event will be
+  // active and not passive.
 
-      if (
-        includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
-        !shouldForceFlushFallbacksInDEV()
-      ) {
-        // This render only included retries, no updates. Throttle committing
-        // retries so that we don't show too many loading states too quickly.
-        var msUntilTimeout =
-          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
+  var isPassiveListener = undefined;
 
-        if (msUntilTimeout > 10) {
-          var nextLanes = getNextLanes(root, NoLanes);
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (
+      domEventName === "touchstart" ||
+      domEventName === "touchmove" ||
+      domEventName === "wheel"
+    ) {
+      isPassiveListener = true;
+    }
+  }
 
-          if (nextLanes !== NoLanes) {
-            // There's additional work on this root.
-            break;
-          } // The render is suspended, it hasn't timed out, and there's no
-          // lower priority work to do. Instead of committing the fallback
-          // immediately, wait for more data to arrive.
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  var unsubscribeListener; // When legacyFBSupport is enabled, it's for when we
+  // want to add a one time event listener to a container.
+  // This should only be used with enableLegacyFBSupport
+  // due to requirement to provide compatibility with
+  // internal FB www event tooling. This works by removing
+  // the event listener as soon as it is invoked. We could
+  // also attempt to use the {once: true} param on
+  // addEventListener, but that requires support and some
+  // browsers do not support this today, and given this is
+  // to support legacy code patterns, it's likely they'll
+  // need support for such browsers.
 
-          root.timeoutHandle = scheduleTimeout(
-            commitRoot.bind(
-              null,
-              root,
-              workInProgressRootRecoverableErrors,
-              workInProgressTransitions
-            ),
-            msUntilTimeout
-          );
-          break;
-        }
-      } // The work expired. Commit immediately.
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = listener; // $FlowFixMe[missing-this-annot]
+    // $FlowFixMe[definition-cycle]
 
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
+    listener = function () {
+      removeEventListener(
+        targetContainer,
+        domEventName,
+        unsubscribeListener,
+        isCapturePhaseListener
       );
-      break;
-    }
-
-    case RootSuspendedWithDelay: {
-      markRootSuspended(root, lanes);
 
-      if (includesOnlyTransitions(lanes)) {
-        // This is a transition, so we should exit without committing a
-        // placeholder and without scheduling a timeout. Delay indefinitely
-        // until we receive more data.
-        break;
+      for (
+        var _len = arguments.length, p = new Array(_len), _key = 0;
+        _key < _len;
+        _key++
+      ) {
+        p[_key] = arguments[_key];
       }
 
-      if (!shouldForceFlushFallbacksInDEV()) {
-        // This is not a transition, but we did trigger an avoided state.
-        // Schedule a placeholder to display after a short delay, using the Just
-        // Noticeable Difference.
-        // TODO: Is the JND optimization worth the added complexity? If this is
-        // the only reason we track the event time, then probably not.
-        // Consider removing.
-        var mostRecentEventTime = getMostRecentEventTime(root, lanes);
-        var eventTimeMs = mostRecentEventTime;
-        var timeElapsedMs = now$1() - eventTimeMs;
-
-        var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
-
-        if (_msUntilTimeout > 10) {
-          // Instead of committing the fallback immediately, wait for more data
-          // to arrive.
-          root.timeoutHandle = scheduleTimeout(
-            commitRoot.bind(
-              null,
-              root,
-              workInProgressRootRecoverableErrors,
-              workInProgressTransitions
-            ),
-            _msUntilTimeout
-          );
-          break;
-        }
-      } // Commit the placeholder.
+      return originalListener.apply(this, p);
+    };
+  } // TODO: There are too many combinations here. Consolidate them.
 
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        listener,
+        isPassiveListener
       );
-      break;
-    }
-
-    case RootCompleted: {
-      // The work completed. Ready to commit.
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
+    } else {
+      unsubscribeListener = addEventCaptureListener(
+        targetContainer,
+        domEventName,
+        listener
       );
-      break;
     }
-
-    default: {
-      throw new Error("Unknown root exit status.");
+  } else {
+    if (isPassiveListener !== undefined) {
+      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        listener,
+        isPassiveListener
+      );
+    } else {
+      unsubscribeListener = addEventBubbleListener(
+        targetContainer,
+        domEventName,
+        listener
+      );
     }
   }
 }
 
-function isRenderConsistentWithExternalStores(finishedWork) {
-  // Search the rendered tree for external store reads, and check whether the
-  // stores were mutated in a concurrent event. Intentionally using an iterative
-  // loop instead of recursion so we can exit early.
-  var node = finishedWork;
+function deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer) {
+  // We defer all click events with legacy FB support mode on.
+  // This means we add a one time event listener to trigger
+  // after the FB delegated listeners fire.
+  var isDeferredListenerForLegacyFBSupport = true;
+  addTrappedEventListener(
+    targetContainer,
+    domEventName,
+    IS_LEGACY_FB_SUPPORT_MODE,
+    false,
+    isDeferredListenerForLegacyFBSupport
+  );
+}
 
-  while (true) {
-    if (node.flags & StoreConsistency) {
-      var updateQueue = node.updateQueue;
+function isMatchingRootContainer(grandContainer, targetContainer) {
+  return (
+    grandContainer === targetContainer ||
+    (grandContainer.nodeType === COMMENT_NODE &&
+      grandContainer.parentNode === targetContainer)
+  );
+}
 
-      if (updateQueue !== null) {
-        var checks = updateQueue.stores;
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst,
+  targetContainer
+) {
+  var ancestorInst = targetInst;
 
-        if (checks !== null) {
-          for (var i = 0; i < checks.length; i++) {
-            var check = checks[i];
-            var getSnapshot = check.getSnapshot;
-            var renderedValue = check.value;
+  if (
+    (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 &&
+    (eventSystemFlags & IS_NON_DELEGATED) === 0
+  ) {
+    var targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+    // defer the event to the null with a one
+    // time event listener so we can defer the event.
 
-            try {
-              if (!objectIs(getSnapshot(), renderedValue)) {
-                // Found an inconsistent store.
-                return false;
-              }
-            } catch (error) {
-              // If `getSnapshot` throws, return `false`. This will schedule
-              // a re-render, and the error will be rethrown during render.
-              return false;
-            }
-          }
-        }
-      }
+    if (
+      enableLegacyFBSupport && // If our event flags match the required flags for entering
+      // FB legacy mode and we are processing the "click" event,
+      // then we can defer the event to the "document", to allow
+      // for legacy FB support, where the expected behavior was to
+      // match React < 16 behavior of delegated clicks to the doc.
+      domEventName === "click" &&
+      (eventSystemFlags & SHOULD_NOT_DEFER_CLICK_FOR_FB_SUPPORT_MODE) === 0 &&
+      !isReplayingEvent(nativeEvent)
+    ) {
+      deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer);
+      return;
     }
 
-    var child = node.child;
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      var node = targetInst;
 
-    if (node.subtreeFlags & StoreConsistency && child !== null) {
-      child.return = node;
-      node = child;
-      continue;
-    }
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
 
-    if (node === finishedWork) {
-      return true;
-    }
+        var nodeTag = node.tag;
 
-    while (node.sibling === null) {
-      if (node.return === null || node.return === finishedWork) {
-        return true;
-      }
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          var container = node.stateNode.containerInfo;
 
-      node = node.return;
-    }
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
 
-    node.sibling.return = node.return;
-    node = node.sibling;
-  } // Flow doesn't know this is unreachable, but eslint does
-  // eslint-disable-next-line no-unreachable
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            var grandNode = node.return;
 
-  return true;
-}
+            while (grandNode !== null) {
+              var grandTag = grandNode.tag;
 
-function markRootSuspended(root, suspendedLanes) {
-  // When suspending, we should always exclude lanes that were pinged or (more
-  // rarely, since we try to avoid it) updated during the render phase.
-  // TODO: Lol maybe there's a better way to factor this besides this
-  // obnoxiously named function :)
-  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
-  suspendedLanes = removeLanes(
-    suspendedLanes,
-    workInProgressRootInterleavedUpdatedLanes
-  );
-  markRootSuspended$1(root, suspendedLanes);
-} // This is the entry point for synchronous tasks that don't go
-// through Scheduler
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                var grandContainer = grandNode.stateNode.containerInfo;
 
-function performSyncWorkOnRoot(root) {
-  {
-    syncNestedUpdateFlag();
-  }
+                if (
+                  isMatchingRootContainer(grandContainer, targetContainerNode)
+                ) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
-  }
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
 
-  flushPassiveEffects();
-  var lanes = getNextLanes(root, NoLanes);
+          while (container !== null) {
+            var parentNode = getClosestInstanceFromNode(container);
 
-  if (!includesSyncLane(lanes)) {
-    // There's no remaining sync work left.
-    ensureRootIsScheduled(root, now$1());
-    return null;
-  }
+            if (parentNode === null) {
+              return;
+            }
 
-  var exitStatus = renderRootSync(root, lanes);
+            var parentTag = parentNode.tag;
 
-  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
-    // If something threw an error, try rendering one more time. We'll render
-    // synchronously to block concurrent data mutations, and we'll includes
-    // all pending updates are included. If it still fails after the second
-    // attempt, we'll give up and commit the resulting tree.
-    var originallyAttemptedLanes = lanes;
-    var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-      root,
-      originallyAttemptedLanes
-    );
+            if (
+              parentTag === HostComponent ||
+              parentTag === HostText ||
+              parentTag === HostHoistable ||
+              parentTag === HostSingleton
+            ) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
 
-    if (errorRetryLanes !== NoLanes) {
-      lanes = errorRetryLanes;
-      exitStatus = recoverFromConcurrentError(
-        root,
-        originallyAttemptedLanes,
-        errorRetryLanes
-      );
+            container = container.parentNode;
+          }
+        }
+
+        node = node.return;
+      }
     }
   }
 
-  if (exitStatus === RootFatalErrored) {
-    var fatalError = workInProgressRootFatalError;
-    prepareFreshStack(root, NoLanes);
-    markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now$1());
-    throw fatalError;
-  }
+  batchedUpdates(function () {
+    return dispatchEventsForPlugins(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      ancestorInst,
+      targetContainer
+    );
+  });
+}
 
-  if (exitStatus === RootDidNotComplete) {
-    // The render unwound without completing the tree. This happens in special
-    // cases where need to exit the current render without producing a
-    // consistent tree or committing.
-    markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now$1());
-    return null;
-  } // We now have a consistent tree. Because this is a sync render, we
-  // will commit it even if something suspended.
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
 
-  var finishedWork = root.current.alternate;
-  root.finishedWork = finishedWork;
-  root.finishedLanes = lanes;
-  commitRoot(
-    root,
-    workInProgressRootRecoverableErrors,
-    workInProgressTransitions
-  ); // Before exiting, make sure there's a callback scheduled for the next
-  // pending level.
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  var captureName = reactName !== null ? reactName + "Capture" : null;
+  var reactEventName = inCapturePhase ? captureName : reactName;
+  var listeners = [];
+  var instance = targetFiber;
+  var lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
 
-  ensureRootIsScheduled(root, now$1());
-  return null;
-}
+  while (instance !== null) {
+    var _instance2 = instance,
+      stateNode = _instance2.stateNode,
+      tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
 
-function flushRoot(root, lanes) {
-  if (lanes !== NoLanes) {
-    markRootEntangled(root, mergeLanes(lanes, SyncLane));
-    ensureRootIsScheduled(root, now$1());
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      lastHostComponent = stateNode; // createEventHandle listeners
 
-    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
-      resetRenderTimer();
-      flushSyncCallbacks();
-    }
-  }
-}
-function getExecutionContext() {
-  return executionContext;
-}
-function batchedUpdates(fn, a) {
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
+      {
+        var eventHandlerListeners = getEventHandlerListeners(lastHostComponent);
 
-  try {
-    return fn(a);
-  } finally {
-    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
-    // most batchedUpdates-like method.
+        if (eventHandlerListeners !== null) {
+          eventHandlerListeners.forEach(function (entry) {
+            if (
+              entry.type === nativeEventType &&
+              entry.capture === inCapturePhase
+            ) {
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+            }
+          });
+        }
+      } // Standard React on* listeners, i.e. onClick or onClickCapture
 
-    if (
-      executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
-      !ReactCurrentActQueue.isBatchingLegacy
+      if (reactEventName !== null) {
+        var listener = getListener(instance, reactEventName);
+
+        if (listener != null) {
+          listeners.push(
+            createDispatchListener(instance, listener, lastHostComponent)
+          );
+        }
+      }
+    } else if (
+      tag === ScopeComponent &&
+      lastHostComponent !== null &&
+      stateNode !== null
     ) {
-      resetRenderTimer();
-      flushSyncCallbacksOnlyInLegacyMode();
-    }
-  }
-}
-function discreteUpdates(fn, a, b, c, d) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig.transition;
+      // Scopes
+      var reactScopeInstance = stateNode;
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    return fn(a, b, c, d);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
+      var _eventHandlerListeners = getEventHandlerListeners(reactScopeInstance);
 
-    if (executionContext === NoContext) {
-      resetRenderTimer();
+      if (_eventHandlerListeners !== null) {
+        _eventHandlerListeners.forEach(function (entry) {
+          if (
+            entry.type === nativeEventType &&
+            entry.capture === inCapturePhase
+          ) {
+            listeners.push(
+              createDispatchListener(
+                instance,
+                entry.callback,
+                lastHostComponent
+              )
+            );
+          }
+        });
+      }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
+
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+    // into consideration that part of the React tree might have been hidden
+    // or deleted (as we're invoking this event during commit). We can find
+    // this out by checking if intercept fiber set on the event matches the
+    // current instance fiber. In which case, we should clear all existing
+    // listeners.
+
+    if (nativeEvent.type === "beforeblur") {
+      // $FlowFixMe[prop-missing] internal field
+      var detachedInterceptFiber = nativeEvent._detachedInterceptFiber;
+
+      if (
+        detachedInterceptFiber !== null &&
+        (detachedInterceptFiber === instance ||
+          detachedInterceptFiber === instance.alternate)
+      ) {
+        listeners = [];
+      }
     }
-  }
-} // Overload the definition to the two valid signatures.
-// Warning, this opts-out of checking the function body.
-// eslint-disable-next-line no-unused-vars
-// eslint-disable-next-line no-redeclare
-// eslint-disable-next-line no-redeclare
 
-function flushSync$1(fn) {
-  // In legacy mode, we flush pending passive effects at the beginning of the
-  // next event, not at the end of the previous one.
-  if (
-    rootWithPendingPassiveEffects !== null &&
-    rootWithPendingPassiveEffects.tag === LegacyRoot &&
-    (executionContext & (RenderContext | CommitContext)) === NoContext
-  ) {
-    flushPassiveEffects();
+    instance = instance.return;
   }
 
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
-  var prevTransition = ReactCurrentBatchConfig.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  var captureName = reactName + "Capture";
+  var listeners = [];
+  var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
 
-    if (fn) {
-      return fn();
-    } else {
-      return undefined;
-    }
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
-    // Note that this will happen even if batchedUpdates is higher up
-    // the stack.
+  while (instance !== null) {
+    var _instance3 = instance,
+      stateNode = _instance3.stateNode,
+      tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e. <div>)
 
-    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
-      flushSyncCallbacks();
-    }
-  }
-}
-function isAlreadyRendering() {
-  // Used by the renderer to print a warning if certain APIs are called from
-  // the wrong context.
-  return (executionContext & (RenderContext | CommitContext)) !== NoContext;
-}
-function isInvalidExecutionContextForEventFunction() {
-  // Used to throw if certain APIs are called from the wrong context.
-  return (executionContext & RenderContext) !== NoContext;
-}
-function flushControlled(fn) {
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
-  var prevTransition = ReactCurrentBatchConfig.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      var currentTarget = stateNode;
+      var captureListener = getListener(instance, captureName);
+
+      if (captureListener != null) {
+        listeners.unshift(
+          createDispatchListener(instance, captureListener, currentTarget)
+        );
+      }
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    fn();
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-    executionContext = prevExecutionContext;
+      var bubbleListener = getListener(instance, reactName);
 
-    if (executionContext === NoContext) {
-      // Flush the immediate callbacks that were scheduled during this batch
-      resetRenderTimer();
-      flushSyncCallbacks();
+      if (bubbleListener != null) {
+        listeners.push(
+          createDispatchListener(instance, bubbleListener, currentTarget)
+        );
+      }
     }
+
+    instance = instance.return;
   }
-} // This is called by the HiddenContext module when we enter or leave a
-// hidden subtree. The stack logic is managed there because that's the only
-// place that ever modifies it. Which module it lives in doesn't matter for
-// performance because this function will get inlined regardless
 
-function setRenderLanes(subtreeRenderLanes) {
-  renderLanes = subtreeRenderLanes;
-}
-function getRenderLanes() {
-  return renderLanes;
+  return listeners;
 }
 
-function resetWorkInProgressStack() {
-  if (workInProgress === null) return;
-  var interruptedWork;
-
-  if (workInProgressSuspendedReason === NotSuspended) {
-    // Normal case. Work-in-progress hasn't started yet. Unwind all
-    // its parents.
-    interruptedWork = workInProgress.return;
-  } else {
-    // Work-in-progress is in suspended state. Reset the work loop and unwind
-    // both the suspended fiber and all its parents.
-    resetSuspendedWorkLoopOnUnwind();
-    interruptedWork = workInProgress;
+function getParent(inst) {
+  if (inst === null) {
+    return null;
   }
 
-  while (interruptedWork !== null) {
-    var current = interruptedWork.alternate;
-    unwindInterruptedWork(current, interruptedWork);
-    interruptedWork = interruptedWork.return;
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && inst.tag !== HostSingleton);
+
+  if (inst) {
+    return inst;
   }
 
-  workInProgress = null;
+  return null;
 }
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
 
-function prepareFreshStack(root, lanes) {
-  root.finishedWork = null;
-  root.finishedLanes = NoLanes;
-  var timeoutHandle = root.timeoutHandle;
-
-  if (timeoutHandle !== noTimeout) {
-    // The root previous suspended and scheduled a timeout to commit a fallback
-    // state. Now that we have additional work, cancel the timeout.
-    root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
+function getLowestCommonAncestor(instA, instB) {
+  var nodeA = instA;
+  var nodeB = instB;
+  var depthA = 0;
 
-    cancelTimeout(timeoutHandle);
+  for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
   }
 
-  resetWorkInProgressStack();
-  workInProgressRoot = root;
-  var rootWorkInProgress = createWorkInProgress(root.current, null);
-  workInProgress = rootWorkInProgress;
-  workInProgressRootRenderLanes = renderLanes = lanes;
-  workInProgressSuspendedReason = NotSuspended;
-  workInProgressThrownValue = null;
-  workInProgressRootDidAttachPingListener = false;
-  workInProgressRootExitStatus = RootInProgress;
-  workInProgressRootFatalError = null;
-  workInProgressRootSkippedLanes = NoLanes;
-  workInProgressRootInterleavedUpdatedLanes = NoLanes;
-  workInProgressRootPingedLanes = NoLanes;
-  workInProgressRootConcurrentErrors = null;
-  workInProgressRootRecoverableErrors = null;
-  finishQueueingConcurrentUpdates();
+  var depthB = 0;
 
-  {
-    ReactStrictModeWarnings.discardPendingWarnings();
-  }
+  for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
 
-  return rootWorkInProgress;
-}
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
 
-function resetSuspendedWorkLoopOnUnwind() {
-  // Reset module-level state that was set during the render phase.
-  resetContextDependencies();
-  resetHooksOnUnwind();
-  resetChildReconcilerOnUnwind();
-}
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
 
-function handleThrow(root, thrownValue) {
-  // A component threw an exception. Usually this is because it suspended, but
-  // it also includes regular program errors.
-  //
-  // We're either going to unwind the stack to show a Suspense or error
-  // boundary, or we're going to replay the component again. Like after a
-  // promise resolves.
-  //
-  // Until we decide whether we're going to unwind or replay, we should preserve
-  // the current state of the work loop without resetting anything.
-  //
-  // If we do decide to unwind the stack, module-level variables will be reset
-  // in resetSuspendedWorkLoopOnUnwind.
-  // These should be reset immediately because they're only supposed to be set
-  // when React is executing user code.
-  resetHooksAfterThrow();
-  resetCurrentFiber();
-  ReactCurrentOwner.current = null;
+  var depth = depthA;
 
-  if (thrownValue === SuspenseException) {
-    // This is a special type of exception used for Suspense. For historical
-    // reasons, the rest of the Suspense implementation expects the thrown value
-    // to be a thenable, because before `use` existed that was the (unstable)
-    // API for suspending. This implementation detail can change later, once we
-    // deprecate the old API in favor of `use`.
-    thrownValue = getSuspendedThenable();
-    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
-      ? SuspendedOnData
-      : SuspendedOnImmediate;
-  } else if (thrownValue === SelectiveHydrationException) {
-    // An update flowed into a dehydrated boundary. Before we can apply the
-    // update, we need to finish hydrating. Interrupt the work-in-progress
-    // render so we can restart at the hydration lane.
-    //
-    // The ideal implementation would be able to switch contexts without
-    // unwinding the current stack.
-    //
-    // We could name this something more general but as of now it's the only
-    // case where we think this should happen.
-    workInProgressSuspendedReason = SuspendedOnHydration;
-  } else {
-    // This is a regular error.
-    var isWakeable =
-      thrownValue !== null &&
-      typeof thrownValue === "object" &&
-      typeof thrownValue.then === "function";
-    workInProgressSuspendedReason = isWakeable // A wakeable object was thrown by a legacy Suspense implementation.
-      ? // This has slightly different behavior than suspending with `use`.
-        SuspendedOnDeprecatedThrowPromise // This is a regular error. If something earlier in the component already
-      : // suspended, we must clear the thenable state to unblock the work loop.
-        SuspendedOnError;
+  while (depth--) {
+    if (nodeA === nodeB || (nodeB !== null && nodeA === nodeB.alternate)) {
+      return nodeA;
+    }
+
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
   }
 
-  workInProgressThrownValue = thrownValue;
-  var erroredWork = workInProgress;
+  return null;
+}
 
-  if (erroredWork === null) {
-    // This is a fatal error
-    workInProgressRootExitStatus = RootFatalErrored;
-    workInProgressRootFatalError = thrownValue;
-    return;
-  }
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
+) {
+  var registrationName = event._reactName;
+  var listeners = [];
+  var instance = target;
 
-  if (erroredWork.mode & ProfileMode) {
-    // Record the time spent rendering before an error was thrown. This
-    // avoids inaccurate Profiler durations in the case of a
-    // suspended render.
-    stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
-  }
+  while (instance !== null) {
+    if (instance === common) {
+      break;
+    }
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
+    var _instance4 = instance,
+      alternate = _instance4.alternate,
+      stateNode = _instance4.stateNode,
+      tag = _instance4.tag;
 
-    switch (workInProgressSuspendedReason) {
-      case SuspendedOnError: {
-        markComponentErrored(
-          erroredWork,
-          thrownValue,
-          workInProgressRootRenderLanes
-        );
-        break;
-      }
+    if (alternate !== null && alternate === common) {
+      break;
+    }
 
-      case SuspendedOnData:
-      case SuspendedOnImmediate:
-      case SuspendedOnDeprecatedThrowPromise:
-      case SuspendedAndReadyToContinue: {
-        var wakeable = thrownValue;
-        markComponentSuspended(
-          erroredWork,
-          wakeable,
-          workInProgressRootRenderLanes
-        );
-        break;
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      var currentTarget = stateNode;
+
+      if (inCapturePhase) {
+        var captureListener = getListener(instance, registrationName);
+
+        if (captureListener != null) {
+          listeners.unshift(
+            createDispatchListener(instance, captureListener, currentTarget)
+          );
+        }
+      } else if (!inCapturePhase) {
+        var bubbleListener = getListener(instance, registrationName);
+
+        if (bubbleListener != null) {
+          listeners.push(
+            createDispatchListener(instance, bubbleListener, currentTarget)
+          );
+        }
       }
     }
-  }
-}
 
-function shouldAttemptToSuspendUntilDataResolves() {
-  // Check if there are other pending updates that might possibly unblock this
-  // component from suspending. This mirrors the check in
-  // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
-  // TODO: Consider unwinding immediately, using the
-  // SuspendedOnHydration mechanism.
-  if (
-    includesNonIdleWork(workInProgressRootSkippedLanes) ||
-    includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)
-  ) {
-    // Suspend normally. renderDidSuspendDelayIfPossible will handle
-    // interrupting the work loop.
-    return false;
-  } // TODO: We should be able to remove the equivalent check in
-  // finishConcurrentRender, and rely just on this one.
+    instance = instance.return;
+  }
 
-  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
-    // If we're rendering inside the "shell" of the app, it's better to suspend
-    // rendering and wait for the data to resolve. Otherwise, we should switch
-    // to a fallback and continue rendering.
-    return getShellBoundary() === null;
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
   }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
 
-  var handler = getSuspenseHandler();
+function accumulateEnterLeaveTwoPhaseListeners(
+  dispatchQueue,
+  leaveEvent,
+  enterEvent,
+  from,
+  to
+) {
+  var common = from && to ? getLowestCommonAncestor(from, to) : null;
 
-  if (handler === null);
-  else {
-    if (includesOnlyRetries(workInProgressRootRenderLanes)) {
-      // During a retry, we can suspend rendering if the nearest Suspense boundary
-      // is the boundary of the "shell", because we're guaranteed not to block
-      // any new content from appearing.
-      return handler === getShellBoundary();
-    }
-  } // For all other Lanes besides Transitions and Retries, we should not wait
-  // for the data to load.
-  // TODO: We should wait during Offscreen prerendering, too.
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(
+      dispatchQueue,
+      leaveEvent,
+      from,
+      common,
+      false
+    );
+  }
 
-  return false;
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(
+      dispatchQueue,
+      enterEvent,
+      to,
+      common,
+      true
+    );
+  }
 }
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
+) {
+  var listeners = [];
+  var eventListeners = getEventHandlerListeners(currentTarget);
 
-function pushDispatcher(container) {
-  prepareRendererToRender(container);
-  var prevDispatcher = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
-
-  if (prevDispatcher === null) {
-    // The React isomorphic package does not include a default dispatcher.
-    // Instead the first renderer will lazily attach one, in order to give
-    // nicer error messages.
-    return ContextOnlyDispatcher;
-  } else {
-    return prevDispatcher;
+  if (eventListeners !== null) {
+    eventListeners.forEach(function (entry) {
+      if (entry.type === reactEventType && entry.capture === inCapturePhase) {
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
+        );
+      }
+    });
   }
+
+  return listeners;
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? "capture" : "bubble");
 }
 
-function popDispatcher(prevDispatcher) {
-  resetRendererAfterRender();
-  ReactCurrentDispatcher.current = prevDispatcher;
+var didWarnInvalidHydration = false;
+var didWarnScriptTags = false;
+var DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML";
+var SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning";
+var SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
+var AUTOFOCUS = "autoFocus";
+var CHILDREN = "children";
+var STYLE$1 = "style";
+var HTML = "__html";
+var warnedUnknownTags;
+var canDiffStyleForHydrationWarning;
+
+{
+  warnedUnknownTags = {
+    // There are working polyfills for <dialog>. Let people use it.
+    dialog: true,
+    // Electron ships a custom <webview> tag to display external web content in
+    // an isolated frame and process.
+    // This tag is not present in non Electron environments such as JSDom which
+    // is often used for testing purposes.
+    // @see https://electronjs.org/docs/api/webview-tag
+    webview: true
+  }; // IE 11 parses & normalizes the style attribute as opposed to other
+  // browsers. It adds spaces and sorts the properties in some
+  // non-alphabetical order. Handling that would require sorting CSS
+  // properties in the client & server versions or applying
+  // `expectedStyle` to a temporary DOM node to read its `style` attribute
+  // normalized. Since it only affects IE, we're skipping style warnings
+  // in that browser completely in favor of doing all that work.
+  // See https://github.com/facebook/react/issues/11807
+
+  canDiffStyleForHydrationWarning =
+    disableIEWorkarounds || (canUseDOM && !document.documentMode);
 }
 
-function pushCacheDispatcher() {
+function validatePropertiesInDevelopment(type, props) {
   {
-    var prevCacheDispatcher = ReactCurrentCache.current;
-    ReactCurrentCache.current = DefaultCacheDispatcher;
-    return prevCacheDispatcher;
+    validateProperties$2(type, props);
+    validateProperties$1(type, props);
+    validateProperties(type, props, {
+      registrationNameDependencies: registrationNameDependencies,
+      possibleRegistrationNames: possibleRegistrationNames
+    });
   }
 }
 
-function popCacheDispatcher(prevCacheDispatcher) {
+function warnForPropDifference(propName, serverValue, clientValue) {
   {
-    ReactCurrentCache.current = prevCacheDispatcher;
+    if (didWarnInvalidHydration) {
+      return;
+    }
+
+    var normalizedClientValue = normalizeMarkupForTextOrAttribute(clientValue);
+    var normalizedServerValue = normalizeMarkupForTextOrAttribute(serverValue);
+
+    if (normalizedServerValue === normalizedClientValue) {
+      return;
+    }
+
+    didWarnInvalidHydration = true;
+
+    error(
+      "Prop `%s` did not match. Server: %s Client: %s",
+      propName,
+      JSON.stringify(normalizedServerValue),
+      JSON.stringify(normalizedClientValue)
+    );
   }
 }
 
-function markCommitTimeOfFallback() {
-  globalMostRecentFallbackTime = now$1();
-}
-function markSkippedUpdateLanes(lane) {
-  workInProgressRootSkippedLanes = mergeLanes(
-    lane,
-    workInProgressRootSkippedLanes
-  );
-}
-function renderDidSuspend() {
-  if (workInProgressRootExitStatus === RootInProgress) {
-    workInProgressRootExitStatus = RootSuspended;
+function warnForExtraAttributes(attributeNames) {
+  {
+    if (didWarnInvalidHydration) {
+      return;
+    }
+
+    didWarnInvalidHydration = true;
+    var names = [];
+    attributeNames.forEach(function (name) {
+      names.push(name);
+    });
+
+    error("Extra attributes from the server: %s", names);
   }
 }
-function renderDidSuspendDelayIfPossible() {
-  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
-  // this render.
 
-  if (
-    workInProgressRoot !== null &&
-    (includesNonIdleWork(workInProgressRootSkippedLanes) ||
-      includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))
-  ) {
-    // Mark the current render as suspended so that we switch to working on
-    // the updates that were skipped. Usually we only suspend at the end of
-    // the render phase.
-    // TODO: We should probably always mark the root as suspended immediately
-    // (inside this function), since by suspending at the end of the render
-    // phase introduces a potential mistake where we suspend lanes that were
-    // pinged or updated while we were rendering.
-    // TODO: Consider unwinding immediately, using the
-    // SuspendedOnHydration mechanism.
-    // $FlowFixMe[incompatible-call] need null check workInProgressRoot
-    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+function warnForInvalidEventListener(registrationName, listener) {
+  {
+    if (listener === false) {
+      error(
+        "Expected `%s` listener to be a function, instead got `false`.\n\n" +
+          "If you used to conditionally omit it with %s={condition && value}, " +
+          "pass %s={condition ? value : undefined} instead.",
+        registrationName,
+        registrationName,
+        registrationName
+      );
+    } else {
+      error(
+        "Expected `%s` listener to be a function, instead got a value of `%s` type.",
+        registrationName,
+        typeof listener
+      );
+    }
   }
-}
-function renderDidError(error) {
-  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
-    workInProgressRootExitStatus = RootErrored;
+} // Parse the HTML and read it back to normalize the HTML string so that it
+// can be used for comparison.
+
+function normalizeHTML(parent, html) {
+  {
+    // We could have created a separate document here to avoid
+    // re-initializing custom elements if they exist. But this breaks
+    // how <noscript> is being handled. So we use the same document.
+    // See the discussion in https://github.com/facebook/react/pull/11157.
+    var testElement =
+      parent.namespaceURI === HTML_NAMESPACE
+        ? parent.ownerDocument.createElement(parent.tagName)
+        : parent.ownerDocument.createElementNS(
+            parent.namespaceURI,
+            parent.tagName
+          );
+    testElement.innerHTML = html;
+    return testElement.innerHTML;
   }
+} // HTML parsing normalizes CR and CRLF to LF.
+// It also can turn \u0000 into \uFFFD inside attributes.
+// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
+// If we have a mismatch, it might be caused by that.
+// We will still patch up in this case but not fire the warning.
 
-  if (workInProgressRootConcurrentErrors === null) {
-    workInProgressRootConcurrentErrors = [error];
-  } else {
-    workInProgressRootConcurrentErrors.push(error);
+var NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+var NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+
+function normalizeMarkupForTextOrAttribute(markup) {
+  {
+    checkHtmlStringCoercion(markup);
   }
-} // Called during render to determine if anything has suspended.
-// Returns false if we're not sure.
 
-function renderHasNotSuspendedYet() {
-  // If something errored or completed, we can't really be sure,
-  // so those are false.
-  return workInProgressRootExitStatus === RootInProgress;
-} // TODO: Over time, this function and renderRootConcurrent have become more
-// and more similar. Not sure it makes sense to maintain forked paths. Consider
-// unifying them again.
+  var markupString = typeof markup === "string" ? markup : "" + markup;
+  return markupString
+    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
+    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
+}
 
-function renderRootSync(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= RenderContext;
-  var prevDispatcher = pushDispatcher(root.containerInfo);
-  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
-  // and prepare a fresh one. Otherwise we'll continue where we left off.
+function checkForUnmatchedText(
+  serverText,
+  clientText,
+  isConcurrentMode,
+  shouldWarnDev
+) {
+  var normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
+  var normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
 
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    {
-      if (isDevToolsPresent) {
-        var memoizedUpdaters = root.memoizedUpdaters;
+  if (normalizedServerText === normalizedClientText) {
+    return;
+  }
 
-        if (memoizedUpdaters.size > 0) {
-          restorePendingUpdaters(root, workInProgressRootRenderLanes);
-          memoizedUpdaters.clear();
-        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
-        // If we bailout on this work, we'll move them back (like above).
-        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
-        // That way we can keep the current update and future updates separate.
+  if (shouldWarnDev) {
+    {
+      if (!didWarnInvalidHydration) {
+        didWarnInvalidHydration = true;
 
-        movePendingFibersToMemoized(root, lanes);
+        error(
+          'Text content did not match. Server: "%s" Client: "%s"',
+          normalizedServerText,
+          normalizedClientText
+        );
       }
     }
+  }
 
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    prepareFreshStack(root, lanes);
+  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+    // In concurrent roots, we throw when there's a text mismatch and revert to
+    // client rendering, up to the nearest Suspense boundary.
+    throw new Error("Text content does not match server-rendered HTML.");
   }
+}
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return rootContainerElement.nodeType === DOCUMENT_NODE
+    ? rootContainerElement
+    : rootContainerElement.ownerDocument;
+}
 
-  {
-    if (enableDebugTracing) {
-      logRenderStarted(lanes);
+function noop() {}
+
+function trapClickOnNonInteractiveElement(node) {
+  // Mobile Safari does not fire properly bubble click events on
+  // non-interactive elements, which means delegated click listeners do not
+  // fire. The workaround for this bug involves attaching an empty click
+  // listener on the target node.
+  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+  // Just set it using the onclick property so that we don't have to manage any
+  // bookkeeping for it. Not sure if we need to clear it when the listener is
+  // removed.
+  // TODO: Only do this for the relevant Safaris maybe?
+  node.onclick = noop;
+}
+
+function setInitialDOMProperties(
+  tag,
+  domElement,
+  nextProps,
+  isCustomComponentTag
+) {
+  for (var propKey in nextProps) {
+    if (!nextProps.hasOwnProperty(propKey)) {
+      continue;
     }
-  }
 
-  if (enableSchedulingProfiler) {
-    markRenderStarted(lanes);
-  }
+    var nextProp = nextProps[propKey];
 
-  outer: do {
-    try {
-      if (
-        workInProgressSuspendedReason !== NotSuspended &&
-        workInProgress !== null
-      ) {
-        // The work loop is suspended. During a synchronous render, we don't
-        // yield to the main thread. Immediately unwind the stack. This will
-        // trigger either a fallback or an error boundary.
-        // TODO: For discrete and "default" updates (anything that's not
-        // flushSync), we want to wait for the microtasks the flush before
-        // unwinding. Will probably implement this using renderRootConcurrent,
-        // or merge renderRootSync and renderRootConcurrent into the same
-        // function and fork the behavior some other way.
-        var unitOfWork = workInProgress;
-        var thrownValue = workInProgressThrownValue;
+    if (propKey === STYLE$1) {
+      {
+        if (nextProp) {
+          // Freeze the next style object so that we can assume it won't be
+          // mutated. We have already warned for this in the past.
+          Object.freeze(nextProp);
+        }
+      } // Relies on `updateStylesByID` not mutating `styleUpdates`.
 
-        switch (workInProgressSuspendedReason) {
-          case SuspendedOnHydration: {
-            // Selective hydration. An update flowed into a dehydrated tree.
-            // Interrupt the current render so the work loop can switch to the
-            // hydration lane.
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = RootDidNotComplete;
-            break outer;
-          }
+      setValueForStyles(domElement, nextProp);
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+      var nextHtml = nextProp ? nextProp[HTML] : undefined;
 
-          default: {
-            // Continue with the normal work loop.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
+      if (nextHtml != null) {
+        if (disableIEWorkarounds) {
+          domElement.innerHTML = nextHtml;
+        } else {
+          setInnerHTML$1(domElement, nextHtml);
         }
       }
+    } else if (propKey === CHILDREN) {
+      if (typeof nextProp === "string") {
+        // Avoid setting initial textContent when the text is empty. In IE11 setting
+        // textContent on a <textarea> will cause the placeholder to not
+        // show within the <textarea> until it has been focused and blurred again.
+        // https://github.com/facebook/react/issues/6731#issuecomment-254874553
+        var canSetTextContent =
+          tag !== "body" && (tag !== "textarea" || nextProp !== "");
 
-      workLoopSync();
-      break;
-    } catch (thrownValue) {
-      handleThrow(root, thrownValue);
+        if (canSetTextContent) {
+          setTextContent(domElement, nextProp);
+        }
+      } else if (typeof nextProp === "number") {
+        var _canSetTextContent = tag !== "body";
+
+        if (_canSetTextContent) {
+          setTextContent(domElement, "" + nextProp);
+        }
+      }
+    } else if (
+      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+      propKey === SUPPRESS_HYDRATION_WARNING$1
+    );
+    else if (propKey === AUTOFOCUS);
+    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      if (nextProp != null) {
+        if (typeof nextProp !== "function") {
+          warnForInvalidEventListener(propKey, nextProp);
+        }
+
+        if (propKey === "onScroll") {
+          listenToNonDelegatedEvent("scroll", domElement);
+        }
+      }
+    } else if (nextProp != null) {
+      setValueForProperty(domElement, propKey, nextProp, isCustomComponentTag);
     }
-  } while (true);
+  }
+}
 
-  resetContextDependencies();
-  executionContext = prevExecutionContext;
-  popDispatcher(prevDispatcher);
-  popCacheDispatcher(prevCacheDispatcher);
+function updateDOMProperties(
+  domElement,
+  updatePayload,
+  wasCustomComponentTag,
+  isCustomComponentTag
+) {
+  // TODO: Handle wasCustomComponentTag
+  for (var i = 0; i < updatePayload.length; i += 2) {
+    var propKey = updatePayload[i];
+    var propValue = updatePayload[i + 1];
 
-  if (workInProgress !== null) {
-    // This is a sync render, so we should have finished the whole tree.
-    throw new Error(
-      "Cannot commit an incomplete root. This error is likely caused by a " +
-        "bug in React. Please file an issue."
-    );
+    if (propKey === STYLE$1) {
+      setValueForStyles(domElement, propValue);
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+      if (disableIEWorkarounds) {
+        domElement.innerHTML = propValue;
+      } else {
+        setInnerHTML$1(domElement, propValue);
+      }
+    } else if (propKey === CHILDREN) {
+      setTextContent(domElement, propValue);
+    } else {
+      setValueForProperty(domElement, propKey, propValue, isCustomComponentTag);
+    }
   }
+} // creates a script element that won't execute
+
+function createPotentiallyInlineScriptElement(ownerDocument) {
+  // Create the script via .innerHTML so its "parser-inserted" flag is
+  // set to true and it does not execute
+  var div = ownerDocument.createElement("div");
 
   {
-    if (enableDebugTracing) {
-      logRenderStopped();
+    if (enableTrustedTypesIntegration && !didWarnScriptTags) {
+      error(
+        "Encountered a script tag while rendering React component. " +
+          "Scripts inside React components are never executed when rendering " +
+          "on the client. Consider using template tag instead " +
+          "(https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)."
+      );
+
+      didWarnScriptTags = true;
     }
   }
 
-  if (enableSchedulingProfiler) {
-    markRenderStopped();
-  } // Set this to null to indicate there's no in-progress render.
-
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+  div.innerHTML = "<script><" + "/script>"; // eslint-disable-line
+  // This is guaranteed to yield a script element.
 
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
-} // The work loop is an extremely hot path. Tell Closure not to inline it.
+  var firstChild = div.firstChild;
+  var element = div.removeChild(firstChild);
+  return element;
+}
+function createSelectElement(props, ownerDocument) {
+  var element;
 
-/** @noinline */
+  if (typeof props.is === "string") {
+    element = ownerDocument.createElement("select", {
+      is: props.is
+    });
+  } else {
+    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+    // See discussion in https://github.com/facebook/react/pull/6896
+    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+    element = ownerDocument.createElement("select");
+  }
 
-function workLoopSync() {
-  // Perform work without checking if we need to yield between fiber.
-  while (workInProgress !== null) {
-    performUnitOfWork(workInProgress);
+  if (props.multiple) {
+    element.multiple = true;
+  } else if (props.size) {
+    // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
+    // it is possible that no option is selected.
+    //
+    // This is only necessary when a select in "single selection mode".
+    element.size = props.size;
   }
-}
 
-function renderRootConcurrent(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= RenderContext;
-  var prevDispatcher = pushDispatcher(root.containerInfo);
-  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
-  // and prepare a fresh one. Otherwise we'll continue where we left off.
+  return element;
+} // Creates elements in the HTML namesapce
 
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    {
-      if (isDevToolsPresent) {
-        var memoizedUpdaters = root.memoizedUpdaters;
+function createHTMLElement(type, props, ownerDocument) {
+  {
+    switch (type) {
+      case "script":
+      case "select":
+        error(
+          'createHTMLElement was called with a "%s" type. This type has special creation logic in React and should use the create function implemented specifically for it. This is a bug in React.',
+          type
+        );
 
-        if (memoizedUpdaters.size > 0) {
-          restorePendingUpdaters(root, workInProgressRootRenderLanes);
-          memoizedUpdaters.clear();
-        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
-        // If we bailout on this work, we'll move them back (like above).
-        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
-        // That way we can keep the current update and future updates separate.
+        break;
 
-        movePendingFibersToMemoized(root, lanes);
-      }
+      case "svg":
+      case "math":
+        error(
+          'createHTMLElement was called with a "%s" type. This type must be created with Document.createElementNS which this method does not implement. This is a bug in React.',
+          type
+        );
     }
-
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    resetRenderTimer();
-    prepareFreshStack(root, lanes);
   }
 
+  var isCustomComponentTag;
+  var element;
+
   {
-    if (enableDebugTracing) {
-      logRenderStarted(lanes);
+    isCustomComponentTag = isCustomComponent(type, props); // Should this check be gated by parent namespace? Not sure we want to
+    // allow <SVG> or <mATH>.
+
+    if (!isCustomComponentTag && type !== type.toLowerCase()) {
+      error(
+        "<%s /> is using incorrect casing. " +
+          "Use PascalCase for React components, " +
+          "or lowercase for HTML elements.",
+        type
+      );
     }
   }
 
-  if (enableSchedulingProfiler) {
-    markRenderStarted(lanes);
+  if (typeof props.is === "string") {
+    element = ownerDocument.createElement(type, {
+      is: props.is
+    });
+  } else {
+    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+    // See discussion in https://github.com/facebook/react/pull/6896
+    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+    element = ownerDocument.createElement(type);
   }
 
-  outer: do {
-    try {
-      if (
-        workInProgressSuspendedReason !== NotSuspended &&
-        workInProgress !== null
-      ) {
-        // The work loop is suspended. We need to either unwind the stack or
-        // replay the suspended component.
-        var unitOfWork = workInProgress;
-        var thrownValue = workInProgressThrownValue;
-
-        switch (workInProgressSuspendedReason) {
-          case SuspendedOnError: {
-            // Unwind then continue with the normal work loop.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
-
-          case SuspendedOnData: {
-            var thenable = thrownValue;
-
-            if (isThenableResolved(thenable)) {
-              // The data resolved. Try rendering the component again.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(unitOfWork);
-              break;
-            } // The work loop is suspended on data. We should wait for it to
-            // resolve before continuing to render.
-            // TODO: Handle the case where the promise resolves synchronously.
-            // Usually this is handled when we instrument the promise to add a
-            // `status` field, but if the promise already has a status, we won't
-            // have added a listener until right here.
-
-            var onResolution = function () {
-              // Check if the root is still suspended on this promise.
-              if (
-                workInProgressSuspendedReason === SuspendedOnData &&
-                workInProgressRoot === root
-              ) {
-                // Mark the root as ready to continue rendering.
-                workInProgressSuspendedReason = SuspendedAndReadyToContinue;
-              } // Ensure the root is scheduled. We should do this even if we're
-              // currently working on a different root, so that we resume
-              // rendering later.
-
-              ensureRootIsScheduled(root, now$1());
-            };
-
-            thenable.then(onResolution, onResolution);
-            break outer;
-          }
+  {
+    if (
+      !isCustomComponentTag && // $FlowFixMe[method-unbinding]
+      Object.prototype.toString.call(element) ===
+        "[object HTMLUnknownElement]" &&
+      !hasOwnProperty.call(warnedUnknownTags, type)
+    ) {
+      warnedUnknownTags[type] = true;
 
-          case SuspendedOnImmediate: {
-            // If this fiber just suspended, it's possible the data is already
-            // cached. Yield to the main thread to give it a chance to ping. If
-            // it does, we can retry immediately without unwinding the stack.
-            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
-            break outer;
-          }
+      error(
+        "The tag <%s> is unrecognized in this browser. " +
+          "If you meant to render a React component, start its name with " +
+          "an uppercase letter.",
+        type
+      );
+    }
+  }
 
-          case SuspendedAndReadyToContinue: {
-            var _thenable = thrownValue;
+  return element;
+}
+function createTextNode(text, rootContainerElement) {
+  return getOwnerDocumentFromRootContainer(rootContainerElement).createTextNode(
+    text
+  );
+}
+function setInitialProperties(domElement, tag, rawProps) {
+  var isCustomComponentTag = isCustomComponent(tag, rawProps);
 
-            if (isThenableResolved(_thenable)) {
-              // The data resolved. Try rendering the component again.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(unitOfWork);
-            } else {
-              // Otherwise, unwind then continue with the normal work loop.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            }
+  {
+    validatePropertiesInDevelopment(tag, rawProps);
+  } // TODO: Make sure that we check isMounted before firing any of these events.
 
-            break;
-          }
+  var props;
 
-          case SuspendedOnDeprecatedThrowPromise: {
-            // Suspended by an old implementation that uses the `throw promise`
-            // pattern. The newer replaying behavior can cause subtle issues
-            // like infinite ping loops. So we maintain the old behavior and
-            // always unwind.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
+  switch (tag) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", domElement);
+      listenToNonDelegatedEvent("close", domElement);
+      props = rawProps;
+      break;
 
-          case SuspendedOnHydration: {
-            // Selective hydration. An update flowed into a dehydrated tree.
-            // Interrupt the current render so the work loop can switch to the
-            // hydration lane.
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = RootDidNotComplete;
-            break outer;
-          }
+    case "iframe":
+    case "object":
+    case "embed":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
 
-          default: {
-            throw new Error(
-              "Unexpected SuspendedReason. This is a bug in React."
-            );
-          }
-        }
+    case "video":
+    case "audio":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (var i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
       }
 
-      if (true && ReactCurrentActQueue.current !== null) {
-        // `act` special case: If we're inside an `act` scope, don't consult
-        // `shouldYield`. Always keep working until the render is complete.
-        // This is not just an optimization: in a unit test environment, we
-        // can't trust the result of `shouldYield`, because the host I/O is
-        // likely mocked.
-        workLoopSync();
-      } else {
-        workLoopConcurrent();
-      }
+      props = rawProps;
+      break;
 
+    case "source":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent("error", domElement);
+      props = rawProps;
       break;
-    } catch (thrownValue) {
-      handleThrow(root, thrownValue);
-    }
-  } while (true);
 
-  resetContextDependencies();
-  popDispatcher(prevDispatcher);
-  popCacheDispatcher(prevCacheDispatcher);
-  executionContext = prevExecutionContext;
+    case "img":
+    case "image":
+    case "link":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent("error", domElement);
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
 
-  {
-    if (enableDebugTracing) {
-      logRenderStopped();
-    }
-  } // Check if the tree has completed.
+    case "details":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent("toggle", domElement);
+      props = rawProps;
+      break;
 
-  if (workInProgress !== null) {
-    // Still work remaining.
-    if (enableSchedulingProfiler) {
-      markRenderYielded();
-    }
+    case "input":
+      initWrapperState$2(domElement, rawProps);
+      props = getHostProps$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-    return RootInProgress;
-  } else {
-    // Completed the tree.
-    if (enableSchedulingProfiler) {
-      markRenderStopped();
-    } // Set this to null to indicate there's no in-progress render.
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-    workInProgressRoot = null;
-    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+    case "option":
+      validateProps(domElement, rawProps);
+      props = rawProps;
+      break;
 
-    finishQueueingConcurrentUpdates(); // Return the final exit status.
+    case "select":
+      initWrapperState$1(domElement, rawProps);
+      props = getHostProps$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-    return workInProgressRootExitStatus;
-  }
-}
-/** @noinline */
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-function workLoopConcurrent() {
-  // Perform work until Scheduler asks us to yield
-  while (workInProgress !== null && !shouldYield()) {
-    // $FlowFixMe[incompatible-call] found when upgrading Flow
-    performUnitOfWork(workInProgress);
-  }
-}
+    case "textarea":
+      initWrapperState(domElement, rawProps);
+      props = getHostProps(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-function performUnitOfWork(unitOfWork) {
-  // The current, flushed, state of this fiber is the alternate. 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 = unitOfWork.alternate;
-  setCurrentFiber(unitOfWork);
-  var next;
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
-    startProfilerTimer(unitOfWork);
-    next = beginWork(current, unitOfWork, renderLanes);
-    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
-  } else {
-    next = beginWork(current, unitOfWork, renderLanes);
+    default:
+      props = rawProps;
   }
 
-  resetCurrentFiber();
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  assertValidProps(tag, props);
+  setInitialDOMProperties(tag, domElement, props, isCustomComponentTag);
 
-  if (next === null) {
-    // If this doesn't spawn new work, complete the current work.
-    completeUnitOfWork(unitOfWork);
-  } else {
-    workInProgress = next;
-  }
+  switch (tag) {
+    case "input":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper$3(domElement, rawProps, false);
+      break;
 
-  ReactCurrentOwner.current = null;
-}
+    case "textarea":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper(domElement);
+      break;
 
-function replaySuspendedUnitOfWork(unitOfWork) {
-  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
-  // just suspended.
-  //
-  var current = unitOfWork.alternate;
-  setCurrentFiber(unitOfWork);
-  var next;
-  setCurrentFiber(unitOfWork);
-  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+    case "option":
+      postMountWrapper$2(domElement, rawProps);
+      break;
 
-  if (isProfilingMode) {
-    startProfilerTimer(unitOfWork);
+    case "select":
+      postMountWrapper$1(domElement, rawProps);
+      break;
+
+    default:
+      if (typeof props.onClick === "function") {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        trapClickOnNonInteractiveElement(domElement);
+      }
+
+      break;
   }
+} // Calculate the diff between the two objects.
 
-  switch (unitOfWork.tag) {
-    case IndeterminateComponent: {
-      // Because it suspended with `use`, we can assume it's a
-      // function component.
-      unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
-    }
-    // eslint-disable-next-line no-fallthrough
+function diffProperties(domElement, tag, lastRawProps, nextRawProps) {
+  {
+    validatePropertiesInDevelopment(tag, nextRawProps);
+  }
 
-    case FunctionComponent:
-    case ForwardRef: {
-      // Resolve `defaultProps`. This logic is copied from `beginWork`.
-      // TODO: Consider moving this switch statement into that module. Also,
-      // could maybe use this as an opportunity to say `use` doesn't work with
-      // `defaultProps` :)
-      var Component = unitOfWork.type;
-      var unresolvedProps = unitOfWork.pendingProps;
-      var resolvedProps =
-        unitOfWork.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      next = replayFunctionComponent(
-        current,
-        unitOfWork,
-        resolvedProps,
-        Component,
-        workInProgressRootRenderLanes
-      );
+  var updatePayload = null;
+  var lastProps;
+  var nextProps;
+
+  switch (tag) {
+    case "input":
+      lastProps = getHostProps$2(domElement, lastRawProps);
+      nextProps = getHostProps$2(domElement, nextRawProps);
+      updatePayload = [];
       break;
-    }
 
-    case SimpleMemoComponent: {
-      var _Component = unitOfWork.type;
-      var nextProps = unitOfWork.pendingProps;
-      next = replayFunctionComponent(
-        current,
-        unitOfWork,
-        nextProps,
-        _Component,
-        workInProgressRootRenderLanes
-      );
+    case "select":
+      lastProps = getHostProps$1(domElement, lastRawProps);
+      nextProps = getHostProps$1(domElement, nextRawProps);
+      updatePayload = [];
       break;
-    }
 
-    default: {
-      // Other types besides function components are reset completely before
-      // being replayed. Currently this only happens when a Usable type is
-      // reconciled — the reconciler will suspend.
-      //
-      // We reset the fiber back to its original state; however, this isn't
-      // a full "unwind" because we're going to reuse the promises that were
-      // reconciled previously. So it's intentional that we don't call
-      // resetSuspendedWorkLoopOnUnwind here.
-      unwindInterruptedWork(current, unitOfWork);
-      unitOfWork = workInProgress = resetWorkInProgress(
-        unitOfWork,
-        renderLanes
-      );
-      next = beginWork(current, unitOfWork, renderLanes);
+    case "textarea":
+      lastProps = getHostProps(domElement, lastRawProps);
+      nextProps = getHostProps(domElement, nextRawProps);
+      updatePayload = [];
       break;
-    }
-  }
 
-  if (isProfilingMode) {
-    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
-  } // The begin phase finished successfully without suspending. Return to the
-  // normal work loop.
+    default:
+      lastProps = lastRawProps;
+      nextProps = nextRawProps;
 
-  resetCurrentFiber();
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+      if (
+        typeof lastProps.onClick !== "function" &&
+        typeof nextProps.onClick === "function"
+      ) {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        trapClickOnNonInteractiveElement(domElement);
+      }
 
-  if (next === null) {
-    // If this doesn't spawn new work, complete the current work.
-    completeUnitOfWork(unitOfWork);
-  } else {
-    workInProgress = next;
+      break;
   }
 
-  ReactCurrentOwner.current = null;
-}
+  assertValidProps(tag, nextProps);
+  var propKey;
+  var styleName;
+  var styleUpdates = null;
 
-function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
-  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
-  // that threw an exception.
-  //
-  // Return to the normal work loop. This will unwind the stack, and potentially
-  // result in showing a fallback.
-  resetSuspendedWorkLoopOnUnwind();
-  var returnFiber = unitOfWork.return;
+  for (propKey in lastProps) {
+    if (
+      nextProps.hasOwnProperty(propKey) ||
+      !lastProps.hasOwnProperty(propKey) ||
+      lastProps[propKey] == null
+    ) {
+      continue;
+    }
 
-  if (returnFiber === null || workInProgressRoot === null) {
-    // Expected to be working on a non-root fiber. This is a fatal error
-    // because there's no ancestor that can handle it; the root is
-    // supposed to capture all errors that weren't caught by an error
-    // boundary.
-    workInProgressRootExitStatus = RootFatalErrored;
-    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
-    // sibling, or the parent if there are no siblings. But since the root
-    // has no siblings nor a parent, we set it to null. Usually this is
-    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
-    // intentionally not calling those, we need set it here.
-    // TODO: Consider calling `unwindWork` to pop the contexts.
+    if (propKey === STYLE$1) {
+      var lastStyle = lastProps[propKey];
 
-    workInProgress = null;
-    return;
-  }
+      for (styleName in lastStyle) {
+        if (lastStyle.hasOwnProperty(styleName)) {
+          if (!styleUpdates) {
+            styleUpdates = {};
+          }
 
-  try {
-    // Find and mark the nearest Suspense or error boundary that can handle
-    // this "exception".
-    throwException(
-      workInProgressRoot,
-      returnFiber,
-      unitOfWork,
-      thrownValue,
-      workInProgressRootRenderLanes
+          styleUpdates[styleName] = "";
+        }
+      }
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML || propKey === CHILDREN);
+    else if (
+      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+      propKey === SUPPRESS_HYDRATION_WARNING$1
     );
-  } catch (error) {
-    // We had trouble processing the error. An example of this happening is
-    // when accessing the `componentDidCatch` property of an error boundary
-    // throws an error. A weird edge case. There's a regression test for this.
-    // To prevent an infinite loop, bubble the error up to the next parent.
-    workInProgress = returnFiber;
-    throw error;
-  } // Return to the normal work loop.
+    else if (propKey === AUTOFOCUS);
+    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      // This is a special case. If any listener updates we need to ensure
+      // that the "current" fiber pointer gets updated so we need a commit
+      // to update this element.
+      if (!updatePayload) {
+        updatePayload = [];
+      }
+    } else {
+      // For all other deleted properties we add it to the queue. We use
+      // the allowed property list in the commit phase instead.
+      (updatePayload = updatePayload || []).push(propKey, null);
+    }
+  }
 
-  completeUnitOfWork(unitOfWork);
-}
+  for (propKey in nextProps) {
+    var nextProp = nextProps[propKey];
+    var lastProp = lastProps != null ? lastProps[propKey] : undefined;
 
-function completeUnitOfWork(unitOfWork) {
-  // Attempt to complete the current unit of work, then move to the next
-  // sibling. If there are no more siblings, return to the parent fiber.
-  var completedWork = unitOfWork;
+    if (
+      !nextProps.hasOwnProperty(propKey) ||
+      nextProp === lastProp ||
+      (nextProp == null && lastProp == null)
+    ) {
+      continue;
+    }
 
-  do {
-    // The current, flushed, state of this fiber is the alternate. 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 = completedWork.alternate;
-    var returnFiber = completedWork.return; // Check if the work completed or if something threw.
+    if (propKey === STYLE$1) {
+      {
+        if (nextProp) {
+          // Freeze the next style object so that we can assume it won't be
+          // mutated. We have already warned for this in the past.
+          Object.freeze(nextProp);
+        }
+      }
 
-    if ((completedWork.flags & Incomplete) === NoFlags$1) {
-      setCurrentFiber(completedWork);
-      var next = void 0;
+      if (lastProp) {
+        // Unset styles on `lastProp` but not on `nextProp`.
+        for (styleName in lastProp) {
+          if (
+            lastProp.hasOwnProperty(styleName) &&
+            (!nextProp || !nextProp.hasOwnProperty(styleName))
+          ) {
+            if (!styleUpdates) {
+              styleUpdates = {};
+            }
 
-      if ((completedWork.mode & ProfileMode) === NoMode) {
-        next = completeWork(current, completedWork, renderLanes);
-      } else {
-        startProfilerTimer(completedWork);
-        next = completeWork(current, completedWork, renderLanes); // Update render duration assuming we didn't error.
+            styleUpdates[styleName] = "";
+          }
+        } // Update styles that changed since `lastProp`.
 
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
-      }
+        for (styleName in nextProp) {
+          if (
+            nextProp.hasOwnProperty(styleName) &&
+            lastProp[styleName] !== nextProp[styleName]
+          ) {
+            if (!styleUpdates) {
+              styleUpdates = {};
+            }
 
-      resetCurrentFiber();
+            styleUpdates[styleName] = nextProp[styleName];
+          }
+        }
+      } else {
+        // Relies on `updateStylesByID` not mutating `styleUpdates`.
+        if (!styleUpdates) {
+          if (!updatePayload) {
+            updatePayload = [];
+          }
 
-      if (next !== null) {
-        // Completing this fiber spawned new work. Work on that next.
-        workInProgress = next;
-        return;
-      }
-    } else {
-      // This fiber did not complete because something threw. Pop values off
-      // the stack without entering the complete phase. If this is a boundary,
-      // capture values if possible.
-      var _next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.
+          updatePayload.push(propKey, styleUpdates);
+        }
 
-      if (_next !== null) {
-        // 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
-        // from the effect tag.
-        _next.flags &= HostEffectMask;
-        workInProgress = _next;
-        return;
+        styleUpdates = nextProp;
       }
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+      var nextHtml = nextProp ? nextProp[HTML] : undefined;
+      var lastHtml = lastProp ? lastProp[HTML] : undefined;
 
-      if ((completedWork.mode & ProfileMode) !== NoMode) {
-        // Record the render duration for the fiber that errored.
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
-
-        var actualDuration = completedWork.actualDuration;
-        var child = completedWork.child;
-
-        while (child !== null) {
-          // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
-          actualDuration += child.actualDuration;
-          child = child.sibling;
+      if (nextHtml != null) {
+        if (lastHtml !== nextHtml) {
+          (updatePayload = updatePayload || []).push(propKey, nextHtml);
+        }
+      }
+    } else if (propKey === CHILDREN) {
+      if (typeof nextProp === "string" || typeof nextProp === "number") {
+        (updatePayload = updatePayload || []).push(propKey, "" + nextProp);
+      }
+    } else if (
+      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+      propKey === SUPPRESS_HYDRATION_WARNING$1
+    );
+    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      if (nextProp != null) {
+        // We eagerly listen to this even though we haven't committed yet.
+        if (typeof nextProp !== "function") {
+          warnForInvalidEventListener(propKey, nextProp);
         }
 
-        completedWork.actualDuration = actualDuration;
+        if (propKey === "onScroll") {
+          listenToNonDelegatedEvent("scroll", domElement);
+        }
       }
 
-      if (returnFiber !== null) {
-        // Mark the parent fiber as incomplete and clear its subtree flags.
-        returnFiber.flags |= Incomplete;
-        returnFiber.subtreeFlags = NoFlags$1;
-        returnFiber.deletions = null;
-      } else {
-        // We've unwound all the way to the root.
-        workInProgressRootExitStatus = RootDidNotComplete;
-        workInProgress = null;
-        return;
+      if (!updatePayload && lastProp !== nextProp) {
+        // This is a special case. If any listener updates we need to ensure
+        // that the "current" props pointer gets updated so we need a commit
+        // to update this element.
+        updatePayload = [];
       }
+    } else {
+      // For any other property we always add it to the queue and then we
+      // filter it out using the allowed property list during the commit.
+      (updatePayload = updatePayload || []).push(propKey, nextProp);
+    }
+  }
+
+  if (styleUpdates) {
+    {
+      validateShorthandPropertyCollisionInDev(styleUpdates, nextProps[STYLE$1]);
     }
 
-    var siblingFiber = completedWork.sibling;
+    (updatePayload = updatePayload || []).push(STYLE$1, styleUpdates);
+  }
+
+  return updatePayload;
+} // Apply the diff.
+
+function updateProperties(
+  domElement,
+  updatePayload,
+  tag,
+  lastRawProps,
+  nextRawProps
+) {
+  // Update checked *before* name.
+  // In the middle of an update, it is possible to have multiple checked.
+  // When a checked radio tries to change name, browser makes another radio's checked false.
+  if (
+    tag === "input" &&
+    nextRawProps.type === "radio" &&
+    nextRawProps.name != null
+  ) {
+    updateChecked(domElement, nextRawProps);
+  }
+
+  var wasCustomComponentTag = isCustomComponent(tag, lastRawProps);
+  var isCustomComponentTag = isCustomComponent(tag, nextRawProps); // Apply the diff.
 
-    if (siblingFiber !== null) {
-      // If there is more work to do in this returnFiber, do that next.
-      workInProgress = siblingFiber;
-      return;
-    } // Otherwise, return to the parent
-    // $FlowFixMe[incompatible-type] we bail out when we get a null
+  updateDOMProperties(
+    domElement,
+    updatePayload,
+    wasCustomComponentTag,
+    isCustomComponentTag
+  ); // TODO: Ensure that an update gets scheduled if any of the special props
+  // changed.
 
-    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+  switch (tag) {
+    case "input":
+      // Update the wrapper around inputs *after* updating props. This has to
+      // happen after `updateDOMProperties`. Otherwise HTML5 input validations
+      // raise warnings and prevent the new value from being assigned.
+      updateWrapper$1(domElement, nextRawProps);
+      break;
 
-    workInProgress = completedWork;
-  } while (completedWork !== null); // We've reached the root.
+    case "textarea":
+      updateWrapper(domElement, nextRawProps);
+      break;
 
-  if (workInProgressRootExitStatus === RootInProgress) {
-    workInProgressRootExitStatus = RootCompleted;
+    case "select":
+      // <select> value update needs to occur after <option> children
+      // reconciliation
+      postUpdateWrapper(domElement, nextRawProps);
+      break;
   }
 }
 
-function commitRoot(root, recoverableErrors, transitions) {
-  // TODO: This no longer makes any sense. We already wrap the mutation and
-  // layout phases. Should be able to remove.
-  var previousUpdateLanePriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig.transition;
+function getPossibleStandardName(propName) {
+  {
+    var lowerCasedName = propName.toLowerCase();
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    commitRootImpl(
-      root,
-      recoverableErrors,
-      transitions,
-      previousUpdateLanePriority
-    );
-  } finally {
-    ReactCurrentBatchConfig.transition = prevTransition;
-    setCurrentUpdatePriority(previousUpdateLanePriority);
-  }
+    if (!possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+      return null;
+    }
 
-  return null;
+    return possibleStandardNames[lowerCasedName] || null;
+  }
 }
 
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
+function diffHydratedProperties(
+  domElement,
+  tag,
+  rawProps,
+  isConcurrentMode,
+  shouldWarnDev,
+  parentNamespaceDev
 ) {
-  do {
-    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
-    // means `flushPassiveEffects` will sometimes result in additional
-    // passive effects. So we need to keep flushing in a loop until there are
-    // no more pending effects.
-    // TODO: Might be better if `flushPassiveEffects` did not automatically
-    // flush synchronous work at the end, to avoid factoring hazards like this.
-    flushPassiveEffects();
-  } while (rootWithPendingPassiveEffects !== null);
+  var isCustomComponentTag;
+  var extraAttributeNames;
 
-  flushRenderPhaseStrictModeWarningsInDEV();
+  {
+    isCustomComponentTag = isCustomComponent(tag, rawProps);
+    validatePropertiesInDevelopment(tag, rawProps);
+  } // TODO: Make sure that we check isMounted before firing any of these events.
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
-  }
+  switch (tag) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", domElement);
+      listenToNonDelegatedEvent("close", domElement);
+      break;
 
-  var finishedWork = root.finishedWork;
-  var lanes = root.finishedLanes;
+    case "iframe":
+    case "object":
+    case "embed":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent("load", domElement);
+      break;
 
-  {
-    if (enableDebugTracing) {
-      logCommitStarted(lanes);
-    }
-  }
+    case "video":
+    case "audio":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (var i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      }
 
-  if (enableSchedulingProfiler) {
-    markCommitStarted(lanes);
-  }
+      break;
 
-  if (finishedWork === null) {
-    {
-      if (enableDebugTracing) {
-        logCommitStopped();
-      }
-    }
+    case "source":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent("error", domElement);
+      break;
 
-    if (enableSchedulingProfiler) {
-      markCommitStopped();
-    }
+    case "img":
+    case "image":
+    case "link":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent("error", domElement);
+      listenToNonDelegatedEvent("load", domElement);
+      break;
 
-    return null;
-  } else {
-    {
-      if (lanes === NoLanes) {
-        error(
-          "root.finishedLanes should not be empty during a commit. This is a " +
-            "bug in React."
-        );
-      }
-    }
-  }
+    case "details":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent("toggle", domElement);
+      break;
 
-  root.finishedWork = null;
-  root.finishedLanes = NoLanes;
+    case "input":
+      initWrapperState$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-  if (finishedWork === root.current) {
-    throw new Error(
-      "Cannot commit the same tree as before. This error is likely caused by " +
-        "a bug in React. Please file an issue."
-    );
-  } // commitRoot never returns a continuation; it always finishes synchronously.
-  // So we can clear these now to allow a new callback to be scheduled.
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-  root.callbackNode = null;
-  root.callbackPriority = NoLane; // Check which lanes no longer have any work scheduled on them, and mark
-  // those as finished.
+    case "option":
+      validateProps(domElement, rawProps);
+      break;
 
-  var remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
-  // during the render phase; don't mark them as finished.
+    case "select":
+      initWrapperState$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-  var concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
-  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
-  markRootFinished(root, remainingLanes);
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-  if (root === workInProgressRoot) {
-    // We can reset these now that they are finished.
-    workInProgressRoot = null;
-    workInProgress = null;
-    workInProgressRootRenderLanes = NoLanes;
-  } // If there are pending passive effects, schedule a callback to process them.
-  // Do this as early as possible, so it is queued before anything else that
-  // might get scheduled in the commit phase. (See #16714.)
-  // TODO: Delete all other places that schedule the passive effect callback
-  // They're redundant.
+    case "textarea":
+      initWrapperState(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-  if (
-    (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 ||
-    (finishedWork.flags & PassiveMask) !== NoFlags$1
-  ) {
-    if (!rootDoesHavePassiveEffects) {
-      rootDoesHavePassiveEffects = true;
-      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
-      // to store it in pendingPassiveTransitions until they get processed
-      // We need to pass this through as an argument to commitRoot
-      // because workInProgressTransitions might have changed between
-      // the previous render and commit if we throttle the commit
-      // with setTimeout
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+  }
 
-      pendingPassiveTransitions = transitions;
-      scheduleCallback(NormalPriority$1, function () {
-        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
-        // *after* passive effects fire to avoid freeing a cache pool that may
-        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+  assertValidProps(tag, rawProps);
 
-        return null;
-      });
-    }
-  } // Check if there are any effects in the whole tree.
-  // TODO: This is left over from the effect list implementation, where we had
-  // to check for the existence of `firstEffect` to satisfy Flow. I think the
-  // only other reason this optimization exists is because it affects profiling.
-  // Reconsider whether this is necessary.
+  {
+    extraAttributeNames = new Set();
+    var attributes = domElement.attributes;
 
-  var subtreeHasEffects =
-    (finishedWork.subtreeFlags &
-      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
-    NoFlags$1;
-  var rootHasEffect =
-    (finishedWork.flags &
-      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
-    NoFlags$1;
+    for (var _i = 0; _i < attributes.length; _i++) {
+      var name = attributes[_i].name.toLowerCase();
 
-  if (subtreeHasEffects || rootHasEffect) {
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = getCurrentUpdatePriority$1();
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    var prevExecutionContext = executionContext;
-    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+      switch (name) {
+        // Controlled attributes are not validated
+        // TODO: Only ignore them on controlled tags.
+        case "value":
+          break;
 
-    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
-    // of the effect list for each phase: all mutation effects come before all
-    // layout effects, and so on.
-    // The first phase a "before mutation" phase. We use this phase to read the
-    // state of the host tree right before we mutate it. This is where
-    // getSnapshotBeforeUpdate is called.
+        case "checked":
+          break;
 
-    var shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
+        case "selected":
+          break;
 
-    {
-      // Mark the current commit time to be shared by all Profilers in this
-      // batch. This enables them to be grouped later.
-      recordCommitTime();
+        default:
+          // Intentionally use the original name.
+          // See discussion in https://github.com/facebook/react/pull/10676.
+          extraAttributeNames.add(attributes[_i].name);
+      }
     }
+  }
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      // Track the root here, rather than in commitLayoutEffects(), because of ref setters.
-      // Updates scheduled during ref detachment should also be flagged.
-      rootCommittingMutationOrLayoutEffects = root;
-    } // The next phase is the mutation phase, where we mutate the host tree.
-
-    commitMutationEffects(root, finishedWork, lanes);
+  var updatePayload = null;
 
-    {
-      if (shouldFireAfterActiveInstanceBlur) {
-        afterActiveInstanceBlur();
-      }
+  for (var propKey in rawProps) {
+    if (!rawProps.hasOwnProperty(propKey)) {
+      continue;
     }
 
-    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
-    // the mutation phase, so that the previous tree is still current during
-    // componentWillUnmount, but before the layout phase, so that the finished
-    // work is current during componentDidMount/Update.
+    var nextProp = rawProps[propKey];
 
-    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
-    // the host tree after it's been mutated. The idiomatic use case for this is
-    // layout, but class component lifecycles also fire here for legacy reasons.
+    if (propKey === CHILDREN) {
+      // For text content children we compare against textContent. This
+      // might match additional HTML that is hidden when we read it using
+      // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
+      // satisfies our requirement. Our requirement is not to produce perfect
+      // HTML and attributes. Ideally we should preserve structure but it's
+      // ok not to if the visible content is still enough to indicate what
+      // even listeners these nodes might be wired up to.
+      // TODO: Warn if there is more than a single textNode as a child.
+      // TODO: Should we use domElement.firstChild.nodeValue to compare?
+      if (typeof nextProp === "string") {
+        if (domElement.textContent !== nextProp) {
+          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
+            checkForUnmatchedText(
+              domElement.textContent,
+              nextProp,
+              isConcurrentMode,
+              shouldWarnDev
+            );
+          }
 
-    {
-      if (enableDebugTracing) {
-        logLayoutEffectsStarted(lanes);
+          updatePayload = [CHILDREN, nextProp];
+        }
+      } else if (typeof nextProp === "number") {
+        if (domElement.textContent !== "" + nextProp) {
+          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
+            checkForUnmatchedText(
+              domElement.textContent,
+              nextProp,
+              isConcurrentMode,
+              shouldWarnDev
+            );
+          }
+
+          updatePayload = [CHILDREN, "" + nextProp];
+        }
       }
-    }
+    } else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      if (nextProp != null) {
+        if (typeof nextProp !== "function") {
+          warnForInvalidEventListener(propKey, nextProp);
+        }
 
-    if (enableSchedulingProfiler) {
-      markLayoutEffectsStarted(lanes);
-    }
+        if (propKey === "onScroll") {
+          listenToNonDelegatedEvent("scroll", domElement);
+        }
+      }
+    } else if (
+      shouldWarnDev &&
+      true && // Convince Flow we've calculated it (it's DEV-only in this method.)
+      typeof isCustomComponentTag === "boolean"
+    ) {
+      // Validate that the properties correspond to their expected values.
+      var serverValue = void 0;
+      var propertyInfo =
+        isCustomComponentTag && enableCustomElementPropertySupport
+          ? null
+          : getPropertyInfo(propKey);
 
-    commitLayoutEffects(finishedWork, root, lanes);
+      if (rawProps[SUPPRESS_HYDRATION_WARNING$1] === true);
+      else if (
+        propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+        propKey === SUPPRESS_HYDRATION_WARNING$1 || // Controlled attributes are not validated
+        // TODO: Only ignore them on controlled tags.
+        propKey === "value" ||
+        propKey === "checked" ||
+        propKey === "selected"
+      );
+      else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+        var serverHTML = domElement.innerHTML;
+        var nextHtml = nextProp ? nextProp[HTML] : undefined;
 
-    {
-      if (enableDebugTracing) {
-        logLayoutEffectsStopped();
-      }
-    }
+        if (nextHtml != null) {
+          var expectedHTML = normalizeHTML(domElement, nextHtml);
 
-    if (enableSchedulingProfiler) {
-      markLayoutEffectsStopped();
-    }
+          if (expectedHTML !== serverHTML) {
+            warnForPropDifference(propKey, serverHTML, expectedHTML);
+          }
+        }
+      } else if (propKey === STYLE$1) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.delete(propKey);
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      rootCommittingMutationOrLayoutEffects = null;
-    } // Tell Scheduler to yield at the end of the frame, so the browser has an
-    // opportunity to paint.
+        if (canDiffStyleForHydrationWarning) {
+          var expectedStyle = createDangerousStringForStyles(nextProp);
+          serverValue = domElement.getAttribute("style");
 
-    requestPaint();
-    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
+          if (expectedStyle !== serverValue) {
+            warnForPropDifference(propKey, serverValue, expectedStyle);
+          }
+        }
+      } else if (
+        enableCustomElementPropertySupport &&
+        isCustomComponentTag &&
+        (propKey === "offsetParent" ||
+          propKey === "offsetTop" ||
+          propKey === "offsetLeft" ||
+          propKey === "offsetWidth" ||
+          propKey === "offsetHeight" ||
+          propKey === "isContentEditable" ||
+          propKey === "outerText" ||
+          propKey === "outerHTML")
+      ) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.delete(propKey.toLowerCase());
 
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-  } else {
-    // No effects.
-    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
-    // no effects.
-    // TODO: Maybe there's a better way to report this.
+        {
+          error(
+            "Assignment to read-only property will result in a no-op: `%s`",
+            propKey
+          );
+        }
+      } else if (isCustomComponentTag && !enableCustomElementPropertySupport) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.delete(propKey.toLowerCase());
+        serverValue = getValueForAttribute(
+          domElement,
+          propKey,
+          nextProp,
+          isCustomComponentTag
+        );
 
-    {
-      recordCommitTime();
-    }
-  }
+        if (nextProp !== serverValue) {
+          warnForPropDifference(propKey, serverValue, nextProp);
+        }
+      } else if (
+        !shouldIgnoreAttribute(propKey, propertyInfo, isCustomComponentTag) &&
+        !shouldRemoveAttribute(
+          propKey,
+          nextProp,
+          propertyInfo,
+          isCustomComponentTag
+        )
+      ) {
+        var isMismatchDueToBadCasing = false;
 
-  var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
+        if (propertyInfo !== null) {
+          // $FlowFixMe - Should be inferred as not undefined.
+          extraAttributeNames.delete(propertyInfo.attributeName);
+          serverValue = getValueForProperty(
+            domElement,
+            propKey,
+            nextProp,
+            propertyInfo
+          );
+        } else {
+          var ownNamespaceDev = parentNamespaceDev;
 
-  if (rootDoesHavePassiveEffects) {
-    // This commit has passive effects. Stash a reference to them. But don't
-    // schedule a callback until after flushing layout work.
-    rootDoesHavePassiveEffects = false;
-    rootWithPendingPassiveEffects = root;
-    pendingPassiveEffectsLanes = lanes;
-  } else {
-    // There were no passive effects, so we can immediately release the cache
-    // pool for this render.
-    releaseRootPooledCache(root, remainingLanes);
+          if (ownNamespaceDev === HTML_NAMESPACE) {
+            ownNamespaceDev = getIntrinsicNamespace(tag);
+          }
 
-    {
-      nestedPassiveUpdateCount = 0;
-      rootWithPassiveNestedUpdates = null;
-    }
-  } // Read this again, since an effect might have updated it
+          if (ownNamespaceDev === HTML_NAMESPACE) {
+            // $FlowFixMe - Should be inferred as not undefined.
+            extraAttributeNames.delete(propKey.toLowerCase());
+          } else {
+            var standardName = getPossibleStandardName(propKey);
 
-  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
-  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
-  // is to detect whether something might have called setState inside
-  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
-  // inside `componentDidCatch` is itself flawed — that's why we recommend
-  // `getDerivedStateFromError` instead. However, it could be improved by
-  // checking if remainingLanes includes Sync work, instead of whether there's
-  // any work remaining at all (which would also include stuff like Suspense
-  // retries or transitions). It's been like this for a while, though, so fixing
-  // it probably isn't that urgent.
+            if (standardName !== null && standardName !== propKey) {
+              // If an SVG prop is supplied with bad casing, it will
+              // be successfully parsed from HTML, but will produce a mismatch
+              // (and would be incorrectly rendered on the client).
+              // However, we already warn about bad casing elsewhere.
+              // So we'll skip the misleading extra mismatch warning in this case.
+              isMismatchDueToBadCasing = true; // $FlowFixMe - Should be inferred as not undefined.
 
-  if (remainingLanes === NoLanes) {
-    // If there's no remaining work, we can clear the set of already failed
-    // error boundaries.
-    legacyErrorBoundariesThatAlreadyFailed = null;
-  }
+              extraAttributeNames.delete(standardName);
+            } // $FlowFixMe - Should be inferred as not undefined.
 
-  {
-    if (!rootDidHavePassiveEffects) {
-      commitDoubleInvokeEffectsInDEV(root, false);
-    }
-  }
+            extraAttributeNames.delete(propKey);
+          }
 
-  onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
+          serverValue = getValueForAttribute(
+            domElement,
+            propKey,
+            nextProp,
+            isCustomComponentTag
+          );
+        }
 
-  {
-    if (isDevToolsPresent) {
-      root.memoizedUpdaters.clear();
+        var dontWarnCustomElement =
+          enableCustomElementPropertySupport &&
+          isCustomComponentTag &&
+          (typeof nextProp === "function" || typeof nextProp === "object");
+
+        if (
+          !dontWarnCustomElement &&
+          nextProp !== serverValue &&
+          !isMismatchDueToBadCasing
+        ) {
+          warnForPropDifference(propKey, serverValue, nextProp);
+        }
+      }
     }
   }
 
   {
-    onCommitRoot();
-  } // Always call this before exiting `commitRoot`, to ensure that any
-  // additional work on this root is scheduled.
-
-  ensureRootIsScheduled(root, now$1());
-
-  if (recoverableErrors !== null) {
-    // There were errors during this render, but recovered from them without
-    // needing to surface it to the UI. We log them here.
-    var onRecoverableError = root.onRecoverableError;
-
-    for (var i = 0; i < recoverableErrors.length; i++) {
-      var recoverableError = recoverableErrors[i];
-      var errorInfo = makeErrorInfo(
-        recoverableError.digest,
-        recoverableError.stack
-      );
-      onRecoverableError(recoverableError.value, errorInfo);
+    if (shouldWarnDev) {
+      if (
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.size > 0 &&
+        rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true
+      ) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        warnForExtraAttributes(extraAttributeNames);
+      }
     }
   }
 
-  if (hasUncaughtError) {
-    hasUncaughtError = false;
-    var error$1 = firstUncaughtError;
-    firstUncaughtError = null;
-    throw error$1;
-  } // If the passive effects are the result of a discrete render, flush them
-  // synchronously at the end of the current task so that the result is
-  // immediately observable. Otherwise, we assume that they are not
-  // order-dependent and do not need to be observed by external systems, so we
-  // can wait until after paint.
-  // TODO: We can optimize this by not scheduling the callback earlier. Since we
-  // currently schedule the callback in multiple places, will wait until those
-  // are consolidated.
+  switch (tag) {
+    case "input":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper$3(domElement, rawProps, true);
+      break;
 
-  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
-    flushPassiveEffects();
-  } // Read this again, since a passive effect might have updated it
+    case "textarea":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper(domElement);
+      break;
 
-  remainingLanes = root.pendingLanes;
+    case "select":
+    case "option":
+      // For input and textarea we current always set the value property at
+      // post mount to force it to diverge from attributes. However, for
+      // option and select we don't quite do the same thing and select
+      // is not resilient to the DOM state changing so we don't do that here.
+      // TODO: Consider not doing this for input and textarea.
+      break;
 
-  if (includesSyncLane(remainingLanes)) {
-    {
-      markNestedUpdateScheduled();
-    } // Count the number of times the root synchronously re-renders without
-    // finishing. If there are too many, it indicates an infinite update loop.
+    default:
+      if (typeof rawProps.onClick === "function") {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        trapClickOnNonInteractiveElement(domElement);
+      }
 
-    if (root === rootWithNestedUpdates) {
-      nestedUpdateCount++;
-    } else {
-      nestedUpdateCount = 0;
-      rootWithNestedUpdates = root;
+      break;
+  }
+
+  return updatePayload;
+}
+function diffHydratedText(textNode, text, isConcurrentMode) {
+  var isDifferent = textNode.nodeValue !== text;
+  return isDifferent;
+}
+function warnForDeletedHydratableElement(parentNode, child) {
+  {
+    if (didWarnInvalidHydration) {
+      return;
     }
-  } else {
-    nestedUpdateCount = 0;
-  } // If layout work was scheduled, flush it now.
 
-  flushSyncCallbacks();
+    didWarnInvalidHydration = true;
 
+    error(
+      "Did not expect server HTML to contain a <%s> in <%s>.",
+      child.nodeName.toLowerCase(),
+      parentNode.nodeName.toLowerCase()
+    );
+  }
+}
+function warnForDeletedHydratableText(parentNode, child) {
   {
-    if (enableDebugTracing) {
-      logCommitStopped();
+    if (didWarnInvalidHydration) {
+      return;
     }
-  }
 
-  if (enableSchedulingProfiler) {
-    markCommitStopped();
+    didWarnInvalidHydration = true;
+
+    error(
+      'Did not expect server HTML to contain the text node "%s" in <%s>.',
+      child.nodeValue,
+      parentNode.nodeName.toLowerCase()
+    );
   }
+}
+function warnForInsertedHydratedElement(parentNode, tag, props) {
+  {
+    if (didWarnInvalidHydration) {
+      return;
+    }
 
-  if (enableTransitionTracing) {
-    // We process transitions during passive effects. However, passive effects can be
-    // processed synchronously during the commit phase as well as asynchronously after
-    // paint. At the end of the commit phase, we schedule a callback that will be called
-    // after the next paint. If the transitions have already been processed (passive
-    // effect phase happened synchronously), we will schedule a callback to process
-    // the transitions. However, if we don't have any pending transition callbacks, this
-    // means that the transitions have yet to be processed (passive effects processed after paint)
-    // so we will store the end time of paint so that we can process the transitions
-    // and then call the callback via the correct end time.
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    didWarnInvalidHydration = true;
 
-    if (prevRootTransitionCallbacks !== null) {
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+    error(
+      "Expected server HTML to contain a matching <%s> in <%s>.",
+      tag,
+      parentNode.nodeName.toLowerCase()
+    );
+  }
+}
+function warnForInsertedHydratedText(parentNode, text) {
+  {
+    if (text === "") {
+      // We expect to insert empty text nodes since they're not represented in
+      // the HTML.
+      // TODO: Remove this special case if we can just avoid inserting empty
+      // text nodes.
+      return;
+    }
 
-        if (prevPendingTransitionCallbacks !== null) {
-          currentPendingTransitionCallbacks = null;
-          scheduleCallback(IdlePriority, function () {
-            processTransitionCallbacks(
-              prevPendingTransitionCallbacks,
-              endTime,
-              prevRootTransitionCallbacks
-            );
-          });
-        } else {
-          currentEndTime = endTime;
-        }
-      });
+    if (didWarnInvalidHydration) {
+      return;
     }
-  }
 
-  return null;
+    didWarnInvalidHydration = true;
+
+    error(
+      'Expected server HTML to contain a matching text node for "%s" in <%s>.',
+      text,
+      parentNode.nodeName.toLowerCase()
+    );
+  }
 }
+function restoreControlledState(domElement, tag, props) {
+  switch (tag) {
+    case "input":
+      restoreControlledState$3(domElement, props);
+      return;
 
-function makeErrorInfo(digest, componentStack) {
-  {
-    var errorInfo = {
-      componentStack: componentStack,
-      digest: digest
-    };
-    Object.defineProperty(errorInfo, "digest", {
-      configurable: false,
-      enumerable: true,
-      get: function () {
-        error(
-          'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
-            " This property is deprecated and will be removed in a future version of React." +
-            " To access the digest of an Error look for this property on the Error instance itself."
-        );
+    case "textarea":
+      restoreControlledState$1(domElement, props);
+      return;
 
-        return digest;
-      }
-    });
-    return errorInfo;
+    case "select":
+      restoreControlledState$2(domElement, props);
+      return;
   }
 }
 
-function releaseRootPooledCache(root, remainingLanes) {
+// This validation code was written based on the HTML5 parsing spec:
+// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
+//
+// Note: this does not catch all invalid nesting, nor does it try to (as it's
+// not clear what practical benefit doing so provides); instead, we warn only
+// for cases where the parser will give a parse tree differing from what React
+// intended. For example, <b><div></div></b> is invalid but we don't warn
+// because it still parses correctly; we do warn for other cases like nested
+// <p> tags where the beginning of the second element implicitly closes the
+// first, causing a confusing mess.
+// https://html.spec.whatwg.org/multipage/syntax.html#special
+var specialTags = [
+  "address",
+  "applet",
+  "area",
+  "article",
+  "aside",
+  "base",
+  "basefont",
+  "bgsound",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "caption",
+  "center",
+  "col",
+  "colgroup",
+  "dd",
+  "details",
+  "dir",
+  "div",
+  "dl",
+  "dt",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "frame",
+  "frameset",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "iframe",
+  "img",
+  "input",
+  "isindex",
+  "li",
+  "link",
+  "listing",
+  "main",
+  "marquee",
+  "menu",
+  "menuitem",
+  "meta",
+  "nav",
+  "noembed",
+  "noframes",
+  "noscript",
+  "object",
+  "ol",
+  "p",
+  "param",
+  "plaintext",
+  "pre",
+  "script",
+  "section",
+  "select",
+  "source",
+  "style",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr",
+  "track",
+  "ul",
+  "wbr",
+  "xmp"
+]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
+
+var inScopeTags = [
+  "applet",
+  "caption",
+  "html",
+  "table",
+  "td",
+  "th",
+  "marquee",
+  "object",
+  "template", // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
+  // TODO: Distinguish by namespace here -- for <title>, including it here
+  // errs on the side of fewer warnings
+  "foreignObject",
+  "desc",
+  "title"
+]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
+
+var buttonScopeTags = inScopeTags.concat(["button"]); // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
+
+var impliedEndTags = ["dd", "dt", "li", "option", "optgroup", "p", "rp", "rt"];
+var emptyAncestorInfoDev = {
+  current: null,
+  formTag: null,
+  aTagInScope: null,
+  buttonTagInScope: null,
+  nobrTagInScope: null,
+  pTagInButtonScope: null,
+  listItemTagAutoclosing: null,
+  dlItemTagAutoclosing: null,
+  containerTagInScope: null
+};
+
+function updatedAncestorInfoDev(oldInfo, tag) {
   {
-    var pooledCacheLanes = (root.pooledCacheLanes &= remainingLanes);
+    var ancestorInfo = assign({}, oldInfo || emptyAncestorInfoDev);
 
-    if (pooledCacheLanes === NoLanes) {
-      // None of the remaining work relies on the cache pool. Clear it so
-      // subsequent requests get a new cache
-      var pooledCache = root.pooledCache;
+    var info = {
+      tag: tag
+    };
 
-      if (pooledCache != null) {
-        root.pooledCache = null;
-        releaseCache(pooledCache);
-      }
+    if (inScopeTags.indexOf(tag) !== -1) {
+      ancestorInfo.aTagInScope = null;
+      ancestorInfo.buttonTagInScope = null;
+      ancestorInfo.nobrTagInScope = null;
     }
-  }
-}
 
-function flushPassiveEffects() {
-  // Returns whether passive effects were flushed.
-  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
-  // probably just combine the two functions. I believe they were only separate
-  // in the first place because we used to wrap it with
-  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
-  // priority within React itself, so we can mutate the variable directly.
-  if (rootWithPendingPassiveEffects !== null) {
-    // Cache the root since rootWithPendingPassiveEffects is cleared in
-    // flushPassiveEffectsImpl
-    var root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
-    // method can be called from various places, not always from commitRoot
-    // where the remaining lanes are known
+    if (buttonScopeTags.indexOf(tag) !== -1) {
+      ancestorInfo.pTagInButtonScope = null;
+    } // See rules for 'li', 'dd', 'dt' start tags in
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
 
-    var remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = NoLanes;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    var previousPriority = getCurrentUpdatePriority$1();
+    if (
+      specialTags.indexOf(tag) !== -1 &&
+      tag !== "address" &&
+      tag !== "div" &&
+      tag !== "p"
+    ) {
+      ancestorInfo.listItemTagAutoclosing = null;
+      ancestorInfo.dlItemTagAutoclosing = null;
+    }
 
-    try {
-      ReactCurrentBatchConfig.transition = null;
-      setCurrentUpdatePriority(priority);
-      return flushPassiveEffectsImpl();
-    } finally {
-      setCurrentUpdatePriority(previousPriority);
-      ReactCurrentBatchConfig.transition = prevTransition; // Once passive effects have run for the tree - giving components a
-      // chance to retain cache instances they use - release the pooled
-      // cache at the root (if there is one)
+    ancestorInfo.current = info;
 
-      releaseRootPooledCache(root, remainingLanes);
+    if (tag === "form") {
+      ancestorInfo.formTag = info;
     }
-  }
-
-  return false;
-}
-function enqueuePendingPassiveProfilerEffect(fiber) {
-  {
-    pendingPassiveProfilerEffects.push(fiber);
 
-    if (!rootDoesHavePassiveEffects) {
-      rootDoesHavePassiveEffects = true;
-      scheduleCallback(NormalPriority$1, function () {
-        flushPassiveEffects();
-        return null;
-      });
+    if (tag === "a") {
+      ancestorInfo.aTagInScope = info;
     }
-  }
-}
 
-function flushPassiveEffectsImpl() {
-  if (rootWithPendingPassiveEffects === null) {
-    return false;
-  } // Cache and clear the transitions flag
+    if (tag === "button") {
+      ancestorInfo.buttonTagInScope = info;
+    }
 
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects;
-  var lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
-  // Figure out why and fix it. It's not causing any known issues (probably
-  // because it's only used for profiling), but it's a refactor hazard.
+    if (tag === "nobr") {
+      ancestorInfo.nobrTagInScope = info;
+    }
 
-  pendingPassiveEffectsLanes = NoLanes;
+    if (tag === "p") {
+      ancestorInfo.pTagInButtonScope = info;
+    }
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Cannot flush passive effects while already rendering.");
-  }
+    if (tag === "li") {
+      ancestorInfo.listItemTagAutoclosing = info;
+    }
 
-  {
-    isFlushingPassiveEffects = true;
-    didScheduleUpdateDuringPassiveEffects = false;
+    if (tag === "dd" || tag === "dt") {
+      ancestorInfo.dlItemTagAutoclosing = info;
+    }
 
-    if (enableDebugTracing) {
-      logPassiveEffectsStarted(lanes);
+    if (tag === "#document" || tag === "html") {
+      ancestorInfo.containerTagInScope = null;
+    } else if (!ancestorInfo.containerTagInScope) {
+      ancestorInfo.containerTagInScope = info;
     }
-  }
 
-  if (enableSchedulingProfiler) {
-    markPassiveEffectsStarted(lanes);
+    return ancestorInfo;
   }
+}
+/**
+ * Returns whether
+ */
+
+function isTagValidWithParent(tag, parentTag) {
+  // First, let's check if we're in an unusual parsing mode...
+  switch (parentTag) {
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
+    case "select":
+      return tag === "option" || tag === "optgroup" || tag === "#text";
 
-  var prevExecutionContext = executionContext;
-  executionContext |= CommitContext;
-  commitPassiveUnmountEffects(root.current);
-  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+    case "optgroup":
+      return tag === "option" || tag === "#text";
+    // Strictly speaking, seeing an <option> doesn't mean we're in a <select>
+    // but
 
-  {
-    var profilerEffects = pendingPassiveProfilerEffects;
-    pendingPassiveProfilerEffects = [];
+    case "option":
+      return tag === "#text";
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
+    // No special behavior since these rules fall back to "in body" mode for
+    // all except special table nodes which cause bad parsing behavior anyway.
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
 
-    for (var i = 0; i < profilerEffects.length; i++) {
-      var fiber = profilerEffects[i];
-      commitPassiveEffectDurations(root, fiber);
-    }
-  }
+    case "tr":
+      return (
+        tag === "th" ||
+        tag === "td" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
+      );
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
 
-  {
-    if (enableDebugTracing) {
-      logPassiveEffectsStopped();
-    }
-  }
+    case "tbody":
+    case "thead":
+    case "tfoot":
+      return (
+        tag === "tr" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
+      );
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
 
-  if (enableSchedulingProfiler) {
-    markPassiveEffectsStopped();
-  }
+    case "colgroup":
+      return tag === "col" || tag === "template";
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
 
-  {
-    commitDoubleInvokeEffectsInDEV(root, true);
-  }
+    case "table":
+      return (
+        tag === "caption" ||
+        tag === "colgroup" ||
+        tag === "tbody" ||
+        tag === "tfoot" ||
+        tag === "thead" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
+      );
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
 
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
+    case "head":
+      return (
+        tag === "base" ||
+        tag === "basefont" ||
+        tag === "bgsound" ||
+        tag === "link" ||
+        tag === "meta" ||
+        tag === "title" ||
+        tag === "noscript" ||
+        tag === "noframes" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
+      );
+    // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
 
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    var prevEndTime = currentEndTime;
+    case "html":
+      return tag === "head" || tag === "body" || tag === "frameset";
 
-    if (
-      prevPendingTransitionCallbacks !== null &&
-      prevRootTransitionCallbacks !== null &&
-      prevEndTime !== null
-    ) {
-      currentPendingTransitionCallbacks = null;
-      currentEndTime = null;
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
-        );
-      });
-    }
-  }
+    case "frameset":
+      return tag === "frame";
 
-  {
-    // If additional passive effects were scheduled, increment a counter. If this
-    // exceeds the limit, we'll fire a warning.
-    if (didScheduleUpdateDuringPassiveEffects) {
-      if (root === rootWithPassiveNestedUpdates) {
-        nestedPassiveUpdateCount++;
-      } else {
-        nestedPassiveUpdateCount = 0;
-        rootWithPassiveNestedUpdates = root;
-      }
-    } else {
-      nestedPassiveUpdateCount = 0;
-    }
+    case "#document":
+      return tag === "html";
+  } // Probably in the "in body" parsing mode, so we outlaw only tag combos
+  // where the parsing rules cause implicit opens or closes to be added.
+  // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
 
-    isFlushingPassiveEffects = false;
-    didScheduleUpdateDuringPassiveEffects = false;
-  } // TODO: Move to commitPassiveMountEffects
+  switch (tag) {
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return (
+        parentTag !== "h1" &&
+        parentTag !== "h2" &&
+        parentTag !== "h3" &&
+        parentTag !== "h4" &&
+        parentTag !== "h5" &&
+        parentTag !== "h6"
+      );
 
-  onPostCommitRoot(root);
+    case "rp":
+    case "rt":
+      return impliedEndTags.indexOf(parentTag) === -1;
 
-  {
-    var stateNode = root.current.stateNode;
-    stateNode.effectDuration = 0;
-    stateNode.passiveEffectDuration = 0;
+    case "body":
+    case "caption":
+    case "col":
+    case "colgroup":
+    case "frameset":
+    case "frame":
+    case "head":
+    case "html":
+    case "tbody":
+    case "td":
+    case "tfoot":
+    case "th":
+    case "thead":
+    case "tr":
+      // These tags are only valid with a few parents that have special child
+      // parsing rules -- if we're down here, then none of those matched and
+      // so we allow it only if we don't know what the parent is, as all other
+      // cases are invalid.
+      return parentTag == null;
   }
 
   return true;
 }
+/**
+ * Returns whether
+ */
 
-function isAlreadyFailedLegacyErrorBoundary(instance) {
-  return (
-    legacyErrorBoundariesThatAlreadyFailed !== null &&
-    legacyErrorBoundariesThatAlreadyFailed.has(instance)
-  );
-}
-function markLegacyErrorBoundaryAsFailed(instance) {
-  if (legacyErrorBoundariesThatAlreadyFailed === null) {
-    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
-  } else {
-    legacyErrorBoundariesThatAlreadyFailed.add(instance);
-  }
-}
+function findInvalidAncestorForTag(tag, ancestorInfo) {
+  switch (tag) {
+    case "address":
+    case "article":
+    case "aside":
+    case "blockquote":
+    case "center":
+    case "details":
+    case "dialog":
+    case "dir":
+    case "div":
+    case "dl":
+    case "fieldset":
+    case "figcaption":
+    case "figure":
+    case "footer":
+    case "header":
+    case "hgroup":
+    case "main":
+    case "menu":
+    case "nav":
+    case "ol":
+    case "p":
+    case "section":
+    case "summary":
+    case "ul":
+    case "pre":
+    case "listing":
+    case "table":
+    case "hr":
+    case "xmp":
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return ancestorInfo.pTagInButtonScope;
 
-function prepareToThrowUncaughtError(error) {
-  if (!hasUncaughtError) {
-    hasUncaughtError = true;
-    firstUncaughtError = error;
-  }
-}
+    case "form":
+      return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
 
-var onUncaughtError = prepareToThrowUncaughtError;
+    case "li":
+      return ancestorInfo.listItemTagAutoclosing;
 
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  var errorInfo = createCapturedValueAtFiber(error, sourceFiber);
-  var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
-  var root = enqueueUpdate(rootFiber, update, SyncLane);
-  var eventTime = requestEventTime();
+    case "dd":
+    case "dt":
+      return ancestorInfo.dlItemTagAutoclosing;
 
-  if (root !== null) {
-    markRootUpdated(root, SyncLane, eventTime);
-    ensureRootIsScheduled(root, eventTime);
-  }
-}
+    case "button":
+      return ancestorInfo.buttonTagInScope;
 
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
-  {
-    reportUncaughtErrorInDEV(error$1);
-    setIsRunningInsertionEffect(false);
-  }
+    case "a":
+      // Spec says something about storing a list of markers, but it sounds
+      // equivalent to this check.
+      return ancestorInfo.aTagInScope;
 
-  if (sourceFiber.tag === HostRoot) {
-    // Error was thrown at the root. There is no parent, so the root
-    // itself should capture it.
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error$1);
-    return;
+    case "nobr":
+      return ancestorInfo.nobrTagInScope;
   }
 
-  var fiber = null;
+  return null;
+}
 
-  if (skipUnmountedBoundaries) {
-    fiber = nearestMountedAncestor;
-  } else {
-    fiber = sourceFiber.return;
-  }
+var didWarn = {};
 
-  while (fiber !== null) {
-    if (fiber.tag === HostRoot) {
-      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error$1);
-      return;
-    } else if (fiber.tag === ClassComponent) {
-      var ctor = fiber.type;
-      var instance = fiber.stateNode;
+function validateDOMNesting(childTag, childText, ancestorInfo) {
+  {
+    ancestorInfo = ancestorInfo || emptyAncestorInfoDev;
+    var parentInfo = ancestorInfo.current;
+    var parentTag = parentInfo && parentInfo.tag;
 
-      if (
-        typeof ctor.getDerivedStateFromError === "function" ||
-        (typeof instance.componentDidCatch === "function" &&
-          !isAlreadyFailedLegacyErrorBoundary(instance))
-      ) {
-        var errorInfo = createCapturedValueAtFiber(error$1, sourceFiber);
-        var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
-        var root = enqueueUpdate(fiber, update, SyncLane);
-        var eventTime = requestEventTime();
+    if (childText != null) {
+      if (childTag != null) {
+        error(
+          "validateDOMNesting: when childText is passed, childTag should be null"
+        );
+      }
 
-        if (root !== null) {
-          markRootUpdated(root, SyncLane, eventTime);
-          ensureRootIsScheduled(root, eventTime);
-        }
+      childTag = "#text";
+    } else if (childTag == null) {
+      error("validateDOMNesting: when childText or childTag must be provided");
 
-        return;
-      }
+      return;
     }
 
-    fiber = fiber.return;
-  }
+    var invalidParent = isTagValidWithParent(childTag, parentTag)
+      ? null
+      : parentInfo;
+    var invalidAncestor = invalidParent
+      ? null
+      : findInvalidAncestorForTag(childTag, ancestorInfo);
+    var invalidParentOrAncestor = invalidParent || invalidAncestor;
 
-  {
-    // TODO: Until we re-land skipUnmountedBoundaries (see #20147), this warning
-    // will fire for errors that are thrown by destroy functions inside deleted
-    // trees. What it should instead do is propagate the error to the parent of
-    // the deleted tree. In the meantime, do not add this warning to the
-    // allowlist; this is only for our internal use.
-    error(
-      "Internal React error: Attempted to capture a commit phase error " +
-        "inside a detached tree. This indicates a bug in React. Likely " +
-        "causes include deleting the same fiber more than once, committing an " +
-        "already-finished tree, or an inconsistent return pointer.\n\n" +
-        "Error message:\n\n%s",
-      error$1
-    );
-  }
-}
-function attachPingListener(root, wakeable, lanes) {
-  // Attach a ping listener
-  //
-  // The data might resolve before we have a chance to commit the fallback. Or,
-  // in the case of a refresh, we'll never commit a fallback. So we need to
-  // attach a listener now. When it resolves ("pings"), we can decide whether to
-  // try rendering the tree again.
-  //
-  // Only attach a listener if one does not already exist for the lanes
-  // we're currently rendering (which acts like a "thread ID" here).
-  //
-  // We only need to do this in concurrent mode. Legacy Suspense always
-  // commits fallbacks synchronously, so there are no pings.
-  var pingCache = root.pingCache;
-  var threadIDs;
+    if (!invalidParentOrAncestor) {
+      return;
+    }
 
-  if (pingCache === null) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else {
-    threadIDs = pingCache.get(wakeable);
+    var ancestorTag = invalidParentOrAncestor.tag;
+    var warnKey = String(!!invalidParent) + "|" + childTag + "|" + ancestorTag; // eslint-disable-next-line react-internal/safe-string-coercion
 
-    if (threadIDs === undefined) {
-      threadIDs = new Set();
-      pingCache.set(wakeable, threadIDs);
+    if (didWarn[warnKey]) {
+      return;
     }
-  }
-
-  if (!threadIDs.has(lanes)) {
-    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
 
-    threadIDs.add(lanes);
-    var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
+    didWarn[warnKey] = true;
+    var tagDisplayName = childTag;
+    var whitespaceInfo = "";
 
-    {
-      if (isDevToolsPresent) {
-        // If we have pending work still, restore the original updaters
-        restorePendingUpdaters(root, lanes);
+    if (childTag === "#text") {
+      if (childText != null && /\S/.test(childText)) {
+        tagDisplayName = "Text nodes";
+      } else {
+        tagDisplayName = "Whitespace text nodes";
+        whitespaceInfo =
+          " Make sure you don't have any extra whitespace between tags on " +
+          "each line of your source code.";
       }
+    } else {
+      tagDisplayName = "<" + childTag + ">";
     }
 
-    wakeable.then(ping, ping);
-  }
-}
-
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
-
-  if (pingCache !== null) {
-    // The wakeable resolved, so we no longer need to memoize, because it will
-    // never be thrown again.
-    pingCache.delete(wakeable);
-  }
-
-  var eventTime = requestEventTime();
-  markRootPinged(root, pingedLanes);
-  warnIfSuspenseResolutionNotWrappedWithActDEV(root);
+    if (invalidParent) {
+      var info = "";
 
-  if (
-    workInProgressRoot === root &&
-    isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)
-  ) {
-    // Received a ping at the same priority level at which we're currently
-    // rendering. We might want to restart this render. This should mirror
-    // the logic of whether or not a root suspends once it completes.
-    // TODO: If we're rendering sync either due to Sync, Batched or expired,
-    // we should probably never restart.
-    // If we're suspended with delay, or if it's a retry, we'll always suspend
-    // so we can always restart.
-    if (
-      workInProgressRootExitStatus === RootSuspendedWithDelay ||
-      (workInProgressRootExitStatus === RootSuspended &&
-        includesOnlyRetries(workInProgressRootRenderLanes) &&
-        now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
-    ) {
-      // Force a restart from the root by unwinding the stack. Unless this is
-      // being called from the render phase, because that would cause a crash.
-      if ((executionContext & RenderContext) === NoContext) {
-        prepareFreshStack(root, NoLanes);
+      if (ancestorTag === "table" && childTag === "tr") {
+        info +=
+          " Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by " +
+          "the browser.";
       }
+
+      error(
+        "validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s",
+        tagDisplayName,
+        ancestorTag,
+        whitespaceInfo,
+        info
+      );
     } else {
-      // Even though we can't restart right now, we might get an
-      // opportunity later. So we mark this render as having a ping.
-      workInProgressRootPingedLanes = mergeLanes(
-        workInProgressRootPingedLanes,
-        pingedLanes
+      error(
+        "validateDOMNesting(...): %s cannot appear as a descendant of " +
+          "<%s>.",
+        tagDisplayName,
+        ancestorTag
       );
     }
   }
-
-  ensureRootIsScheduled(root, eventTime);
 }
 
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  // The boundary fiber (a Suspense component or SuspenseList component)
-  // previously was rendered in its fallback state. One of the promises that
-  // suspended it has resolved, which means at least part of the tree was
-  // likely unblocked. Try rendering again, at a new lanes.
-  if (retryLane === NoLane) {
-    // TODO: Assign this to `suspenseState.retryLane`? to avoid
-    // unnecessary entanglement?
-    retryLane = requestRetryLane(boundaryFiber);
-  } // TODO: Special case idle priority?
-
-  var eventTime = requestEventTime();
-  var root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
-
-  if (root !== null) {
-    markRootUpdated(root, retryLane, eventTime);
-    ensureRootIsScheduled(root, eventTime);
-  }
-}
+function validateLinkPropsForStyleResource(props) {
+  {
+    // This should only be called when we know we are opting into Resource semantics (i.e. precedence is not null)
+    var href = props.href,
+      onLoad = props.onLoad,
+      onError = props.onError,
+      disabled = props.disabled;
+    var includedProps = [];
+    if (onLoad) includedProps.push("`onLoad`");
+    if (onError) includedProps.push("`onError`");
+    if (disabled != null) includedProps.push("`disabled`");
+    var includedPropsPhrase = propNamesListJoin(includedProps, "and");
+    includedPropsPhrase += includedProps.length === 1 ? " prop" : " props";
+    var withArticlePhrase =
+      includedProps.length === 1
+        ? "an " + includedPropsPhrase
+        : "the " + includedPropsPhrase;
 
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState;
-  var retryLane = NoLane;
+    if (includedProps.length) {
+      error(
+        'React encountered a <link rel="stylesheet" href="%s" ... /> with a `precedence` prop that' +
+          " also included %s. The presence of loading and error handlers indicates an intent to manage" +
+          " the stylesheet loading state from your from your Component code and React will not hoist or" +
+          " deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet" +
+          " using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.",
+        href,
+        withArticlePhrase,
+        includedPropsPhrase
+      );
 
-  if (suspenseState !== null) {
-    retryLane = suspenseState.retryLane;
+      return true;
+    }
   }
 
-  retryTimedOutBoundary(boundaryFiber, retryLane);
+  return false;
 }
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = NoLane; // Default
 
-  var retryCache;
+function propNamesListJoin(list, combinator) {
+  switch (list.length) {
+    case 0:
+      return "";
 
-  switch (boundaryFiber.tag) {
-    case SuspenseComponent:
-      retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
+    case 1:
+      return list[0];
 
-      if (suspenseState !== null) {
-        retryLane = suspenseState.retryLane;
-      }
+    case 2:
+      return list[0] + " " + combinator + " " + list[1];
 
-      break;
+    default:
+      return (
+        list.slice(0, -1).join(", ") +
+        ", " +
+        combinator +
+        " " +
+        list[list.length - 1]
+      );
+  }
+}
 
-    case SuspenseListComponent:
-      retryCache = boundaryFiber.stateNode;
-      break;
+function validatePreloadArguments(href, options) {
+  {
+    if (!href || typeof href !== "string") {
+      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
 
-    case OffscreenComponent: {
-      var instance = boundaryFiber.stateNode;
-      retryCache = instance._retryCache;
-      break;
-    }
+      error(
+        "ReactDOM.preload() expected the first argument to be a string representing an href but found %s instead.",
+        typeOfArg
+      );
+    } else if (typeof options !== "object" || options === null) {
+      var _typeOfArg = getValueDescriptorExpectingObjectForWarning(options);
 
-    default:
-      throw new Error(
-        "Pinged unknown suspense boundary type. " +
-          "This is probably a bug in React."
+      error(
+        'ReactDOM.preload() expected the second argument to be an options argument containing at least an "as" property' +
+          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
+        _typeOfArg,
+        href
       );
-  }
+    } else {
+      var as = options.as;
 
-  if (retryCache !== null) {
-    // The wakeable resolved, so we no longer need to memoize, because it will
-    // never be thrown again.
-    retryCache.delete(wakeable);
-  }
+      switch (as) {
+        // Font specific validation of options
+        case "font": {
+          if (options.crossOrigin === "use-credentials") {
+            error(
+              'ReactDOM.preload() was called with an "as" type of "font" and with a "crossOrigin" option of "use-credentials".' +
+                ' Fonts preloading must use crossOrigin "anonymous" to be functional. Please update your font preload to omit' +
+                ' the crossOrigin option or change it to any other value than "use-credentials" (Browsers default all other values' +
+                ' to anonymous mode). The href for the preload call where this warning originated is "%s"',
+              href
+            );
+          }
 
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-} // Computes the next Just Noticeable Difference (JND) boundary.
-// The theory is that a person can't tell the difference between small differences in time.
-// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
-// difference in the experience. However, waiting for longer might mean that we can avoid
-// showing an intermediate loading state. The longer we have already waited, the harder it
-// is to tell small differences in time. Therefore, the longer we've already waited,
-// the longer we can wait additionally. At some point we have to give up though.
-// We pick a train model where the next boundary commits at a consistent schedule.
-// These particular numbers are vague estimates. We expect to adjust them based on research.
+          break;
+        }
 
-function jnd(timeElapsed) {
-  return timeElapsed < 120
-    ? 120
-    : timeElapsed < 480
-    ? 480
-    : timeElapsed < 1080
-    ? 1080
-    : timeElapsed < 1920
-    ? 1920
-    : timeElapsed < 3000
-    ? 3000
-    : timeElapsed < 4320
-    ? 4320
-    : ceil(timeElapsed / 1960) * 1960;
-}
+        case "script":
+        case "style": {
+          break;
+        }
+        // We have an invalid as type and need to warn
 
-function throwIfInfiniteUpdateLoopDetected() {
-  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
-    nestedUpdateCount = 0;
-    nestedPassiveUpdateCount = 0;
-    rootWithNestedUpdates = null;
-    rootWithPassiveNestedUpdates = null;
-    throw new Error(
-      "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."
-    );
-  }
+        default: {
+          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
 
+          error(
+            'ReactDOM.preload() expected a valid "as" type in the options (second) argument but found %s instead.' +
+              " Please use one of the following valid values instead: %s. The href for the preload call where this" +
+              ' warning originated is "%s".',
+            typeOfAs,
+            '"style", "font", or "script"',
+            href
+          );
+        }
+      }
+    }
+  }
+}
+function validatePreinitArguments(href, options) {
   {
-    if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
-      nestedPassiveUpdateCount = 0;
-      rootWithPassiveNestedUpdates = null;
+    if (!href || typeof href !== "string") {
+      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
 
       error(
-        "Maximum update depth exceeded. This can happen when a component " +
-          "calls setState inside useEffect, but useEffect either doesn't " +
-          "have a dependency array, or one of the dependencies changes on " +
-          "every render."
+        "ReactDOM.preinit() expected the first argument to be a string representing an href but found %s instead.",
+        typeOfArg
       );
-    }
-  }
-}
+    } else if (typeof options !== "object" || options === null) {
+      var _typeOfArg2 = getValueDescriptorExpectingObjectForWarning(options);
 
-function flushRenderPhaseStrictModeWarningsInDEV() {
-  {
-    ReactStrictModeWarnings.flushLegacyContextWarning();
-    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
-  }
-}
+      error(
+        'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
+          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
+        _typeOfArg2,
+        href
+      );
+    } else {
+      var as = options.as;
 
-function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
-  {
-    {
-      legacyCommitDoubleInvokeEffectsInDEV(root.current, hasPassiveEffects);
+      switch (as) {
+        case "style":
+        case "script": {
+          break;
+        }
+        // We have an invalid as type and need to warn
+
+        default: {
+          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
+
+          error(
+            'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
+              ' specifying the Resource type. It found %s instead. Currently, valid resource types for for preinit are "style"' +
+              ' and "script". The href for the preinit call where this warning originated is "%s".',
+            typeOfAs,
+            href
+          );
+        }
+      }
     }
   }
 }
+function getValueDescriptorExpectingObjectForWarning(thing) {
+  return thing === null
+    ? "`null`"
+    : thing === undefined
+    ? "`undefined`"
+    : thing === ""
+    ? "an empty string"
+    : 'something with type "' + typeof thing + '"';
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+  return thing === null
+    ? "`null`"
+    : thing === undefined
+    ? "`undefined`"
+    : thing === ""
+    ? "an empty string"
+    : typeof thing === "string"
+    ? JSON.stringify(thing)
+    : 'something with type "' + typeof thing + '"';
+}
 
-function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
-  // TODO (StrictEffects) Should we set a marker on the root if it contains strict effects
-  // so we don't traverse unnecessarily? similar to subtreeFlags but just at the root level.
-  // Maybe not a big deal since this is DEV only behavior.
-  setCurrentFiber(fiber);
-  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectUnmountInDEV);
+var Dispatcher$1 = Internals.Dispatcher;
+// In the future this may need to change, especially when modules / scripts are supported
+// It is valid to preload even when we aren't actively rendering. For cases where Float functions are
+// called when there is no rendering we track the last used document. It is not safe to insert
+// arbitrary resources into the lastCurrentDocument b/c it may not actually be the document
+// that the resource is meant to apply too (for example stylesheets or scripts). This is only
+// appropriate for resources that don't really have a strict tie to the document itself for example
+// preloads
 
-  if (hasPassiveEffects) {
-    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectUnmountInDEV);
-  }
+var lastCurrentDocument = null;
+var previousDispatcher = null;
+function prepareToRenderResources(rootContainer) {
+  var rootNode = getHoistableRoot(rootContainer);
+  lastCurrentDocument = getDocumentFromRoot(rootNode);
+  previousDispatcher = Dispatcher$1.current;
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+}
+function cleanupAfterRenderResources() {
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+}
+function prepareToCommitHoistables() {
+  tagCaches = null;
+} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
+// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
+// from Internals -> ReactDOM -> FloatClient -> Internals so this doesn't introduce a new one.
 
-  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectMountInDEV);
+var ReactDOMClientDispatcher = {
+  prefetchDNS: prefetchDNS$1,
+  preconnect: preconnect$1,
+  preload: preload$1,
+  preinit: preinit$1
+}; // global collections of Resources
 
-  if (hasPassiveEffects) {
-    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectMountInDEV);
-  }
+var preloadPropsMap = new Map();
+var preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
 
-  resetCurrentFiber();
+function getHoistableRoot(container) {
+  // $FlowFixMe[method-unbinding]
+  return typeof container.getRootNode === "function"
+    ? /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
+       * but it's either a `Document` or `ShadowRoot`. */
+      container.getRootNode()
+    : container.ownerDocument;
 }
 
-function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
-  var current = firstChild;
-  var subtreeRoot = null;
-
-  while (current != null) {
-    var primarySubtreeFlag = current.subtreeFlags & fiberFlags;
+function getCurrentResourceRoot() {
+  var currentContainer = getCurrentRootHostContainer();
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+} // Preloads are somewhat special. Even if we don't have the Document
+// used by the root that is rendering a component trying to insert a preload
+// we can still seed the file cache by doing the preload on any document we have
+// access to. We prefer the currentDocument if it exists, we also prefer the
+// lastCurrentDocument if that exists. As a fallback we will use the window.document
+// if available.
 
-    if (
-      current !== subtreeRoot &&
-      current.child != null &&
-      primarySubtreeFlag !== NoFlags$1
-    ) {
-      current = current.child;
-    } else {
-      if ((current.flags & fiberFlags) !== NoFlags$1) {
-        invokeEffectFn(current);
-      }
+function getDocumentForPreloads() {
+  var root = getCurrentResourceRoot();
 
-      if (current.sibling !== null) {
-        current = current.sibling;
-      } else {
-        current = subtreeRoot = current.return;
-      }
+  if (root) {
+    return root.ownerDocument || root;
+  } else {
+    try {
+      return lastCurrentDocument || window.document;
+    } catch (error) {
+      return null;
     }
   }
 }
 
-var didWarnStateUpdateForNotYetMountedComponent = null;
-function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
-  {
-    if ((executionContext & RenderContext) !== NoContext) {
-      // We let the other warning about render phase updates deal with this one.
-      return;
-    }
-
-    if (!(fiber.mode & ConcurrentMode)) {
-      return;
-    }
-
-    var tag = fiber.tag;
-
-    if (
-      tag !== IndeterminateComponent &&
-      tag !== HostRoot &&
-      tag !== ClassComponent &&
-      tag !== FunctionComponent &&
-      tag !== ForwardRef &&
-      tag !== MemoComponent &&
-      tag !== SimpleMemoComponent
-    ) {
-      // Only warn for user-defined components, not internal ones like Suspense.
-      return;
-    } // We show the whole stack but dedupe on the top component's name because
-    // the problematic code almost always lies inside that component.
+function getDocumentFromRoot(root) {
+  return root.ownerDocument || root;
+}
 
-    var componentName = getComponentNameFromFiber(fiber) || "ReactComponent";
+function preconnectAs(rel, crossOrigin, href) {
+  var ownerDocument = getDocumentForPreloads();
 
-    if (didWarnStateUpdateForNotYetMountedComponent !== null) {
-      if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
-        return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+  if (typeof href === "string" && href && ownerDocument) {
+    var limitedEscapedHref =
+      escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    var key = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
 
-      didWarnStateUpdateForNotYetMountedComponent.add(componentName);
-    } else {
-      didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
+    if (typeof crossOrigin === "string") {
+      key += '[crossorigin="' + crossOrigin + '"]';
     }
 
-    var previousFiber = current;
+    if (!preconnectsSet.has(key)) {
+      preconnectsSet.add(key);
+      var preconnectProps = {
+        rel: rel,
+        crossOrigin: crossOrigin,
+        href: href
+      };
 
-    try {
-      setCurrentFiber(fiber);
+      if (null === ownerDocument.querySelector(key)) {
+        var preloadInstance = ownerDocument.createElement("link");
+        setInitialProperties(preloadInstance, "link", preconnectProps);
+        markNodeAsHoistable(preloadInstance);
+        ownerDocument.head.appendChild(preloadInstance);
+      }
+    }
+  }
+} // --------------------------------------
+//      ReactDOM.prefetchDNS
+// --------------------------------------
 
+function prefetchDNS$1(href, options) {
+  {
+    if (typeof href !== "string" || !href) {
       error(
-        "Can't perform a React state update on a component that hasn't mounted yet. " +
-          "This indicates that you have a side-effect in your render function that " +
-          "asynchronously later calls tries to update the component. Move this work to " +
-          "useEffect instead."
+        "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        getValueDescriptorExpectingObjectForWarning(href)
       );
-    } finally {
-      if (previousFiber) {
-        setCurrentFiber(fiber);
+    } else if (options != null) {
+      if (
+        typeof options === "object" &&
+        hasOwnProperty.call(options, "crossOrigin")
+      ) {
+        error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        );
       } else {
-        resetCurrentFiber();
+        error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        );
       }
     }
   }
-}
-var beginWork;
 
-if (replayFailedUnitOfWorkWithInvokeGuardedCallback) {
-  var dummyFiber = null;
-
-  beginWork = function (current, unitOfWork, lanes) {
-    // If a component throws an error, we replay it again in a synchronously
-    // dispatched event, so that the debugger will treat it as an uncaught
-    // error See ReactErrorUtils for more information.
-    // Before entering the begin phase, copy the work-in-progress onto a dummy
-    // fiber. If beginWork throws, we'll use this to reset the state.
-    var originalWorkInProgressCopy = assignFiberPropertiesInDEV(
-      dummyFiber,
-      unitOfWork
-    );
-
-    try {
-      return beginWork$1(current, unitOfWork, lanes);
-    } catch (originalError) {
-      if (
-        didSuspendOrErrorWhileHydratingDEV() ||
-        originalError === SuspenseException ||
-        originalError === SelectiveHydrationException ||
-        (originalError !== null &&
-          typeof originalError === "object" &&
-          typeof originalError.then === "function")
-      ) {
-        // Don't replay promises.
-        // Don't replay errors if we are hydrating and have already suspended or handled an error
-        throw originalError;
-      } // Don't reset current debug fiber, since we're about to work on the
-      // same fiber again.
-      // Unwind the failed stack frame
+  preconnectAs("dns-prefetch", null, href);
+} // --------------------------------------
+//      ReactDOM.preconnect
+// --------------------------------------
 
-      resetSuspendedWorkLoopOnUnwind();
-      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
+function preconnect$1(href, options) {
+  {
+    if (typeof href !== "string" || !href) {
+      error(
+        "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        getValueDescriptorExpectingObjectForWarning(href)
+      );
+    } else if (options != null && typeof options !== "object") {
+      error(
+        "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
+        getValueDescriptorExpectingEnumForWarning(options)
+      );
+    } else if (options != null && typeof options.crossOrigin !== "string") {
+      error(
+        "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
+        getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
+      );
+    }
+  }
 
-      assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
+  var crossOrigin =
+    options == null || typeof options.crossOrigin !== "string"
+      ? null
+      : options.crossOrigin === "use-credentials"
+      ? "use-credentials"
+      : "";
+  preconnectAs("preconnect", crossOrigin, href);
+} // --------------------------------------
+//      ReactDOM.preload
+// --------------------------------------
 
-      if (unitOfWork.mode & ProfileMode) {
-        // Reset the profiler timer.
-        startProfilerTimer(unitOfWork);
-      } // Run beginWork again.
+function preload$1(href, options) {
+  {
+    validatePreloadArguments(href, options);
+  }
 
-      invokeGuardedCallback(
-        null,
-        beginWork$1,
-        null,
-        current,
-        unitOfWork,
-        lanes
-      );
+  var ownerDocument = getDocumentForPreloads();
 
-      if (hasCaughtError()) {
-        var replayError = clearCaughtError();
+  if (
+    typeof href === "string" &&
+    href &&
+    typeof options === "object" &&
+    options !== null &&
+    ownerDocument
+  ) {
+    var as = options.as;
+    var limitedEscapedHref =
+      escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    var preloadKey =
+      'link[rel="preload"][as="' + as + '"][href="' + limitedEscapedHref + '"]';
+    var key = preloadKey;
 
-        if (
-          typeof replayError === "object" &&
-          replayError !== null &&
-          replayError._suppressLogging &&
-          typeof originalError === "object" &&
-          originalError !== null &&
-          !originalError._suppressLogging
-        ) {
-          // If suppressed, let the flag carry over to the original error which is the one we'll rethrow.
-          originalError._suppressLogging = true;
-        }
-      } // We always throw the original error in case the second render pass is not idempotent.
-      // This can happen if a memoized function or CommonJS module doesn't throw after first invocation.
+    switch (as) {
+      case "style":
+        key = getStyleKey(href);
+        break;
 
-      throw originalError;
+      case "script":
+        key = getScriptKey(href);
+        break;
     }
-  };
-} else {
-  beginWork = beginWork$1;
-}
 
-var didWarnAboutUpdateInRender = false;
-var didWarnAboutUpdateInRenderForAnotherComponent;
+    if (!preloadPropsMap.has(key)) {
+      var preloadProps = preloadPropsFromPreloadOptions(href, as, options);
+      preloadPropsMap.set(key, preloadProps);
 
-{
-  didWarnAboutUpdateInRenderForAnotherComponent = new Set();
+      if (null === ownerDocument.querySelector(preloadKey)) {
+        var preloadInstance = ownerDocument.createElement("link");
+        setInitialProperties(preloadInstance, "link", preloadProps);
+        markNodeAsHoistable(preloadInstance);
+        ownerDocument.head.appendChild(preloadInstance);
+      }
+    }
+  }
 }
 
-function warnAboutRenderPhaseUpdatesInDEV(fiber) {
+function preloadPropsFromPreloadOptions(href, as, options) {
+  return {
+    href: href,
+    rel: "preload",
+    as: as,
+    crossOrigin: as === "font" ? "" : options.crossOrigin,
+    integrity: options.integrity,
+    type: options.type
+  };
+} // --------------------------------------
+//      ReactDOM.preinit
+// --------------------------------------
+
+function preinit$1(href, options) {
   {
-    if (isRendering) {
-      switch (fiber.tag) {
-        case FunctionComponent:
-        case ForwardRef:
-        case SimpleMemoComponent: {
-          var renderingComponentName =
-            (workInProgress && getComponentNameFromFiber(workInProgress)) ||
-            "Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
+    validatePreinitArguments(href, options);
+  }
 
-          var dedupeKey = renderingComponentName;
+  if (
+    typeof href === "string" &&
+    href &&
+    typeof options === "object" &&
+    options !== null
+  ) {
+    var resourceRoot = getCurrentResourceRoot();
+    var as = options.as;
 
-          if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
-            didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
-            var setStateComponentName =
-              getComponentNameFromFiber(fiber) || "Unknown";
+    if (!resourceRoot) {
+      if (as === "style" || as === "script") {
+        // We are going to emit a preload as a best effort fallback since this preinit
+        // was called outside of a render. Given the passive nature of this fallback
+        // we do not warn in dev when props disagree if there happens to already be a
+        // matching preload with this href
+        var preloadDocument = getDocumentForPreloads();
 
-            error(
-              "Cannot update a component (`%s`) while rendering a " +
-                "different component (`%s`). To locate the bad setState() call inside `%s`, " +
-                "follow the stack trace as described in https://reactjs.org/link/setstate-in-render",
-              setStateComponentName,
-              renderingComponentName,
-              renderingComponentName
-            );
-          }
+        if (preloadDocument) {
+          var limitedEscapedHref =
+            escapeSelectorAttributeValueInsideDoubleQuotes(href);
+          var preloadKey =
+            'link[rel="preload"][as="' +
+            as +
+            '"][href="' +
+            limitedEscapedHref +
+            '"]';
+          var key = preloadKey;
 
-          break;
-        }
+          switch (as) {
+            case "style":
+              key = getStyleKey(href);
+              break;
 
-        case ClassComponent: {
-          if (!didWarnAboutUpdateInRender) {
-            error(
-              "Cannot update during an existing state transition (such as " +
-                "within `render`). Render methods should be a pure " +
-                "function of props and state."
+            case "script":
+              key = getScriptKey(href);
+              break;
+          }
+
+          if (!preloadPropsMap.has(key)) {
+            var preloadProps = preloadPropsFromPreinitOptions(
+              href,
+              as,
+              options
             );
+            preloadPropsMap.set(key, preloadProps);
 
-            didWarnAboutUpdateInRender = true;
+            if (null === preloadDocument.querySelector(preloadKey)) {
+              var preloadInstance = preloadDocument.createElement("link");
+              setInitialProperties(preloadInstance, "link", preloadProps);
+              markNodeAsHoistable(preloadInstance);
+              preloadDocument.head.appendChild(preloadInstance);
+            }
           }
-
-          break;
         }
       }
-    }
-  }
-}
 
-function restorePendingUpdaters(root, lanes) {
-  {
-    if (isDevToolsPresent) {
-      var memoizedUpdaters = root.memoizedUpdaters;
-      memoizedUpdaters.forEach(function (schedulingFiber) {
-        addFiberToLanesMap(root, schedulingFiber, lanes);
-      }); // This function intentionally does not clear memoized updaters.
-      // Those may still be relevant to the current commit
-      // and a future one (e.g. Suspense).
+      return;
     }
-  }
-}
-var fakeActCallbackNode = {}; // $FlowFixMe[missing-local-annot]
 
-function scheduleCallback(priorityLevel, callback) {
-  {
-    // If we're currently inside an `act` scope, bypass Scheduler and push to
-    // the `act` queue instead.
-    var actQueue = ReactCurrentActQueue.current;
+    switch (as) {
+      case "style": {
+        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
 
-    if (actQueue !== null) {
-      actQueue.push(callback);
-      return fakeActCallbackNode;
-    } else {
-      return scheduleCallback$2(priorityLevel, callback);
-    }
-  }
-}
+        var _key = getStyleKey(href);
 
-function cancelCallback(callbackNode) {
-  if (callbackNode === fakeActCallbackNode) {
-    return;
-  } // In production, always call Scheduler. This function will be stripped out.
+        var precedence = options.precedence || "default"; // Check if this resource already exists
 
-  return cancelCallback$1(callbackNode);
-}
+        var resource = styles.get(_key);
 
-function shouldForceFlushFallbacksInDEV() {
-  // Never force flush in production. This function should get stripped out.
-  return ReactCurrentActQueue.current !== null;
-}
+        if (resource) {
+          // We can early return. The resource exists and there is nothing
+          // more to do
+          return;
+        } // Attempt to hydrate instance from DOM
 
-function warnIfUpdatesNotWrappedWithActDEV(fiber) {
-  {
-    if (fiber.mode & ConcurrentMode) {
-      if (!isConcurrentActEnvironment()) {
-        // Not in an act environment. No need to warn.
-        return;
-      }
-    } else {
-      // Legacy mode has additional cases where we suppress a warning.
-      if (!isLegacyActEnvironment()) {
-        // Not in an act environment. No need to warn.
-        return;
-      }
+        var instance = resourceRoot.querySelector(
+          getStylesheetSelectorFromKey(_key)
+        );
 
-      if (executionContext !== NoContext) {
-        // Legacy mode doesn't warn if the update is batched, i.e.
-        // batchedUpdates or flushSync.
-        return;
-      }
+        if (!instance) {
+          // Construct a new instance and insert it
+          var stylesheetProps = stylesheetPropsFromPreinitOptions(
+            href,
+            precedence,
+            options
+          );
 
-      if (
-        fiber.tag !== FunctionComponent &&
-        fiber.tag !== ForwardRef &&
-        fiber.tag !== SimpleMemoComponent
-      ) {
-        // For backwards compatibility with pre-hooks code, legacy mode only
-        // warns for updates that originate from a hook.
+          var _preloadProps = preloadPropsMap.get(_key);
+
+          if (_preloadProps) {
+            adoptPreloadPropsForStylesheet(stylesheetProps, _preloadProps);
+          }
+
+          var ownerDocument = getDocumentFromRoot(resourceRoot);
+          instance = ownerDocument.createElement("link");
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, "link", stylesheetProps);
+          insertStylesheet(instance, precedence, resourceRoot);
+        } // Construct a Resource and cache it
+
+        resource = {
+          type: "stylesheet",
+          instance: instance,
+          count: 1
+        };
+        styles.set(_key, resource);
         return;
       }
-    }
 
-    if (ReactCurrentActQueue.current === null) {
-      var previousFiber = current;
+      case "script": {
+        var src = href;
+        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
 
-      try {
-        setCurrentFiber(fiber);
+        var _key2 = getScriptKey(src); // Check if this resource already exists
 
-        error(
-          "An update to %s inside a test was not wrapped in act(...).\n\n" +
-            "When testing, code that causes React state updates should be " +
-            "wrapped into act(...):\n\n" +
-            "act(() => {\n" +
-            "  /* fire events that update state */\n" +
-            "});\n" +
-            "/* assert on the output */\n\n" +
-            "This ensures that you're testing the behavior the user would see " +
-            "in the browser." +
-            " Learn more at https://reactjs.org/link/wrap-tests-with-act",
-          getComponentNameFromFiber(fiber)
+        var _resource = scripts.get(_key2);
+
+        if (_resource) {
+          // We can early return. The resource exists and there is nothing
+          // more to do
+          return;
+        } // Attempt to hydrate instance from DOM
+
+        var _instance = resourceRoot.querySelector(
+          getScriptSelectorFromKey(_key2)
         );
-      } finally {
-        if (previousFiber) {
-          setCurrentFiber(fiber);
-        } else {
-          resetCurrentFiber();
-        }
+
+        if (!_instance) {
+          // Construct a new instance and insert it
+          var scriptProps = scriptPropsFromPreinitOptions(src, options); // Adopt certain preload props
+
+          var _preloadProps2 = preloadPropsMap.get(_key2);
+
+          if (_preloadProps2) {
+            adoptPreloadPropsForScript(scriptProps, _preloadProps2);
+          }
+
+          var _ownerDocument = getDocumentFromRoot(resourceRoot);
+
+          _instance = _ownerDocument.createElement("script");
+          markNodeAsHoistable(_instance);
+          setInitialProperties(_instance, "link", scriptProps);
+
+          _ownerDocument.head.appendChild(_instance);
+        } // Construct a Resource and cache it
+
+        _resource = {
+          type: "script",
+          instance: _instance,
+          count: 1
+        };
+        scripts.set(_key2, _resource);
+        return;
       }
     }
   }
 }
 
-function warnIfSuspenseResolutionNotWrappedWithActDEV(root) {
-  {
-    if (
-      root.tag !== LegacyRoot &&
-      isConcurrentActEnvironment() &&
-      ReactCurrentActQueue.current === null
-    ) {
-      error(
-        "A suspended resource finished loading inside a test, but the event " +
-          "was not wrapped in act(...).\n\n" +
-          "When testing, code that resolves suspended data should be wrapped " +
-          "into act(...):\n\n" +
-          "act(() => {\n" +
-          "  /* finish loading suspended data */\n" +
-          "});\n" +
-          "/* assert on the output */\n\n" +
-          "This ensures that you're testing the behavior the user would see " +
-          "in the browser." +
-          " Learn more at https://reactjs.org/link/wrap-tests-with-act"
-      );
-    }
-  }
+function preloadPropsFromPreinitOptions(href, as, options) {
+  return {
+    href: href,
+    rel: "preload",
+    as: as,
+    crossOrigin: as === "font" ? "" : options.crossOrigin,
+    integrity: options.integrity
+  };
 }
 
-function setIsRunningInsertionEffect(isRunning) {
-  {
-    isRunningInsertionEffect = isRunning;
-  }
+function stylesheetPropsFromPreinitOptions(href, precedence, options) {
+  return {
+    rel: "stylesheet",
+    href: href,
+    "data-precedence": precedence,
+    crossOrigin: options.crossOrigin
+  };
 }
 
-/* eslint-disable react-internal/prod-error-codes */
-// Used by React Refresh runtime through DevTools Global Hook.
-
-var resolveFamily = null;
-var failedBoundaries = null;
-var setRefreshHandler = function (handler) {
-  {
-    resolveFamily = handler;
-  }
-};
-function resolveFunctionForHotReloading(type) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return type;
-    }
-
-    var family = resolveFamily(type);
+function scriptPropsFromPreinitOptions(src, options) {
+  return {
+    src: src,
+    async: true,
+    crossOrigin: options.crossOrigin,
+    integrity: options.integrity
+  };
+} // --------------------------------------
+//      Resources from render
+// --------------------------------------
+// This function is called in begin work and we should always have a currentDocument set
 
-    if (family === undefined) {
-      return type;
-    } // Use the latest known implementation.
+function getResource(type, currentProps, pendingProps) {
+  var resourceRoot = getCurrentResourceRoot();
 
-    return family.current;
+  if (!resourceRoot) {
+    throw new Error(
+      '"resourceRoot" was expected to exist. This is a bug in React.'
+    );
   }
-}
-function resolveClassForHotReloading(type) {
-  // No implementation differences.
-  return resolveFunctionForHotReloading(type);
-}
-function resolveForwardRefForHotReloading(type) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return type;
-    }
 
-    var family = resolveFamily(type);
+  switch (type) {
+    case "meta":
+    case "title": {
+      return null;
+    }
 
-    if (family === undefined) {
-      // Check if we're dealing with a real forwardRef. Don't want to crash early.
+    case "style": {
       if (
-        type !== null &&
-        type !== undefined &&
-        typeof type.render === "function"
+        typeof pendingProps.precedence === "string" &&
+        typeof pendingProps.href === "string"
       ) {
-        // ForwardRef is special because its resolved .type is an object,
-        // but it's possible that we only have its inner render function in the map.
-        // If that inner render function is different, we'll build a new forwardRef type.
-        var currentRender = resolveFunctionForHotReloading(type.render);
+        var key = getStyleKey(pendingProps.href);
+        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+        var resource = styles.get(key);
 
-        if (type.render !== currentRender) {
-          var syntheticType = {
-            $$typeof: REACT_FORWARD_REF_TYPE,
-            render: currentRender
+        if (!resource) {
+          resource = {
+            type: "style",
+            instance: null,
+            count: 0
           };
-
-          if (type.displayName !== undefined) {
-            syntheticType.displayName = type.displayName;
-          }
-
-          return syntheticType;
+          styles.set(key, resource);
         }
-      }
 
-      return type;
-    } // Use the latest known implementation.
+        return resource;
+      }
 
-    return family.current;
-  }
-}
-function isCompatibleFamilyForHotReloading(fiber, element) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return false;
+      return {
+        type: "void",
+        instance: null,
+        count: 0
+      };
     }
 
-    var prevType = fiber.elementType;
-    var nextType = element.type; // If we got here, we know types aren't === equal.
+    case "link": {
+      if (
+        pendingProps.rel === "stylesheet" &&
+        typeof pendingProps.href === "string" &&
+        typeof pendingProps.precedence === "string"
+      ) {
+        var qualifiedProps = pendingProps;
 
-    var needsCompareFamilies = false;
-    var $$typeofNextType =
-      typeof nextType === "object" && nextType !== null
-        ? nextType.$$typeof
-        : null;
+        var _key3 = getStyleKey(qualifiedProps.href);
 
-    switch (fiber.tag) {
-      case ClassComponent: {
-        if (typeof nextType === "function") {
-          needsCompareFamilies = true;
-        }
+        var _styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
 
-        break;
-      }
+        var _resource2 = _styles.get(_key3);
 
-      case FunctionComponent: {
-        if (typeof nextType === "function") {
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          // We don't know the inner type yet.
-          // We're going to assume that the lazy inner type is stable,
-          // and so it is sufficient to avoid reconciling it away.
-          // We're not going to unwrap or actually use the new lazy type.
-          needsCompareFamilies = true;
-        }
+        if (!_resource2) {
+          // We asserted this above but Flow can't figure out that the type satisfies
+          var ownerDocument = getDocumentFromRoot(resourceRoot);
+          _resource2 = {
+            type: "stylesheet",
+            instance: null,
+            count: 0
+          };
 
-        break;
-      }
+          _styles.set(_key3, _resource2);
 
-      case ForwardRef: {
-        if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          needsCompareFamilies = true;
+          if (!preloadPropsMap.has(_key3)) {
+            preloadStylesheet(
+              ownerDocument,
+              _key3,
+              preloadPropsFromStylesheet(qualifiedProps)
+            );
+          }
         }
 
-        break;
+        return _resource2;
       }
 
-      case MemoComponent:
-      case SimpleMemoComponent: {
-        if ($$typeofNextType === REACT_MEMO_TYPE) {
-          // TODO: if it was but can no longer be simple,
-          // we shouldn't set this.
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          needsCompareFamilies = true;
-        }
+      return null;
+    }
+
+    case "script": {
+      if (typeof pendingProps.src === "string" && pendingProps.async === true) {
+        var scriptProps = pendingProps;
+
+        var _key4 = getScriptKey(scriptProps.src);
 
-        break;
-      }
+        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
 
-      default:
-        return false;
-    } // Check if both types have a family and it's the same one.
+        var _resource3 = scripts.get(_key4);
 
-    if (needsCompareFamilies) {
-      // Note: memo() and forwardRef() we'll compare outer rather than inner type.
-      // This means both of them need to be registered to preserve state.
-      // If we unwrapped and compared the inner types for wrappers instead,
-      // then we would risk falsely saying two separate memo(Foo)
-      // calls are equivalent because they wrap the same Foo function.
-      var prevFamily = resolveFamily(prevType); // $FlowFixMe[not-a-function] found when upgrading Flow
+        if (!_resource3) {
+          _resource3 = {
+            type: "script",
+            instance: null,
+            count: 0
+          };
+          scripts.set(_key4, _resource3);
+        }
 
-      if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
-        return true;
+        return _resource3;
       }
+
+      return {
+        type: "void",
+        instance: null,
+        count: 0
+      };
     }
 
-    return false;
+    default: {
+      throw new Error(
+        'getResource encountered a type it did not expect: "' +
+          type +
+          '". this is a bug in React.'
+      );
+    }
   }
 }
-function markFailedErrorBoundaryForHotReloading(fiber) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return;
-    }
 
-    if (typeof WeakSet !== "function") {
-      return;
-    }
+function styleTagPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    "data-href": rawProps.href,
+    "data-precedence": rawProps.precedence,
+    href: null,
+    precedence: null
+  });
+}
 
-    if (failedBoundaries === null) {
-      failedBoundaries = new WeakSet();
-    }
+function getStyleKey(href) {
+  var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return 'href~="' + limitedEscapedHref + '"';
+}
 
-    failedBoundaries.add(fiber);
-  }
+function getStyleTagSelectorFromKey(key) {
+  return "style[data-" + key + "]";
 }
-var scheduleRefresh = function (root, update) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return;
-    }
 
-    var staleFamilies = update.staleFamilies,
-      updatedFamilies = update.updatedFamilies;
-    flushPassiveEffects();
-    flushSync$1(function () {
-      scheduleFibersWithFamiliesRecursively(
-        root.current,
-        updatedFamilies,
-        staleFamilies
-      );
-    });
-  }
-};
-var scheduleRoot = function (root, element) {
-  {
-    if (root.context !== emptyContextObject) {
-      // Super edge case: root has a legacy _renderSubtree context
-      // but we don't know the parentComponent so we can't pass it.
-      // Just ignore. We'll delete this with _renderSubtree code path later.
-      return;
-    }
+function getStylesheetSelectorFromKey(key) {
+  return 'link[rel="stylesheet"][' + key + "]";
+}
 
-    flushPassiveEffects();
-    flushSync$1(function () {
-      updateContainer(element, root, null, null);
-    });
-  }
-};
+function getPreloadStylesheetSelectorFromKey(key) {
+  return 'link[rel="preload"][as="style"][' + key + "]";
+}
 
-function scheduleFibersWithFamiliesRecursively(
-  fiber,
-  updatedFamilies,
-  staleFamilies
-) {
-  {
-    var alternate = fiber.alternate,
-      child = fiber.child,
-      sibling = fiber.sibling,
-      tag = fiber.tag,
-      type = fiber.type;
-    var candidateType = null;
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    "data-precedence": rawProps.precedence,
+    precedence: null
+  });
+}
 
-    switch (tag) {
-      case FunctionComponent:
-      case SimpleMemoComponent:
-      case ClassComponent:
-        candidateType = type;
-        break;
+function preloadStylesheet(ownerDocument, key, preloadProps) {
+  preloadPropsMap.set(key, preloadProps);
 
-      case ForwardRef:
-        candidateType = type.render;
-        break;
+  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+    // There is no matching stylesheet instance in the Document.
+    // We will insert a preload now to kick off loading because
+    // we expect this stylesheet to commit
+    if (
+      null ===
+      ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key))
+    ) {
+      var preloadInstance = ownerDocument.createElement("link");
+      setInitialProperties(preloadInstance, "link", preloadProps);
+      markNodeAsHoistable(preloadInstance);
+      ownerDocument.head.appendChild(preloadInstance);
     }
+  }
+}
 
-    if (resolveFamily === null) {
-      throw new Error("Expected resolveFamily to be set during hot reload.");
-    }
+function preloadPropsFromStylesheet(props) {
+  return {
+    rel: "preload",
+    as: "style",
+    href: props.href,
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
+}
 
-    var needsRender = false;
-    var needsRemount = false;
+function getScriptKey(src) {
+  var limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
+  return '[src="' + limitedEscapedSrc + '"]';
+}
 
-    if (candidateType !== null) {
-      var family = resolveFamily(candidateType);
+function getScriptSelectorFromKey(key) {
+  return "script[async]" + key;
+} // --------------------------------------
+//      Hoistable Resource Reconciliation
+// --------------------------------------
 
-      if (family !== undefined) {
-        if (staleFamilies.has(family)) {
-          needsRemount = true;
-        } else if (updatedFamilies.has(family)) {
-          if (tag === ClassComponent) {
-            needsRemount = true;
-          } else {
-            needsRender = true;
-          }
-        }
-      }
-    }
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
 
-    if (failedBoundaries !== null) {
-      if (
-        failedBoundaries.has(fiber) || // $FlowFixMe[incompatible-use] found when upgrading Flow
-        (alternate !== null && failedBoundaries.has(alternate))
-      ) {
-        needsRemount = true;
-      }
-    }
+  if (resource.instance === null) {
+    switch (resource.type) {
+      case "style": {
+        var qualifiedProps = props;
+        var key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
 
-    if (needsRemount) {
-      fiber._debugNeedsRemount = true;
-    }
+        var instance = hoistableRoot.querySelector(
+          getStyleTagSelectorFromKey(key)
+        );
 
-    if (needsRemount || needsRender) {
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+        if (instance) {
+          resource.instance = instance;
+          markNodeAsHoistable(instance);
+          return instance;
+        }
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+        var styleProps = styleTagPropsFromRawProps(props);
+        var ownerDocument = getDocumentFromRoot(hoistableRoot);
+        instance = ownerDocument.createElement("style");
+        markNodeAsHoistable(instance);
+        setInitialProperties(instance, "style", styleProps);
+        insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+        resource.instance = instance;
+        return instance;
       }
-    }
 
-    if (child !== null && !needsRemount) {
-      scheduleFibersWithFamiliesRecursively(
-        child,
-        updatedFamilies,
-        staleFamilies
-      );
-    }
+      case "stylesheet": {
+        // This typing is enforce by `getResource`. If we change the logic
+        // there for what qualifies as a stylesheet resource we need to ensure
+        // this cast still makes sense;
+        var _qualifiedProps = props;
 
-    if (sibling !== null) {
-      scheduleFibersWithFamiliesRecursively(
-        sibling,
-        updatedFamilies,
-        staleFamilies
-      );
-    }
-  }
-}
+        var _key5 = getStyleKey(_qualifiedProps.href); // Attempt to hydrate instance from DOM
 
-var findHostInstancesForRefresh = function (root, families) {
-  {
-    var hostInstances = new Set();
-    var types = new Set(
-      families.map(function (family) {
-        return family.current;
-      })
-    );
-    findHostInstancesForMatchingFibersRecursively(
-      root.current,
-      types,
-      hostInstances
-    );
-    return hostInstances;
-  }
-};
+        var _instance2 = hoistableRoot.querySelector(
+          getStylesheetSelectorFromKey(_key5)
+        );
 
-function findHostInstancesForMatchingFibersRecursively(
-  fiber,
-  types,
-  hostInstances
-) {
-  {
-    var child = fiber.child,
-      sibling = fiber.sibling,
-      tag = fiber.tag,
-      type = fiber.type;
-    var candidateType = null;
+        if (_instance2) {
+          resource.instance = _instance2;
+          markNodeAsHoistable(_instance2);
+          return _instance2;
+        }
 
-    switch (tag) {
-      case FunctionComponent:
-      case SimpleMemoComponent:
-      case ClassComponent:
-        candidateType = type;
-        break;
+        var stylesheetProps = stylesheetPropsFromRawProps(props);
+        var preloadProps = preloadPropsMap.get(_key5);
 
-      case ForwardRef:
-        candidateType = type.render;
-        break;
-    }
+        if (preloadProps) {
+          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+        } // Construct and insert a new instance
 
-    var didMatch = false;
+        var _ownerDocument2 = getDocumentFromRoot(hoistableRoot);
 
-    if (candidateType !== null) {
-      if (types.has(candidateType)) {
-        didMatch = true;
+        _instance2 = _ownerDocument2.createElement("link");
+        markNodeAsHoistable(_instance2);
+        var linkInstance = _instance2;
+        linkInstance._p = new Promise(function (resolve, reject) {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        }).then(
+          function () {
+            return (linkInstance._p.s = "l");
+          },
+          function () {
+            return (linkInstance._p.s = "e");
+          }
+        );
+        setInitialProperties(_instance2, "link", stylesheetProps);
+        insertStylesheet(_instance2, _qualifiedProps.precedence, hoistableRoot);
+        resource.instance = _instance2;
+        return _instance2;
       }
-    }
 
-    if (didMatch) {
-      // We have a match. This only drills down to the closest host components.
-      // There's no need to search deeper because for the purpose of giving
-      // visual feedback, "flashing" outermost parent rectangles is sufficient.
-      findHostInstancesForFiberShallowly(fiber, hostInstances);
-    } else {
-      // If there's no match, maybe there will be one further down in the child tree.
-      if (child !== null) {
-        findHostInstancesForMatchingFibersRecursively(
-          child,
-          types,
-          hostInstances
+      case "script": {
+        // This typing is enforce by `getResource`. If we change the logic
+        // there for what qualifies as a stylesheet resource we need to ensure
+        // this cast still makes sense;
+        var borrowedScriptProps = props;
+
+        var _key6 = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+
+        var _instance3 = hoistableRoot.querySelector(
+          getScriptSelectorFromKey(_key6)
         );
-      }
-    }
 
-    if (sibling !== null) {
-      findHostInstancesForMatchingFibersRecursively(
-        sibling,
-        types,
-        hostInstances
-      );
-    }
-  }
-}
+        if (_instance3) {
+          resource.instance = _instance3;
+          markNodeAsHoistable(_instance3);
+          return _instance3;
+        }
 
-function findHostInstancesForFiberShallowly(fiber, hostInstances) {
-  {
-    var foundHostInstances = findChildHostInstancesForFiberShallowly(
-      fiber,
-      hostInstances
-    );
+        var scriptProps = borrowedScriptProps;
 
-    if (foundHostInstances) {
-      return;
-    } // If we didn't find any host children, fallback to closest host parent.
+        var _preloadProps3 = preloadPropsMap.get(_key6);
 
-    var node = fiber;
+        if (_preloadProps3) {
+          scriptProps = assign({}, borrowedScriptProps);
+          adoptPreloadPropsForScript(scriptProps, _preloadProps3);
+        } // Construct and insert a new instance
 
-    while (true) {
-      switch (node.tag) {
-        case HostSingleton:
-        case HostComponent:
-          hostInstances.add(node.stateNode);
-          return;
+        var _ownerDocument3 = getDocumentFromRoot(hoistableRoot);
 
-        case HostPortal:
-          hostInstances.add(node.stateNode.containerInfo);
-          return;
+        _instance3 = _ownerDocument3.createElement("script");
+        markNodeAsHoistable(_instance3);
+        setInitialProperties(_instance3, "link", scriptProps);
 
-        case HostRoot:
-          hostInstances.add(node.stateNode.containerInfo);
-          return;
+        _ownerDocument3.head.appendChild(_instance3);
+
+        resource.instance = _instance3;
+        return _instance3;
       }
 
-      if (node.return === null) {
-        throw new Error("Expected to reach root first.");
+      case "void": {
+        return null;
       }
 
-      node = node.return;
+      default: {
+        throw new Error(
+          'acquireResource encountered a resource type it did not expect: "' +
+            resource.type +
+            '". this is a bug in React.'
+        );
+      }
     }
   }
+
+  return resource.instance;
+}
+function releaseResource(resource) {
+  resource.count--;
 }
 
-function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
-  {
-    var node = fiber;
-    var foundHostInstances = false;
+function insertStylesheet(instance, precedence, root) {
+  var nodes = root.querySelectorAll(
+    'link[rel="stylesheet"][data-precedence],style[data-precedence]'
+  );
+  var last = nodes.length ? nodes[nodes.length - 1] : null;
+  var prior = last;
+
+  for (var i = 0; i < nodes.length; i++) {
+    var node = nodes[i];
+    var nodePrecedence = node.dataset.precedence;
+
+    if (nodePrecedence === precedence) {
+      prior = node;
+    } else if (prior !== last) {
+      break;
+    }
+  }
+
+  if (prior) {
+    // We get the prior from the document so we know it is in the tree.
+    // We also know that links can't be the topmost Node so the parentNode
+    // must exist.
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    var parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
+  }
+}
+
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  if (stylesheetProps.crossOrigin == null)
+    stylesheetProps.crossOrigin = preloadProps.crossOrigin;
+  if (stylesheetProps.referrerPolicy == null)
+    stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+}
+
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  if (scriptProps.crossOrigin == null)
+    scriptProps.crossOrigin = preloadProps.crossOrigin;
+  if (scriptProps.referrerPolicy == null)
+    scriptProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (scriptProps.integrity == null)
+    scriptProps.referrerPolicy = preloadProps.integrity;
+} // --------------------------------------
+//      Hoistable Element Reconciliation
+// --------------------------------------
+
+var tagCaches = null;
+function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
+  var ownerDocument = getDocumentFromRoot(hoistableRoot);
+  var instance = null;
+
+  getInstance: switch (type) {
+    case "title": {
+      instance = ownerDocument.getElementsByTagName("title")[0];
 
-    while (true) {
       if (
-        node.tag === HostComponent ||
-        node.tag === HostHoistable ||
-        node.tag === HostSingleton
+        !instance ||
+        isOwnedInstance(instance) ||
+        instance.namespaceURI === SVG_NAMESPACE ||
+        instance.hasAttribute("itemprop")
       ) {
-        // We got a match.
-        foundHostInstances = true;
-        hostInstances.add(node.stateNode); // There may still be more, so keep searching.
-      } else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
+        instance = ownerDocument.createElement(type);
+        ownerDocument.head.insertBefore(
+          instance,
+          ownerDocument.querySelector("head > title")
+        );
       }
 
-      if (node === fiber) {
-        return foundHostInstances;
-      }
+      setInitialProperties(instance, type, props);
+      precacheFiberNode(internalInstanceHandle, instance);
+      markNodeAsHoistable(instance);
+      return instance;
+    }
+
+    case "link": {
+      var cache = getHydratableHoistableCache("link", "href", ownerDocument);
+      var key = type + (props.href || "");
+      var maybeNodes = cache.get(key);
+
+      if (maybeNodes) {
+        var nodes = maybeNodes;
+
+        for (var i = 0; i < nodes.length; i++) {
+          var node = nodes[i];
+
+          if (
+            node.getAttribute("href") !==
+              (props.href == null ? null : props.href) ||
+            node.getAttribute("rel") !==
+              (props.rel == null ? null : props.rel) ||
+            node.getAttribute("title") !==
+              (props.title == null ? null : props.title) ||
+            node.getAttribute("crossorigin") !==
+              (props.crossOrigin == null ? null : props.crossOrigin)
+          ) {
+            // mismatch, try the next node;
+            continue;
+          }
 
-      while (node.sibling === null) {
-        if (node.return === null || node.return === fiber) {
-          return foundHostInstances;
+          instance = node;
+          nodes.splice(i, 1);
+          break getInstance;
         }
-
-        node = node.return;
       }
 
-      node.sibling.return = node.return;
-      node = node.sibling;
+      instance = ownerDocument.createElement(type);
+      setInitialProperties(instance, type, props);
+      ownerDocument.head.appendChild(instance);
+      break;
     }
-  }
-
-  return false;
-}
 
-var hasBadMapPolyfill;
+    case "meta": {
+      var _cache = getHydratableHoistableCache(
+        "meta",
+        "content",
+        ownerDocument
+      );
 
-{
-  hasBadMapPolyfill = false;
+      var _key7 = type + (props.content || "");
 
-  try {
-    var nonExtensibleObject = Object.preventExtensions({});
-    /* eslint-disable no-new */
+      var _maybeNodes = _cache.get(_key7);
 
-    new Map([[nonExtensibleObject, null]]);
-    new Set([nonExtensibleObject]);
-    /* eslint-enable no-new */
-  } catch (e) {
-    // TODO: Consider warning about bad polyfills
-    hasBadMapPolyfill = true;
-  }
-}
+      if (_maybeNodes) {
+        var _nodes = _maybeNodes;
 
-function FiberNode(tag, pendingProps, key, mode) {
-  // Instance
-  this.tag = tag;
-  this.key = key;
-  this.elementType = null;
-  this.type = null;
-  this.stateNode = null; // Fiber
+        for (var _i = 0; _i < _nodes.length; _i++) {
+          var _node = _nodes[_i]; // We coerce content to string because it is the most likely one to
+          // use a `toString` capable value. For the rest we just do identity match
+          // passing non-strings here is not really valid anyway.
 
-  this.return = null;
-  this.child = null;
-  this.sibling = null;
-  this.index = 0;
-  this.ref = null;
-  this.refCleanup = null;
-  this.pendingProps = pendingProps;
-  this.memoizedProps = null;
-  this.updateQueue = null;
-  this.memoizedState = null;
-  this.dependencies = null;
-  this.mode = mode; // Effects
+          {
+            checkAttributeStringCoercion(props.content, "content");
+          }
 
-  this.flags = NoFlags$1;
-  this.subtreeFlags = NoFlags$1;
-  this.deletions = null;
-  this.lanes = NoLanes;
-  this.childLanes = NoLanes;
-  this.alternate = null;
+          if (
+            _node.getAttribute("content") !==
+              (props.content == null ? null : "" + props.content) ||
+            _node.getAttribute("name") !==
+              (props.name == null ? null : props.name) ||
+            _node.getAttribute("property") !==
+              (props.property == null ? null : props.property) ||
+            _node.getAttribute("http-equiv") !==
+              (props.httpEquiv == null ? null : props.httpEquiv) ||
+            _node.getAttribute("charset") !==
+              (props.charSet == null ? null : props.charSet)
+          ) {
+            // mismatch, try the next node;
+            continue;
+          }
 
-  {
-    // Note: The following is done to avoid a v8 performance cliff.
-    //
-    // Initializing the fields below to smis and later updating them with
-    // double values will cause Fibers to end up having separate shapes.
-    // This behavior/bug has something to do with Object.preventExtension().
-    // Fortunately this only impacts DEV builds.
-    // Unfortunately it makes React unusably slow for some applications.
-    // To work around this, initialize the fields below with doubles.
-    //
-    // Learn more about this here:
-    // https://github.com/facebook/react/issues/14365
-    // https://bugs.chromium.org/p/v8/issues/detail?id=8538
-    this.actualDuration = Number.NaN;
-    this.actualStartTime = Number.NaN;
-    this.selfBaseDuration = Number.NaN;
-    this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
-    // This won't trigger the performance cliff mentioned above,
-    // and it simplifies other profiler code (including DevTools).
+          instance = _node;
 
-    this.actualDuration = 0;
-    this.actualStartTime = -1;
-    this.selfBaseDuration = 0;
-    this.treeBaseDuration = 0;
-  }
+          _nodes.splice(_i, 1);
 
-  {
-    // This isn't directly used but is handy for debugging internals:
-    this._debugSource = null;
-    this._debugOwner = null;
-    this._debugNeedsRemount = false;
-    this._debugHookTypes = null;
+          break getInstance;
+        }
+      }
 
-    if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
-      Object.preventExtensions(this);
+      instance = ownerDocument.createElement(type);
+      setInitialProperties(instance, type, props);
+      ownerDocument.head.appendChild(instance);
+      break;
     }
-  }
-} // This is a constructor function, rather than a POJO constructor, still
-// please ensure we do the following:
-// 1) Nobody should add any instance methods on this. Instance methods can be
-//    more difficult to predict when they get optimized and they are almost
-//    never inlined properly in static compilers.
-// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
-//    always know when it is a fiber.
-// 3) We might want to experiment with using numeric keys since they are easier
-//    to optimize in a non-JIT environment.
-// 4) We can easily go from a constructor to a createFiber object literal if that
-//    is faster.
-// 5) It should be easy to port this to a C struct and keep a C implementation
-//    compatible.
 
-function createFiber(tag, pendingProps, key, mode) {
-  // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
-  return new FiberNode(tag, pendingProps, key, mode);
-}
+    default:
+      throw new Error(
+        'getNodesForType encountered a type it did not expect: "' +
+          type +
+          '". This is a bug in React.'
+      );
+  } // This node is a match
 
-function shouldConstruct(Component) {
-  var prototype = Component.prototype;
-  return !!(prototype && prototype.isReactComponent);
+  precacheFiberNode(internalInstanceHandle, instance);
+  markNodeAsHoistable(instance);
+  return instance;
 }
 
-function isSimpleFunctionComponent(type) {
-  return (
-    typeof type === "function" &&
-    !shouldConstruct(type) &&
-    type.defaultProps === undefined
-  );
-}
-function resolveLazyComponentTag(Component) {
-  if (typeof Component === "function") {
-    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
-  } else if (Component !== undefined && Component !== null) {
-    var $$typeof = Component.$$typeof;
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  var cache;
+  var caches;
 
-    if ($$typeof === REACT_FORWARD_REF_TYPE) {
-      return ForwardRef;
-    }
+  if (tagCaches === null) {
+    cache = new Map();
+    caches = tagCaches = new Map();
+    caches.set(ownerDocument, cache);
+  } else {
+    caches = tagCaches;
+    var maybeCache = caches.get(ownerDocument);
 
-    if ($$typeof === REACT_MEMO_TYPE) {
-      return MemoComponent;
+    if (!maybeCache) {
+      cache = new Map();
+      caches.set(ownerDocument, cache);
+    } else {
+      cache = maybeCache;
     }
   }
 
-  return IndeterminateComponent;
-} // This is used to create an alternate fiber to do work on.
+  if (cache.has(type)) {
+    // We use type as a special key that signals that this cache has been seeded for this type
+    return cache;
+  } // Mark this cache as seeded for this type
 
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
+  cache.set(type, null);
+  var nodes = ownerDocument.getElementsByTagName(type);
 
-  if (workInProgress === null) {
-    // We use a double buffering pooling technique because we know that we'll
-    // only ever need at most two versions of a tree. We pool the "other" unused
-    // node that we're free to reuse. This is lazily created to avoid allocating
-    // extra objects for things that are never updated. It also allow us to
-    // reclaim the extra memory if needed.
-    workInProgress = createFiber(
-      current.tag,
-      pendingProps,
-      current.key,
-      current.mode
-    );
-    workInProgress.elementType = current.elementType;
-    workInProgress.type = current.type;
-    workInProgress.stateNode = current.stateNode;
+  for (var i = 0; i < nodes.length; i++) {
+    var node = nodes[i];
 
-    {
-      // DEV-only fields
-      workInProgress._debugSource = current._debugSource;
-      workInProgress._debugOwner = current._debugOwner;
-      workInProgress._debugHookTypes = current._debugHookTypes;
-    }
+    if (
+      !isOwnedInstance(node) &&
+      (type !== "link" || node.getAttribute("rel") !== "stylesheet") &&
+      node.namespaceURI !== SVG_NAMESPACE
+    ) {
+      var nodeKey = node.getAttribute(keyAttribute) || "";
+      var key = type + nodeKey;
+      var existing = cache.get(key);
 
-    workInProgress.alternate = current;
-    current.alternate = workInProgress;
-  } else {
-    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+      if (existing) {
+        existing.push(node);
+      } else {
+        cache.set(key, [node]);
+      }
+    }
+  }
 
-    workInProgress.type = current.type; // We already have an alternate.
-    // Reset the effect tag.
+  return cache;
+}
 
-    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+function mountHoistable(hoistableRoot, type, instance) {
+  var ownerDocument = getDocumentFromRoot(hoistableRoot);
+  ownerDocument.head.insertBefore(
+    instance,
+    type === "title" ? ownerDocument.querySelector("head > title") : null
+  );
+}
+function unmountHoistable(instance) {
+  instance.parentNode.removeChild(instance);
+} // When passing user input into querySelector(All) the embedded string must not alter
+// the semantics of the query. This escape function is safe to use when we know the
+// provided value is going to be wrapped in double quotes as part of an attribute selector
+// Do not use it anywhere else
+// we escape double quotes and backslashes
 
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.deletions = null;
+var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
 
-    {
-      // We intentionally reset, rather than copy, actualDuration & actualStartTime.
-      // This prevents time from endlessly accumulating in new commits.
-      // This has the downside of resetting values for different priority renders,
-      // But works for yielding (the common case) and should support resuming.
-      workInProgress.actualDuration = 0;
-      workInProgress.actualStartTime = -1;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(
+    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
+    function (ch) {
+      return "\\" + ch.charCodeAt(0).toString(16);
     }
-  } // Reset all effects except static ones.
-  // Static effects are not specific to a render.
+  );
+}
 
-  workInProgress.flags = current.flags & StaticMask;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
-  // it cannot be shared with the current fiber.
+var SUPPRESS_HYDRATION_WARNING = "suppressHydrationWarning";
+var SUSPENSE_START_DATA = "$";
+var SUSPENSE_END_DATA = "/$";
+var SUSPENSE_PENDING_START_DATA = "$?";
+var SUSPENSE_FALLBACK_START_DATA = "$!";
+var STYLE = "style";
+var eventsEnabled = null;
+var selectionInformation = null;
+function getRootHostContext(rootContainerInstance) {
+  var type;
+  var namespace;
+  var nodeType = rootContainerInstance.nodeType;
 
-  var currentDependencies = current.dependencies;
-  workInProgress.dependencies =
-    currentDependencies === null
-      ? null
-      : {
-          lanes: currentDependencies.lanes,
-          firstContext: currentDependencies.firstContext
-        }; // These will be overridden during the parent's reconciliation
+  switch (nodeType) {
+    case DOCUMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE: {
+      type = nodeType === DOCUMENT_NODE ? "#document" : "#fragment";
+      var root = rootContainerInstance.documentElement;
+      namespace = root ? root.namespaceURI : getChildNamespace(null, "");
+      break;
+    }
 
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
+    default: {
+      var container =
+        nodeType === COMMENT_NODE
+          ? rootContainerInstance.parentNode
+          : rootContainerInstance;
+      var ownNamespace = container.namespaceURI || null;
+      type = container.tagName;
+      namespace = getChildNamespace(ownNamespace, type);
+      break;
+    }
+  }
 
   {
-    workInProgress.selfBaseDuration = current.selfBaseDuration;
-    workInProgress.treeBaseDuration = current.treeBaseDuration;
+    var validatedTag = type.toLowerCase();
+    var ancestorInfo = updatedAncestorInfoDev(null, validatedTag);
+    return {
+      namespace: namespace,
+      ancestorInfo: ancestorInfo
+    };
   }
-
+}
+function getChildHostContext(parentHostContext, type) {
   {
-    workInProgress._debugNeedsRemount = current._debugNeedsRemount;
-
-    switch (workInProgress.tag) {
-      case IndeterminateComponent:
-      case FunctionComponent:
-      case SimpleMemoComponent:
-        workInProgress.type = resolveFunctionForHotReloading(current.type);
-        break;
-
-      case ClassComponent:
-        workInProgress.type = resolveClassForHotReloading(current.type);
-        break;
-
-      case ForwardRef:
-        workInProgress.type = resolveForwardRefForHotReloading(current.type);
-        break;
-    }
+    var parentHostContextDev = parentHostContext;
+    var namespace = getChildNamespace(parentHostContextDev.namespace, type);
+    var ancestorInfo = updatedAncestorInfoDev(
+      parentHostContextDev.ancestorInfo,
+      type
+    );
+    return {
+      namespace: namespace,
+      ancestorInfo: ancestorInfo
+    };
   }
+}
+function getPublicInstance(instance) {
+  return instance;
+}
+function prepareForCommit(containerInfo) {
+  eventsEnabled = isEnabled();
+  selectionInformation = getSelectionInformation();
+  var activeInstance = null;
 
-  return workInProgress;
-} // Used to reuse a Fiber for a second pass.
-
-function resetWorkInProgress(workInProgress, renderLanes) {
-  // This resets the Fiber to what createFiber or createWorkInProgress would
-  // have set the values to before during the first pass. Ideally this wouldn't
-  // be necessary but unfortunately many code paths reads from the workInProgress
-  // when they should be reading from current and writing to workInProgress.
-  // We assume pendingProps, index, key, ref, return are still untouched to
-  // avoid doing another reconciliation.
-  // Reset the effect flags but keep any Placement tags, since that's something
-  // that child fiber is setting, not the reconciliation.
-  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
-
-  var current = workInProgress.alternate;
-
-  if (current === null) {
-    // Reset to createFiber's initial values.
-    workInProgress.childLanes = NoLanes;
-    workInProgress.lanes = renderLanes;
-    workInProgress.child = null;
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.memoizedProps = null;
-    workInProgress.memoizedState = null;
-    workInProgress.updateQueue = null;
-    workInProgress.dependencies = null;
-    workInProgress.stateNode = null;
-
-    {
-      // Note: We don't reset the actualTime counts. It's useful to accumulate
-      // actual time across multiple render passes.
-      workInProgress.selfBaseDuration = 0;
-      workInProgress.treeBaseDuration = 0;
-    }
-  } else {
-    // Reset to the cloned values that createWorkInProgress would've.
-    workInProgress.childLanes = current.childLanes;
-    workInProgress.lanes = current.lanes;
-    workInProgress.child = current.child;
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.deletions = null;
-    workInProgress.memoizedProps = current.memoizedProps;
-    workInProgress.memoizedState = current.memoizedState;
-    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
-
-    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
-    // it cannot be shared with the current fiber.
-
-    var currentDependencies = current.dependencies;
-    workInProgress.dependencies =
-      currentDependencies === null
-        ? null
-        : {
-            lanes: currentDependencies.lanes,
-            firstContext: currentDependencies.firstContext
-          };
+  {
+    var focusedElem = selectionInformation.focusedElem;
 
-    {
-      // Note: We don't reset the actualTime counts. It's useful to accumulate
-      // actual time across multiple render passes.
-      workInProgress.selfBaseDuration = current.selfBaseDuration;
-      workInProgress.treeBaseDuration = current.treeBaseDuration;
+    if (focusedElem !== null) {
+      activeInstance = getClosestInstanceFromNode(focusedElem);
     }
   }
 
-  return workInProgress;
+  setEnabled(false);
+  return activeInstance;
 }
-function createHostRootFiber(
-  tag,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride
+function beforeActiveInstanceBlur(internalInstanceHandle) {
+  {
+    setEnabled(true);
+    dispatchBeforeDetachedBlur(
+      selectionInformation.focusedElem,
+      internalInstanceHandle
+    );
+    setEnabled(false);
+  }
+}
+function afterActiveInstanceBlur() {
+  {
+    setEnabled(true);
+    dispatchAfterDetachedBlur(selectionInformation.focusedElem);
+    setEnabled(false);
+  }
+}
+function resetAfterCommit(containerInfo) {
+  restoreSelection(selectionInformation);
+  setEnabled(eventsEnabled);
+  eventsEnabled = null;
+  selectionInformation = null;
+}
+function createHoistableInstance(
+  type,
+  props,
+  rootContainerInstance,
+  internalInstanceHandle
 ) {
-  var mode;
-
-  if (tag === ConcurrentRoot) {
-    mode = ConcurrentMode;
+  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  var domElement = createHTMLElement(type, props, ownerDocument);
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  setInitialProperties(domElement, type, props);
+  markNodeAsHoistable(domElement);
+  return domElement;
+}
+function createInstance(
+  type,
+  props,
+  rootContainerInstance,
+  hostContext,
+  internalInstanceHandle
+) {
+  var namespace;
 
-    if (isStrictMode === true || createRootStrictEffectsByDefault) {
-      mode |= StrictLegacyMode | StrictEffectsMode;
-    }
+  {
+    // TODO: take namespace into account when validating.
+    var hostContextDev = hostContext;
+    validateDOMNesting(type, null, hostContextDev.ancestorInfo);
 
     if (
-      // Only for internal experiments.
-      concurrentUpdatesByDefaultOverride
+      typeof props.children === "string" ||
+      typeof props.children === "number"
     ) {
-      mode |= ConcurrentUpdatesByDefaultMode;
+      var string = "" + props.children;
+      var ownAncestorInfo = updatedAncestorInfoDev(
+        hostContextDev.ancestorInfo,
+        type
+      );
+      validateDOMNesting(null, string, ownAncestorInfo);
     }
-  } else {
-    mode = NoMode;
-  }
 
-  if (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;
+    namespace = hostContextDev.namespace;
   }
 
-  return createFiber(HostRoot, null, null, mode);
-}
-function createFiberFromTypeAndProps(
-  type, // React$ElementType
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
-
-  var resolvedType = type;
-
-  if (typeof type === "function") {
-    if (shouldConstruct(type)) {
-      fiberTag = ClassComponent;
-
-      {
-        resolvedType = resolveClassForHotReloading(resolvedType);
-      }
-    } else {
-      {
-        resolvedType = resolveFunctionForHotReloading(resolvedType);
-      }
-    }
-  } else if (typeof type === "string") {
-    {
-      var hostContext = getHostContext();
-      fiberTag = isHostHoistableType(type, pendingProps, hostContext)
-        ? HostHoistable
-        : isHostSingletonType(type)
-        ? HostSingleton
-        : HostComponent;
-    }
-  } else {
-    getTag: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
-
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = Mode;
-        mode |= StrictLegacyMode;
-
-        if ((mode & ConcurrentMode) !== NoMode) {
-          // Strict effects should never run on legacy roots
-          mode |= StrictEffectsMode;
-        }
-
-        break;
-
-      case REACT_PROFILER_TYPE:
-        return createFiberFromProfiler(pendingProps, mode, lanes, key);
-
-      case REACT_SUSPENSE_TYPE:
-        return createFiberFromSuspense(pendingProps, mode, lanes, key);
-
-      case REACT_SUSPENSE_LIST_TYPE:
-        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
-
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
-
-      case REACT_LEGACY_HIDDEN_TYPE: {
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      }
-
-      // eslint-disable-next-line no-fallthrough
-
-      case REACT_SCOPE_TYPE: {
-        return createFiberFromScope(type, pendingProps, mode, lanes, key);
-      }
-
-      // eslint-disable-next-line no-fallthrough
-
-      case REACT_CACHE_TYPE: {
-        return createFiberFromCache(pendingProps, mode, lanes, key);
-      }
-
-      // eslint-disable-next-line no-fallthrough
-
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing) {
-          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
-        }
+  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  var domElement;
 
-      // eslint-disable-next-line no-fallthrough
+  switch (namespace) {
+    case SVG_NAMESPACE:
+    case MATH_NAMESPACE:
+      domElement = ownerDocument.createElementNS(namespace, type);
+      break;
 
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = Mode;
-          mode |= DebugTracingMode;
+    default:
+      switch (type) {
+        case "svg":
+          domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
           break;
-        }
-
-      // eslint-disable-next-line no-fallthrough
-
-      default: {
-        if (typeof type === "object" && type !== null) {
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = ContextProvider;
-              break getTag;
-
-            case REACT_CONTEXT_TYPE:
-              // This is a consumer
-              fiberTag = ContextConsumer;
-              break getTag;
-
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = ForwardRef;
 
-              {
-                resolvedType = resolveForwardRefForHotReloading(resolvedType);
-              }
+        case "math":
+          domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+          break;
 
-              break getTag;
+        case "script":
+          domElement = createPotentiallyInlineScriptElement(ownerDocument);
+          break;
 
-            case REACT_MEMO_TYPE:
-              fiberTag = MemoComponent;
-              break getTag;
+        case "select":
+          domElement = createSelectElement(props, ownerDocument);
+          break;
 
-            case REACT_LAZY_TYPE:
-              fiberTag = LazyComponent;
-              resolvedType = null;
-              break getTag;
-          }
-        }
+        default:
+          domElement = createHTMLElement(type, props, ownerDocument);
+      }
+  }
 
-        var info = "";
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  return domElement;
+}
+function appendInitialChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function finalizeInitialChildren(domElement, type, props, hostContext) {
+  setInitialProperties(domElement, type, props);
 
-        {
-          if (
-            type === undefined ||
-            (typeof type === "object" &&
-              type !== null &&
-              Object.keys(type).length === 0)
-          ) {
-            info +=
-              " You likely forgot to export your component from the file " +
-              "it's defined in, or you might have mixed up default and " +
-              "named imports.";
-          }
+  switch (type) {
+    case "button":
+    case "input":
+    case "select":
+    case "textarea":
+      return !!props.autoFocus;
 
-          var ownerName = owner ? getComponentNameFromFiber(owner) : null;
+    case "img":
+      return true;
 
-          if (ownerName) {
-            info += "\n\nCheck the render method of `" + ownerName + "`.";
-          }
-        }
+    default:
+      return false;
+  }
+}
+function prepareUpdate(domElement, type, oldProps, newProps, hostContext) {
+  {
+    var hostContextDev = hostContext;
 
-        throw new Error(
-          "Element type is invalid: expected a string (for built-in " +
-            "components) or a class/function (for composite components) " +
-            ("but got: " + (type == null ? type : typeof type) + "." + info)
-        );
-      }
+    if (
+      typeof newProps.children !== typeof oldProps.children &&
+      (typeof newProps.children === "string" ||
+        typeof newProps.children === "number")
+    ) {
+      var string = "" + newProps.children;
+      var ownAncestorInfo = updatedAncestorInfoDev(
+        hostContextDev.ancestorInfo,
+        type
+      );
+      validateDOMNesting(null, string, ownAncestorInfo);
     }
   }
 
-  var fiber = createFiber(fiberTag, pendingProps, key, mode);
-  fiber.elementType = type;
-  fiber.type = resolvedType;
-  fiber.lanes = lanes;
-
+  return diffProperties(domElement, type, oldProps, newProps);
+}
+function shouldSetTextContent(type, props) {
+  return (
+    type === "textarea" ||
+    type === "noscript" ||
+    typeof props.children === "string" ||
+    typeof props.children === "number" ||
+    (typeof props.dangerouslySetInnerHTML === "object" &&
+      props.dangerouslySetInnerHTML !== null &&
+      props.dangerouslySetInnerHTML.__html != null)
+  );
+}
+function createTextInstance(
+  text,
+  rootContainerInstance,
+  hostContext,
+  internalInstanceHandle
+) {
   {
-    fiber._debugOwner = owner;
+    var hostContextDev = hostContext;
+    validateDOMNesting(null, text, hostContextDev.ancestorInfo);
   }
 
-  return fiber;
+  var textNode = createTextNode(text, rootContainerInstance);
+  precacheFiberNode(internalInstanceHandle, textNode);
+  return textNode;
 }
-function createFiberFromElement(element, mode, lanes) {
-  var owner = null;
+function getCurrentEventPriority() {
+  var currentEvent = window.event;
 
-  {
-    owner = element._owner;
+  if (currentEvent === undefined) {
+    return DefaultEventPriority;
   }
 
-  var type = element.type;
-  var key = element.key;
-  var pendingProps = element.props;
-  var fiber = createFiberFromTypeAndProps(
-    type,
-    key,
-    pendingProps,
-    owner,
-    mode,
-    lanes
-  );
-
-  {
-    fiber._debugSource = element._source;
-    fiber._debugOwner = element._owner;
-  }
+  return getEventPriority(currentEvent.type);
+}
+var isPrimaryRenderer = true;
+// if a component just imports ReactDOM (e.g. for findDOMNode).
+// Some environments might not have setTimeout or clearTimeout.
 
-  return fiber;
+var scheduleTimeout = typeof setTimeout === "function" ? setTimeout : undefined;
+var cancelTimeout =
+  typeof clearTimeout === "function" ? clearTimeout : undefined;
+var noTimeout = -1;
+var localPromise = typeof Promise === "function" ? Promise : undefined;
+var localRequestAnimationFrame =
+  typeof requestAnimationFrame === "function"
+    ? requestAnimationFrame
+    : scheduleTimeout;
+function getInstanceFromNode(node) {
+  return getClosestInstanceFromNode(node) || null;
 }
-function createFiberFromFragment(elements, mode, lanes, key) {
-  var fiber = createFiber(Fragment, elements, key, mode);
-  fiber.lanes = lanes;
-  return fiber;
+function preparePortalMount(portalInstance) {
+  listenToAllSupportedEvents(portalInstance);
 }
-
-function createFiberFromScope(scope, pendingProps, mode, lanes, key) {
-  var fiber = createFiber(ScopeComponent, pendingProps, key, mode);
-  fiber.type = scope;
-  fiber.elementType = scope;
-  fiber.lanes = lanes;
-  return fiber;
+function prepareScopeUpdate(scopeInstance, internalInstanceHandle) {
+  {
+    precacheFiberNode(internalInstanceHandle, scopeInstance);
+  }
 }
-
-function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+function getInstanceFromScope(scopeInstance) {
   {
-    if (typeof pendingProps.id !== "string") {
-      error(
-        'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
-        typeof pendingProps.id
-      );
-    }
+    return getFiberFromScopeInstance(scopeInstance);
   }
+} // -------------------
+var scheduleMicrotask =
+  typeof queueMicrotask === "function"
+    ? queueMicrotask
+    : typeof localPromise !== "undefined"
+    ? function (callback) {
+        return localPromise
+          .resolve(null)
+          .then(callback)
+          .catch(handleErrorInNextTick);
+      }
+    : scheduleTimeout; // TODO: Determine the best fallback here.
 
-  var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
-  fiber.elementType = REACT_PROFILER_TYPE;
-  fiber.lanes = lanes;
+function handleErrorInNextTick(error) {
+  setTimeout(function () {
+    throw error;
+  });
+} // -------------------
+function commitMount(domElement, type, newProps, internalInstanceHandle) {
+  // Despite the naming that might imply otherwise, this method only
+  // fires if there is an `Update` effect scheduled during mounting.
+  // This happens if `finalizeInitialChildren` returns `true` (which it
+  // does to implement the `autoFocus` attribute on the client). But
+  // there are also other cases when this might happen (such as patching
+  // up text content during hydration mismatch). So we'll check this again.
+  switch (type) {
+    case "button":
+    case "input":
+    case "select":
+    case "textarea":
+      if (newProps.autoFocus) {
+        domElement.focus();
+      }
 
-  {
-    fiber.stateNode = {
-      effectDuration: 0,
-      passiveEffectDuration: 0
-    };
-  }
+      return;
 
-  return fiber;
-}
+    case "img": {
+      if (newProps.src) {
+        domElement.src = newProps.src;
+      }
 
-function createFiberFromSuspense(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_SUSPENSE_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_OFFSCREEN_TYPE;
-  fiber.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: OffscreenVisible,
-    _pendingVisibility: OffscreenVisible,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
+      return;
     }
-  };
-  fiber.stateNode = primaryChildInstance;
-  return fiber;
+  }
 }
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(LegacyHiddenComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  fiber.lanes = lanes; // Adding a stateNode for legacy hidden because it's currently using
-  // the offscreen implementation, which depends on a state node
+function commitUpdate(
+  domElement,
+  updatePayload,
+  type,
+  oldProps,
+  newProps,
+  internalInstanceHandle
+) {
+  // Apply the diff to the DOM node.
+  updateProperties(domElement, updatePayload, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
+  // with current event handlers.
 
-  var instance = {
-    _visibility: OffscreenVisible,
-    _pendingVisibility: OffscreenVisible,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
-    }
-  };
-  fiber.stateNode = instance;
-  return fiber;
-}
-function createFiberFromCache(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(CacheComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_CACHE_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromTracingMarker(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(TracingMarkerComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_TRACING_MARKER_TYPE;
-  fiber.lanes = lanes;
-  var tracingMarkerInstance = {
-    tag: TransitionTracingMarker,
-    transitions: null,
-    pendingBoundaries: null,
-    aborts: null,
-    name: pendingProps.name
-  };
-  fiber.stateNode = tracingMarkerInstance;
-  return fiber;
+  updateFiberProps(domElement, newProps);
 }
-function createFiberFromText(content, mode, lanes) {
-  var fiber = createFiber(HostText, content, null, mode);
-  fiber.lanes = lanes;
-  return fiber;
+function resetTextContent(domElement) {
+  setTextContent(domElement, "");
 }
-function createFiberFromHostInstanceForDeletion() {
-  var fiber = createFiber(HostComponent, null, null, NoMode);
-  fiber.elementType = "DELETED";
-  return fiber;
+function commitTextUpdate(textInstance, oldText, newText) {
+  textInstance.nodeValue = newText;
 }
-function createFiberFromDehydratedFragment(dehydratedNode) {
-  var fiber = createFiber(DehydratedFragment, null, null, NoMode);
-  fiber.stateNode = dehydratedNode;
-  return fiber;
+function appendChild(parentInstance, child) {
+  parentInstance.appendChild(child);
 }
-function createFiberFromPortal(portal, mode, lanes) {
-  var pendingProps = portal.children !== null ? portal.children : [];
-  var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
-  fiber.lanes = lanes;
-  fiber.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    // Used by persistent updates
-    implementation: portal.implementation
-  };
-  return fiber;
-} // Used for stashing WIP properties to replay failed work in DEV.
+function appendChildToContainer(container, child) {
+  var parentNode;
 
-function assignFiberPropertiesInDEV(target, source) {
-  if (target === null) {
-    // This Fiber's initial properties will always be overwritten.
-    // We only use a Fiber to ensure the same hidden class so DEV isn't slow.
-    target = createFiber(IndeterminateComponent, null, null, NoMode);
-  } // This is intentionally written as a list of all properties.
-  // We tried to use Object.assign() instead but this is called in
-  // the hottest path, and Object.assign() was too slow:
-  // https://github.com/facebook/react/issues/12502
-  // This code is DEV-only so size is not a concern.
+  if (container.nodeType === COMMENT_NODE) {
+    parentNode = container.parentNode;
+    parentNode.insertBefore(child, container);
+  } else {
+    parentNode = container;
+    parentNode.appendChild(child);
+  } // This container might be used for a portal.
+  // If something inside a portal is clicked, that click should bubble
+  // through the React tree. However, on Mobile Safari the click would
+  // never bubble through the *DOM* tree unless an ancestor with onclick
+  // event exists. So we wouldn't see it and dispatch it.
+  // This is why we ensure that non React root containers have inline onclick
+  // defined.
+  // https://github.com/facebook/react/issues/11918
 
-  target.tag = source.tag;
-  target.key = source.key;
-  target.elementType = source.elementType;
-  target.type = source.type;
-  target.stateNode = source.stateNode;
-  target.return = source.return;
-  target.child = source.child;
-  target.sibling = source.sibling;
-  target.index = source.index;
-  target.ref = source.ref;
-  target.refCleanup = source.refCleanup;
-  target.pendingProps = source.pendingProps;
-  target.memoizedProps = source.memoizedProps;
-  target.updateQueue = source.updateQueue;
-  target.memoizedState = source.memoizedState;
-  target.dependencies = source.dependencies;
-  target.mode = source.mode;
-  target.flags = source.flags;
-  target.subtreeFlags = source.subtreeFlags;
-  target.deletions = source.deletions;
-  target.lanes = source.lanes;
-  target.childLanes = source.childLanes;
-  target.alternate = source.alternate;
+  var reactRootContainer = container._reactRootContainer;
 
-  {
-    target.actualDuration = source.actualDuration;
-    target.actualStartTime = source.actualStartTime;
-    target.selfBaseDuration = source.selfBaseDuration;
-    target.treeBaseDuration = source.treeBaseDuration;
+  if (
+    (reactRootContainer === null || reactRootContainer === undefined) &&
+    parentNode.onclick === null
+  ) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(parentNode);
+  }
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  parentInstance.insertBefore(child, beforeChild);
+}
+function insertInContainerBefore(container, child, beforeChild) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.insertBefore(child, beforeChild);
+  } else {
+    container.insertBefore(child, beforeChild);
   }
-
-  target._debugSource = source._debugSource;
-  target._debugOwner = source._debugOwner;
-  target._debugNeedsRemount = source._debugNeedsRemount;
-  target._debugHookTypes = source._debugHookTypes;
-  return target;
 }
 
-function FiberRootNode(
-  containerInfo, // $FlowFixMe[missing-local-annot]
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
-) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.pendingChildren = null;
-  this.current = null;
-  this.pingCache = null;
-  this.finishedWork = null;
-  this.timeoutHandle = noTimeout;
-  this.context = null;
-  this.pendingContext = null;
-  this.callbackNode = null;
-  this.callbackPriority = NoLane;
-  this.eventTimes = createLaneMap(NoLanes);
-  this.expirationTimes = createLaneMap(NoTimestamp);
-  this.pendingLanes = NoLanes;
-  this.suspendedLanes = NoLanes;
-  this.pingedLanes = NoLanes;
-  this.expiredLanes = NoLanes;
-  this.mutableReadLanes = NoLanes;
-  this.finishedLanes = NoLanes;
-  this.errorRecoveryDisabledLanes = NoLanes;
-  this.entangledLanes = NoLanes;
-  this.entanglements = createLaneMap(NoLanes);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
+function createEvent(type, bubbles) {
+  var event = document.createEvent("Event");
+  event.initEvent(type, bubbles, false);
+  return event;
+}
 
+function dispatchBeforeDetachedBlur(target, internalInstanceHandle) {
   {
-    this.pooledCache = null;
-    this.pooledCacheLanes = NoLanes;
+    var event = createEvent("beforeblur", true); // Dispatch "beforeblur" directly on the target,
+    // so it gets picked up by the event system and
+    // can propagate through the React internal tree.
+    // $FlowFixMe: internal field
+
+    event._detachedInterceptFiber = internalInstanceHandle;
+    target.dispatchEvent(event);
   }
+}
 
+function dispatchAfterDetachedBlur(target) {
   {
-    this.mutableSourceEagerHydrationData = null;
+    var event = createEvent("afterblur", false); // So we know what was detached, make the relatedTarget the
+    // detached target on the "afterblur" event.
+
+    event.relatedTarget = target; // Dispatch the event on the document.
+
+    document.dispatchEvent(event);
   }
+}
 
-  {
-    this.hydrationCallbacks = null;
+function removeChild(parentInstance, child) {
+  parentInstance.removeChild(child);
+}
+function removeChildFromContainer(container, child) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.removeChild(child);
+  } else {
+    container.removeChild(child);
   }
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  var node = suspenseInstance; // Delete all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
 
-  this.incompleteTransitions = new Map();
+  var depth = 0;
 
-  if (enableTransitionTracing) {
-    this.transitionCallbacks = null;
-    var transitionLanesMap = (this.transitionLanes = []);
+  do {
+    var nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
 
-    for (var i = 0; i < TotalLanes; i++) {
-      transitionLanesMap.push(null);
+    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
+      var data = nextNode.data;
+
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        } else {
+          depth--;
+        }
+      } else if (
+        data === SUSPENSE_START_DATA ||
+        data === SUSPENSE_PENDING_START_DATA ||
+        data === SUSPENSE_FALLBACK_START_DATA
+      ) {
+        depth++;
+      }
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+    node = nextNode;
+  } while (node); // TODO: Warn, we didn't find the end comment boundary.
+  // Retry if any event replaying was blocked on this.
+
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
+  if (container.nodeType === COMMENT_NODE) {
+    clearSuspenseBoundary(container.parentNode, suspenseInstance);
+  } else if (container.nodeType === ELEMENT_NODE) {
+    clearSuspenseBoundary(container, suspenseInstance);
+  } else; // Retry if any event replaying was blocked on this.
+
+  retryIfBlockedOn(container);
+}
+function hideInstance(instance) {
+  // TODO: Does this work for all element types? What about MathML? Should we
+  // pass host context to this method?
+  instance = instance;
+  var style = instance.style; // $FlowFixMe[method-unbinding]
+
+  if (typeof style.setProperty === "function") {
+    style.setProperty("display", "none", "important");
+  } else {
+    style.display = "none";
+  }
+}
+function hideTextInstance(textInstance) {
+  textInstance.nodeValue = "";
+}
+function unhideInstance(instance, props) {
+  instance = instance;
+  var styleProp = props[STYLE];
+  var display =
+    styleProp !== undefined &&
+    styleProp !== null &&
+    styleProp.hasOwnProperty("display")
+      ? styleProp.display
+      : null;
+  instance.style.display = dangerousStyleValue("display", display);
+}
+function unhideTextInstance(textInstance, text) {
+  textInstance.nodeValue = text;
+}
+function clearContainer(container) {
+  {
+    var nodeType = container.nodeType;
+
+    if (nodeType === DOCUMENT_NODE) {
+      clearContainerSparingly(container);
+    } else if (nodeType === ELEMENT_NODE) {
+      switch (container.nodeName) {
+        case "HEAD":
+        case "HTML":
+        case "BODY":
+          clearContainerSparingly(container);
+          return;
+
+        default: {
+          container.textContent = "";
+        }
+      }
     }
   }
+}
 
-  {
-    this.effectDuration = 0;
-    this.passiveEffectDuration = 0;
+function clearContainerSparingly(container) {
+  var node;
+  var nextNode = container.firstChild;
+
+  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
+    nextNode = nextNode.nextSibling;
   }
 
-  {
-    this.memoizedUpdaters = new Set();
-    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
+  while (nextNode) {
+    node = nextNode;
+    nextNode = nextNode.nextSibling;
 
-    for (var _i = 0; _i < TotalLanes; _i++) {
-      pendingUpdatersLaneMap.push(new Set());
+    switch (node.nodeName) {
+      case "HTML":
+      case "HEAD":
+      case "BODY": {
+        var element = node;
+        clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
+        // may still hold on to references to the previous fiber tree. We detatch them
+        // prospectively to reset them to a baseline starting state since we cannot create
+        // new instances.
+
+        detachDeletedInstance(element);
+        continue;
+      }
+
+      case "STYLE": {
+        continue;
+      }
+
+      case "LINK": {
+        if (node.rel.toLowerCase() === "stylesheet") {
+          continue;
+        }
+      }
     }
+
+    container.removeChild(node);
   }
 
-  {
-    switch (tag) {
-      case ConcurrentRoot:
-        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
-        break;
+  return;
+} // Making this so we can eventually move all of the instance caching to the commit phase.
+// inserted without breaking hydration
 
-      case LegacyRoot:
-        this._debugRootType = hydrate ? "hydrate()" : "render()";
-        break;
+function isHydratableType(type, props) {
+  {
+    if (type === "script") {
+      var async = props.async,
+        onLoad = props.onLoad,
+        onError = props.onError;
+      return !(async && (onLoad || onError));
     }
+
+    return true;
   }
 }
+function isHydratableText(text) {
+  return text !== "";
+}
+function shouldSkipHydratableForInstance(instance, type, props) {
+  if (instance.nodeType !== ELEMENT_NODE) {
+    // This is a suspense boundary or Text node.
+    // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
+    // and this is a hydration error.
+    // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
+    // but it seems reasonable and conservative to reject this as a hydration error as well
+    return false;
+  } else if (
+    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
+    isMarkedHoistable(instance)
+  ) {
+    // We are either about to
+    return true;
+  } else {
+    // We have an Element with the right type.
+    var element = instance;
+    var anyProps = props; // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
+    // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
+    // using high entropy attributes for certain types. This technique will fail for strange insertions like
+    // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
 
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
-  // host config, but because they are passed in at runtime, we have to thread
-  // them through the root constructor. Perhaps we should put them all into a
-  // single type, like a DynamicHostConfig that is defined by the renderer.
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
-) {
-  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
-  var root = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
-  );
+    switch (type) {
+      // case 'title':
+      //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
+      // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
+      case "meta": {
+        // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
+        // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
+        // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
+        // implications are minimal
+        if (!element.hasAttribute("itemprop")) {
+          // This is a Hoistable
+          return true;
+        }
 
-  {
-    root.hydrationCallbacks = hydrationCallbacks;
-  }
+        break;
+      }
 
-  if (enableTransitionTracing) {
-    root.transitionCallbacks = transitionCallbacks;
-  } // Cyclic construction. This cheats the type system right now because
-  // stateNode is any.
+      case "link": {
+        // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
+        // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
+        // matches.
+        var rel = element.getAttribute("rel");
 
-  var uninitializedFiber = createHostRootFiber(
-    tag,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride
-  );
-  root.current = uninitializedFiber;
-  uninitializedFiber.stateNode = root;
+        if (rel === "stylesheet" && element.hasAttribute("data-precedence")) {
+          // This is a stylesheet resource
+          return true;
+        } else if (
+          rel !== anyProps.rel ||
+          element.getAttribute("href") !==
+            (anyProps.href == null ? null : anyProps.href) ||
+          element.getAttribute("crossorigin") !==
+            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) ||
+          element.getAttribute("title") !==
+            (anyProps.title == null ? null : anyProps.title)
+        ) {
+          // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
+          // and title could vary for rel alternate
+          return true;
+        }
 
-  {
-    var initialCache = createCache();
-    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
-    // for newly mounted boundaries during a render. In general, the
-    // pooledCache is always cleared from the root at the end of a render:
-    // it is either released when render commits, or moved to an Offscreen
-    // component if rendering suspends. Because the lifetime of the pooled
-    // cache is distinct from the main memoizedState.cache, it must be
-    // retained separately.
+        break;
+      }
 
-    root.pooledCache = initialCache;
-    retainCache(initialCache);
-    var initialState = {
-      element: initialChildren,
-      isDehydrated: hydrate,
-      cache: initialCache
-    };
-    uninitializedFiber.memoizedState = initialState;
-  }
+      case "style": {
+        // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
+        // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
+        if (element.hasAttribute("data-precedence")) {
+          // This is a style resource
+          return true;
+        }
 
-  initializeUpdateQueue(uninitializedFiber);
-  return root;
-}
+        break;
+      }
 
-var ReactVersion = "18.3.0-www-modern-ce2970c7";
+      case "script": {
+        // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
+        // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
+        // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
+        // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
+        // if we learn it is problematic
+        var srcAttr = element.getAttribute("src");
 
-function createPortal$1(
-  children,
-  containerInfo, // TODO: figure out the API for cross-renderer implementation.
-  implementation
-) {
-  var key =
-    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+        if (
+          srcAttr &&
+          element.hasAttribute("async") &&
+          !element.hasAttribute("itemprop")
+        ) {
+          // This is an async script resource
+          return true;
+        } else if (
+          srcAttr !== (anyProps.src == null ? null : anyProps.src) ||
+          element.getAttribute("type") !==
+            (anyProps.type == null ? null : anyProps.type) ||
+          element.getAttribute("crossorigin") !==
+            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)
+        ) {
+          // This script is for a different src
+          return true;
+        }
 
-  {
-    checkKeyStringCoercion(key);
+        break;
+      }
+    } // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
+    // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
+    // that should work in the vast majority of cases.
+
+    return false;
+  }
+}
+function shouldSkipHydratableForTextInstance(instance) {
+  return instance.nodeType === ELEMENT_NODE;
+}
+function shouldSkipHydratableForSuspenseInstance(instance) {
+  return instance.nodeType === ELEMENT_NODE;
+}
+function canHydrateInstance(instance, type, props) {
+  if (
+    instance.nodeType !== ELEMENT_NODE ||
+    instance.nodeName.toLowerCase() !== type.toLowerCase()
+  ) {
+    return null;
+  } else {
+    return instance;
   }
+}
+function canHydrateTextInstance(instance, text) {
+  if (text === "") return null;
 
-  return {
-    // This tag allow us to uniquely identify this as a React Portal
-    $$typeof: REACT_PORTAL_TYPE,
-    key: key == null ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
-  };
+  if (instance.nodeType !== TEXT_NODE) {
+    // Empty strings are not parsed by HTML so there won't be a correct match here.
+    return null;
+  } // This has now been refined to a text node.
+
+  return instance;
+}
+function canHydrateSuspenseInstance(instance) {
+  if (instance.nodeType !== COMMENT_NODE) {
+    return null;
+  } // This has now been refined to a suspense node.
+
+  return instance;
+}
+function isSuspenseInstancePending(instance) {
+  return instance.data === SUSPENSE_PENDING_START_DATA;
+}
+function isSuspenseInstanceFallback(instance) {
+  return instance.data === SUSPENSE_FALLBACK_START_DATA;
 }
+function getSuspenseInstanceFallbackErrorDetails(instance) {
+  var dataset = instance.nextSibling && instance.nextSibling.dataset;
+  var digest, message, stack;
 
-// Might add PROFILE later.
+  if (dataset) {
+    digest = dataset.dgst;
 
-var didWarnAboutNestedUpdates;
+    {
+      message = dataset.msg;
+      stack = dataset.stck;
+    }
+  }
 
-{
-  didWarnAboutNestedUpdates = false;
+  {
+    return {
+      message: message,
+      digest: digest,
+      stack: stack
+    };
+  }
+}
+function registerSuspenseInstanceRetry(instance, callback) {
+  instance._reactRetry = callback;
 }
 
-function getContextForSubtree(parentComponent) {
-  if (!parentComponent) {
-    return emptyContextObject;
-  }
+function getNextHydratable(node) {
+  // Skip non-hydratable nodes.
+  for (; node != null; node = node.nextSibling) {
+    var nodeType = node.nodeType;
 
-  var fiber = get(parentComponent);
-  var parentContext = findCurrentUnmaskedContext();
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
+      break;
+    }
 
-  if (fiber.tag === ClassComponent) {
-    var Component = fiber.type;
+    if (nodeType === COMMENT_NODE) {
+      var nodeData = node.data;
 
-    if (isContextProvider()) {
-      return processChildContext(fiber, Component, parentContext);
+      if (
+        nodeData === SUSPENSE_START_DATA ||
+        nodeData === SUSPENSE_FALLBACK_START_DATA ||
+        nodeData === SUSPENSE_PENDING_START_DATA
+      ) {
+        break;
+      }
+
+      if (nodeData === SUSPENSE_END_DATA) {
+        return null;
+      }
     }
   }
 
-  return parentContext;
+  return node;
 }
 
-function createContainer(
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
-) {
-  var hydrate = false;
-  var initialChildren = null;
-  return createFiberRoot(
-    containerInfo,
-    tag,
-    hydrate,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
-  );
+function getNextHydratableSibling(instance) {
+  return getNextHydratable(instance.nextSibling);
 }
-function createHydrationContainer(
-  initialChildren, // TODO: Remove `callback` when we delete legacy mode.
-  callback,
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+function getFirstHydratableChild(parentInstance) {
+  return getNextHydratable(parentInstance.firstChild);
+}
+function getFirstHydratableChildWithinContainer(parentContainer) {
+  return getNextHydratable(parentContainer.firstChild);
+}
+function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
+  return getNextHydratable(parentInstance.nextSibling);
+}
+function hydrateInstance(
+  instance,
+  type,
+  props,
+  hostContext,
+  internalInstanceHandle,
+  shouldWarnDev
 ) {
-  var hydrate = true;
-  var root = createFiberRoot(
-    containerInfo,
-    tag,
-    hydrate,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
-  ); // TODO: Move this to FiberRoot constructor
+  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
+  // get attached.
 
-  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
-  // a regular update because the initial render must match was was rendered
-  // on the server.
-  // NOTE: This update intentionally doesn't have a payload. We're only using
-  // the update to schedule work on the root fiber (and, for legacy roots, to
-  // enqueue the callback if one is provided).
+  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  // when the legacy root API is removed.
+
+  var isConcurrentMode =
+    (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
+  var parentNamespace;
 
-  var current = root.current;
-  var lane = requestUpdateLane(current);
-  var update = createUpdate(lane);
-  update.callback =
-    callback !== undefined && callback !== null ? callback : null;
-  var eventTime = requestEventTime();
-  enqueueUpdate(current, update, lane);
-  scheduleInitialHydrationOnRoot(root, lane, eventTime);
-  return root;
-}
-function updateContainer(element, container, parentComponent, callback) {
   {
-    onScheduleRoot(container, element);
+    var hostContextDev = hostContext;
+    parentNamespace = hostContextDev.namespace;
   }
 
-  var current$1 = container.current;
-  var lane = requestUpdateLane(current$1);
+  return diffHydratedProperties(
+    instance,
+    type,
+    props,
+    isConcurrentMode,
+    shouldWarnDev,
+    parentNamespace
+  );
+}
+function hydrateTextInstance(
+  textInstance,
+  text,
+  internalInstanceHandle,
+  shouldWarnDev
+) {
+  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  return diffHydratedText(textInstance, text);
+}
+function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
+  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+}
+function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
+  var node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
 
-  if (enableSchedulingProfiler) {
-    markRenderScheduled(lane);
-  }
+  var depth = 0;
 
-  var context = getContextForSubtree(parentComponent);
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      var data = node.data;
 
-  if (container.context === null) {
-    container.context = context;
-  } else {
-    container.pendingContext = context;
-  }
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          return getNextHydratableSibling(node);
+        } else {
+          depth--;
+        }
+      } else if (
+        data === SUSPENSE_START_DATA ||
+        data === SUSPENSE_FALLBACK_START_DATA ||
+        data === SUSPENSE_PENDING_START_DATA
+      ) {
+        depth++;
+      }
+    }
 
-  {
-    if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
-      didWarnAboutNestedUpdates = true;
+    node = node.nextSibling;
+  } // TODO: Warn, we didn't find the end comment boundary.
 
-      error(
-        "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.",
-        getComponentNameFromFiber(current) || "Unknown"
-      );
-    }
-  }
+  return null;
+} // Returns the SuspenseInstance if this node is a direct child of a
+// SuspenseInstance. I.e. if its previous sibling is a Comment with
+// SUSPENSE_x_START_DATA. Otherwise, null.
 
-  var update = createUpdate(lane); // Caution: React DevTools currently depends on this property
-  // being called "element".
+function getParentSuspenseInstance(targetInstance) {
+  var node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
 
-  update.payload = {
-    element: element
-  };
-  callback = callback === undefined ? null : callback;
+  var depth = 0;
 
-  if (callback !== null) {
-    {
-      if (typeof callback !== "function") {
-        error(
-          "render(...): Expected the last optional `callback` argument to be a " +
-            "function. Instead received: %s.",
-          callback
-        );
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      var data = node.data;
+
+      if (
+        data === SUSPENSE_START_DATA ||
+        data === SUSPENSE_FALLBACK_START_DATA ||
+        data === SUSPENSE_PENDING_START_DATA
+      ) {
+        if (depth === 0) {
+          return node;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_END_DATA) {
+        depth++;
       }
     }
 
-    update.callback = callback;
+    node = node.previousSibling;
   }
 
-  var root = enqueueUpdate(current$1, update, lane);
-
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, current$1, lane, eventTime);
-    entangleTransitions(root, current$1, lane);
+  return null;
+}
+function commitHydratedContainer(container) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(container);
+}
+function commitHydratedSuspenseInstance(suspenseInstance) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(suspenseInstance);
+} // @TODO remove this function once float lands and hydrated tail nodes
+function didNotMatchHydratedContainerTextInstance(
+  parentContainer,
+  textInstance,
+  text,
+  isConcurrentMode,
+  shouldWarnDev
+) {
+  checkForUnmatchedText(
+    textInstance.nodeValue,
+    text,
+    isConcurrentMode,
+    shouldWarnDev
+  );
+}
+function didNotMatchHydratedTextInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  textInstance,
+  text,
+  isConcurrentMode,
+  shouldWarnDev
+) {
+  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+    checkForUnmatchedText(
+      textInstance.nodeValue,
+      text,
+      isConcurrentMode,
+      shouldWarnDev
+    );
   }
-
-  return lane;
 }
-function attemptSynchronousHydration(fiber) {
-  switch (fiber.tag) {
-    case HostRoot: {
-      var root = fiber.stateNode;
-
-      if (isRootDehydrated(root)) {
-        // Flush the first scheduled "update".
-        var lanes = getHighestPriorityPendingLanes(root);
-        flushRoot(root, lanes);
-      }
-
-      break;
-    }
-
-    case SuspenseComponent: {
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
-        if (root !== null) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);
-        }
-      }); // If we're still blocked after this, we need to increase
-      // the priority of any promises resolving within this
-      // boundary so that they next attempt also has higher pri.
-
-      var retryLane = SyncLane;
-      markRetryLaneIfNotHydrated(fiber, retryLane);
-      break;
+function didNotHydrateInstanceWithinContainer(parentContainer, instance) {
+  {
+    if (instance.nodeType === ELEMENT_NODE) {
+      warnForDeletedHydratableElement(parentContainer, instance);
+    } else if (instance.nodeType === COMMENT_NODE);
+    else {
+      warnForDeletedHydratableText(parentContainer, instance);
     }
   }
 }
+function didNotHydrateInstanceWithinSuspenseInstance(parentInstance, instance) {
+  {
+    // $FlowFixMe: Only Element or Document can be parent nodes.
+    var parentNode = parentInstance.parentNode;
 
-function markRetryLaneImpl(fiber, retryLane) {
-  var suspenseState = fiber.memoizedState;
-
-  if (suspenseState !== null && suspenseState.dehydrated !== null) {
-    suspenseState.retryLane = higherPriorityLane(
-      suspenseState.retryLane,
-      retryLane
-    );
-  }
-} // Increases the priority of thenables when they resolve within this boundary.
-
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  var alternate = fiber.alternate;
-
-  if (alternate) {
-    markRetryLaneImpl(alternate, retryLane);
+    if (parentNode !== null) {
+      if (instance.nodeType === ELEMENT_NODE) {
+        warnForDeletedHydratableElement(parentNode, instance);
+      } else if (instance.nodeType === COMMENT_NODE);
+      else {
+        warnForDeletedHydratableText(parentNode, instance);
+      }
+    }
   }
 }
-
-function attemptDiscreteHydration(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority and they should not suspend on I/O,
-    // since you have to wrap anything that might suspend in
-    // Suspense.
-    return;
+function didNotHydrateInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  instance,
+  isConcurrentMode
+) {
+  {
+    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+      if (instance.nodeType === ELEMENT_NODE) {
+        warnForDeletedHydratableElement(parentInstance, instance);
+      } else if (instance.nodeType === COMMENT_NODE);
+      else {
+        warnForDeletedHydratableText(parentInstance, instance);
+      }
+    }
   }
-
-  var lane = SyncLane;
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
-
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+}
+function didNotFindHydratableInstanceWithinContainer(
+  parentContainer,
+  type,
+  props
+) {
+  {
+    warnForInsertedHydratedElement(parentContainer, type);
   }
-
-  markRetryLaneIfNotHydrated(fiber, lane);
 }
-function attemptContinuousHydration(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority and they should not suspend on I/O,
-    // since you have to wrap anything that might suspend in
-    // Suspense.
-    return;
+function didNotFindHydratableTextInstanceWithinContainer(
+  parentContainer,
+  text
+) {
+  {
+    warnForInsertedHydratedText(parentContainer, text);
   }
-
-  var lane = SelectiveHydrationLane;
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
-
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+}
+function didNotFindHydratableInstanceWithinSuspenseInstance(
+  parentInstance,
+  type,
+  props
+) {
+  {
+    // $FlowFixMe: Only Element or Document can be parent nodes.
+    var parentNode = parentInstance.parentNode;
+    if (parentNode !== null) warnForInsertedHydratedElement(parentNode, type);
   }
-
-  markRetryLaneIfNotHydrated(fiber, lane);
 }
-function attemptHydrationAtCurrentPriority(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority other than synchronously flush it.
-    return;
+function didNotFindHydratableTextInstanceWithinSuspenseInstance(
+  parentInstance,
+  text
+) {
+  {
+    // $FlowFixMe: Only Element or Document can be parent nodes.
+    var parentNode = parentInstance.parentNode;
+    if (parentNode !== null) warnForInsertedHydratedText(parentNode, text);
   }
-
-  var lane = requestUpdateLane(fiber);
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
-
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+}
+function didNotFindHydratableInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  type,
+  props,
+  isConcurrentMode
+) {
+  {
+    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+      warnForInsertedHydratedElement(parentInstance, type);
+    }
   }
-
-  markRetryLaneIfNotHydrated(fiber, lane);
 }
-
-var shouldErrorImpl = function (fiber) {
-  return null;
-};
-
-function shouldError(fiber) {
-  return shouldErrorImpl(fiber);
+function didNotFindHydratableTextInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  text,
+  isConcurrentMode
+) {
+  {
+    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+      warnForInsertedHydratedText(parentInstance, text);
+    }
+  }
 }
+function errorHydratingContainer(parentContainer) {
+  {
+    // TODO: This gets logged by onRecoverableError, too, so we should be
+    // able to remove it.
+    error(
+      "An error occurred during hydration. The server HTML was replaced with client content in <%s>.",
+      parentContainer.nodeName.toLowerCase()
+    );
+  }
+} // -------------------
+function requestPostPaintCallback(callback) {
+  localRequestAnimationFrame(function () {
+    localRequestAnimationFrame(function (time) {
+      return callback(time);
+    });
+  });
+} // -------------------
+function isHostHoistableType(type, props, hostContext) {
+  var outsideHostContainerContext;
+  var namespace;
 
-var shouldSuspendImpl = function (fiber) {
-  return false;
-};
-
-function shouldSuspend(fiber) {
-  return shouldSuspendImpl(fiber);
-}
-var overrideHookState = null;
-var overrideHookStateDeletePath = null;
-var overrideHookStateRenamePath = null;
-var overrideProps = null;
-var overridePropsDeletePath = null;
-var overridePropsRenamePath = null;
-var scheduleUpdate = null;
-var setErrorHandler = null;
-var setSuspenseHandler = null;
+  {
+    var hostContextDev = hostContext; // We can only render resources when we are not within the host container context
 
-{
-  var copyWithDeleteImpl = function (obj, path, index) {
-    var key = path[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+    outsideHostContainerContext =
+      !hostContextDev.ancestorInfo.containerTagInScope;
+    namespace = hostContextDev.namespace;
+  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
 
-    if (index + 1 === path.length) {
-      if (isArray(updated)) {
-        updated.splice(key, 1);
-      } else {
-        delete updated[key];
+  if (namespace === SVG_NAMESPACE || props.itemProp != null) {
+    {
+      if (
+        outsideHostContainerContext &&
+        props.itemProp != null &&
+        (type === "meta" ||
+          type === "title" ||
+          type === "style" ||
+          type === "link" ||
+          type === "script")
+      ) {
+        error(
+          "Cannot render a <%s> outside the main document if it has an `itemProp` prop. `itemProp` suggests the tag belongs to an" +
+            " `itemScope` which can appear anywhere in the DOM. If you were intending for React to hoist this <%s> remove the `itemProp` prop." +
+            " Otherwise, try moving this tag into the <head> or <body> of the Document.",
+          type,
+          type
+        );
       }
+    }
 
-      return updated;
-    } // $FlowFixMe number or string is fine here
+    return false;
+  }
 
-    updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
-    return updated;
-  };
+  switch (type) {
+    case "meta":
+    case "title": {
+      return true;
+    }
 
-  var copyWithDelete = function (obj, path) {
-    return copyWithDeleteImpl(obj, path, 0);
-  };
+    case "style": {
+      if (
+        typeof props.precedence !== "string" ||
+        typeof props.href !== "string" ||
+        props.href === ""
+      ) {
+        {
+          if (outsideHostContainerContext) {
+            error(
+              "Cannot render a <style> outside the main document without knowing its precedence and a unique href key." +
+                " React can hoist and deduplicate <style> tags if you provide a `precedence` prop along with an `href` prop that" +
+                ' does not conflic with the `href` values used in any other hoisted <style> or <link rel="stylesheet" ...> tags. ' +
+                " Note that hoisting <style> tags is considered an advanced feature that most will not use directly." +
+                ' Consider moving the <style> tag to the <head> or consider adding a `precedence="default"` and `href="some unique resource identifier"`, or move the <style>' +
+                " to the <style> tag."
+            );
+          }
+        }
 
-  var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
-    var oldKey = oldPath[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+        return false;
+      }
 
-    if (index + 1 === oldPath.length) {
-      var newKey = newPath[index]; // $FlowFixMe number or string is fine here
+      return true;
+    }
 
-      updated[newKey] = updated[oldKey];
+    case "link": {
+      if (
+        typeof props.rel !== "string" ||
+        typeof props.href !== "string" ||
+        props.href === "" ||
+        props.onLoad ||
+        props.onError
+      ) {
+        {
+          if (
+            props.rel === "stylesheet" &&
+            typeof props.precedence === "string"
+          ) {
+            validateLinkPropsForStyleResource(props);
+          }
 
-      if (isArray(updated)) {
-        updated.splice(oldKey, 1);
-      } else {
-        delete updated[oldKey];
+          if (outsideHostContainerContext) {
+            if (
+              typeof props.rel !== "string" ||
+              typeof props.href !== "string" ||
+              props.href === ""
+            ) {
+              error(
+                "Cannot render a <link> outside the main document without a `rel` and `href` prop." +
+                  " Try adding a `rel` and/or `href` prop to this <link> or moving the link into the <head> tag"
+              );
+            } else if (props.onError || props.onLoad) {
+              error(
+                "Cannot render a <link> with onLoad or onError listeners outside the main document." +
+                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
+                  " somewhere in the <body>."
+              );
+            }
+          }
+        }
+
+        return false;
       }
-    } else {
-      // $FlowFixMe number or string is fine here
-      updated[oldKey] = copyWithRenameImpl(
-        // $FlowFixMe number or string is fine here
-        obj[oldKey],
-        oldPath,
-        newPath,
-        index + 1
-      );
-    }
 
-    return updated;
-  };
+      switch (props.rel) {
+        case "stylesheet": {
+          var precedence = props.precedence,
+            disabled = props.disabled;
 
-  var copyWithRename = function (obj, oldPath, newPath) {
-    if (oldPath.length !== newPath.length) {
-      warn("copyWithRename() expects paths of the same length");
+          {
+            if (typeof precedence !== "string") {
+              if (outsideHostContainerContext) {
+                error(
+                  'Cannot render a <link rel="stylesheet" /> outside the main document without knowing its precedence.' +
+                    ' Consider adding precedence="default" or moving it into the root <head> tag.'
+                );
+              }
+            }
+          }
 
-      return;
-    } else {
-      for (var i = 0; i < newPath.length - 1; i++) {
-        if (oldPath[i] !== newPath[i]) {
-          warn(
-            "copyWithRename() expects paths to be the same except for the deepest key"
-          );
+          return typeof precedence === "string" && disabled == null;
+        }
 
-          return;
+        default: {
+          return true;
         }
       }
     }
 
-    return copyWithRenameImpl(obj, oldPath, newPath, 0);
-  };
-
-  var copyWithSetImpl = function (obj, path, index, value) {
-    if (index >= path.length) {
-      return value;
-    }
-
-    var key = path[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj); // $FlowFixMe number or string is fine here
-
-    updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
-    return updated;
-  };
-
-  var copyWithSet = function (obj, path, value) {
-    return copyWithSetImpl(obj, path, 0, value);
-  };
+    case "script": {
+      if (
+        props.async !== true ||
+        props.onLoad ||
+        props.onError ||
+        typeof props.src !== "string" ||
+        !props.src
+      ) {
+        {
+          if (outsideHostContainerContext) {
+            if (props.async !== true) {
+              error(
+                "Cannot render a sync or defer <script> outside the main document without knowing its order." +
+                  ' Try adding async="" or moving it into the root <head> tag.'
+              );
+            } else if (props.onLoad || props.onError) {
+              error(
+                "Cannot render a <script> with onLoad or onError listeners outside the main document." +
+                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
+                  " somewhere in the <body>."
+              );
+            } else {
+              error(
+                "Cannot render a <script> outside the main document without `async={true}` and a non-empty `src` prop." +
+                  " Ensure there is a valid `src` and either make the script async or move it into the root <head> tag or" +
+                  " somewhere in the <body>."
+              );
+            }
+          }
+        }
 
-  var findHook = function (fiber, id) {
-    // For now, the "id" of stateful hooks is just the stateful hook index.
-    // This may change in the future with e.g. nested hooks.
-    var currentHook = fiber.memoizedState;
+        return false;
+      }
 
-    while (currentHook !== null && id > 0) {
-      currentHook = currentHook.next;
-      id--;
+      return true;
     }
 
-    return currentHook;
-  }; // Support DevTools editable values for useState and useReducer.
-
-  overrideHookState = function (fiber, id, path, value) {
-    var hook = findHook(fiber, id);
+    case "noscript":
+    case "template": {
+      {
+        if (outsideHostContainerContext) {
+          error(
+            "Cannot render <%s> outside the main document. Try moving it into the root <head> tag.",
+            type
+          );
+        }
+      }
 
-    if (hook !== null) {
-      var newState = copyWithSet(hook.memoizedState, path, value);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+      return false;
+    }
+  }
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  return false;
+}
+function prepareRendererToRender(rootContainer) {
+  {
+    prepareToRenderResources(rootContainer);
+  }
+}
+function resetRendererAfterRender() {
+  {
+    cleanupAfterRenderResources();
+  }
+}
+function isHostSingletonType(type) {
+  return type === "html" || type === "head" || type === "body";
+}
+function resolveSingletonInstance(
+  type,
+  props,
+  rootContainerInstance,
+  hostContext,
+  validateDOMNestingDev
+) {
+  {
+    var hostContextDev = hostContext;
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-      }
+    if (validateDOMNestingDev) {
+      validateDOMNesting(type, null, hostContextDev.ancestorInfo);
     }
-  };
-
-  overrideHookStateDeletePath = function (fiber, id, path) {
-    var hook = findHook(fiber, id);
+  }
 
-    if (hook !== null) {
-      var newState = copyWithDelete(hook.memoizedState, path);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  switch (type) {
+    case "html": {
+      var documentElement = ownerDocument.documentElement;
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      if (!documentElement) {
+        throw new Error(
+          "React expected an <html> element (document.documentElement) to exist in the Document but one was" +
+            " not found. React never removes the documentElement for any Document it renders into so" +
+            " the cause is likely in some other script running on this page."
+        );
       }
-    }
-  };
-
-  overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
-    var hook = findHook(fiber, id);
 
-    if (hook !== null) {
-      var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+      return documentElement;
+    }
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    case "head": {
+      var head = ownerDocument.head;
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      if (!head) {
+        throw new Error(
+          "React expected a <head> element (document.head) to exist in the Document but one was" +
+            " not found. React never removes the head for any Document it renders into so" +
+            " the cause is likely in some other script running on this page."
+        );
       }
-    }
-  }; // Support DevTools props for function components, forwardRef, memo, host components, etc.
-
-  overrideProps = function (fiber, path, value) {
-    fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
+      return head;
     }
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-    }
-  };
+    case "body": {
+      var body = ownerDocument.body;
 
-  overridePropsDeletePath = function (fiber, path) {
-    fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
+      if (!body) {
+        throw new Error(
+          "React expected a <body> element (document.body) to exist in the Document but one was" +
+            " not found. React never removes the body for any Document it renders into so" +
+            " the cause is likely in some other script running on this page."
+        );
+      }
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
+      return body;
     }
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    default: {
+      throw new Error(
+        "resolveSingletonInstance was called with an element type that is not supported. This is a bug in React."
+      );
     }
-  };
+  }
+}
+function acquireSingletonInstance(
+  type,
+  props,
+  instance,
+  internalInstanceHandle
+) {
+  {
+    var currentInstanceHandle = getInstanceFromNode$1(instance);
 
-  overridePropsRenamePath = function (fiber, oldPath, newPath) {
-    fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
+    if (currentInstanceHandle) {
+      var tagName = instance.tagName.toLowerCase();
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
+      error(
+        "You are mounting a new %s component when a previous one has not first unmounted. It is an" +
+          " error to render more than one %s component at a time and attributes and children of these" +
+          " components will likely fail in unpredictable ways. Please only render a single instance of" +
+          " <%s> and if you need to mount a new one, ensure any previous ones have unmounted first.",
+        tagName,
+        tagName,
+        tagName
+      );
     }
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    switch (type) {
+      case "html":
+      case "head":
+      case "body": {
+        break;
+      }
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      default: {
+        error(
+          "acquireSingletonInstance was called with an element type that is not supported. This is a bug in React."
+        );
+      }
     }
-  };
-
-  scheduleUpdate = function (fiber) {
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  }
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-    }
-  };
+  var attributes = instance.attributes;
 
-  setErrorHandler = function (newShouldErrorImpl) {
-    shouldErrorImpl = newShouldErrorImpl;
-  };
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
 
-  setSuspenseHandler = function (newShouldSuspendImpl) {
-    shouldSuspendImpl = newShouldSuspendImpl;
-  };
+  setInitialProperties(instance, type, props);
+  precacheFiberNode(internalInstanceHandle, instance);
+  updateFiberProps(instance, props);
 }
+function releaseSingletonInstance(instance) {
+  var attributes = instance.attributes;
 
-function findHostInstanceByFiber(fiber) {
-  var hostFiber = findCurrentHostFiber(fiber);
-
-  if (hostFiber === null) {
-    return null;
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
   }
 
-  return hostFiber.stateNode;
+  detachDeletedInstance(instance);
 }
+function clearSingleton(instance) {
+  var element = instance;
+  var node = element.firstChild;
 
-function emptyFindFiberByHostInstance(instance) {
-  return null;
-}
+  while (node) {
+    var nextNode = node.nextSibling;
+    var nodeName = node.nodeName;
 
-function getCurrentFiberForDevTools() {
-  return current;
-}
+    if (
+      isMarkedHoistable(node) ||
+      nodeName === "HEAD" ||
+      nodeName === "BODY" ||
+      nodeName === "STYLE" ||
+      (nodeName === "LINK" && node.rel.toLowerCase() === "stylesheet")
+    );
+    else {
+      element.removeChild(node);
+    }
 
-function injectIntoDevTools(devToolsConfig) {
-  var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
-  var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
-  return injectInternals({
-    bundleType: devToolsConfig.bundleType,
-    version: devToolsConfig.version,
-    rendererPackageName: devToolsConfig.rendererPackageName,
-    rendererConfig: devToolsConfig.rendererConfig,
-    overrideHookState: overrideHookState,
-    overrideHookStateDeletePath: overrideHookStateDeletePath,
-    overrideHookStateRenamePath: overrideHookStateRenamePath,
-    overrideProps: overrideProps,
-    overridePropsDeletePath: overridePropsDeletePath,
-    overridePropsRenamePath: overridePropsRenamePath,
-    setErrorHandler: setErrorHandler,
-    setSuspenseHandler: setSuspenseHandler,
-    scheduleUpdate: scheduleUpdate,
-    currentDispatcherRef: ReactCurrentDispatcher,
-    findHostInstanceByFiber: findHostInstanceByFiber,
-    findFiberByHostInstance:
-      findFiberByHostInstance || emptyFindFiberByHostInstance,
-    // React Refresh
-    findHostInstancesForRefresh: findHostInstancesForRefresh,
-    scheduleRefresh: scheduleRefresh,
-    scheduleRoot: scheduleRoot,
-    setRefreshHandler: setRefreshHandler,
-    // Enables DevTools to append owner stacks to error messages in DEV mode.
-    getCurrentFiber: getCurrentFiberForDevTools,
-    // Enables DevTools to detect reconciler version rather than renderer version
-    // which may not match for third party renderers.
-    reconcilerVersion: ReactVersion
-  });
+    node = nextNode;
+  }
+
+  return;
 }
 
 var Dispatcher = Internals.Dispatcher;
@@ -43210,13 +43156,6 @@ function preinit() {
   // so we favor silent bailout over warning or erroring.
 }
 
-setAttemptSynchronousHydration(attemptSynchronousHydration);
-setAttemptDiscreteHydration(attemptDiscreteHydration);
-setAttemptContinuousHydration(attemptContinuousHydration);
-setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority);
-setGetCurrentUpdatePriority(getCurrentUpdatePriority$1);
-setAttemptHydrationAtPriority(runWithPriority);
-
 {
   if (
     typeof Map !== "function" || // $FlowFixMe Flow incorrectly thinks Map has no prototype
@@ -43234,9 +43173,6 @@ setAttemptHydrationAtPriority(runWithPriority);
   }
 }
 
-setRestoreImplementation(restoreControlledState);
-setBatchingImplementation(batchedUpdates, discreteUpdates, flushSync$1);
-
 function createPortal(children, container) {
   var key =
     arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
@@ -43299,7 +43235,7 @@ Internals.Events = [
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
 var foundDevTools = injectIntoDevTools({
   findFiberByHostInstance: getClosestInstanceFromNode,
@@ -43344,7 +43280,7 @@ exports.preconnect = preconnect;
 exports.prefetchDNS = prefetchDNS;
 exports.preinit = preinit;
 exports.preload = preload;
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = createEventHandle;
 exports.unstable_flushControlled = flushControlled;
 exports.unstable_runWithPriority = runWithPriority;
diff --git a/compiled/facebook-www/ReactDOM-prod.classic.js b/compiled/facebook-www/ReactDOM-prod.classic.js
index 9f6141bc1ddb4..0d7f4a31bd304 100644
--- a/compiled/facebook-www/ReactDOM-prod.classic.js
+++ b/compiled/facebook-www/ReactDOM-prod.classic.js
@@ -20,6 +20,7 @@ var Scheduler = require("scheduler"),
   dynamicFeatureFlags = require("ReactFeatureFlags"),
   disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   enableFilterEmptyStringAttributesDOM =
@@ -1354,7 +1355,10 @@ function setInitialProperties(domElement, tag, rawProps) {
         ? setValueForStyles(domElement, nextProp)
         : "dangerouslySetInnerHTML" === propKey
         ? ((nextProp = nextProp ? nextProp.__html : void 0),
-          null != nextProp && setInnerHTML$1(domElement, nextProp))
+          null != nextProp &&
+            (disableIEWorkarounds
+              ? (domElement.innerHTML = nextProp)
+              : setInnerHTML$1(domElement, nextProp)))
         : "children" === propKey
         ? "string" === typeof nextProp
           ? "body" === tag ||
@@ -1427,7 +1431,9 @@ function updateProperties(
     "style" === propKey
       ? setValueForStyles(domElement, propValue)
       : "dangerouslySetInnerHTML" === propKey
-      ? setInnerHTML$1(domElement, propValue)
+      ? disableIEWorkarounds
+        ? (domElement.innerHTML = propValue)
+        : setInnerHTML$1(domElement, propValue)
       : "children" === propKey
       ? setTextContent(domElement, propValue)
       : setValueForProperty(domElement, propKey, propValue, lastRawProps);
@@ -2777,17 +2783,46 @@ function getResourcesFromRoot(root) {
 function markNodeAsHoistable(node) {
   node[internalHoistableMarker] = !0;
 }
-var restoreImpl = null,
-  restoreTarget = null,
+var restoreTarget = null,
   restoreQueue = null;
 function restoreStateOfTarget(target) {
-  if ((target = getInstanceFromNode(target))) {
-    if ("function" !== typeof restoreImpl)
-      throw Error(formatProdErrorMessage(280));
-    var stateNode = target.stateNode;
-    stateNode &&
-      ((stateNode = getFiberCurrentPropsFromNode(stateNode)),
-      restoreImpl(target.stateNode, target.type, stateNode));
+  var internalInstance = getInstanceFromNode(target);
+  if (internalInstance && (target = internalInstance.stateNode)) {
+    var props = getFiberCurrentPropsFromNode(target);
+    a: switch (((target = internalInstance.stateNode), internalInstance.type)) {
+      case "input":
+        updateWrapper$1(target, props);
+        internalInstance = props.name;
+        if ("radio" === props.type && null != internalInstance) {
+          for (props = target; props.parentNode; ) props = props.parentNode;
+          props = props.querySelectorAll(
+            "input[name=" +
+              JSON.stringify("" + internalInstance) +
+              '][type="radio"]'
+          );
+          for (
+            internalInstance = 0;
+            internalInstance < props.length;
+            internalInstance++
+          ) {
+            var otherNode = props[internalInstance];
+            if (otherNode !== target && otherNode.form === target.form) {
+              var otherProps = getFiberCurrentPropsFromNode(otherNode);
+              if (!otherProps) throw Error(formatProdErrorMessage(90));
+              updateValueIfChanged(otherNode);
+              updateWrapper$1(otherNode, otherProps);
+            }
+          }
+        }
+        break a;
+      case "textarea":
+        updateWrapper(target, props);
+        break a;
+      case "select":
+        (internalInstance = props.value),
+          null != internalInstance &&
+            updateOptions(target, !!props.multiple, internalInstance, !1);
+    }
   }
 }
 function enqueueStateRestore(target) {
@@ -2808,3083 +2843,847 @@ function restoreStateIfNeeded() {
         restoreStateOfTarget(queuedTargets[target]);
   }
 }
-function batchedUpdatesImpl(fn, bookkeeping) {
-  return fn(bookkeeping);
+var emptyContextObject = {},
+  contextStackCursor = createCursor(emptyContextObject),
+  didPerformWorkStackCursor = createCursor(!1),
+  previousContext = emptyContextObject;
+function getMaskedContext(workInProgress, unmaskedContext) {
+  var contextTypes = workInProgress.type.contextTypes;
+  if (!contextTypes) return emptyContextObject;
+  var instance = workInProgress.stateNode;
+  if (
+    instance &&
+    instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
+  )
+    return instance.__reactInternalMemoizedMaskedChildContext;
+  var context = {},
+    key;
+  for (key in contextTypes) context[key] = unmaskedContext[key];
+  instance &&
+    ((workInProgress = workInProgress.stateNode),
+    (workInProgress.__reactInternalMemoizedUnmaskedChildContext =
+      unmaskedContext),
+    (workInProgress.__reactInternalMemoizedMaskedChildContext = context));
+  return context;
 }
-function flushSyncImpl() {}
-var isInsideEventHandler = !1;
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) return fn(a, b);
-  isInsideEventHandler = !0;
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    if (
-      ((isInsideEventHandler = !1),
-      null !== restoreTarget || null !== restoreQueue)
-    )
-      flushSyncImpl(), restoreStateIfNeeded();
-  }
+function isContextProvider(type) {
+  type = type.childContextTypes;
+  return null !== type && void 0 !== type;
 }
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-  if (null === stateNode) return null;
-  var props = getFiberCurrentPropsFromNode(stateNode);
-  if (null === props) return null;
-  stateNode = props[registrationName];
-  a: switch (registrationName) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      (props = !props.disabled) ||
-        ((inst = inst.type),
-        (props = !(
-          "button" === inst ||
-          "input" === inst ||
-          "select" === inst ||
-          "textarea" === inst
-        )));
-      inst = !props;
-      break a;
-    default:
-      inst = !1;
-  }
-  if (inst) return null;
-  if (stateNode && "function" !== typeof stateNode)
-    throw Error(
-      formatProdErrorMessage(231, registrationName, typeof stateNode)
-    );
-  return stateNode;
+function popContext() {
+  pop(didPerformWorkStackCursor);
+  pop(contextStackCursor);
 }
-var passiveBrowserEventsSupported = !1;
-if (canUseDOM)
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = !0;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = !1;
-  }
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
-  throw Error(formatProdErrorMessage(255));
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
+function pushTopLevelContextObject(fiber, context, didChange) {
+  if (contextStackCursor.current !== emptyContextObject)
+    throw Error(formatProdErrorMessage(168));
+  push(contextStackCursor, context);
+  push(didPerformWorkStackCursor, didChange);
 }
-var hasError = !1,
-  caughtError = null,
-  hasRethrowError = !1,
-  rethrowError = null,
-  reporter = {
-    onError: function (error) {
-      hasError = !0;
-      caughtError = error;
-    }
-  };
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = !1;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
+function processChildContext(fiber, type, parentContext) {
+  var instance = fiber.stateNode;
+  type = type.childContextTypes;
+  if ("function" !== typeof instance.getChildContext) return parentContext;
+  instance = instance.getChildContext();
+  for (var contextKey in instance)
+    if (!(contextKey in type))
+      throw Error(
+        formatProdErrorMessage(
+          108,
+          getComponentNameFromFiber(fiber) || "Unknown",
+          contextKey
+        )
+      );
+  return assign({}, parentContext, instance);
 }
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
-  if (hasError) {
-    if (hasError) {
-      var error = caughtError;
-      hasError = !1;
-      caughtError = null;
-    } else throw Error(formatProdErrorMessage(198));
-    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
-  }
+function pushContextProvider(workInProgress) {
+  workInProgress =
+    ((workInProgress = workInProgress.stateNode) &&
+      workInProgress.__reactInternalMemoizedMergedChildContext) ||
+    emptyContextObject;
+  previousContext = contextStackCursor.current;
+  push(contextStackCursor, workInProgress);
+  push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
+  return !0;
 }
-var EventListenerWWW = require("EventListener"),
-  root = null,
-  startText = null,
-  fallbackText = null;
-function getData() {
-  if (fallbackText) return fallbackText;
-  var start,
-    startValue = startText,
-    startLength = startValue.length,
-    end,
-    endValue = "value" in root ? root.value : root.textContent,
-    endLength = endValue.length;
-  for (
-    start = 0;
-    start < startLength && startValue[start] === endValue[start];
-    start++
-  );
-  var minEnd = startLength - start;
-  for (
-    end = 1;
-    end <= minEnd &&
-    startValue[startLength - end] === endValue[endLength - end];
-    end++
-  );
-  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
+function invalidateContextProvider(workInProgress, type, didChange) {
+  var instance = workInProgress.stateNode;
+  if (!instance) throw Error(formatProdErrorMessage(169));
+  didChange
+    ? ((workInProgress = processChildContext(
+        workInProgress,
+        type,
+        previousContext
+      )),
+      (instance.__reactInternalMemoizedMergedChildContext = workInProgress),
+      pop(didPerformWorkStackCursor),
+      pop(contextStackCursor),
+      push(contextStackCursor, workInProgress))
+    : pop(didPerformWorkStackCursor);
+  push(didPerformWorkStackCursor, didChange);
 }
-function getEventCharCode(nativeEvent) {
-  var keyCode = nativeEvent.keyCode;
-  "charCode" in nativeEvent
-    ? ((nativeEvent = nativeEvent.charCode),
-      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
-    : (nativeEvent = keyCode);
-  10 === nativeEvent && (nativeEvent = 13);
-  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
+function is(x, y) {
+  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
 }
-function functionThatReturnsTrue() {
-  return !0;
+var objectIs = "function" === typeof Object.is ? Object.is : is,
+  syncQueue = null,
+  includesLegacySyncCallbacks = !1,
+  isFlushingSyncQueue = !1;
+function scheduleSyncCallback(callback) {
+  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
 }
-function functionThatReturnsFalse() {
-  return !1;
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = !0;
+  scheduleSyncCallback(callback);
 }
-function createSyntheticEvent(Interface) {
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-    for (var propName in Interface)
-      Interface.hasOwnProperty(propName) &&
-        ((reactName = Interface[propName]),
-        (this[propName] = reactName
-          ? reactName(nativeEvent)
-          : nativeEvent[propName]));
-    this.isDefaultPrevented = (
-      null != nativeEvent.defaultPrevented
-        ? nativeEvent.defaultPrevented
-        : !1 === nativeEvent.returnValue
-    )
-      ? functionThatReturnsTrue
-      : functionThatReturnsFalse;
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  }
-  assign(SyntheticBaseEvent.prototype, {
-    preventDefault: function () {
-      this.defaultPrevented = !0;
-      var event = this.nativeEvent;
-      event &&
-        (event.preventDefault
-          ? event.preventDefault()
-          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
-        (this.isDefaultPrevented = functionThatReturnsTrue));
-    },
-    stopPropagation: function () {
-      var event = this.nativeEvent;
-      event &&
-        (event.stopPropagation
-          ? event.stopPropagation()
-          : "unknown" !== typeof event.cancelBubble &&
-            (event.cancelBubble = !0),
-        (this.isPropagationStopped = functionThatReturnsTrue));
-    },
-    persist: function () {},
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
-}
-var EventInterface = {
-    eventPhase: 0,
-    bubbles: 0,
-    cancelable: 0,
-    timeStamp: function (event) {
-      return event.timeStamp || Date.now();
-    },
-    defaultPrevented: 0,
-    isTrusted: 0
-  },
-  SyntheticEvent = createSyntheticEvent(EventInterface),
-  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
-  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
-  lastMovementX,
-  lastMovementY,
-  lastMouseEvent,
-  MouseEventInterface = assign({}, UIEventInterface, {
-    screenX: 0,
-    screenY: 0,
-    clientX: 0,
-    clientY: 0,
-    pageX: 0,
-    pageY: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    getModifierState: getEventModifierState,
-    button: 0,
-    buttons: 0,
-    relatedTarget: function (event) {
-      return void 0 === event.relatedTarget
-        ? event.fromElement === event.srcElement
-          ? event.toElement
-          : event.fromElement
-        : event.relatedTarget;
-    },
-    movementX: function (event) {
-      if ("movementX" in event) return event.movementX;
-      event !== lastMouseEvent &&
-        (lastMouseEvent && "mousemove" === event.type
-          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
-            (lastMovementY = event.screenY - lastMouseEvent.screenY))
-          : (lastMovementY = lastMovementX = 0),
-        (lastMouseEvent = event));
-      return lastMovementX;
-    },
-    movementY: function (event) {
-      return "movementY" in event ? event.movementY : lastMovementY;
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && null !== syncQueue) {
+    isFlushingSyncQueue = !0;
+    var previousUpdatePriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
+      var callback = queue[i];
+      try {
+        do callback = callback(!0);
+        while (null !== callback);
+      } catch (error) {
+        null === errors ? (errors = [error]) : errors.push(error);
+      }
     }
-  }),
-  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
-  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
-  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
-  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
-  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
-  AnimationEventInterface = assign({}, EventInterface, {
-    animationName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
-  ClipboardEventInterface = assign({}, EventInterface, {
-    clipboardData: function (event) {
-      return "clipboardData" in event
-        ? event.clipboardData
-        : window.clipboardData;
+    syncQueue = null;
+    includesLegacySyncCallbacks = !1;
+    currentUpdatePriority = previousUpdatePriority;
+    isFlushingSyncQueue = !1;
+    if (null !== errors) {
+      if (1 < errors.length) {
+        if ("function" === typeof AggregateError)
+          throw new AggregateError(errors);
+        for (
+          previousUpdatePriority = 1;
+          previousUpdatePriority < errors.length;
+          previousUpdatePriority++
+        )
+          scheduleCallback$2(
+            ImmediatePriority,
+            throwError.bind(null, errors[previousUpdatePriority])
+          );
+      }
+      throw errors[0];
     }
-  }),
-  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
-  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
-  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
-  normalizeKey = {
-    Esc: "Escape",
-    Spacebar: " ",
-    Left: "ArrowLeft",
-    Up: "ArrowUp",
-    Right: "ArrowRight",
-    Down: "ArrowDown",
-    Del: "Delete",
-    Win: "OS",
-    Menu: "ContextMenu",
-    Apps: "ContextMenu",
-    Scroll: "ScrollLock",
-    MozPrintableKey: "Unidentified"
-  },
-  translateToKey = {
-    8: "Backspace",
-    9: "Tab",
-    12: "Clear",
-    13: "Enter",
-    16: "Shift",
-    17: "Control",
-    18: "Alt",
-    19: "Pause",
-    20: "CapsLock",
-    27: "Escape",
-    32: " ",
-    33: "PageUp",
-    34: "PageDown",
-    35: "End",
-    36: "Home",
-    37: "ArrowLeft",
-    38: "ArrowUp",
-    39: "ArrowRight",
-    40: "ArrowDown",
-    45: "Insert",
-    46: "Delete",
-    112: "F1",
-    113: "F2",
-    114: "F3",
-    115: "F4",
-    116: "F5",
-    117: "F6",
-    118: "F7",
-    119: "F8",
-    120: "F9",
-    121: "F10",
-    122: "F11",
-    123: "F12",
-    144: "NumLock",
-    145: "ScrollLock",
-    224: "Meta"
-  },
-  modifierKeyToProp = {
-    Alt: "altKey",
-    Control: "ctrlKey",
-    Meta: "metaKey",
-    Shift: "shiftKey"
-  };
-function modifierStateGetter(keyArg) {
-  var nativeEvent = this.nativeEvent;
-  return nativeEvent.getModifierState
-    ? nativeEvent.getModifierState(keyArg)
-    : (keyArg = modifierKeyToProp[keyArg])
-    ? !!nativeEvent[keyArg]
-    : !1;
+  }
+  return null;
 }
-function getEventModifierState() {
-  return modifierStateGetter;
+function throwError(error) {
+  throw error;
 }
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-    key: function (nativeEvent) {
-      if (nativeEvent.key) {
-        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
-        if ("Unidentified" !== key) return key;
-      }
-      return "keypress" === nativeEvent.type
-        ? ((nativeEvent = getEventCharCode(nativeEvent)),
-          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
-        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
-        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
-        : "";
-    },
-    code: 0,
-    location: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    repeat: 0,
-    locale: 0,
-    getModifierState: getEventModifierState,
-    charCode: function (event) {
-      return "keypress" === event.type ? getEventCharCode(event) : 0;
-    },
-    keyCode: function (event) {
-      return "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    },
-    which: function (event) {
-      return "keypress" === event.type
-        ? getEventCharCode(event)
-        : "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    }
-  }),
-  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
-  PointerEventInterface = assign({}, MouseEventInterface, {
-    pointerId: 0,
-    width: 0,
-    height: 0,
-    pressure: 0,
-    tangentialPressure: 0,
-    tiltX: 0,
-    tiltY: 0,
-    twist: 0,
-    pointerType: 0,
-    isPrimary: 0
-  }),
-  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
-  TouchEventInterface = assign({}, UIEventInterface, {
-    touches: 0,
-    targetTouches: 0,
-    changedTouches: 0,
-    altKey: 0,
-    metaKey: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    getModifierState: getEventModifierState
-  }),
-  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
-  TransitionEventInterface = assign({}, EventInterface, {
-    propertyName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
-  WheelEventInterface = assign({}, MouseEventInterface, {
-    deltaX: function (event) {
-      return "deltaX" in event
-        ? event.deltaX
-        : "wheelDeltaX" in event
-        ? -event.wheelDeltaX
-        : 0;
-    },
-    deltaY: function (event) {
-      return "deltaY" in event
-        ? event.deltaY
-        : "wheelDeltaY" in event
-        ? -event.wheelDeltaY
-        : "wheelDelta" in event
-        ? -event.wheelDelta
-        : 0;
-    },
-    deltaZ: 0,
-    deltaMode: 0
-  }),
-  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
-  END_KEYCODES = [9, 13, 27, 32],
-  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
-  documentMode = null;
-canUseDOM &&
-  "documentMode" in document &&
-  (documentMode = document.documentMode);
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
-  useFallbackCompositionData =
-    canUseDOM &&
-    (!canUseCompositionEvent ||
-      (documentMode && 8 < documentMode && 11 >= documentMode)),
-  SPACEBAR_CHAR = String.fromCharCode(32),
-  hasSpaceKeypress = !1;
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
-    case "keydown":
-      return 229 !== nativeEvent.keyCode;
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      return !0;
-    default:
-      return !1;
-  }
-}
-function getDataFromCustomEvent(nativeEvent) {
-  nativeEvent = nativeEvent.detail;
-  return "object" === typeof nativeEvent && "data" in nativeEvent
-    ? nativeEvent.data
-    : null;
-}
-var isComposing = !1;
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
-    case "keypress":
-      if (32 !== nativeEvent.which) return null;
-      hasSpaceKeypress = !0;
-      return SPACEBAR_CHAR;
-    case "textInput":
-      return (
-        (domEventName = nativeEvent.data),
-        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
-      );
-    default:
-      return null;
-  }
+var forkStack = [],
+  forkStackIndex = 0,
+  treeForkProvider = null,
+  treeForkCount = 0,
+  idStack = [],
+  idStackIndex = 0,
+  treeContextProvider = null,
+  treeContextId = 1,
+  treeContextOverflow = "";
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
 }
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  if (isComposing)
-    return "compositionend" === domEventName ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-      ? ((domEventName = getData()),
-        (fallbackText = startText = root = null),
-        (isComposing = !1),
-        domEventName)
-      : null;
-  switch (domEventName) {
-    case "paste":
-      return null;
-    case "keypress":
-      if (
-        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
-        (nativeEvent.ctrlKey && nativeEvent.altKey)
-      ) {
-        if (nativeEvent.char && 1 < nativeEvent.char.length)
-          return nativeEvent.char;
-        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
-      }
-      return null;
-    case "compositionend":
-      return useFallbackCompositionData && "ko" !== nativeEvent.locale
-        ? null
-        : nativeEvent.data;
-    default:
-      return null;
-  }
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  workInProgress = treeContextOverflow;
+  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
+  baseIdWithLeadingBit &= ~(1 << baseLength);
+  index += 1;
+  var length = 32 - clz32(totalChildren) + baseLength;
+  if (30 < length) {
+    var numberOfOverflowBits = baseLength - (baseLength % 5);
+    length = (
+      baseIdWithLeadingBit &
+      ((1 << numberOfOverflowBits) - 1)
+    ).toString(32);
+    baseIdWithLeadingBit >>= numberOfOverflowBits;
+    baseLength -= numberOfOverflowBits;
+    treeContextId =
+      (1 << (32 - clz32(totalChildren) + baseLength)) |
+      (index << baseLength) |
+      baseIdWithLeadingBit;
+    treeContextOverflow = length + workInProgress;
+  } else
+    (treeContextId =
+      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
+      (treeContextOverflow = workInProgress);
 }
-var supportedInputTypes = {
-  color: !0,
-  date: !0,
-  datetime: !0,
-  "datetime-local": !0,
-  email: !0,
-  month: !0,
-  number: !0,
-  password: !0,
-  range: !0,
-  search: !0,
-  tel: !0,
-  text: !0,
-  time: !0,
-  url: !0,
-  week: !0
-};
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return "input" === nodeName
-    ? !!supportedInputTypes[elem.type]
-    : "textarea" === nodeName
-    ? !0
-    : !1;
+function pushMaterializedTreeId(workInProgress) {
+  null !== workInProgress.return &&
+    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
 }
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
-) {
-  enqueueStateRestore(target);
-  inst = accumulateTwoPhaseListeners(inst, "onChange");
-  0 < inst.length &&
-    ((nativeEvent = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    )),
-    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+function popTreeContext(workInProgress) {
+  for (; workInProgress === treeForkProvider; )
+    (treeForkProvider = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null),
+      (treeForkCount = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null);
+  for (; workInProgress === treeContextProvider; )
+    (treeContextProvider = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextOverflow = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextId = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null);
 }
-var activeElement$1 = null,
-  activeElementInst$1 = null;
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
+var hydrationParentFiber = null,
+  nextHydratableInstance = null,
+  isHydrating = !1,
+  hydrationErrors = null,
+  rootOrSingletonContext = !1;
+function deleteHydratableInstance(returnFiber, instance) {
+  var fiber = createFiber(5, null, null, 0);
+  fiber.elementType = "DELETED";
+  fiber.stateNode = instance;
+  fiber.return = returnFiber;
+  instance = returnFiber.deletions;
+  null === instance
+    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
+    : instance.push(fiber);
 }
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
-  if (updateValueIfChanged(targetNode)) return targetInst;
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & -4097) | 2;
 }
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if ("change" === domEventName) return targetInst;
+function tryHydrateInstance(fiber, nextInstance) {
+  var type = fiber.type;
+  nextInstance =
+    1 !== nextInstance.nodeType ||
+    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
+      (rootOrSingletonContext = !1),
+      !0)
+    : !1;
 }
-var isInputEventSupported = !1;
-if (canUseDOM) {
-  var JSCompiler_inline_result$jscomp$259;
-  if (canUseDOM) {
-    var isSupported$jscomp$inline_488 = "oninput" in document;
-    if (!isSupported$jscomp$inline_488) {
-      var element$jscomp$inline_489 = document.createElement("div");
-      element$jscomp$inline_489.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_488 =
-        "function" === typeof element$jscomp$inline_489.oninput;
-    }
-    JSCompiler_inline_result$jscomp$259 = isSupported$jscomp$inline_488;
-  } else JSCompiler_inline_result$jscomp$259 = !1;
-  isInputEventSupported =
-    JSCompiler_inline_result$jscomp$259 &&
-    (!document.documentMode || 9 < document.documentMode);
-}
-function stopWatchingForValueChange() {
-  activeElement$1 &&
-    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
-    (activeElementInst$1 = activeElement$1 = null));
+function tryHydrateText(fiber, nextInstance) {
+  nextInstance =
+    "" === fiber.pendingProps
+      ? null
+      : 3 !== nextInstance.nodeType
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = null),
+      !0)
+    : !1;
 }
-function handlePropertyChange(nativeEvent) {
-  if (
-    "value" === nativeEvent.propertyName &&
-    getInstIfValueChanged(activeElementInst$1)
-  ) {
-    var dispatchQueue = [];
-    createAndAccumulateChangeEvent(
-      dispatchQueue,
-      activeElementInst$1,
-      nativeEvent,
-      getEventTarget(nativeEvent)
-    );
-    batchedUpdates$1(runEventInBatch, dispatchQueue);
+function tryHydrateSuspense(fiber, nextInstance) {
+  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
+  if (null !== nextInstance) {
+    var JSCompiler_inline_result =
+      null !== treeContextProvider
+        ? { id: treeContextId, overflow: treeContextOverflow }
+        : null;
+    fiber.memoizedState = {
+      dehydrated: nextInstance,
+      treeContext: JSCompiler_inline_result,
+      retryLane: 1073741824
+    };
+    JSCompiler_inline_result = createFiber(18, null, null, 0);
+    JSCompiler_inline_result.stateNode = nextInstance;
+    JSCompiler_inline_result.return = fiber;
+    fiber.child = JSCompiler_inline_result;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = null;
+    return !0;
   }
+  return !1;
 }
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  "focusin" === domEventName
-    ? (stopWatchingForValueChange(),
-      (activeElement$1 = target),
-      (activeElementInst$1 = targetInst),
-      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
-    : "focusout" === domEventName && stopWatchingForValueChange();
-}
-function getTargetInstForInputEventPolyfill(domEventName) {
-  if (
-    "selectionchange" === domEventName ||
-    "keyup" === domEventName ||
-    "keydown" === domEventName
-  )
-    return getInstIfValueChanged(activeElementInst$1);
-}
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
-}
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if ("input" === domEventName || "change" === domEventName)
-    return getInstIfValueChanged(targetInst);
+function shouldClientRenderOnMismatch(fiber) {
+  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
 }
-function is(x, y) {
-  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+function throwOnHydrationMismatch() {
+  throw Error(formatProdErrorMessage(418));
 }
-var objectIs = "function" === typeof Object.is ? Object.is : is;
-function shallowEqual(objA, objB) {
-  if (objectIs(objA, objB)) return !0;
-  if (
-    "object" !== typeof objA ||
-    null === objA ||
-    "object" !== typeof objB ||
-    null === objB
+function advanceToFirstAttemptableInstance(fiber) {
+  for (
+    ;
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    );
+
   )
-    return !1;
-  var keysA = Object.keys(objA),
-    keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) return !1;
-  for (keysB = 0; keysB < keysA.length; keysB++) {
-    var currentKey = keysA[keysB];
-    if (
-      !hasOwnProperty.call(objB, currentKey) ||
-      !objectIs(objA[currentKey], objB[currentKey])
-    )
-      return !1;
-  }
-  return !0;
-}
-var skipSelectionChangeEvent =
-    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
-  activeElement = null,
-  activeElementInst = null,
-  lastSelection = null,
-  mouseDown = !1;
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  var doc =
-    nativeEventTarget.window === nativeEventTarget
-      ? nativeEventTarget.document
-      : 9 === nativeEventTarget.nodeType
-      ? nativeEventTarget
-      : nativeEventTarget.ownerDocument;
-  mouseDown ||
-    null == activeElement ||
-    activeElement !== getActiveElement(doc) ||
-    ((doc = activeElement),
-    "selectionStart" in doc && hasSelectionCapabilities(doc)
-      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
-      : ((doc = (
-          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
-          window
-        ).getSelection()),
-        (doc = {
-          anchorNode: doc.anchorNode,
-          anchorOffset: doc.anchorOffset,
-          focusNode: doc.focusNode,
-          focusOffset: doc.focusOffset
-        })),
-    (lastSelection && shallowEqual(lastSelection, doc)) ||
-      ((lastSelection = doc),
-      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
-      0 < doc.length &&
-        ((nativeEvent = new SyntheticEvent(
-          "onSelect",
-          "select",
-          null,
-          nativeEvent,
-          nativeEventTarget
-        )),
-        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
-        (nativeEvent.target = activeElement))));
-}
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
-}
-var vendorPrefixes = {
-    animationend: makePrefixMap("Animation", "AnimationEnd"),
-    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-    animationstart: makePrefixMap("Animation", "AnimationStart"),
-    transitionend: makePrefixMap("Transition", "TransitionEnd")
-  },
-  prefixedEventNames = {},
-  style = {};
-canUseDOM &&
-  ((style = document.createElement("div").style),
-  "AnimationEvent" in window ||
-    (delete vendorPrefixes.animationend.animation,
-    delete vendorPrefixes.animationiteration.animation,
-    delete vendorPrefixes.animationstart.animation),
-  "TransitionEvent" in window ||
-    delete vendorPrefixes.transitionend.transition);
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
-  if (!vendorPrefixes[eventName]) return eventName;
-  var prefixMap = vendorPrefixes[eventName],
-    styleProp;
-  for (styleProp in prefixMap)
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
-  return eventName;
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-var ANIMATION_END = getVendorPrefixedEventName("animationend"),
-  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
-  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
-  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
-  topLevelEventsToReactNames = new Map(),
-  simpleEventPluginEvents =
-    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
-      " "
+function advanceToFirstAttemptableTextInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
     );
-topLevelEventsToReactNames.set("beforeblur", null);
-topLevelEventsToReactNames.set("afterblur", null);
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
 }
-for (
-  var i$jscomp$inline_501 = 0;
-  i$jscomp$inline_501 < simpleEventPluginEvents.length;
-  i$jscomp$inline_501++
-) {
-  var eventName$jscomp$inline_502 =
-      simpleEventPluginEvents[i$jscomp$inline_501],
-    domEventName$jscomp$inline_503 = eventName$jscomp$inline_502.toLowerCase(),
-    capitalizedEvent$jscomp$inline_504 =
-      eventName$jscomp$inline_502[0].toUpperCase() +
-      eventName$jscomp$inline_502.slice(1);
-  registerSimpleEvent(
-    domEventName$jscomp$inline_503,
-    "on" + capitalizedEvent$jscomp$inline_504
-  );
+function advanceToFirstAttemptableSuspenseInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-registerSimpleEvent("dblclick", "onDoubleClick");
-registerSimpleEvent("focusin", "onFocus");
-registerSimpleEvent("focusout", "onBlur");
-registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
-registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
-registerTwoPhaseEvent(
-  "onChange",
-  "change click focusin focusout input keydown keyup selectionchange".split(" ")
-);
-registerTwoPhaseEvent(
-  "onSelect",
-  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
-    " "
-  )
-);
-registerTwoPhaseEvent("onBeforeInput", [
-  "compositionend",
-  "keypress",
-  "textInput",
-  "paste"
-]);
-registerTwoPhaseEvent(
-  "onCompositionEnd",
-  "compositionend focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionStart",
-  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionUpdate",
-  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
-);
-var mediaEventTypes =
-    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
-      " "
-    ),
-  nonDelegatedEvents = new Set(
-    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
-  );
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
-  event.currentTarget = null;
+function prepareToHydrateHostInstance(fiber) {
+  var instance = fiber.stateNode,
+    type = fiber.type,
+    props = fiber.memoizedProps;
+  instance[internalInstanceKey] = fiber;
+  instance[internalPropsKey] = props;
+  switch (type) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", instance);
+      listenToNonDelegatedEvent("close", instance);
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "video":
+    case "audio":
+      for (var i = 0; i < mediaEventTypes.length; i++)
+        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", instance);
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", instance);
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", instance);
+      break;
+    case "input":
+      initWrapperState$2(instance, props);
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "select":
+      instance._wrapperState = { wasMultiple: !!props.multiple };
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "textarea":
+      initWrapperState(instance, props),
+        listenToNonDelegatedEvent("invalid", instance);
+  }
+  assertValidProps(type, props);
+  var updatePayload = null,
+    propKey;
+  for (propKey in props)
+    props.hasOwnProperty(propKey) &&
+      ((i = props[propKey]),
+      "children" === propKey
+        ? "string" === typeof i
+          ? instance.textContent !== i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", i]))
+          : "number" === typeof i &&
+            instance.textContent !== "" + i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", "" + i]))
+        : registrationNameDependencies.hasOwnProperty(propKey) &&
+          null != i &&
+          "onScroll" === propKey &&
+          listenToNonDelegatedEvent("scroll", instance));
+  switch (type) {
+    case "input":
+      track(instance);
+      postMountWrapper$3(instance, props, !0);
+      break;
+    case "textarea":
+      track(instance);
+      postMountWrapper(instance);
+      break;
+    case "select":
+    case "option":
+      break;
+    default:
+      "function" === typeof props.onClick && (instance.onclick = noop$1);
+  }
+  instance = updatePayload;
+  fiber.updateQueue = instance;
+  return null !== instance ? !0 : !1;
 }
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  eventSystemFlags = 0 !== (eventSystemFlags & 4);
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event;
-    _dispatchQueue$i = _dispatchQueue$i.listeners;
+function popToNextHostParent(fiber) {
+  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
+    switch (hydrationParentFiber.tag) {
+      case 3:
+      case 27:
+        rootOrSingletonContext = !0;
+        return;
+      case 5:
+      case 13:
+        rootOrSingletonContext = !1;
+        return;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
+}
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) return !1;
+  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
+  var shouldClear = !1;
+  3 === fiber.tag ||
+    27 === fiber.tag ||
+    (5 === fiber.tag &&
+      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
+    (shouldClear = !0);
+  if (shouldClear && (shouldClear = nextHydratableInstance))
+    if (shouldClientRenderOnMismatch(fiber))
+      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
+    else
+      for (; shouldClear; )
+        deleteHydratableInstance(fiber, shouldClear),
+          (shouldClear = getNextHydratable(shouldClear.nextSibling));
+  popToNextHostParent(fiber);
+  if (13 === fiber.tag) {
+    fiber = fiber.memoizedState;
+    fiber = null !== fiber ? fiber.dehydrated : null;
+    if (!fiber) throw Error(formatProdErrorMessage(317));
     a: {
-      var previousInstance = void 0;
-      if (eventSystemFlags)
-        for (
-          var i$jscomp$0 = _dispatchQueue$i.length - 1;
-          0 <= i$jscomp$0;
-          i$jscomp$0--
-        ) {
-          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
-            instance = _dispatchListeners$i.instance,
-            currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
-      else
-        for (
-          i$jscomp$0 = 0;
-          i$jscomp$0 < _dispatchQueue$i.length;
-          i$jscomp$0++
-        ) {
-          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
-          instance = _dispatchListeners$i.instance;
-          currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
+      fiber = fiber.nextSibling;
+      for (shouldClear = 0; fiber; ) {
+        if (8 === fiber.nodeType) {
+          var data = fiber.data;
+          if ("/$" === data) {
+            if (0 === shouldClear) {
+              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
+              break a;
+            }
+            shouldClear--;
+          } else
+            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
         }
+        fiber = fiber.nextSibling;
+      }
+      nextHydratableInstance = null;
     }
-  }
-  if (hasRethrowError)
-    throw (
-      ((dispatchQueue = rethrowError),
-      (hasRethrowError = !1),
-      (rethrowError = null),
-      dispatchQueue)
-    );
+  } else
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratable(fiber.stateNode.nextSibling)
+      : null;
+  return !0;
 }
-function listenToNonDelegatedEvent(domEventName, targetElement) {
-  var listenerSet = getEventListenerSet(targetElement),
-    listenerSetKey = domEventName + "__bubble";
-  listenerSet.has(listenerSetKey) ||
-    (addTrappedEventListener(targetElement, domEventName, 2, !1),
-    listenerSet.add(listenerSetKey));
+function warnIfUnhydratedTailNodes() {
+  for (var nextInstance = nextHydratableInstance; nextInstance; )
+    nextInstance = getNextHydratable(nextInstance.nextSibling);
 }
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
-  var eventSystemFlags = 0;
-  isCapturePhaseListener && (eventSystemFlags |= 4);
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
+function resetHydrationState() {
+  nextHydratableInstance = hydrationParentFiber = null;
+  isHydrating = !1;
 }
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = !0;
-    allNativeEvents.forEach(function (domEventName) {
-      "selectionchange" !== domEventName &&
-        (nonDelegatedEvents.has(domEventName) ||
-          listenToNativeEvent(domEventName, !1, rootContainerElement),
-        listenToNativeEvent(domEventName, !0, rootContainerElement));
-    });
-    var ownerDocument =
-      9 === rootContainerElement.nodeType
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
-    null === ownerDocument ||
-      ownerDocument[listeningMarker] ||
-      ((ownerDocument[listeningMarker] = !0),
-      listenToNativeEvent("selectionchange", !1, ownerDocument));
-  }
+function queueHydrationError(error) {
+  null === hydrationErrors
+    ? (hydrationErrors = [error])
+    : hydrationErrors.push(error);
 }
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  eventSystemFlags = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  );
-  var isPassiveListener = void 0;
-  !passiveBrowserEventsSupported ||
-    ("touchstart" !== domEventName &&
-      "touchmove" !== domEventName &&
-      "wheel" !== domEventName) ||
-    (isPassiveListener = !0);
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = eventSystemFlags;
-    eventSystemFlags = function () {
-      unsubscribeListener.remove();
-      for (
-        var _len = arguments.length, p = Array(_len), _key = 0;
-        _key < _len;
-        _key++
-      )
-        p[_key] = arguments[_key];
-      return originalListener.apply(this, p);
+var concurrentQueues = [],
+  concurrentQueuesIndex = 0,
+  concurrentlyUpdatedLanes = 0;
+function finishQueueingConcurrentUpdates() {
+  for (
+    var endIndex = concurrentQueuesIndex,
+      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
+    i < endIndex;
+
+  ) {
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    if (null !== queue && null !== update) {
+      var pending = queue.pending;
+      null === pending
+        ? (update.next = update)
+        : ((update.next = pending.next), (pending.next = update));
+      queue.pending = update;
+    }
+    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+  }
+}
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes |= lane;
+  fiber.lanes |= lane;
+  fiber = fiber.alternate;
+  null !== fiber && (fiber.lanes |= lane);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  sourceFiber.lanes |= lane;
+  var alternate = sourceFiber.alternate;
+  null !== alternate && (alternate.lanes |= lane);
+  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
+    (parent.childLanes |= lane),
+      (alternate = parent.alternate),
+      null !== alternate && (alternate.childLanes |= lane),
+      22 === parent.tag &&
+        ((sourceFiber = parent.stateNode),
+        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
+      (sourceFiber = parent),
+      (parent = parent.return);
+  isHidden &&
+    null !== update &&
+    3 === sourceFiber.tag &&
+    ((parent = sourceFiber.stateNode),
+    (isHidden = 31 - clz32(lane)),
+    (parent = parent.hiddenUpdates),
+    (sourceFiber = parent[isHidden]),
+    null === sourceFiber
+      ? (parent[isHidden] = [update])
+      : sourceFiber.push(update),
+    (update.lane = lane | 1073741824));
+}
+function getRootForUpdatedFiber(sourceFiber) {
+  if (50 < nestedUpdateCount)
+    throw (
+      ((nestedUpdateCount = 0),
+      (rootWithNestedUpdates = null),
+      Error(formatProdErrorMessage(185)))
+    );
+  for (var parent = sourceFiber.return; null !== parent; )
+    (sourceFiber = parent), (parent = sourceFiber.return);
+  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
+}
+var hasForceUpdate = !1;
+function initializeUpdateQueue(fiber) {
+  fiber.updateQueue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
+    callbacks: null
+  };
+}
+function cloneUpdateQueue(current, workInProgress) {
+  current = current.updateQueue;
+  workInProgress.updateQueue === current &&
+    (workInProgress.updateQueue = {
+      baseState: current.baseState,
+      firstBaseUpdate: current.firstBaseUpdate,
+      lastBaseUpdate: current.lastBaseUpdate,
+      shared: current.shared,
+      callbacks: null
+    });
+}
+function createUpdate(lane) {
+  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
+}
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
+  if (null === updateQueue) return null;
+  updateQueue = updateQueue.shared;
+  if (
+    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
+    0 === (executionContext & 2)
+  )
+    return (
+      enqueueUpdate$1(fiber, updateQueue, update, lane),
+      getRootForUpdatedFiber(fiber)
+    );
+  var pending = updateQueue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  updateQueue.pending = update;
+  update = getRootForUpdatedFiber(fiber);
+  markUpdateLaneFromFiberToRoot(fiber, null, lane);
+  return update;
+}
+function entangleTransitions(root, fiber, lane) {
+  fiber = fiber.updateQueue;
+  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
+    var queueLanes = fiber.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    fiber.lanes = lane;
+    markRootEntangled(root, lane);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  var queue = workInProgress.updateQueue,
+    current = workInProgress.alternate;
+  if (
+    null !== current &&
+    ((current = current.updateQueue), queue === current)
+  ) {
+    var newFirst = null,
+      newLast = null;
+    queue = queue.firstBaseUpdate;
+    if (null !== queue) {
+      do {
+        var clone = {
+          lane: queue.lane,
+          tag: queue.tag,
+          payload: queue.payload,
+          callback: null,
+          next: null
+        };
+        null === newLast
+          ? (newFirst = newLast = clone)
+          : (newLast = newLast.next = clone);
+        queue = queue.next;
+      } while (null !== queue);
+      null === newLast
+        ? (newFirst = newLast = capturedUpdate)
+        : (newLast = newLast.next = capturedUpdate);
+    } else newFirst = newLast = capturedUpdate;
+    queue = {
+      baseState: current.baseState,
+      firstBaseUpdate: newFirst,
+      lastBaseUpdate: newLast,
+      shared: current.shared,
+      callbacks: current.callbacks
     };
+    workInProgress.updateQueue = queue;
+    return;
   }
-  var unsubscribeListener = isCapturePhaseListener
-    ? void 0 !== isPassiveListener
-      ? EventListenerWWW.captureWithPassiveFlag(
-          targetContainer,
-          domEventName,
-          eventSystemFlags,
-          isPassiveListener
-        )
-      : EventListenerWWW.capture(
-          targetContainer,
-          domEventName,
-          eventSystemFlags
-        )
-    : void 0 !== isPassiveListener
-    ? EventListenerWWW.bubbleWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        eventSystemFlags,
-        isPassiveListener
-      )
-    : EventListenerWWW.listen(targetContainer, domEventName, eventSystemFlags);
+  workInProgress = queue.lastBaseUpdate;
+  null === workInProgress
+    ? (queue.firstBaseUpdate = capturedUpdate)
+    : (workInProgress.next = capturedUpdate);
+  queue.lastBaseUpdate = capturedUpdate;
 }
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst$jscomp$0,
-  targetContainer
+function processUpdateQueue(
+  workInProgress$jscomp$0,
+  props,
+  instance$jscomp$0,
+  renderLanes
 ) {
-  var ancestorInst = targetInst$jscomp$0;
-  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
-    if (
-      enableLegacyFBSupport &&
-      "click" === domEventName &&
-      0 === (eventSystemFlags & 20) &&
-      nativeEvent !== currentReplayingEvent
-    ) {
-      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
-      return;
-    }
-    if (null !== targetInst$jscomp$0)
-      a: for (;;) {
-        if (null === targetInst$jscomp$0) return;
-        var nodeTag = targetInst$jscomp$0.tag;
-        if (3 === nodeTag || 4 === nodeTag) {
-          var container = targetInst$jscomp$0.stateNode.containerInfo;
-          if (
-            container === targetContainer ||
-            (8 === container.nodeType &&
-              container.parentNode === targetContainer)
-          )
-            break;
-          if (4 === nodeTag)
-            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
-              var grandTag = nodeTag.tag;
-              if (3 === grandTag || 4 === grandTag)
-                if (
-                  ((grandTag = nodeTag.stateNode.containerInfo),
-                  grandTag === targetContainer ||
-                    (8 === grandTag.nodeType &&
-                      grandTag.parentNode === targetContainer))
-                )
-                  return;
-              nodeTag = nodeTag.return;
-            }
-          for (; null !== container; ) {
-            nodeTag = getClosestInstanceFromNode(container);
-            if (null === nodeTag) return;
-            grandTag = nodeTag.tag;
-            if (
-              5 === grandTag ||
-              6 === grandTag ||
-              26 === grandTag ||
-              27 === grandTag
-            ) {
-              targetInst$jscomp$0 = ancestorInst = nodeTag;
-              continue a;
-            }
-            container = container.parentNode;
+  var queue = workInProgress$jscomp$0.updateQueue;
+  hasForceUpdate = !1;
+  var firstBaseUpdate = queue.firstBaseUpdate,
+    lastBaseUpdate = queue.lastBaseUpdate,
+    pendingQueue = queue.shared.pending;
+  if (null !== pendingQueue) {
+    queue.shared.pending = null;
+    var lastPendingUpdate = pendingQueue,
+      firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null;
+    null === lastBaseUpdate
+      ? (firstBaseUpdate = firstPendingUpdate)
+      : (lastBaseUpdate.next = firstPendingUpdate);
+    lastBaseUpdate = lastPendingUpdate;
+    var current = workInProgress$jscomp$0.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      (pendingQueue = current.lastBaseUpdate),
+      pendingQueue !== lastBaseUpdate &&
+        (null === pendingQueue
+          ? (current.firstBaseUpdate = firstPendingUpdate)
+          : (pendingQueue.next = firstPendingUpdate),
+        (current.lastBaseUpdate = lastPendingUpdate)));
+  }
+  if (null !== firstBaseUpdate) {
+    var newState = queue.baseState;
+    lastBaseUpdate = 0;
+    current = firstPendingUpdate = lastPendingUpdate = null;
+    pendingQueue = firstBaseUpdate;
+    do {
+      var updateLane = pendingQueue.lane & -1073741825,
+        isHiddenUpdate = updateLane !== pendingQueue.lane;
+      if (
+        isHiddenUpdate
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes & updateLane) === updateLane
+      ) {
+        null !== current &&
+          (current = current.next =
+            {
+              lane: 0,
+              tag: pendingQueue.tag,
+              payload: pendingQueue.payload,
+              callback: null,
+              next: null
+            });
+        a: {
+          var workInProgress = workInProgress$jscomp$0,
+            update = pendingQueue;
+          updateLane = props;
+          var instance = instance$jscomp$0;
+          switch (update.tag) {
+            case 1:
+              workInProgress = update.payload;
+              if ("function" === typeof workInProgress) {
+                newState = workInProgress.call(instance, newState, updateLane);
+                break a;
+              }
+              newState = workInProgress;
+              break a;
+            case 3:
+              workInProgress.flags = (workInProgress.flags & -65537) | 128;
+            case 0:
+              workInProgress = update.payload;
+              updateLane =
+                "function" === typeof workInProgress
+                  ? workInProgress.call(instance, newState, updateLane)
+                  : workInProgress;
+              if (null === updateLane || void 0 === updateLane) break a;
+              newState = assign({}, newState, updateLane);
+              break a;
+            case 2:
+              hasForceUpdate = !0;
           }
         }
-        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+        updateLane = pendingQueue.callback;
+        null !== updateLane &&
+          ((workInProgress$jscomp$0.flags |= 64),
+          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
+          (isHiddenUpdate = queue.callbacks),
+          null === isHiddenUpdate
+            ? (queue.callbacks = [updateLane])
+            : isHiddenUpdate.push(updateLane));
+      } else
+        (isHiddenUpdate = {
+          lane: updateLane,
+          tag: pendingQueue.tag,
+          payload: pendingQueue.payload,
+          callback: pendingQueue.callback,
+          next: null
+        }),
+          null === current
+            ? ((firstPendingUpdate = current = isHiddenUpdate),
+              (lastPendingUpdate = newState))
+            : (current = current.next = isHiddenUpdate),
+          (lastBaseUpdate |= updateLane);
+      pendingQueue = pendingQueue.next;
+      if (null === pendingQueue)
+        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
+          break;
+        else
+          (isHiddenUpdate = pendingQueue),
+            (pendingQueue = isHiddenUpdate.next),
+            (isHiddenUpdate.next = null),
+            (queue.lastBaseUpdate = isHiddenUpdate),
+            (queue.shared.pending = null);
+    } while (1);
+    null === current && (lastPendingUpdate = newState);
+    queue.baseState = lastPendingUpdate;
+    queue.firstBaseUpdate = firstPendingUpdate;
+    queue.lastBaseUpdate = current;
+    null === firstBaseUpdate && (queue.shared.lanes = 0);
+    workInProgressRootSkippedLanes |= lastBaseUpdate;
+    workInProgress$jscomp$0.lanes = lastBaseUpdate;
+    workInProgress$jscomp$0.memoizedState = newState;
+  }
+}
+function callCallback(callback, context) {
+  if ("function" !== typeof callback)
+    throw Error(formatProdErrorMessage(191, callback));
+  callback.call(context);
+}
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
+  if (null !== callbacks)
+    for (
+      updateQueue.callbacks = null, updateQueue = 0;
+      updateQueue < callbacks.length;
+      updateQueue++
+    )
+      callCallback(callbacks[updateQueue], context);
+}
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) return !0;
+  if (
+    "object" !== typeof objA ||
+    null === objA ||
+    "object" !== typeof objB ||
+    null === objB
+  )
+    return !1;
+  var keysA = Object.keys(objA),
+    keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return !1;
+  for (keysB = 0; keysB < keysA.length; keysB++) {
+    var currentKey = keysA[keysB];
+    if (
+      !hasOwnProperty.call(objB, currentKey) ||
+      !objectIs(objA[currentKey], objB[currentKey])
+    )
+      return !1;
+  }
+  return !0;
+}
+var SuspenseException = Error(formatProdErrorMessage(460));
+function isThenableResolved(thenable) {
+  thenable = thenable.status;
+  return "fulfilled" === thenable || "rejected" === thenable;
+}
+function noop() {}
+function trackUsedThenable(thenableState, thenable, index) {
+  index = thenableState[index];
+  void 0 === index
+    ? thenableState.push(thenable)
+    : index !== thenable && (thenable.then(noop, noop), (thenable = index));
+  switch (thenable.status) {
+    case "fulfilled":
+      return thenable.value;
+    case "rejected":
+      throw thenable.reason;
+    default:
+      "string" === typeof thenable.status
+        ? thenable.then(noop, noop)
+        : ((thenableState = thenable),
+          (thenableState.status = "pending"),
+          thenableState.then(
+            function (fulfilledValue) {
+              if ("pending" === thenable.status) {
+                var fulfilledThenable = thenable;
+                fulfilledThenable.status = "fulfilled";
+                fulfilledThenable.value = fulfilledValue;
+              }
+            },
+            function (error) {
+              if ("pending" === thenable.status) {
+                var rejectedThenable = thenable;
+                rejectedThenable.status = "rejected";
+                rejectedThenable.reason = error;
+              }
+            }
+          ));
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
       }
-  }
-  batchedUpdates$1(function () {
-    var targetInst = ancestorInst,
-      nativeEventTarget = getEventTarget(nativeEvent),
-      dispatchQueue = [];
-    a: {
-      var reactName = topLevelEventsToReactNames.get(domEventName);
-      if (void 0 !== reactName) {
-        var SyntheticEventCtor = SyntheticEvent,
-          reactEventType = domEventName;
-        switch (domEventName) {
-          case "keypress":
-            if (0 === getEventCharCode(nativeEvent)) break a;
-          case "keydown":
-          case "keyup":
-            SyntheticEventCtor = SyntheticKeyboardEvent;
-            break;
-          case "focusin":
-            reactEventType = "focus";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "focusout":
-            reactEventType = "blur";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "beforeblur":
-          case "afterblur":
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "click":
-            if (2 === nativeEvent.button) break a;
-          case "auxclick":
-          case "dblclick":
-          case "mousedown":
-          case "mousemove":
-          case "mouseup":
-          case "mouseout":
-          case "mouseover":
-          case "contextmenu":
-            SyntheticEventCtor = SyntheticMouseEvent;
-            break;
-          case "drag":
-          case "dragend":
-          case "dragenter":
-          case "dragexit":
-          case "dragleave":
-          case "dragover":
-          case "dragstart":
-          case "drop":
-            SyntheticEventCtor = SyntheticDragEvent;
-            break;
-          case "touchcancel":
-          case "touchend":
-          case "touchmove":
-          case "touchstart":
-            SyntheticEventCtor = SyntheticTouchEvent;
-            break;
-          case ANIMATION_END:
-          case ANIMATION_ITERATION:
-          case ANIMATION_START:
-            SyntheticEventCtor = SyntheticAnimationEvent;
-            break;
-          case TRANSITION_END:
-            SyntheticEventCtor = SyntheticTransitionEvent;
-            break;
-          case "scroll":
-            SyntheticEventCtor = SyntheticUIEvent;
-            break;
-          case "wheel":
-            SyntheticEventCtor = SyntheticWheelEvent;
-            break;
-          case "copy":
-          case "cut":
-          case "paste":
-            SyntheticEventCtor = SyntheticClipboardEvent;
-            break;
-          case "gotpointercapture":
-          case "lostpointercapture":
-          case "pointercancel":
-          case "pointerdown":
-          case "pointermove":
-          case "pointerout":
-          case "pointerover":
-          case "pointerup":
-            SyntheticEventCtor = SyntheticPointerEvent;
-        }
-        var inCapturePhase = 0 !== (eventSystemFlags & 4);
-        eventSystemFlags & 1
-          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
-              reactEventType,
-              targetContainer,
-              inCapturePhase
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })))
-          : ((inCapturePhase = accumulateSinglePhaseListeners(
-              targetInst,
-              reactName,
-              nativeEvent.type,
-              inCapturePhase,
-              !inCapturePhase && "scroll" === domEventName,
-              nativeEvent
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })));
-      }
-    }
-    if (0 === (eventSystemFlags & 7)) {
-      a: {
-        reactName =
-          "mouseover" === domEventName || "pointerover" === domEventName;
-        SyntheticEventCtor =
-          "mouseout" === domEventName || "pointerout" === domEventName;
-        if (
-          reactName &&
-          nativeEvent !== currentReplayingEvent &&
-          (reactEventType =
-            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
-          (getClosestInstanceFromNode(reactEventType) ||
-            reactEventType[internalContainerInstanceKey])
-        )
-          break a;
-        if (SyntheticEventCtor || reactName) {
-          reactName =
-            nativeEventTarget.window === nativeEventTarget
-              ? nativeEventTarget
-              : (reactName = nativeEventTarget.ownerDocument)
-              ? reactName.defaultView || reactName.parentWindow
-              : window;
-          if (SyntheticEventCtor) {
-            if (
-              ((reactEventType =
-                nativeEvent.relatedTarget || nativeEvent.toElement),
-              (SyntheticEventCtor = targetInst),
-              (reactEventType = reactEventType
-                ? getClosestInstanceFromNode(reactEventType)
-                : null),
-              null !== reactEventType)
-            ) {
-              inCapturePhase = getNearestMountedFiber(reactEventType);
-              var tag = reactEventType.tag;
-              if (
-                reactEventType !== inCapturePhase ||
-                (5 !== tag && 27 !== tag && 6 !== tag)
-              )
-                reactEventType = null;
-            }
-          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
-          if (SyntheticEventCtor !== reactEventType) {
-            tag = SyntheticMouseEvent;
-            var leaveEventType = "onMouseLeave",
-              enterEventType = "onMouseEnter",
-              eventTypePrefix = "mouse";
-            if ("pointerout" === domEventName || "pointerover" === domEventName)
-              (tag = SyntheticPointerEvent),
-                (leaveEventType = "onPointerLeave"),
-                (enterEventType = "onPointerEnter"),
-                (eventTypePrefix = "pointer");
-            inCapturePhase =
-              null == SyntheticEventCtor
-                ? reactName
-                : getNodeFromInstance(SyntheticEventCtor);
-            var toNode =
-              null == reactEventType
-                ? reactName
-                : getNodeFromInstance(reactEventType);
-            reactName = new tag(
-              leaveEventType,
-              eventTypePrefix + "leave",
-              SyntheticEventCtor,
-              nativeEvent,
-              nativeEventTarget
-            );
-            reactName.target = inCapturePhase;
-            reactName.relatedTarget = toNode;
-            leaveEventType = null;
-            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
-              ((tag = new tag(
-                enterEventType,
-                eventTypePrefix + "enter",
-                reactEventType,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              (tag.target = toNode),
-              (tag.relatedTarget = inCapturePhase),
-              (leaveEventType = tag));
-            inCapturePhase = leaveEventType;
-            if (SyntheticEventCtor && reactEventType)
-              b: {
-                tag = SyntheticEventCtor;
-                enterEventType = reactEventType;
-                eventTypePrefix = 0;
-                for (toNode = tag; toNode; toNode = getParent(toNode))
-                  eventTypePrefix++;
-                toNode = 0;
-                for (
-                  leaveEventType = enterEventType;
-                  leaveEventType;
-                  leaveEventType = getParent(leaveEventType)
-                )
-                  toNode++;
-                for (; 0 < eventTypePrefix - toNode; )
-                  (tag = getParent(tag)), eventTypePrefix--;
-                for (; 0 < toNode - eventTypePrefix; )
-                  (enterEventType = getParent(enterEventType)), toNode--;
-                for (; eventTypePrefix--; ) {
-                  if (
-                    tag === enterEventType ||
-                    (null !== enterEventType &&
-                      tag === enterEventType.alternate)
-                  )
-                    break b;
-                  tag = getParent(tag);
-                  enterEventType = getParent(enterEventType);
-                }
-                tag = null;
-              }
-            else tag = null;
-            null !== SyntheticEventCtor &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                reactName,
-                SyntheticEventCtor,
-                tag,
-                !1
-              );
-            null !== reactEventType &&
-              null !== inCapturePhase &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                inCapturePhase,
-                reactEventType,
-                tag,
-                !0
-              );
-          }
-        }
-      }
-      a: {
-        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
-        SyntheticEventCtor =
-          reactName.nodeName && reactName.nodeName.toLowerCase();
-        if (
-          "select" === SyntheticEventCtor ||
-          ("input" === SyntheticEventCtor && "file" === reactName.type)
-        )
-          var getTargetInstFunc = getTargetInstForChangeEvent;
-        else if (isTextInputElement(reactName))
-          if (isInputEventSupported)
-            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-          else {
-            getTargetInstFunc = getTargetInstForInputEventPolyfill;
-            var handleEventFunc = handleEventsForInputEventPolyfill;
-          }
-        else
-          (SyntheticEventCtor = reactName.nodeName),
-            !SyntheticEventCtor ||
-            "input" !== SyntheticEventCtor.toLowerCase() ||
-            ("checkbox" !== reactName.type && "radio" !== reactName.type)
-              ? enableCustomElementPropertySupport &&
-                targetInst &&
-                isCustomComponent(
-                  targetInst.elementType,
-                  targetInst.memoizedProps
-                ) &&
-                (getTargetInstFunc = getTargetInstForChangeEvent)
-              : (getTargetInstFunc = getTargetInstForClickEvent);
-        if (
-          getTargetInstFunc &&
-          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
-        ) {
-          createAndAccumulateChangeEvent(
-            dispatchQueue,
-            getTargetInstFunc,
-            nativeEvent,
-            nativeEventTarget
-          );
-          break a;
-        }
-        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
-        "focusout" === domEventName &&
-          (handleEventFunc = reactName._wrapperState) &&
-          handleEventFunc.controlled &&
-          "number" === reactName.type &&
-          (disableInputAttributeSyncing ||
-            setDefaultValue(reactName, "number", reactName.value));
-      }
-      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
-      switch (domEventName) {
-        case "focusin":
-          if (
-            isTextInputElement(handleEventFunc) ||
-            "true" === handleEventFunc.contentEditable
-          )
-            (activeElement = handleEventFunc),
-              (activeElementInst = targetInst),
-              (lastSelection = null);
-          break;
-        case "focusout":
-          lastSelection = activeElementInst = activeElement = null;
-          break;
-        case "mousedown":
-          mouseDown = !0;
-          break;
-        case "contextmenu":
-        case "mouseup":
-        case "dragend":
-          mouseDown = !1;
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-          break;
-        case "selectionchange":
-          if (skipSelectionChangeEvent) break;
-        case "keydown":
-        case "keyup":
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-      }
-      var fallbackData;
-      if (canUseCompositionEvent)
-        b: {
-          switch (domEventName) {
-            case "compositionstart":
-              var eventType = "onCompositionStart";
-              break b;
-            case "compositionend":
-              eventType = "onCompositionEnd";
-              break b;
-            case "compositionupdate":
-              eventType = "onCompositionUpdate";
-              break b;
-          }
-          eventType = void 0;
-        }
-      else
-        isComposing
-          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
-            (eventType = "onCompositionEnd")
-          : "keydown" === domEventName &&
-            229 === nativeEvent.keyCode &&
-            (eventType = "onCompositionStart");
-      eventType &&
-        (useFallbackCompositionData &&
-          "ko" !== nativeEvent.locale &&
-          (isComposing || "onCompositionStart" !== eventType
-            ? "onCompositionEnd" === eventType &&
-              isComposing &&
-              (fallbackData = getData())
-            : ((root = nativeEventTarget),
-              (startText = "value" in root ? root.value : root.textContent),
-              (isComposing = !0))),
-        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
-        0 < handleEventFunc.length &&
-          ((eventType = new SyntheticCompositionEvent(
-            eventType,
-            domEventName,
-            null,
-            nativeEvent,
-            nativeEventTarget
-          )),
-          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
-          fallbackData
-            ? (eventType.data = fallbackData)
-            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
-              null !== fallbackData && (eventType.data = fallbackData))));
-      if (
-        (fallbackData = canUseTextInputEvent
-          ? getNativeBeforeInputChars(domEventName, nativeEvent)
-          : getFallbackBeforeInputChars(domEventName, nativeEvent))
-      )
-        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
-          0 < targetInst.length &&
-            ((nativeEventTarget = new SyntheticCompositionEvent(
-              "onBeforeInput",
-              "beforeinput",
-              null,
-              nativeEvent,
-              nativeEventTarget
-            )),
-            dispatchQueue.push({
-              event: nativeEventTarget,
-              listeners: targetInst
-            }),
-            (nativeEventTarget.data = fallbackData));
-    }
-    processDispatchQueue(dispatchQueue, eventSystemFlags);
-  });
-}
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
-}
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  reactName = inCapturePhase
-    ? null !== reactName
-      ? reactName + "Capture"
-      : null
-    : reactName;
-  for (
-    var listeners = [], instance = targetFiber, lastHostComponent = null;
-    null !== instance;
-
-  ) {
-    var _instance = instance;
-    targetFiber = _instance.stateNode;
-    _instance = _instance.tag;
-    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
-    null === targetFiber
-      ? 21 === _instance &&
-        null !== lastHostComponent &&
-        null !== targetFiber &&
-        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }))
-      : ((lastHostComponent = targetFiber),
-        (targetFiber =
-          lastHostComponent[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }),
-        null !== reactName &&
-          ((targetFiber = getListener(instance, reactName)),
-          null != targetFiber &&
-            listeners.push(
-              createDispatchListener(instance, targetFiber, lastHostComponent)
-            )));
-    if (accumulateTargetOnly) break;
-    "beforeblur" === nativeEvent.type &&
-      ((targetFiber = nativeEvent._detachedInterceptFiber),
-      null === targetFiber ||
-        (targetFiber !== instance && targetFiber !== instance.alternate) ||
-        (listeners = []));
-    instance = instance.return;
-  }
-  return listeners;
-}
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  for (
-    var captureName = reactName + "Capture", listeners = [];
-    null !== targetFiber;
-
-  ) {
-    var _instance2 = targetFiber,
-      stateNode = _instance2.stateNode;
-    _instance2 = _instance2.tag;
-    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
-      null === stateNode ||
-      ((_instance2 = getListener(targetFiber, captureName)),
-      null != _instance2 &&
-        listeners.unshift(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ),
-      (_instance2 = getListener(targetFiber, reactName)),
-      null != _instance2 &&
-        listeners.push(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ));
-    targetFiber = targetFiber.return;
-  }
-  return listeners;
-}
-function getParent(inst) {
-  if (null === inst) return null;
-  do inst = inst.return;
-  while (inst && 5 !== inst.tag && 27 !== inst.tag);
-  return inst ? inst : null;
-}
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  for (
-    var registrationName = event._reactName, listeners = [];
-    null !== target && target !== common;
-
-  ) {
-    var _instance3 = target,
-      alternate = _instance3.alternate,
-      stateNode = _instance3.stateNode;
-    _instance3 = _instance3.tag;
-    if (null !== alternate && alternate === common) break;
-    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
-      null === stateNode ||
-      ((alternate = stateNode),
-      inCapturePhase
-        ? ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.unshift(
-              createDispatchListener(target, stateNode, alternate)
-            ))
-        : inCapturePhase ||
-          ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.push(
-              createDispatchListener(target, stateNode, alternate)
-            )));
-    target = target.return;
-  }
-  0 !== listeners.length &&
-    dispatchQueue.push({ event: event, listeners: listeners });
-}
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [],
-    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
-  null !== eventListeners &&
-    eventListeners.forEach(function (entry) {
-      entry.type === reactEventType &&
-        entry.capture === inCapturePhase &&
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
-        );
-    });
-  return listeners;
-}
-var _attemptSynchronousHydration,
-  attemptDiscreteHydration$1,
-  attemptContinuousHydration$1,
-  attemptHydrationAtCurrentPriority$1,
-  getCurrentUpdatePriority,
-  attemptHydrationAtPriority,
-  hasScheduledReplayAttempt = !1,
-  queuedDiscreteEvents = [],
-  queuedFocus = null,
-  queuedDrag = null,
-  queuedMouse = null,
-  queuedPointers = new Map(),
-  queuedPointerCaptures = new Map(),
-  queuedExplicitHydrationTargets = [],
-  discreteReplayableEvents =
-    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
-      " "
-    );
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
-}
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
-    ((blockedOn = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )),
-    queuedDiscreteEvents.push(blockedOn),
-    1 === queuedDiscreteEvents.length)
-  )
-    for (; null !== blockedOn.blockedOn; ) {
-      domEventName = getInstanceFromNode(blockedOn.blockedOn);
-      if (null === domEventName) break;
-      _attemptSynchronousHydration(domEventName);
-      if (null === blockedOn.blockedOn) replayUnblockedEvents();
-      else break;
-    }
-}
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
-    case "pointerover":
-    case "pointerout":
-      queuedPointers.delete(nativeEvent.pointerId);
-      break;
-    case "gotpointercapture":
-    case "lostpointercapture":
-      queuedPointerCaptures.delete(nativeEvent.pointerId);
-  }
-}
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    null === existingQueuedEvent ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
-  )
-    return (
-      (existingQueuedEvent = createQueuedReplayableEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )),
-      null !== blockedOn &&
-        ((blockedOn = getInstanceFromNode(blockedOn)),
-        null !== blockedOn && attemptContinuousHydration$1(blockedOn)),
-      existingQueuedEvent
-    );
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  blockedOn = existingQueuedEvent.targetContainers;
-  null !== targetContainer &&
-    -1 === blockedOn.indexOf(targetContainer) &&
-    blockedOn.push(targetContainer);
-  return existingQueuedEvent;
-}
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  switch (domEventName) {
-    case "focusin":
-      return (
-        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedFocus,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "dragenter":
-      return (
-        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedDrag,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "mouseover":
-      return (
-        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedMouse,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "pointerover":
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
-      );
-      return !0;
-    case "gotpointercapture":
-      return (
-        (pointerId = nativeEvent.pointerId),
-        queuedPointerCaptures.set(
-          pointerId,
-          accumulateOrCreateContinuousQueuedReplayableEvent(
-            queuedPointerCaptures.get(pointerId) || null,
-            blockedOn,
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          )
-        ),
-        !0
-      );
-  }
-  return !1;
-}
-function attemptExplicitHydrationTarget(queuedTarget) {
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
-  if (null !== targetInst) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-    if (null !== nearestMounted)
-      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
-        if (
-          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
-          null !== targetInst)
-        ) {
-          queuedTarget.blockedOn = targetInst;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (
-        3 === targetInst &&
-        nearestMounted.stateNode.current.memoizedState.isDehydrated
-      ) {
-        queuedTarget.blockedOn =
-          3 === nearestMounted.tag
-            ? nearestMounted.stateNode.containerInfo
-            : null;
-        return;
-      }
-  }
-  queuedTarget.blockedOn = null;
-}
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (null !== queuedEvent.blockedOn) return !1;
-  for (
-    var targetContainers = queuedEvent.targetContainers;
-    0 < targetContainers.length;
-
-  ) {
-    var targetContainer = targetContainers[0],
-      nextBlockedOn = findInstanceBlockingEvent(
-        queuedEvent.domEventName,
-        queuedEvent.eventSystemFlags,
-        targetContainer,
-        queuedEvent.nativeEvent
-      );
-    if (null === nextBlockedOn)
-      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
-        ? ((nextBlockedOn = queuedEvent.nativeEvent),
-          (currentReplayingEvent = targetContainer =
-            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
-          nextBlockedOn.target.dispatchEvent(targetContainer))
-        : ((currentReplayingEvent = queuedEvent.nativeEvent),
-          dispatchEventForPluginEventSystem(
-            queuedEvent.domEventName,
-            queuedEvent.eventSystemFlags,
-            queuedEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          )),
-        (currentReplayingEvent = null);
-    else
-      return (
-        (targetContainers = getInstanceFromNode(nextBlockedOn)),
-        null !== targetContainers &&
-          attemptContinuousHydration$1(targetContainers),
-        (queuedEvent.blockedOn = nextBlockedOn),
-        !1
-      );
-    targetContainers.shift();
-  }
-  return !0;
-}
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
-}
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = !1;
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
-    for (; 0 < queuedDiscreteEvents.length; ) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
-      if (null !== nextDiscreteEvent.blockedOn) {
-        nextDiscreteEvent = getInstanceFromNode(nextDiscreteEvent.blockedOn);
-        null !== nextDiscreteEvent &&
-          attemptDiscreteHydration$1(nextDiscreteEvent);
-        break;
-      }
-      for (
-        var targetContainers = nextDiscreteEvent.targetContainers;
-        0 < targetContainers.length;
-
-      ) {
-        var targetContainer = targetContainers[0],
-          nextBlockedOn = findInstanceBlockingEvent(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            targetContainer,
-            nextDiscreteEvent.nativeEvent
-          );
-        if (null === nextBlockedOn)
-          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
-            dispatchEventForPluginEventSystem(
-              nextDiscreteEvent.domEventName,
-              nextDiscreteEvent.eventSystemFlags,
-              nextDiscreteEvent.nativeEvent,
-              return_targetInst,
-              targetContainer
-            ),
-            (currentReplayingEvent = null);
-        else {
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        }
-        targetContainers.shift();
-      }
-      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
-    }
-  null !== queuedFocus &&
-    attemptReplayContinuousQueuedEvent(queuedFocus) &&
-    (queuedFocus = null);
-  null !== queuedDrag &&
-    attemptReplayContinuousQueuedEvent(queuedDrag) &&
-    (queuedDrag = null);
-  null !== queuedMouse &&
-    attemptReplayContinuousQueuedEvent(queuedMouse) &&
-    (queuedMouse = null);
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
-}
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  queuedEvent.blockedOn === unblocked &&
-    ((queuedEvent.blockedOn = null),
-    hasScheduledReplayAttempt ||
-      ((hasScheduledReplayAttempt = !0),
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      )));
-}
-function retryIfBlockedOn(unblocked) {
-  function unblock(queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
-  }
-  if (0 < queuedDiscreteEvents.length) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
-    }
-  }
-  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
-  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
-  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
-    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
-  for (
-    ;
-    0 < queuedExplicitHydrationTargets.length &&
-    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
-
-  )
-    attemptExplicitHydrationTarget(i),
-      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
-}
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
-  _enabled = !0;
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  switch (getEventPriority(domEventName)) {
-    case 2:
-      var listenerWrapper = dispatchDiscreteEvent;
-      break;
-    case 8:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
-    default:
-      listenerWrapper = dispatchEvent;
-  }
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
-}
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 2),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
-  }
-}
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 8),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
-  }
-}
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (_enabled)
-    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-      var blockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
-      if (null === blockedOn)
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          clearIfContinuousEvent(domEventName, nativeEvent);
-      else if (
-        queueIfContinuousEvent(
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
-      )
-        nativeEvent.stopPropagation();
-      else if (
-        (clearIfContinuousEvent(domEventName, nativeEvent),
-        eventSystemFlags & 4 &&
-          -1 < discreteReplayableEvents.indexOf(domEventName))
-      ) {
-        for (; null !== blockedOn; ) {
-          var fiber = getInstanceFromNode(blockedOn);
-          null !== fiber && _attemptSynchronousHydration(fiber);
-          fiber = findInstanceBlockingEvent(
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          );
-          null === fiber &&
-            dispatchEventForPluginEventSystem(
-              domEventName,
-              eventSystemFlags,
-              nativeEvent,
-              return_targetInst,
-              targetContainer
-            );
-          if (fiber === blockedOn) break;
-          blockedOn = fiber;
-        }
-        null !== blockedOn && nativeEvent.stopPropagation();
-      } else
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-    } else
-      a: if (
-        (blockedOn = 0 === (eventSystemFlags & 4)) &&
-        0 < queuedDiscreteEvents.length &&
-        -1 < discreteReplayableEvents.indexOf(domEventName)
-      )
-        queueDiscreteEvent(
-          null,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        );
-      else if (
-        ((fiber = findInstanceBlockingEvent(
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        null === fiber)
-      )
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
-      else {
-        if (blockedOn) {
-          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
-            queueDiscreteEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            );
-            break a;
-          }
-          if (
-            queueIfContinuousEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            )
-          )
-            break a;
-          clearIfContinuousEvent(domEventName, nativeEvent);
-        }
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-      }
-}
-var return_targetInst = null;
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return_targetInst = null;
-  domEventName = getEventTarget(nativeEvent);
-  domEventName = getClosestInstanceFromNode(domEventName);
-  if (null !== domEventName)
-    if (
-      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
-      null === eventSystemFlags)
-    )
-      domEventName = null;
-    else if (
-      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
-    ) {
-      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
-      if (null !== domEventName) return domEventName;
-      domEventName = null;
-    } else if (3 === targetContainer) {
-      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
-        return 3 === eventSystemFlags.tag
-          ? eventSystemFlags.stateNode.containerInfo
-          : null;
-      domEventName = null;
-    } else eventSystemFlags !== domEventName && (domEventName = null);
-  return_targetInst = domEventName;
-  return null;
-}
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange":
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate":
-    case "beforeblur":
-    case "afterblur":
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return 2;
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel":
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return 8;
-    case "message":
-      switch (getCurrentPriorityLevel()) {
-        case ImmediatePriority:
-          return 2;
-        case UserBlockingPriority:
-          return 8;
-        case NormalPriority$1:
-        case LowPriority:
-          return 32;
-        case IdlePriority:
-          return 536870912;
-        default:
-          return 32;
-      }
-    default:
-      return 32;
-  }
-}
-var emptyContextObject = {},
-  contextStackCursor = createCursor(emptyContextObject),
-  didPerformWorkStackCursor = createCursor(!1),
-  previousContext = emptyContextObject;
-function getMaskedContext(workInProgress, unmaskedContext) {
-  var contextTypes = workInProgress.type.contextTypes;
-  if (!contextTypes) return emptyContextObject;
-  var instance = workInProgress.stateNode;
-  if (
-    instance &&
-    instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
-  )
-    return instance.__reactInternalMemoizedMaskedChildContext;
-  var context = {},
-    key;
-  for (key in contextTypes) context[key] = unmaskedContext[key];
-  instance &&
-    ((workInProgress = workInProgress.stateNode),
-    (workInProgress.__reactInternalMemoizedUnmaskedChildContext =
-      unmaskedContext),
-    (workInProgress.__reactInternalMemoizedMaskedChildContext = context));
-  return context;
-}
-function isContextProvider(type) {
-  type = type.childContextTypes;
-  return null !== type && void 0 !== type;
-}
-function popContext() {
-  pop(didPerformWorkStackCursor);
-  pop(contextStackCursor);
-}
-function pushTopLevelContextObject(fiber, context, didChange) {
-  if (contextStackCursor.current !== emptyContextObject)
-    throw Error(formatProdErrorMessage(168));
-  push(contextStackCursor, context);
-  push(didPerformWorkStackCursor, didChange);
-}
-function processChildContext(fiber, type, parentContext) {
-  var instance = fiber.stateNode;
-  type = type.childContextTypes;
-  if ("function" !== typeof instance.getChildContext) return parentContext;
-  instance = instance.getChildContext();
-  for (var contextKey in instance)
-    if (!(contextKey in type))
-      throw Error(
-        formatProdErrorMessage(
-          108,
-          getComponentNameFromFiber(fiber) || "Unknown",
-          contextKey
-        )
-      );
-  return assign({}, parentContext, instance);
-}
-function pushContextProvider(workInProgress) {
-  workInProgress =
-    ((workInProgress = workInProgress.stateNode) &&
-      workInProgress.__reactInternalMemoizedMergedChildContext) ||
-    emptyContextObject;
-  previousContext = contextStackCursor.current;
-  push(contextStackCursor, workInProgress);
-  push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
-  return !0;
-}
-function invalidateContextProvider(workInProgress, type, didChange) {
-  var instance = workInProgress.stateNode;
-  if (!instance) throw Error(formatProdErrorMessage(169));
-  didChange
-    ? ((workInProgress = processChildContext(
-        workInProgress,
-        type,
-        previousContext
-      )),
-      (instance.__reactInternalMemoizedMergedChildContext = workInProgress),
-      pop(didPerformWorkStackCursor),
-      pop(contextStackCursor),
-      push(contextStackCursor, workInProgress))
-    : pop(didPerformWorkStackCursor);
-  push(didPerformWorkStackCursor, didChange);
-}
-var syncQueue = null,
-  includesLegacySyncCallbacks = !1,
-  isFlushingSyncQueue = !1;
-function scheduleSyncCallback(callback) {
-  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
-}
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = !0;
-  scheduleSyncCallback(callback);
-}
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && null !== syncQueue) {
-    isFlushingSyncQueue = !0;
-    var previousUpdatePriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
-      var callback = queue[i];
-      try {
-        do callback = callback(!0);
-        while (null !== callback);
-      } catch (error) {
-        null === errors ? (errors = [error]) : errors.push(error);
-      }
-    }
-    syncQueue = null;
-    includesLegacySyncCallbacks = !1;
-    currentUpdatePriority = previousUpdatePriority;
-    isFlushingSyncQueue = !1;
-    if (null !== errors) {
-      if (1 < errors.length) {
-        if ("function" === typeof AggregateError)
-          throw new AggregateError(errors);
-        for (
-          previousUpdatePriority = 1;
-          previousUpdatePriority < errors.length;
-          previousUpdatePriority++
-        )
-          scheduleCallback$2(
-            ImmediatePriority,
-            throwError.bind(null, errors[previousUpdatePriority])
-          );
-      }
-      throw errors[0];
-    }
-  }
-  return null;
-}
-function throwError(error) {
-  throw error;
-}
-var forkStack = [],
-  forkStackIndex = 0,
-  treeForkProvider = null,
-  treeForkCount = 0,
-  idStack = [],
-  idStackIndex = 0,
-  treeContextProvider = null,
-  treeContextId = 1,
-  treeContextOverflow = "";
-function pushTreeFork(workInProgress, totalChildren) {
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
-}
-function pushTreeId(workInProgress, totalChildren, index) {
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  workInProgress = treeContextOverflow;
-  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
-  baseIdWithLeadingBit &= ~(1 << baseLength);
-  index += 1;
-  var length = 32 - clz32(totalChildren) + baseLength;
-  if (30 < length) {
-    var numberOfOverflowBits = baseLength - (baseLength % 5);
-    length = (
-      baseIdWithLeadingBit &
-      ((1 << numberOfOverflowBits) - 1)
-    ).toString(32);
-    baseIdWithLeadingBit >>= numberOfOverflowBits;
-    baseLength -= numberOfOverflowBits;
-    treeContextId =
-      (1 << (32 - clz32(totalChildren) + baseLength)) |
-      (index << baseLength) |
-      baseIdWithLeadingBit;
-    treeContextOverflow = length + workInProgress;
-  } else
-    (treeContextId =
-      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
-      (treeContextOverflow = workInProgress);
-}
-function pushMaterializedTreeId(workInProgress) {
-  null !== workInProgress.return &&
-    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
-}
-function popTreeContext(workInProgress) {
-  for (; workInProgress === treeForkProvider; )
-    (treeForkProvider = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null),
-      (treeForkCount = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null);
-  for (; workInProgress === treeContextProvider; )
-    (treeContextProvider = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextOverflow = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextId = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null);
-}
-var hydrationParentFiber = null,
-  nextHydratableInstance = null,
-  isHydrating = !1,
-  hydrationErrors = null,
-  rootOrSingletonContext = !1;
-function deleteHydratableInstance(returnFiber, instance) {
-  var fiber = createFiber(5, null, null, 0);
-  fiber.elementType = "DELETED";
-  fiber.stateNode = instance;
-  fiber.return = returnFiber;
-  instance = returnFiber.deletions;
-  null === instance
-    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
-    : instance.push(fiber);
-}
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & -4097) | 2;
-}
-function tryHydrateInstance(fiber, nextInstance) {
-  var type = fiber.type;
-  nextInstance =
-    1 !== nextInstance.nodeType ||
-    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
-      (rootOrSingletonContext = !1),
-      !0)
-    : !1;
-}
-function tryHydrateText(fiber, nextInstance) {
-  nextInstance =
-    "" === fiber.pendingProps
-      ? null
-      : 3 !== nextInstance.nodeType
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = null),
-      !0)
-    : !1;
-}
-function tryHydrateSuspense(fiber, nextInstance) {
-  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
-  if (null !== nextInstance) {
-    var JSCompiler_inline_result =
-      null !== treeContextProvider
-        ? { id: treeContextId, overflow: treeContextOverflow }
-        : null;
-    fiber.memoizedState = {
-      dehydrated: nextInstance,
-      treeContext: JSCompiler_inline_result,
-      retryLane: 1073741824
-    };
-    JSCompiler_inline_result = createFiber(18, null, null, 0);
-    JSCompiler_inline_result.stateNode = nextInstance;
-    JSCompiler_inline_result.return = fiber;
-    fiber.child = JSCompiler_inline_result;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = null;
-    return !0;
-  }
-  return !1;
-}
-function shouldClientRenderOnMismatch(fiber) {
-  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
-}
-function throwOnHydrationMismatch() {
-  throw Error(formatProdErrorMessage(418));
-}
-function advanceToFirstAttemptableInstance(fiber) {
-  for (
-    ;
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    );
-
-  )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
-}
-function advanceToFirstAttemptableTextInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
-}
-function advanceToFirstAttemptableSuspenseInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
-}
-function prepareToHydrateHostInstance(fiber) {
-  var instance = fiber.stateNode,
-    type = fiber.type,
-    props = fiber.memoizedProps;
-  instance[internalInstanceKey] = fiber;
-  instance[internalPropsKey] = props;
-  switch (type) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", instance);
-      listenToNonDelegatedEvent("close", instance);
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "video":
-    case "audio":
-      for (var i = 0; i < mediaEventTypes.length; i++)
-        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", instance);
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", instance);
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", instance);
-      break;
-    case "input":
-      initWrapperState$2(instance, props);
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "select":
-      instance._wrapperState = { wasMultiple: !!props.multiple };
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "textarea":
-      initWrapperState(instance, props),
-        listenToNonDelegatedEvent("invalid", instance);
-  }
-  assertValidProps(type, props);
-  var updatePayload = null,
-    propKey;
-  for (propKey in props)
-    props.hasOwnProperty(propKey) &&
-      ((i = props[propKey]),
-      "children" === propKey
-        ? "string" === typeof i
-          ? instance.textContent !== i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", i]))
-          : "number" === typeof i &&
-            instance.textContent !== "" + i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", "" + i]))
-        : registrationNameDependencies.hasOwnProperty(propKey) &&
-          null != i &&
-          "onScroll" === propKey &&
-          listenToNonDelegatedEvent("scroll", instance));
-  switch (type) {
-    case "input":
-      track(instance);
-      postMountWrapper$3(instance, props, !0);
-      break;
-    case "textarea":
-      track(instance);
-      postMountWrapper(instance);
-      break;
-    case "select":
-    case "option":
-      break;
-    default:
-      "function" === typeof props.onClick && (instance.onclick = noop$1);
-  }
-  instance = updatePayload;
-  fiber.updateQueue = instance;
-  return null !== instance ? !0 : !1;
-}
-function popToNextHostParent(fiber) {
-  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
-    switch (hydrationParentFiber.tag) {
-      case 3:
-      case 27:
-        rootOrSingletonContext = !0;
-        return;
-      case 5:
-      case 13:
-        rootOrSingletonContext = !1;
-        return;
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
-    }
-}
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) return !1;
-  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
-  var shouldClear = !1;
-  3 === fiber.tag ||
-    27 === fiber.tag ||
-    (5 === fiber.tag &&
-      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
-    (shouldClear = !0);
-  if (shouldClear && (shouldClear = nextHydratableInstance))
-    if (shouldClientRenderOnMismatch(fiber))
-      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
-    else
-      for (; shouldClear; )
-        deleteHydratableInstance(fiber, shouldClear),
-          (shouldClear = getNextHydratable(shouldClear.nextSibling));
-  popToNextHostParent(fiber);
-  if (13 === fiber.tag) {
-    fiber = fiber.memoizedState;
-    fiber = null !== fiber ? fiber.dehydrated : null;
-    if (!fiber) throw Error(formatProdErrorMessage(317));
-    a: {
-      fiber = fiber.nextSibling;
-      for (shouldClear = 0; fiber; ) {
-        if (8 === fiber.nodeType) {
-          var data = fiber.data;
-          if ("/$" === data) {
-            if (0 === shouldClear) {
-              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
-              break a;
-            }
-            shouldClear--;
-          } else
-            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
-        }
-        fiber = fiber.nextSibling;
-      }
-      nextHydratableInstance = null;
-    }
-  } else
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratable(fiber.stateNode.nextSibling)
-      : null;
-  return !0;
-}
-function warnIfUnhydratedTailNodes() {
-  for (var nextInstance = nextHydratableInstance; nextInstance; )
-    nextInstance = getNextHydratable(nextInstance.nextSibling);
-}
-function resetHydrationState() {
-  nextHydratableInstance = hydrationParentFiber = null;
-  isHydrating = !1;
-}
-function queueHydrationError(error) {
-  null === hydrationErrors
-    ? (hydrationErrors = [error])
-    : hydrationErrors.push(error);
-}
-var concurrentQueues = [],
-  concurrentQueuesIndex = 0,
-  concurrentlyUpdatedLanes = 0;
-function finishQueueingConcurrentUpdates() {
-  for (
-    var endIndex = concurrentQueuesIndex,
-      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
-    i < endIndex;
-
-  ) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    if (null !== queue && null !== update) {
-      var pending = queue.pending;
-      null === pending
-        ? (update.next = update)
-        : ((update.next = pending.next), (pending.next = update));
-      queue.pending = update;
-    }
-    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
-  }
-}
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes |= lane;
-  fiber.lanes |= lane;
-  fiber = fiber.alternate;
-  null !== fiber && (fiber.lanes |= lane);
-}
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  sourceFiber.lanes |= lane;
-  var alternate = sourceFiber.alternate;
-  null !== alternate && (alternate.lanes |= lane);
-  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
-    (parent.childLanes |= lane),
-      (alternate = parent.alternate),
-      null !== alternate && (alternate.childLanes |= lane),
-      22 === parent.tag &&
-        ((sourceFiber = parent.stateNode),
-        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
-      (sourceFiber = parent),
-      (parent = parent.return);
-  isHidden &&
-    null !== update &&
-    3 === sourceFiber.tag &&
-    ((parent = sourceFiber.stateNode),
-    (isHidden = 31 - clz32(lane)),
-    (parent = parent.hiddenUpdates),
-    (sourceFiber = parent[isHidden]),
-    null === sourceFiber
-      ? (parent[isHidden] = [update])
-      : sourceFiber.push(update),
-    (update.lane = lane | 1073741824));
-}
-function getRootForUpdatedFiber(sourceFiber) {
-  if (50 < nestedUpdateCount)
-    throw (
-      ((nestedUpdateCount = 0),
-      (rootWithNestedUpdates = null),
-      Error(formatProdErrorMessage(185)))
-    );
-  for (var parent = sourceFiber.return; null !== parent; )
-    (sourceFiber = parent), (parent = sourceFiber.return);
-  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
-}
-var hasForceUpdate = !1;
-function initializeUpdateQueue(fiber) {
-  fiber.updateQueue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
-    callbacks: null
-  };
-}
-function cloneUpdateQueue(current, workInProgress) {
-  current = current.updateQueue;
-  workInProgress.updateQueue === current &&
-    (workInProgress.updateQueue = {
-      baseState: current.baseState,
-      firstBaseUpdate: current.firstBaseUpdate,
-      lastBaseUpdate: current.lastBaseUpdate,
-      shared: current.shared,
-      callbacks: null
-    });
-}
-function createUpdate(lane) {
-  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
-}
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
-  if (null === updateQueue) return null;
-  updateQueue = updateQueue.shared;
-  if (
-    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
-    0 === (executionContext & 2)
-  )
-    return (
-      enqueueUpdate$1(fiber, updateQueue, update, lane),
-      getRootForUpdatedFiber(fiber)
-    );
-  var pending = updateQueue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  updateQueue.pending = update;
-  update = getRootForUpdatedFiber(fiber);
-  markUpdateLaneFromFiberToRoot(fiber, null, lane);
-  return update;
-}
-function entangleTransitions(root, fiber, lane) {
-  fiber = fiber.updateQueue;
-  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
-    var queueLanes = fiber.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    fiber.lanes = lane;
-    markRootEntangled(root, lane);
-  }
-}
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  var queue = workInProgress.updateQueue,
-    current = workInProgress.alternate;
-  if (
-    null !== current &&
-    ((current = current.updateQueue), queue === current)
-  ) {
-    var newFirst = null,
-      newLast = null;
-    queue = queue.firstBaseUpdate;
-    if (null !== queue) {
-      do {
-        var clone = {
-          lane: queue.lane,
-          tag: queue.tag,
-          payload: queue.payload,
-          callback: null,
-          next: null
-        };
-        null === newLast
-          ? (newFirst = newLast = clone)
-          : (newLast = newLast.next = clone);
-        queue = queue.next;
-      } while (null !== queue);
-      null === newLast
-        ? (newFirst = newLast = capturedUpdate)
-        : (newLast = newLast.next = capturedUpdate);
-    } else newFirst = newLast = capturedUpdate;
-    queue = {
-      baseState: current.baseState,
-      firstBaseUpdate: newFirst,
-      lastBaseUpdate: newLast,
-      shared: current.shared,
-      callbacks: current.callbacks
-    };
-    workInProgress.updateQueue = queue;
-    return;
-  }
-  workInProgress = queue.lastBaseUpdate;
-  null === workInProgress
-    ? (queue.firstBaseUpdate = capturedUpdate)
-    : (workInProgress.next = capturedUpdate);
-  queue.lastBaseUpdate = capturedUpdate;
-}
-function processUpdateQueue(
-  workInProgress$jscomp$0,
-  props,
-  instance$jscomp$0,
-  renderLanes
-) {
-  var queue = workInProgress$jscomp$0.updateQueue;
-  hasForceUpdate = !1;
-  var firstBaseUpdate = queue.firstBaseUpdate,
-    lastBaseUpdate = queue.lastBaseUpdate,
-    pendingQueue = queue.shared.pending;
-  if (null !== pendingQueue) {
-    queue.shared.pending = null;
-    var lastPendingUpdate = pendingQueue,
-      firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null;
-    null === lastBaseUpdate
-      ? (firstBaseUpdate = firstPendingUpdate)
-      : (lastBaseUpdate.next = firstPendingUpdate);
-    lastBaseUpdate = lastPendingUpdate;
-    var current = workInProgress$jscomp$0.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      (pendingQueue = current.lastBaseUpdate),
-      pendingQueue !== lastBaseUpdate &&
-        (null === pendingQueue
-          ? (current.firstBaseUpdate = firstPendingUpdate)
-          : (pendingQueue.next = firstPendingUpdate),
-        (current.lastBaseUpdate = lastPendingUpdate)));
-  }
-  if (null !== firstBaseUpdate) {
-    var newState = queue.baseState;
-    lastBaseUpdate = 0;
-    current = firstPendingUpdate = lastPendingUpdate = null;
-    pendingQueue = firstBaseUpdate;
-    do {
-      var updateLane = pendingQueue.lane & -1073741825,
-        isHiddenUpdate = updateLane !== pendingQueue.lane;
-      if (
-        isHiddenUpdate
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes & updateLane) === updateLane
-      ) {
-        null !== current &&
-          (current = current.next =
-            {
-              lane: 0,
-              tag: pendingQueue.tag,
-              payload: pendingQueue.payload,
-              callback: null,
-              next: null
-            });
-        a: {
-          var workInProgress = workInProgress$jscomp$0,
-            update = pendingQueue;
-          updateLane = props;
-          var instance = instance$jscomp$0;
-          switch (update.tag) {
-            case 1:
-              workInProgress = update.payload;
-              if ("function" === typeof workInProgress) {
-                newState = workInProgress.call(instance, newState, updateLane);
-                break a;
-              }
-              newState = workInProgress;
-              break a;
-            case 3:
-              workInProgress.flags = (workInProgress.flags & -65537) | 128;
-            case 0:
-              workInProgress = update.payload;
-              updateLane =
-                "function" === typeof workInProgress
-                  ? workInProgress.call(instance, newState, updateLane)
-                  : workInProgress;
-              if (null === updateLane || void 0 === updateLane) break a;
-              newState = assign({}, newState, updateLane);
-              break a;
-            case 2:
-              hasForceUpdate = !0;
-          }
-        }
-        updateLane = pendingQueue.callback;
-        null !== updateLane &&
-          ((workInProgress$jscomp$0.flags |= 64),
-          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
-          (isHiddenUpdate = queue.callbacks),
-          null === isHiddenUpdate
-            ? (queue.callbacks = [updateLane])
-            : isHiddenUpdate.push(updateLane));
-      } else
-        (isHiddenUpdate = {
-          lane: updateLane,
-          tag: pendingQueue.tag,
-          payload: pendingQueue.payload,
-          callback: pendingQueue.callback,
-          next: null
-        }),
-          null === current
-            ? ((firstPendingUpdate = current = isHiddenUpdate),
-              (lastPendingUpdate = newState))
-            : (current = current.next = isHiddenUpdate),
-          (lastBaseUpdate |= updateLane);
-      pendingQueue = pendingQueue.next;
-      if (null === pendingQueue)
-        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
-          break;
-        else
-          (isHiddenUpdate = pendingQueue),
-            (pendingQueue = isHiddenUpdate.next),
-            (isHiddenUpdate.next = null),
-            (queue.lastBaseUpdate = isHiddenUpdate),
-            (queue.shared.pending = null);
-    } while (1);
-    null === current && (lastPendingUpdate = newState);
-    queue.baseState = lastPendingUpdate;
-    queue.firstBaseUpdate = firstPendingUpdate;
-    queue.lastBaseUpdate = current;
-    null === firstBaseUpdate && (queue.shared.lanes = 0);
-    workInProgressRootSkippedLanes |= lastBaseUpdate;
-    workInProgress$jscomp$0.lanes = lastBaseUpdate;
-    workInProgress$jscomp$0.memoizedState = newState;
-  }
-}
-function callCallback(callback, context) {
-  if ("function" !== typeof callback)
-    throw Error(formatProdErrorMessage(191, callback));
-  callback.call(context);
-}
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
-  if (null !== callbacks)
-    for (
-      updateQueue.callbacks = null, updateQueue = 0;
-      updateQueue < callbacks.length;
-      updateQueue++
-    )
-      callCallback(callbacks[updateQueue], context);
-}
-var SuspenseException = Error(formatProdErrorMessage(460));
-function isThenableResolved(thenable) {
-  thenable = thenable.status;
-  return "fulfilled" === thenable || "rejected" === thenable;
-}
-function noop() {}
-function trackUsedThenable(thenableState, thenable, index) {
-  index = thenableState[index];
-  void 0 === index
-    ? thenableState.push(thenable)
-    : index !== thenable && (thenable.then(noop, noop), (thenable = index));
-  switch (thenable.status) {
-    case "fulfilled":
-      return thenable.value;
-    case "rejected":
-      throw thenable.reason;
-    default:
-      "string" === typeof thenable.status
-        ? thenable.then(noop, noop)
-        : ((thenableState = thenable),
-          (thenableState.status = "pending"),
-          thenableState.then(
-            function (fulfilledValue) {
-              if ("pending" === thenable.status) {
-                var fulfilledThenable = thenable;
-                fulfilledThenable.status = "fulfilled";
-                fulfilledThenable.value = fulfilledValue;
-              }
-            },
-            function (error) {
-              if ("pending" === thenable.status) {
-                var rejectedThenable = thenable;
-                rejectedThenable.status = "rejected";
-                rejectedThenable.reason = error;
-              }
-            }
-          ));
-      switch (thenable.status) {
-        case "fulfilled":
-          return thenable.value;
-        case "rejected":
-          throw thenable.reason;
-      }
-      suspendedThenable = thenable;
-      throw SuspenseException;
+      suspendedThenable = thenable;
+      throw SuspenseException;
   }
 }
 var suspendedThenable = null,
@@ -6729,7 +4528,7 @@ function resetWorkInProgressVersions() {
   workInProgressSources.length = 0;
 }
 var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
   renderLanes$1 = 0,
   currentlyRenderingFiber$1 = null,
   currentHook = null,
@@ -6891,10 +4690,10 @@ createFunctionComponentUpdateQueue = function () {
 function use(usable) {
   if (null !== usable && "object" === typeof usable) {
     if ("function" === typeof usable.then) {
-      var index$87 = thenableIndexCounter;
+      var index$73 = thenableIndexCounter;
       thenableIndexCounter += 1;
       null === thenableState && (thenableState = []);
-      usable = trackUsedThenable(thenableState, usable, index$87);
+      usable = trackUsedThenable(thenableState, usable, index$73);
       null === currentlyRenderingFiber$1.alternate &&
         (null === workInProgressHook
           ? null === currentlyRenderingFiber$1.memoizedState
@@ -7358,18 +5157,18 @@ function startTransition(setPending, callback, options) {
   currentUpdatePriority =
     0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
   setPending(!0);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
   enableTransitionTracing &&
     void 0 !== options &&
     void 0 !== options.name &&
-    ((ReactCurrentBatchConfig$2.transition.name = options.name),
-    (ReactCurrentBatchConfig$2.transition.startTime = now()));
+    ((ReactCurrentBatchConfig$3.transition.name = options.name),
+    (ReactCurrentBatchConfig$3.transition.startTime = now()));
   try {
     setPending(!1), callback();
   } finally {
     (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$2.transition = prevTransition);
+      (ReactCurrentBatchConfig$3.transition = prevTransition);
   }
 }
 function updateId() {
@@ -7385,16 +5184,16 @@ function refreshCache(fiber, seedKey, seedValue) {
       case 3:
         var lane = requestUpdateLane(provider);
         fiber = createUpdate(lane);
-        var root$93 = enqueueUpdate(provider, fiber, lane);
-        if (null !== root$93) {
+        var root$79 = enqueueUpdate(provider, fiber, lane);
+        if (null !== root$79) {
           var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root$93, provider, lane, eventTime);
-          entangleTransitions(root$93, provider, lane);
+          scheduleUpdateOnFiber(root$79, provider, lane, eventTime);
+          entangleTransitions(root$79, provider, lane);
         }
         provider = createCache();
         null !== seedKey &&
           void 0 !== seedKey &&
-          null !== root$93 &&
+          null !== root$79 &&
           provider.data.set(seedKey, seedValue);
         fiber.payload = { cache: provider };
         return;
@@ -7601,15 +5400,15 @@ var HooksDispatcherOnMount = {
       getServerSnapshot = getServerSnapshot();
     } else {
       getServerSnapshot = getSnapshot();
-      var root$89 = workInProgressRoot;
-      if (null === root$89) throw Error(formatProdErrorMessage(349));
-      includesBlockingLane(root$89, renderLanes$1) ||
+      var root$75 = workInProgressRoot;
+      if (null === root$75) throw Error(formatProdErrorMessage(349));
+      includesBlockingLane(root$75, renderLanes$1) ||
         pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
     }
     hook.memoizedState = getServerSnapshot;
-    root$89 = { value: getServerSnapshot, getSnapshot: getSnapshot };
-    hook.queue = root$89;
-    mountEffect(subscribeToStore.bind(null, fiber, root$89, subscribe), [
+    root$75 = { value: getServerSnapshot, getSnapshot: getSnapshot };
+    hook.queue = root$75;
+    mountEffect(subscribeToStore.bind(null, fiber, root$75, subscribe), [
       subscribe
     ]);
     fiber.flags |= 2048;
@@ -7618,7 +5417,7 @@ var HooksDispatcherOnMount = {
       updateStoreInstance.bind(
         null,
         fiber,
-        root$89,
+        root$75,
         getServerSnapshot,
         getSnapshot
       ),
@@ -7937,9 +5736,9 @@ function logCapturedError(boundary, errorInfo) {
         errorBoundary:
           null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
       }) && console.error(errorInfo.value);
-  } catch (e$98) {
+  } catch (e) {
     setTimeout(function () {
-      throw e$98;
+      throw e;
     });
   }
 }
@@ -8117,10 +5916,10 @@ var markerInstanceStack = createCursor(null);
 function pushRootMarkerInstance(workInProgress) {
   if (enableTransitionTracing) {
     var transitions = workInProgressTransitions,
-      root$104 = workInProgress.stateNode;
+      root$89 = workInProgress.stateNode;
     null !== transitions &&
       transitions.forEach(function (transition) {
-        if (!root$104.incompleteTransitions.has(transition)) {
+        if (!root$89.incompleteTransitions.has(transition)) {
           var markerInstance = {
             tag: 0,
             transitions: new Set([transition]),
@@ -8128,11 +5927,11 @@ function pushRootMarkerInstance(workInProgress) {
             aborts: null,
             name: null
           };
-          root$104.incompleteTransitions.set(transition, markerInstance);
+          root$89.incompleteTransitions.set(transition, markerInstance);
         }
       });
     var markerInstances = [];
-    root$104.incompleteTransitions.forEach(function (markerInstance) {
+    root$89.incompleteTransitions.forEach(function (markerInstance) {
       markerInstances.push(markerInstance);
     });
     push(markerInstanceStack, markerInstances);
@@ -8832,14 +6631,14 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
   }
   JSCompiler_temp = current.memoizedState;
   if (null !== JSCompiler_temp) {
-    var dehydrated$111 = JSCompiler_temp.dehydrated;
-    if (null !== dehydrated$111)
+    var dehydrated$96 = JSCompiler_temp.dehydrated;
+    if (null !== dehydrated$96)
       return updateDehydratedSuspenseComponent(
         current,
         workInProgress,
         didSuspend,
         nextProps,
-        dehydrated$111,
+        dehydrated$96,
         JSCompiler_temp,
         renderLanes
       );
@@ -8849,7 +6648,7 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
     showFallback = nextProps.fallback;
     didSuspend = workInProgress.mode;
     JSCompiler_temp = current.child;
-    dehydrated$111 = JSCompiler_temp.sibling;
+    dehydrated$96 = JSCompiler_temp.sibling;
     var primaryChildProps = { mode: "hidden", children: nextProps.children };
     0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
       ? ((nextProps = workInProgress.child),
@@ -8858,8 +6657,8 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         (workInProgress.deletions = null))
       : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
         (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
-    null !== dehydrated$111
-      ? (showFallback = createWorkInProgress(dehydrated$111, showFallback))
+    null !== dehydrated$96
+      ? (showFallback = createWorkInProgress(dehydrated$96, showFallback))
       : ((showFallback = createFiberFromFragment(
           showFallback,
           didSuspend,
@@ -8878,10 +6677,10 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
       ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
       : ((JSCompiler_temp = didSuspend.cachePool),
         null !== JSCompiler_temp
-          ? ((dehydrated$111 = CacheContext._currentValue),
+          ? ((dehydrated$96 = CacheContext._currentValue),
             (JSCompiler_temp =
-              JSCompiler_temp.parent !== dehydrated$111
-                ? { parent: dehydrated$111, pool: dehydrated$111 }
+              JSCompiler_temp.parent !== dehydrated$96
+                ? { parent: dehydrated$96, pool: dehydrated$96 }
                 : JSCompiler_temp))
           : (JSCompiler_temp = getSuspendedCache()),
         (didSuspend = {
@@ -8895,23 +6694,23 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         ((JSCompiler_temp = enableTransitionTracing
           ? markerInstanceStack.current
           : null),
-        (dehydrated$111 = showFallback.updateQueue),
+        (dehydrated$96 = showFallback.updateQueue),
         (primaryChildProps = current.updateQueue),
-        null === dehydrated$111
+        null === dehydrated$96
           ? (showFallback.updateQueue = {
               transitions: didSuspend,
               markerInstances: JSCompiler_temp,
               wakeables: null
             })
-          : dehydrated$111 === primaryChildProps
+          : dehydrated$96 === primaryChildProps
           ? (showFallback.updateQueue = {
               transitions: didSuspend,
               markerInstances: JSCompiler_temp,
               wakeables:
                 null !== primaryChildProps ? primaryChildProps.wakeables : null
             })
-          : ((dehydrated$111.transitions = didSuspend),
-            (dehydrated$111.markerInstances = JSCompiler_temp))));
+          : ((dehydrated$96.transitions = didSuspend),
+            (dehydrated$96.markerInstances = JSCompiler_temp))));
     showFallback.childLanes = current.childLanes & ~renderLanes;
     workInProgress.memoizedState = SUSPENDED_MARKER;
     return nextProps;
@@ -9730,7 +7529,7 @@ function releaseCache(cache) {
       cache.controller.abort();
     });
 }
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
   resumedCache = createCursor(null),
   transitionStack = createCursor(null);
 function peekCacheFromPool() {
@@ -9782,291 +7581,829 @@ function collectScopedNodesFromChildren(
         !0 === fn(type, memoizedProps || emptyObject, instance) &&
         scopedNodes.push(instance);
     }
-    type = node.child;
-    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
-    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
-    startingChild = startingChild.sibling;
+    type = node.child;
+    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
+    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
+    startingChild = startingChild.sibling;
+  }
+}
+function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
+  for (; null !== startingChild; ) {
+    a: {
+      var JSCompiler_inline_result = startingChild;
+      var fn = fn$jscomp$0;
+      if (5 === JSCompiler_inline_result.tag) {
+        var type = JSCompiler_inline_result.type,
+          memoizedProps = JSCompiler_inline_result.memoizedProps,
+          instance = JSCompiler_inline_result.stateNode;
+        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
+          JSCompiler_inline_result = instance;
+          break a;
+        }
+      }
+      type = JSCompiler_inline_result.child;
+      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
+        (type = JSCompiler_inline_result.child.sibling.child);
+      JSCompiler_inline_result =
+        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
+    }
+    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
+    startingChild = startingChild.sibling;
+  }
+  return null;
+}
+function collectNearestChildContextValues(
+  startingChild,
+  context$jscomp$0,
+  childContextValues$jscomp$0
+) {
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      context = context$jscomp$0,
+      childContextValues = childContextValues$jscomp$0;
+    if (10 === node.tag && node.type._context === context)
+      childContextValues.push(node.memoizedProps.value);
+    else {
+      var child = node.child;
+      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
+      null !== child &&
+        collectNearestChildContextValues(child, context, childContextValues);
+    }
+    startingChild = startingChild.sibling;
+  }
+}
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  var scopedNodes = [];
+  null !== currentFiber &&
+    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
+  return 0 === scopedNodes.length ? null : scopedNodes;
+}
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  return null !== currentFiber
+    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
+    : null;
+}
+function containsNode(node) {
+  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
+    if (21 === node.tag && node.stateNode === this) return !0;
+    node = node.return;
+  }
+  return !1;
+}
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return [];
+  currentFiber = currentFiber.child;
+  var childContextValues = [];
+  null !== currentFiber &&
+    collectNearestChildContextValues(currentFiber, context, childContextValues);
+  return childContextValues;
+}
+function markUpdate(workInProgress) {
+  workInProgress.flags |= 4;
+}
+function markRef(workInProgress) {
+  workInProgress.flags |= 2097664;
+}
+function updateHostComponent(current, workInProgress, type, newProps) {
+  var oldProps = current.memoizedProps;
+  if (oldProps !== newProps) {
+    current = workInProgress.stateNode;
+    var updatePayload = null;
+    switch (type) {
+      case "input":
+        oldProps = getHostProps$2(current, oldProps);
+        newProps = getHostProps$2(current, newProps);
+        updatePayload = [];
+        break;
+      case "select":
+        oldProps = assign({}, oldProps, { value: void 0 });
+        newProps = assign({}, newProps, { value: void 0 });
+        updatePayload = [];
+        break;
+      case "textarea":
+        oldProps = getHostProps(current, oldProps);
+        newProps = getHostProps(current, newProps);
+        updatePayload = [];
+        break;
+      default:
+        "function" !== typeof oldProps.onClick &&
+          "function" === typeof newProps.onClick &&
+          (current.onclick = noop$1);
+    }
+    assertValidProps(type, newProps);
+    var styleName;
+    type = null;
+    for (JSCompiler_inline_result in oldProps)
+      if (
+        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
+        null != oldProps[JSCompiler_inline_result]
+      )
+        if ("style" === JSCompiler_inline_result) {
+          var lastStyle = oldProps[JSCompiler_inline_result];
+          for (styleName in lastStyle)
+            lastStyle.hasOwnProperty(styleName) &&
+              (type || (type = {}), (type[styleName] = ""));
+        } else
+          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
+            "children" !== JSCompiler_inline_result &&
+            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+            "suppressHydrationWarning" !== JSCompiler_inline_result &&
+            "autoFocus" !== JSCompiler_inline_result &&
+            (registrationNameDependencies.hasOwnProperty(
+              JSCompiler_inline_result
+            )
+              ? updatePayload || (updatePayload = [])
+              : (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  null
+                ));
+    for (JSCompiler_inline_result in newProps) {
+      var nextProp = newProps[JSCompiler_inline_result];
+      lastStyle =
+        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
+      if (
+        newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        nextProp !== lastStyle &&
+        (null != nextProp || null != lastStyle)
+      )
+        if ("style" === JSCompiler_inline_result)
+          if (lastStyle) {
+            for (styleName in lastStyle)
+              !lastStyle.hasOwnProperty(styleName) ||
+                (nextProp && nextProp.hasOwnProperty(styleName)) ||
+                (type || (type = {}), (type[styleName] = ""));
+            for (styleName in nextProp)
+              nextProp.hasOwnProperty(styleName) &&
+                lastStyle[styleName] !== nextProp[styleName] &&
+                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+          } else
+            type ||
+              (updatePayload || (updatePayload = []),
+              updatePayload.push(JSCompiler_inline_result, type)),
+              (type = nextProp);
+        else
+          "dangerouslySetInnerHTML" === JSCompiler_inline_result
+            ? ((nextProp = nextProp ? nextProp.__html : void 0),
+              (lastStyle = lastStyle ? lastStyle.__html : void 0),
+              null != nextProp &&
+                lastStyle !== nextProp &&
+                (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  nextProp
+                ))
+            : "children" === JSCompiler_inline_result
+            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
+              (updatePayload = updatePayload || []).push(
+                JSCompiler_inline_result,
+                "" + nextProp
+              )
+            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+              "suppressHydrationWarning" !== JSCompiler_inline_result &&
+              (registrationNameDependencies.hasOwnProperty(
+                JSCompiler_inline_result
+              )
+                ? (null != nextProp &&
+                    "onScroll" === JSCompiler_inline_result &&
+                    listenToNonDelegatedEvent("scroll", current),
+                  updatePayload ||
+                    lastStyle === nextProp ||
+                    (updatePayload = []))
+                : (updatePayload = updatePayload || []).push(
+                    JSCompiler_inline_result,
+                    nextProp
+                  ));
+    }
+    type && (updatePayload = updatePayload || []).push("style", type);
+    var JSCompiler_inline_result = updatePayload;
+    (workInProgress.updateQueue = JSCompiler_inline_result) &&
+      markUpdate(workInProgress);
   }
 }
-function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
-  for (; null !== startingChild; ) {
-    a: {
-      var JSCompiler_inline_result = startingChild;
-      var fn = fn$jscomp$0;
-      if (5 === JSCompiler_inline_result.tag) {
-        var type = JSCompiler_inline_result.type,
-          memoizedProps = JSCompiler_inline_result.memoizedProps,
-          instance = JSCompiler_inline_result.stateNode;
-        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
-          JSCompiler_inline_result = instance;
-          break a;
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (!isHydrating)
+    switch (renderState.tailMode) {
+      case "hidden":
+        hasRenderedATailFallback = renderState.tail;
+        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
+          null !== hasRenderedATailFallback.alternate &&
+            (lastTailNode = hasRenderedATailFallback),
+            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
+        null === lastTailNode
+          ? (renderState.tail = null)
+          : (lastTailNode.sibling = null);
+        break;
+      case "collapsed":
+        lastTailNode = renderState.tail;
+        for (var lastTailNode$127 = null; null !== lastTailNode; )
+          null !== lastTailNode.alternate && (lastTailNode$127 = lastTailNode),
+            (lastTailNode = lastTailNode.sibling);
+        null === lastTailNode$127
+          ? hasRenderedATailFallback || null === renderState.tail
+            ? (renderState.tail = null)
+            : (renderState.tail.sibling = null)
+          : (lastTailNode$127.sibling = null);
+    }
+}
+function bubbleProperties(completedWork) {
+  var didBailout =
+      null !== completedWork.alternate &&
+      completedWork.alternate.child === completedWork.child,
+    newChildLanes = 0,
+    subtreeFlags = 0;
+  if (didBailout)
+    for (var child$128 = completedWork.child; null !== child$128; )
+      (newChildLanes |= child$128.lanes | child$128.childLanes),
+        (subtreeFlags |= child$128.subtreeFlags & 14680064),
+        (subtreeFlags |= child$128.flags & 14680064),
+        (child$128.return = completedWork),
+        (child$128 = child$128.sibling);
+  else
+    for (child$128 = completedWork.child; null !== child$128; )
+      (newChildLanes |= child$128.lanes | child$128.childLanes),
+        (subtreeFlags |= child$128.subtreeFlags),
+        (subtreeFlags |= child$128.flags),
+        (child$128.return = completedWork),
+        (child$128 = child$128.sibling);
+  completedWork.subtreeFlags |= subtreeFlags;
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps;
+  popTreeContext(workInProgress);
+  switch (workInProgress.tag) {
+    case 2:
+    case 16:
+    case 15:
+    case 0:
+    case 11:
+    case 7:
+    case 8:
+    case 12:
+    case 9:
+    case 14:
+      return bubbleProperties(workInProgress), null;
+    case 1:
+      return (
+        isContextProvider(workInProgress.type) && popContext(),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 3:
+      renderLanes = workInProgress.stateNode;
+      enableTransitionTracing &&
+        null !== workInProgressTransitions &&
+        (workInProgress.flags |= 2048);
+      newProps = null;
+      null !== current && (newProps = current.memoizedState.cache);
+      workInProgress.memoizedState.cache !== newProps &&
+        (workInProgress.flags |= 2048);
+      popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
+      popHostContainer();
+      pop(didPerformWorkStackCursor);
+      pop(contextStackCursor);
+      resetWorkInProgressVersions();
+      renderLanes.pendingContext &&
+        ((renderLanes.context = renderLanes.pendingContext),
+        (renderLanes.pendingContext = null));
+      if (null === current || null === current.child)
+        popHydrationState(workInProgress)
+          ? markUpdate(workInProgress)
+          : null === current ||
+            (current.memoizedState.isDehydrated &&
+              0 === (workInProgress.flags & 256)) ||
+            ((workInProgress.flags |= 1024),
+            null !== hydrationErrors &&
+              (queueRecoverableErrors(hydrationErrors),
+              (hydrationErrors = null)));
+      bubbleProperties(workInProgress);
+      enableTransitionTracing &&
+        0 !== (workInProgress.subtreeFlags & 8192) &&
+        (workInProgress.flags |= 2048);
+      return null;
+    case 26:
+      return (
+        (current ? current.ref : null) !== workInProgress.ref &&
+          markRef(workInProgress),
+        null === current ||
+        current.memoizedState !== workInProgress.memoizedState
+          ? markUpdate(workInProgress)
+          : null === workInProgress.memoizedState &&
+            updateHostComponent(
+              current,
+              workInProgress,
+              workInProgress.type,
+              workInProgress.pendingProps
+            ),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 27:
+      popHostContext(workInProgress);
+      renderLanes = rootInstanceStackCursor.current;
+      var type = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, type, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor$1.current;
+        popHydrationState(workInProgress)
+          ? prepareToHydrateHostInstance(workInProgress, current)
+          : ((workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              renderLanes
+            )),
+            markUpdate(workInProgress));
+        null !== workInProgress.ref && markRef(workInProgress);
+      }
+      bubbleProperties(workInProgress);
+      return null;
+    case 5:
+      popHostContext(workInProgress);
+      renderLanes = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, renderLanes, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor$1.current;
+        if (popHydrationState(workInProgress))
+          prepareToHydrateHostInstance(workInProgress, current) &&
+            markUpdate(workInProgress);
+        else {
+          type = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          );
+          switch (current) {
+            case "http://www.w3.org/2000/svg":
+            case "http://www.w3.org/1998/Math/MathML":
+              current = type.createElementNS(current, renderLanes);
+              break;
+            default:
+              switch (renderLanes) {
+                case "svg":
+                  current = type.createElementNS(
+                    "http://www.w3.org/2000/svg",
+                    renderLanes
+                  );
+                  break;
+                case "math":
+                  current = type.createElementNS(
+                    "http://www.w3.org/1998/Math/MathML",
+                    renderLanes
+                  );
+                  break;
+                case "script":
+                  current = type.createElement("div");
+                  current.innerHTML = "<script>\x3c/script>";
+                  current = current.removeChild(current.firstChild);
+                  break;
+                case "select":
+                  current =
+                    "string" === typeof newProps.is
+                      ? type.createElement("select", { is: newProps.is })
+                      : type.createElement("select");
+                  newProps.multiple
+                    ? (current.multiple = !0)
+                    : newProps.size && (current.size = newProps.size);
+                  break;
+                default:
+                  current = createHTMLElement(renderLanes, newProps, type);
+              }
+          }
+          current[internalInstanceKey] = workInProgress;
+          current[internalPropsKey] = newProps;
+          a: for (type = workInProgress.child; null !== type; ) {
+            if (5 === type.tag || 6 === type.tag)
+              current.appendChild(type.stateNode);
+            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
+              type.child.return = type;
+              type = type.child;
+              continue;
+            }
+            if (type === workInProgress) break a;
+            for (; null === type.sibling; ) {
+              if (null === type.return || type.return === workInProgress)
+                break a;
+              type = type.return;
+            }
+            type.sibling.return = type.return;
+            type = type.sibling;
+          }
+          workInProgress.stateNode = current;
+          a: switch (
+            (setInitialProperties(current, renderLanes, newProps), renderLanes)
+          ) {
+            case "button":
+            case "input":
+            case "select":
+            case "textarea":
+              current = !!newProps.autoFocus;
+              break a;
+            case "img":
+              current = !0;
+              break a;
+            default:
+              current = !1;
+          }
+          current && markUpdate(workInProgress);
         }
+        null !== workInProgress.ref && markRef(workInProgress);
       }
-      type = JSCompiler_inline_result.child;
-      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
-        (type = JSCompiler_inline_result.child.sibling.child);
-      JSCompiler_inline_result =
-        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
-    }
-    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
-    startingChild = startingChild.sibling;
-  }
-  return null;
-}
-function collectNearestChildContextValues(
-  startingChild,
-  context$jscomp$0,
-  childContextValues$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      context = context$jscomp$0,
-      childContextValues = childContextValues$jscomp$0;
-    if (10 === node.tag && node.type._context === context)
-      childContextValues.push(node.memoizedProps.value);
-    else {
-      var child = node.child;
-      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
-      null !== child &&
-        collectNearestChildContextValues(child, context, childContextValues);
-    }
-    startingChild = startingChild.sibling;
-  }
-}
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  var scopedNodes = [];
-  null !== currentFiber &&
-    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
-  return 0 === scopedNodes.length ? null : scopedNodes;
-}
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  return null !== currentFiber
-    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
-    : null;
-}
-function containsNode(node) {
-  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
-    if (21 === node.tag && node.stateNode === this) return !0;
-    node = node.return;
-  }
-  return !1;
-}
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return [];
-  currentFiber = currentFiber.child;
-  var childContextValues = [];
-  null !== currentFiber &&
-    collectNearestChildContextValues(currentFiber, context, childContextValues);
-  return childContextValues;
-}
-function markUpdate(workInProgress) {
-  workInProgress.flags |= 4;
-}
-function markRef(workInProgress) {
-  workInProgress.flags |= 2097664;
-}
-function updateHostComponent(current, workInProgress, type, newProps) {
-  var oldProps = current.memoizedProps;
-  if (oldProps !== newProps) {
-    current = workInProgress.stateNode;
-    var updatePayload = null;
-    switch (type) {
-      case "input":
-        oldProps = getHostProps$2(current, oldProps);
-        newProps = getHostProps$2(current, newProps);
-        updatePayload = [];
-        break;
-      case "select":
-        oldProps = assign({}, oldProps, { value: void 0 });
-        newProps = assign({}, newProps, { value: void 0 });
-        updatePayload = [];
-        break;
-      case "textarea":
-        oldProps = getHostProps(current, oldProps);
-        newProps = getHostProps(current, newProps);
-        updatePayload = [];
-        break;
-      default:
-        "function" !== typeof oldProps.onClick &&
-          "function" === typeof newProps.onClick &&
-          (current.onclick = noop$1);
-    }
-    assertValidProps(type, newProps);
-    var styleName;
-    type = null;
-    for (JSCompiler_inline_result in oldProps)
+      bubbleProperties(workInProgress);
+      return null;
+    case 6:
+      if (current && null != workInProgress.stateNode)
+        current.memoizedProps !== newProps && markUpdate(workInProgress);
+      else {
+        if ("string" !== typeof newProps && null === workInProgress.stateNode)
+          throw Error(formatProdErrorMessage(166));
+        current = rootInstanceStackCursor.current;
+        if (popHydrationState(workInProgress)) {
+          newProps = workInProgress.stateNode;
+          current = workInProgress.memoizedProps;
+          newProps[internalInstanceKey] = workInProgress;
+          if ((renderLanes = newProps.nodeValue !== current))
+            if (((type = hydrationParentFiber), null !== type))
+              switch (type.tag) {
+                case 3:
+                  newProps = newProps.nodeValue;
+                  normalizeMarkupForTextOrAttribute(current);
+                  normalizeMarkupForTextOrAttribute(newProps);
+                  break;
+                case 27:
+                case 5:
+                  !0 !== type.memoizedProps.suppressHydrationWarning &&
+                    ((newProps = newProps.nodeValue),
+                    normalizeMarkupForTextOrAttribute(current),
+                    normalizeMarkupForTextOrAttribute(newProps));
+              }
+          renderLanes && markUpdate(workInProgress);
+        } else
+          (current =
+            getOwnerDocumentFromRootContainer(current).createTextNode(
+              newProps
+            )),
+            (current[internalInstanceKey] = workInProgress),
+            (workInProgress.stateNode = current);
+      }
+      bubbleProperties(workInProgress);
+      return null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      newProps = workInProgress.memoizedState;
       if (
-        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
-        null != oldProps[JSCompiler_inline_result]
-      )
-        if ("style" === JSCompiler_inline_result) {
-          var lastStyle = oldProps[JSCompiler_inline_result];
-          for (styleName in lastStyle)
-            lastStyle.hasOwnProperty(styleName) &&
-              (type || (type = {}), (type[styleName] = ""));
+        null === current ||
+        (null !== current.memoizedState &&
+          null !== current.memoizedState.dehydrated)
+      ) {
+        if (
+          isHydrating &&
+          null !== nextHydratableInstance &&
+          0 !== (workInProgress.mode & 1) &&
+          0 === (workInProgress.flags & 128)
+        )
+          warnIfUnhydratedTailNodes(),
+            resetHydrationState(),
+            (workInProgress.flags |= 98560),
+            (type = !1);
+        else if (
+          ((type = popHydrationState(workInProgress)),
+          null !== newProps && null !== newProps.dehydrated)
+        ) {
+          if (null === current) {
+            if (!type) throw Error(formatProdErrorMessage(318));
+            type = workInProgress.memoizedState;
+            type = null !== type ? type.dehydrated : null;
+            if (!type) throw Error(formatProdErrorMessage(317));
+            type[internalInstanceKey] = workInProgress;
+          } else
+            resetHydrationState(),
+              0 === (workInProgress.flags & 128) &&
+                (workInProgress.memoizedState = null),
+              (workInProgress.flags |= 4);
+          bubbleProperties(workInProgress);
+          type = !1;
         } else
-          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
-            "children" !== JSCompiler_inline_result &&
-            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-            "suppressHydrationWarning" !== JSCompiler_inline_result &&
-            "autoFocus" !== JSCompiler_inline_result &&
-            (registrationNameDependencies.hasOwnProperty(
-              JSCompiler_inline_result
+          null !== hydrationErrors &&
+            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
+            (type = !0);
+        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
+      }
+      if (0 !== (workInProgress.flags & 128))
+        return (workInProgress.lanes = renderLanes), workInProgress;
+      renderLanes = null !== newProps;
+      current = null !== current && null !== current.memoizedState;
+      if (renderLanes) {
+        newProps = workInProgress.child;
+        type = null;
+        null !== newProps.alternate &&
+          null !== newProps.alternate.memoizedState &&
+          null !== newProps.alternate.memoizedState.cachePool &&
+          (type = newProps.alternate.memoizedState.cachePool.pool);
+        var cache$138 = null;
+        null !== newProps.memoizedState &&
+          null !== newProps.memoizedState.cachePool &&
+          (cache$138 = newProps.memoizedState.cachePool.pool);
+        cache$138 !== type && (newProps.flags |= 2048);
+      }
+      renderLanes !== current &&
+        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
+        renderLanes && (workInProgress.child.flags |= 8192));
+      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
+      null !== workInProgress.updateQueue &&
+        null != workInProgress.memoizedProps.suspenseCallback &&
+        (workInProgress.flags |= 4);
+      bubbleProperties(workInProgress);
+      return null;
+    case 4:
+      return (
+        popHostContainer(),
+        null === current &&
+          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 10:
+      return (
+        popProvider(workInProgress.type._context),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 17:
+      return (
+        isContextProvider(workInProgress.type) && popContext(),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 19:
+      pop(suspenseStackCursor);
+      type = workInProgress.memoizedState;
+      if (null === type) return bubbleProperties(workInProgress), null;
+      newProps = 0 !== (workInProgress.flags & 128);
+      cache$138 = type.rendering;
+      if (null === cache$138)
+        if (newProps) cutOffTailIfNeeded(type, !1);
+        else {
+          if (
+            0 !== workInProgressRootExitStatus ||
+            (null !== current && 0 !== (current.flags & 128))
+          )
+            for (current = workInProgress.child; null !== current; ) {
+              cache$138 = findFirstSuspended(current);
+              if (null !== cache$138) {
+                workInProgress.flags |= 128;
+                cutOffTailIfNeeded(type, !1);
+                current = cache$138.updateQueue;
+                null !== current &&
+                  ((workInProgress.updateQueue = current),
+                  (workInProgress.flags |= 4));
+                workInProgress.subtreeFlags = 0;
+                current = renderLanes;
+                for (renderLanes = workInProgress.child; null !== renderLanes; )
+                  resetWorkInProgress(renderLanes, current),
+                    (renderLanes = renderLanes.sibling);
+                push(
+                  suspenseStackCursor,
+                  (suspenseStackCursor.current & 1) | 2
+                );
+                return workInProgress.child;
+              }
+              current = current.sibling;
+            }
+          null !== type.tail &&
+            now() > workInProgressRootRenderTargetTime &&
+            ((workInProgress.flags |= 128),
+            (newProps = !0),
+            cutOffTailIfNeeded(type, !1),
+            (workInProgress.lanes = 8388608));
+        }
+      else {
+        if (!newProps)
+          if (((current = findFirstSuspended(cache$138)), null !== current)) {
+            if (
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              (current = current.updateQueue),
+              null !== current &&
+                ((workInProgress.updateQueue = current),
+                (workInProgress.flags |= 4)),
+              cutOffTailIfNeeded(type, !0),
+              null === type.tail &&
+                "hidden" === type.tailMode &&
+                !cache$138.alternate &&
+                !isHydrating)
             )
-              ? updatePayload || (updatePayload = [])
-              : (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  null
-                ));
-    for (JSCompiler_inline_result in newProps) {
-      var nextProp = newProps[JSCompiler_inline_result];
-      lastStyle =
-        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
-      if (
-        newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        nextProp !== lastStyle &&
-        (null != nextProp || null != lastStyle)
-      )
-        if ("style" === JSCompiler_inline_result)
-          if (lastStyle) {
-            for (styleName in lastStyle)
-              !lastStyle.hasOwnProperty(styleName) ||
-                (nextProp && nextProp.hasOwnProperty(styleName)) ||
-                (type || (type = {}), (type[styleName] = ""));
-            for (styleName in nextProp)
-              nextProp.hasOwnProperty(styleName) &&
-                lastStyle[styleName] !== nextProp[styleName] &&
-                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+              return bubbleProperties(workInProgress), null;
           } else
-            type ||
-              (updatePayload || (updatePayload = []),
-              updatePayload.push(JSCompiler_inline_result, type)),
-              (type = nextProp);
-        else
-          "dangerouslySetInnerHTML" === JSCompiler_inline_result
-            ? ((nextProp = nextProp ? nextProp.__html : void 0),
-              (lastStyle = lastStyle ? lastStyle.__html : void 0),
-              null != nextProp &&
-                lastStyle !== nextProp &&
-                (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  nextProp
-                ))
-            : "children" === JSCompiler_inline_result
-            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
-              (updatePayload = updatePayload || []).push(
-                JSCompiler_inline_result,
-                "" + nextProp
-              )
-            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-              "suppressHydrationWarning" !== JSCompiler_inline_result &&
-              (registrationNameDependencies.hasOwnProperty(
-                JSCompiler_inline_result
-              )
-                ? (null != nextProp &&
-                    "onScroll" === JSCompiler_inline_result &&
-                    listenToNonDelegatedEvent("scroll", current),
-                  updatePayload ||
-                    lastStyle === nextProp ||
-                    (updatePayload = []))
-                : (updatePayload = updatePayload || []).push(
-                    JSCompiler_inline_result,
-                    nextProp
-                  ));
-    }
-    type && (updatePayload = updatePayload || []).push("style", type);
-    var JSCompiler_inline_result = updatePayload;
-    (workInProgress.updateQueue = JSCompiler_inline_result) &&
-      markUpdate(workInProgress);
+            2 * now() - type.renderingStartTime >
+              workInProgressRootRenderTargetTime &&
+              1073741824 !== renderLanes &&
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              cutOffTailIfNeeded(type, !1),
+              (workInProgress.lanes = 8388608));
+        type.isBackwards
+          ? ((cache$138.sibling = workInProgress.child),
+            (workInProgress.child = cache$138))
+          : ((current = type.last),
+            null !== current
+              ? (current.sibling = cache$138)
+              : (workInProgress.child = cache$138),
+            (type.last = cache$138));
+      }
+      if (null !== type.tail)
+        return (
+          (workInProgress = type.tail),
+          (type.rendering = workInProgress),
+          (type.tail = workInProgress.sibling),
+          (type.renderingStartTime = now()),
+          (workInProgress.sibling = null),
+          (current = suspenseStackCursor.current),
+          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
+          workInProgress
+        );
+      bubbleProperties(workInProgress);
+      return null;
+    case 21:
+      return (
+        null === current
+          ? ((current = {
+              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+              containsNode: containsNode,
+              getChildContextValues: getChildContextValues
+            }),
+            (workInProgress.stateNode = current),
+            (current[internalInstanceKey] = workInProgress),
+            null !== workInProgress.ref &&
+              (markRef(workInProgress), markUpdate(workInProgress)))
+          : (null !== workInProgress.ref && markUpdate(workInProgress),
+            current.ref !== workInProgress.ref && markRef(workInProgress)),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        (newProps = null !== workInProgress.memoizedState),
+        23 !== workInProgress.tag &&
+          (null !== current
+            ? (null !== current.memoizedState) !== newProps &&
+              (workInProgress.flags |= 8192)
+            : newProps && (workInProgress.flags |= 8192)),
+        newProps && 0 !== (workInProgress.mode & 1)
+          ? 0 !== (renderLanes & 1073741824) &&
+            0 === (workInProgress.flags & 128) &&
+            (bubbleProperties(workInProgress),
+            23 !== workInProgress.tag &&
+              workInProgress.subtreeFlags & 6 &&
+              (workInProgress.flags |= 8192))
+          : bubbleProperties(workInProgress),
+        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
+        (renderLanes = null),
+        null !== current &&
+          null !== current.memoizedState &&
+          null !== current.memoizedState.cachePool &&
+          (renderLanes = current.memoizedState.cachePool.pool),
+        (newProps = null),
+        null !== workInProgress.memoizedState &&
+          null !== workInProgress.memoizedState.cachePool &&
+          (newProps = workInProgress.memoizedState.cachePool.pool),
+        newProps !== renderLanes && (workInProgress.flags |= 2048),
+        popTransition(workInProgress, current),
+        null
+      );
+    case 24:
+      return (
+        (renderLanes = null),
+        null !== current && (renderLanes = current.memoizedState.cache),
+        workInProgress.memoizedState.cache !== renderLanes &&
+          (workInProgress.flags |= 2048),
+        popProvider(CacheContext),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 25:
+      return (
+        enableTransitionTracing &&
+          (null !== workInProgress.stateNode &&
+            enableTransitionTracing &&
+            pop(markerInstanceStack),
+          bubbleProperties(workInProgress)),
+        null
+      );
   }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (!isHydrating)
-    switch (renderState.tailMode) {
-      case "hidden":
-        hasRenderedATailFallback = renderState.tail;
-        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
-          null !== hasRenderedATailFallback.alternate &&
-            (lastTailNode = hasRenderedATailFallback),
-            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
-        null === lastTailNode
-          ? (renderState.tail = null)
-          : (lastTailNode.sibling = null);
-        break;
-      case "collapsed":
-        lastTailNode = renderState.tail;
-        for (var lastTailNode$142 = null; null !== lastTailNode; )
-          null !== lastTailNode.alternate && (lastTailNode$142 = lastTailNode),
-            (lastTailNode = lastTailNode.sibling);
-        null === lastTailNode$142
-          ? hasRenderedATailFallback || null === renderState.tail
-            ? (renderState.tail = null)
-            : (renderState.tail.sibling = null)
-          : (lastTailNode$142.sibling = null);
-    }
-}
-function bubbleProperties(completedWork) {
-  var didBailout =
-      null !== completedWork.alternate &&
-      completedWork.alternate.child === completedWork.child,
-    newChildLanes = 0,
-    subtreeFlags = 0;
-  if (didBailout)
-    for (var child$143 = completedWork.child; null !== child$143; )
-      (newChildLanes |= child$143.lanes | child$143.childLanes),
-        (subtreeFlags |= child$143.subtreeFlags & 14680064),
-        (subtreeFlags |= child$143.flags & 14680064),
-        (child$143.return = completedWork),
-        (child$143 = child$143.sibling);
-  else
-    for (child$143 = completedWork.child; null !== child$143; )
-      (newChildLanes |= child$143.lanes | child$143.childLanes),
-        (subtreeFlags |= child$143.subtreeFlags),
-        (subtreeFlags |= child$143.flags),
-        (child$143.return = completedWork),
-        (child$143 = child$143.sibling);
-  completedWork.subtreeFlags |= subtreeFlags;
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
-}
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps;
+function unwindWork(current, workInProgress) {
   popTreeContext(workInProgress);
   switch (workInProgress.tag) {
-    case 2:
-    case 16:
-    case 15:
-    case 0:
-    case 11:
-    case 7:
-    case 8:
-    case 12:
-    case 9:
-    case 14:
-      return bubbleProperties(workInProgress), null;
     case 1:
       return (
-        isContextProvider(workInProgress.type) && popContext(),
-        bubbleProperties(workInProgress),
+        isContextProvider(workInProgress.type) && popContext(),
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 3:
+      return (
+        popProvider(CacheContext),
+        enableTransitionTracing &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        enableTransitionTracing && pop(transitionStack),
+        popHostContainer(),
+        pop(didPerformWorkStackCursor),
+        pop(contextStackCursor),
+        resetWorkInProgressVersions(),
+        (current = workInProgress.flags),
+        0 !== (current & 65536) && 0 === (current & 128)
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 26:
+    case 27:
+    case 5:
+      return popHostContext(workInProgress), null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      current = workInProgress.memoizedState;
+      if (null !== current && null !== current.dehydrated) {
+        if (null === workInProgress.alternate)
+          throw Error(formatProdErrorMessage(340));
+        resetHydrationState();
+      }
+      current = workInProgress.flags;
+      return current & 65536
+        ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+        : null;
+    case 19:
+      return pop(suspenseStackCursor), null;
+    case 4:
+      return popHostContainer(), null;
+    case 10:
+      return popProvider(workInProgress.type._context), null;
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        popTransition(workInProgress, current),
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 24:
+      return popProvider(CacheContext), null;
+    case 25:
+      return (
+        enableTransitionTracing &&
+          null !== workInProgress.stateNode &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
         null
       );
+    default:
+      return null;
+  }
+}
+function unwindInterruptedWork(current, interruptedWork) {
+  popTreeContext(interruptedWork);
+  switch (interruptedWork.tag) {
+    case 1:
+      current = interruptedWork.type.childContextTypes;
+      null !== current && void 0 !== current && popContext();
+      break;
     case 3:
-      renderLanes = workInProgress.stateNode;
-      enableTransitionTracing &&
-        null !== workInProgressTransitions &&
-        (workInProgress.flags |= 2048);
-      newProps = null;
-      null !== current && (newProps = current.memoizedState.cache);
-      workInProgress.memoizedState.cache !== newProps &&
-        (workInProgress.flags |= 2048);
       popProvider(CacheContext);
       enableTransitionTracing &&
         enableTransitionTracing &&
@@ -10076,5371 +8413,7104 @@ function completeWork(current, workInProgress, renderLanes) {
       pop(didPerformWorkStackCursor);
       pop(contextStackCursor);
       resetWorkInProgressVersions();
-      renderLanes.pendingContext &&
-        ((renderLanes.context = renderLanes.pendingContext),
-        (renderLanes.pendingContext = null));
-      if (null === current || null === current.child)
-        popHydrationState(workInProgress)
-          ? markUpdate(workInProgress)
-          : null === current ||
-            (current.memoizedState.isDehydrated &&
-              0 === (workInProgress.flags & 256)) ||
-            ((workInProgress.flags |= 1024),
-            null !== hydrationErrors &&
-              (queueRecoverableErrors(hydrationErrors),
-              (hydrationErrors = null)));
-      bubbleProperties(workInProgress);
-      enableTransitionTracing &&
-        0 !== (workInProgress.subtreeFlags & 8192) &&
-        (workInProgress.flags |= 2048);
-      return null;
+      break;
     case 26:
-      return (
-        (current ? current.ref : null) !== workInProgress.ref &&
-          markRef(workInProgress),
-        null === current ||
-        current.memoizedState !== workInProgress.memoizedState
-          ? markUpdate(workInProgress)
-          : null === workInProgress.memoizedState &&
-            updateHostComponent(
-              current,
-              workInProgress,
-              workInProgress.type,
-              workInProgress.pendingProps
-            ),
-        bubbleProperties(workInProgress),
-        null
-      );
     case 27:
-      popHostContext(workInProgress);
-      renderLanes = rootInstanceStackCursor.current;
-      var type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, type, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor$1.current;
-        popHydrationState(workInProgress)
-          ? prepareToHydrateHostInstance(workInProgress, current)
-          : ((workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              renderLanes
-            )),
-            markUpdate(workInProgress));
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
     case 5:
-      popHostContext(workInProgress);
-      renderLanes = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, renderLanes, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor$1.current;
-        if (popHydrationState(workInProgress))
-          prepareToHydrateHostInstance(workInProgress, current) &&
-            markUpdate(workInProgress);
-        else {
-          type = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
-          );
-          switch (current) {
-            case "http://www.w3.org/2000/svg":
-            case "http://www.w3.org/1998/Math/MathML":
-              current = type.createElementNS(current, renderLanes);
-              break;
-            default:
-              switch (renderLanes) {
-                case "svg":
-                  current = type.createElementNS(
-                    "http://www.w3.org/2000/svg",
-                    renderLanes
-                  );
-                  break;
-                case "math":
-                  current = type.createElementNS(
-                    "http://www.w3.org/1998/Math/MathML",
-                    renderLanes
-                  );
-                  break;
-                case "script":
-                  current = type.createElement("div");
-                  current.innerHTML = "<script>\x3c/script>";
-                  current = current.removeChild(current.firstChild);
-                  break;
-                case "select":
-                  current =
-                    "string" === typeof newProps.is
-                      ? type.createElement("select", { is: newProps.is })
-                      : type.createElement("select");
-                  newProps.multiple
-                    ? (current.multiple = !0)
-                    : newProps.size && (current.size = newProps.size);
-                  break;
-                default:
-                  current = createHTMLElement(renderLanes, newProps, type);
-              }
+      popHostContext(interruptedWork);
+      break;
+    case 4:
+      popHostContainer();
+      break;
+    case 13:
+      popSuspenseHandler(interruptedWork);
+      break;
+    case 19:
+      pop(suspenseStackCursor);
+      break;
+    case 10:
+      popProvider(interruptedWork.type._context);
+      break;
+    case 22:
+    case 23:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+    case 24:
+      popProvider(CacheContext);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        null !== interruptedWork.stateNode &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+  }
+}
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
+if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
+  throw Error(formatProdErrorMessage(255));
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
+}
+var hasError = !1,
+  caughtError = null,
+  hasRethrowError = !1,
+  rethrowError = null,
+  reporter = {
+    onError: function (error) {
+      hasError = !0;
+      caughtError = error;
+    }
+  };
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = !1;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
+) {
+  invokeGuardedCallback.apply(this, arguments);
+  if (hasError) {
+    if (hasError) {
+      var error = caughtError;
+      hasError = !1;
+      caughtError = null;
+    } else throw Error(formatProdErrorMessage(198));
+    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
+  }
+}
+var offscreenSubtreeIsHidden = !1,
+  offscreenSubtreeWasHidden = !1,
+  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+  nextEffect = null;
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    var ref = current.ref;
+    if (null !== ref) {
+      var instance = current.stateNode;
+      switch (current.tag) {
+        case 26:
+        case 27:
+        case 5:
+          var instanceToUse = instance;
+          break;
+        default:
+          instanceToUse = instance;
+      }
+      21 === current.tag && (instanceToUse = instance);
+      "function" === typeof ref
+        ? (current.refCleanup = ref(instanceToUse))
+        : (ref.current = instanceToUse);
+    }
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+function safelyDetachRef(current, nearestMountedAncestor) {
+  var ref = current.ref,
+    refCleanup = current.refCleanup;
+  if (null !== ref)
+    if ("function" === typeof refCleanup)
+      try {
+        refCleanup();
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        (current.refCleanup = null),
+          (current = current.alternate),
+          null != current && (current.refCleanup = null);
+      }
+    else if ("function" === typeof ref)
+      try {
+        ref(null);
+      } catch (error$154) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$154);
+      }
+    else ref.current = null;
+}
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+var focusedInstanceHandle = null,
+  shouldFireAfterActiveInstanceBlur = !1;
+function commitBeforeMutationEffects(root, firstChild) {
+  eventsEnabled = _enabled;
+  root = getActiveElementDeep();
+  if (hasSelectionCapabilities(root)) {
+    if ("selectionStart" in root)
+      var JSCompiler_temp = {
+        start: root.selectionStart,
+        end: root.selectionEnd
+      };
+    else
+      a: {
+        JSCompiler_temp =
+          ((JSCompiler_temp = root.ownerDocument) &&
+            JSCompiler_temp.defaultView) ||
+          window;
+        var selection =
+          JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
+        if (selection && 0 !== selection.rangeCount) {
+          JSCompiler_temp = selection.anchorNode;
+          var anchorOffset = selection.anchorOffset,
+            focusNode = selection.focusNode;
+          selection = selection.focusOffset;
+          try {
+            JSCompiler_temp.nodeType, focusNode.nodeType;
+          } catch (e) {
+            JSCompiler_temp = null;
+            break a;
           }
-          current[internalInstanceKey] = workInProgress;
-          current[internalPropsKey] = newProps;
-          a: for (type = workInProgress.child; null !== type; ) {
-            if (5 === type.tag || 6 === type.tag)
-              current.appendChild(type.stateNode);
-            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
-              type.child.return = type;
-              type = type.child;
-              continue;
+          var length = 0,
+            start = -1,
+            end = -1,
+            indexWithinAnchor = 0,
+            indexWithinFocus = 0,
+            node = root,
+            parentNode = null;
+          b: for (;;) {
+            for (var next; ; ) {
+              node !== JSCompiler_temp ||
+                (0 !== anchorOffset && 3 !== node.nodeType) ||
+                (start = length + anchorOffset);
+              node !== focusNode ||
+                (0 !== selection && 3 !== node.nodeType) ||
+                (end = length + selection);
+              3 === node.nodeType && (length += node.nodeValue.length);
+              if (null === (next = node.firstChild)) break;
+              parentNode = node;
+              node = next;
             }
-            if (type === workInProgress) break a;
-            for (; null === type.sibling; ) {
-              if (null === type.return || type.return === workInProgress)
-                break a;
-              type = type.return;
+            for (;;) {
+              if (node === root) break b;
+              parentNode === JSCompiler_temp &&
+                ++indexWithinAnchor === anchorOffset &&
+                (start = length);
+              parentNode === focusNode &&
+                ++indexWithinFocus === selection &&
+                (end = length);
+              if (null !== (next = node.nextSibling)) break;
+              node = parentNode;
+              parentNode = node.parentNode;
             }
-            type.sibling.return = type.return;
-            type = type.sibling;
-          }
-          workInProgress.stateNode = current;
-          a: switch (
-            (setInitialProperties(current, renderLanes, newProps), renderLanes)
-          ) {
-            case "button":
-            case "input":
-            case "select":
-            case "textarea":
-              current = !!newProps.autoFocus;
-              break a;
-            case "img":
-              current = !0;
-              break a;
-            default:
-              current = !1;
+            node = next;
           }
-          current && markUpdate(workInProgress);
-        }
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        current.memoizedProps !== newProps && markUpdate(workInProgress);
-      else {
-        if ("string" !== typeof newProps && null === workInProgress.stateNode)
-          throw Error(formatProdErrorMessage(166));
-        current = rootInstanceStackCursor.current;
-        if (popHydrationState(workInProgress)) {
-          newProps = workInProgress.stateNode;
-          current = workInProgress.memoizedProps;
-          newProps[internalInstanceKey] = workInProgress;
-          if ((renderLanes = newProps.nodeValue !== current))
-            if (((type = hydrationParentFiber), null !== type))
-              switch (type.tag) {
-                case 3:
-                  newProps = newProps.nodeValue;
-                  normalizeMarkupForTextOrAttribute(current);
-                  normalizeMarkupForTextOrAttribute(newProps);
-                  break;
-                case 27:
-                case 5:
-                  !0 !== type.memoizedProps.suppressHydrationWarning &&
-                    ((newProps = newProps.nodeValue),
-                    normalizeMarkupForTextOrAttribute(current),
-                    normalizeMarkupForTextOrAttribute(newProps));
-              }
-          renderLanes && markUpdate(workInProgress);
-        } else
-          (current =
-            getOwnerDocumentFromRootContainer(current).createTextNode(
-              newProps
-            )),
-            (current[internalInstanceKey] = workInProgress),
-            (workInProgress.stateNode = current);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 13:
-      popSuspenseHandler(workInProgress);
-      newProps = workInProgress.memoizedState;
-      if (
-        null === current ||
-        (null !== current.memoizedState &&
-          null !== current.memoizedState.dehydrated)
-      ) {
-        if (
-          isHydrating &&
-          null !== nextHydratableInstance &&
-          0 !== (workInProgress.mode & 1) &&
-          0 === (workInProgress.flags & 128)
-        )
-          warnIfUnhydratedTailNodes(),
-            resetHydrationState(),
-            (workInProgress.flags |= 98560),
-            (type = !1);
-        else if (
-          ((type = popHydrationState(workInProgress)),
-          null !== newProps && null !== newProps.dehydrated)
-        ) {
-          if (null === current) {
-            if (!type) throw Error(formatProdErrorMessage(318));
-            type = workInProgress.memoizedState;
-            type = null !== type ? type.dehydrated : null;
-            if (!type) throw Error(formatProdErrorMessage(317));
-            type[internalInstanceKey] = workInProgress;
-          } else
-            resetHydrationState(),
-              0 === (workInProgress.flags & 128) &&
-                (workInProgress.memoizedState = null),
-              (workInProgress.flags |= 4);
-          bubbleProperties(workInProgress);
-          type = !1;
-        } else
-          null !== hydrationErrors &&
-            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
-            (type = !0);
-        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
-      }
-      if (0 !== (workInProgress.flags & 128))
-        return (workInProgress.lanes = renderLanes), workInProgress;
-      renderLanes = null !== newProps;
-      current = null !== current && null !== current.memoizedState;
-      if (renderLanes) {
-        newProps = workInProgress.child;
-        type = null;
-        null !== newProps.alternate &&
-          null !== newProps.alternate.memoizedState &&
-          null !== newProps.alternate.memoizedState.cachePool &&
-          (type = newProps.alternate.memoizedState.cachePool.pool);
-        var cache$153 = null;
-        null !== newProps.memoizedState &&
-          null !== newProps.memoizedState.cachePool &&
-          (cache$153 = newProps.memoizedState.cachePool.pool);
-        cache$153 !== type && (newProps.flags |= 2048);
+          JSCompiler_temp =
+            -1 === start || -1 === end ? null : { start: start, end: end };
+        } else JSCompiler_temp = null;
       }
-      renderLanes !== current &&
-        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
-        renderLanes && (workInProgress.child.flags |= 8192));
-      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
-      null !== workInProgress.updateQueue &&
-        null != workInProgress.memoizedProps.suspenseCallback &&
-        (workInProgress.flags |= 4);
-      bubbleProperties(workInProgress);
-      return null;
-    case 4:
-      return (
-        popHostContainer(),
-        null === current &&
-          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 10:
-      return (
-        popProvider(workInProgress.type._context),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 17:
-      return (
-        isContextProvider(workInProgress.type) && popContext(),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 19:
-      pop(suspenseStackCursor);
-      type = workInProgress.memoizedState;
-      if (null === type) return bubbleProperties(workInProgress), null;
-      newProps = 0 !== (workInProgress.flags & 128);
-      cache$153 = type.rendering;
-      if (null === cache$153)
-        if (newProps) cutOffTailIfNeeded(type, !1);
-        else {
+    JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
+  } else JSCompiler_temp = null;
+  selectionInformation = { focusedElem: root, selectionRange: JSCompiler_temp };
+  root = null;
+  JSCompiler_temp = selectionInformation.focusedElem;
+  null !== JSCompiler_temp &&
+    (root = getClosestInstanceFromNode(JSCompiler_temp));
+  _enabled = !1;
+  focusedInstanceHandle = root;
+  for (nextEffect = firstChild; null !== nextEffect; ) {
+    firstChild = nextEffect;
+    root = firstChild.deletions;
+    if (null !== root)
+      for (
+        JSCompiler_temp = 0;
+        JSCompiler_temp < root.length;
+        JSCompiler_temp++
+      )
+        (anchorOffset = root[JSCompiler_temp]),
+          doesFiberContain(anchorOffset, focusedInstanceHandle) &&
+            ((_enabled = shouldFireAfterActiveInstanceBlur = !0),
+            dispatchBeforeDetachedBlur(
+              selectionInformation.focusedElem,
+              anchorOffset
+            ),
+            (_enabled = !1));
+    root = firstChild.child;
+    if (0 !== (firstChild.subtreeFlags & 9236) && null !== root)
+      (root.return = firstChild), (nextEffect = root);
+    else
+      for (; null !== nextEffect; ) {
+        firstChild = nextEffect;
+        try {
+          var current = firstChild.alternate,
+            flags = firstChild.flags,
+            JSCompiler_temp$jscomp$0;
           if (
-            0 !== workInProgressRootExitStatus ||
-            (null !== current && 0 !== (current.flags & 128))
-          )
-            for (current = workInProgress.child; null !== current; ) {
-              cache$153 = findFirstSuspended(current);
-              if (null !== cache$153) {
-                workInProgress.flags |= 128;
-                cutOffTailIfNeeded(type, !1);
-                current = cache$153.updateQueue;
-                null !== current &&
-                  ((workInProgress.updateQueue = current),
-                  (workInProgress.flags |= 4));
-                workInProgress.subtreeFlags = 0;
-                current = renderLanes;
-                for (renderLanes = workInProgress.child; null !== renderLanes; )
-                  resetWorkInProgress(renderLanes, current),
-                    (renderLanes = renderLanes.sibling);
-                push(
-                  suspenseStackCursor,
-                  (suspenseStackCursor.current & 1) | 2
-                );
-                return workInProgress.child;
+            (JSCompiler_temp$jscomp$0 =
+              !shouldFireAfterActiveInstanceBlur &&
+              null !== focusedInstanceHandle)
+          ) {
+            var JSCompiler_temp$jscomp$1;
+            if ((JSCompiler_temp$jscomp$1 = 13 === firstChild.tag))
+              a: {
+                if (null !== current) {
+                  var oldState = current.memoizedState;
+                  if (null === oldState || null !== oldState.dehydrated) {
+                    var newState = firstChild.memoizedState;
+                    JSCompiler_temp$jscomp$1 =
+                      null !== newState && null === newState.dehydrated;
+                    break a;
+                  }
+                }
+                JSCompiler_temp$jscomp$1 = !1;
               }
-              current = current.sibling;
-            }
-          null !== type.tail &&
-            now() > workInProgressRootRenderTargetTime &&
-            ((workInProgress.flags |= 128),
-            (newProps = !0),
-            cutOffTailIfNeeded(type, !1),
-            (workInProgress.lanes = 8388608));
-        }
-      else {
-        if (!newProps)
-          if (((current = findFirstSuspended(cache$153)), null !== current)) {
-            if (
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              (current = current.updateQueue),
-              null !== current &&
-                ((workInProgress.updateQueue = current),
-                (workInProgress.flags |= 4)),
-              cutOffTailIfNeeded(type, !0),
-              null === type.tail &&
-                "hidden" === type.tailMode &&
-                !cache$153.alternate &&
-                !isHydrating)
-            )
-              return bubbleProperties(workInProgress), null;
-          } else
-            2 * now() - type.renderingStartTime >
-              workInProgressRootRenderTargetTime &&
-              1073741824 !== renderLanes &&
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              cutOffTailIfNeeded(type, !1),
-              (workInProgress.lanes = 8388608));
-        type.isBackwards
-          ? ((cache$153.sibling = workInProgress.child),
-            (workInProgress.child = cache$153))
-          : ((current = type.last),
-            null !== current
-              ? (current.sibling = cache$153)
-              : (workInProgress.child = cache$153),
-            (type.last = cache$153));
-      }
-      if (null !== type.tail)
-        return (
-          (workInProgress = type.tail),
-          (type.rendering = workInProgress),
-          (type.tail = workInProgress.sibling),
-          (type.renderingStartTime = now()),
-          (workInProgress.sibling = null),
-          (current = suspenseStackCursor.current),
-          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
-          workInProgress
-        );
-      bubbleProperties(workInProgress);
-      return null;
-    case 21:
-      return (
-        null === current
-          ? ((current = {
-              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-              containsNode: containsNode,
-              getChildContextValues: getChildContextValues
-            }),
-            (workInProgress.stateNode = current),
-            (current[internalInstanceKey] = workInProgress),
-            null !== workInProgress.ref &&
-              (markRef(workInProgress), markUpdate(workInProgress)))
-          : (null !== workInProgress.ref && markUpdate(workInProgress),
-            current.ref !== workInProgress.ref && markRef(workInProgress)),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        (newProps = null !== workInProgress.memoizedState),
-        23 !== workInProgress.tag &&
-          (null !== current
-            ? (null !== current.memoizedState) !== newProps &&
-              (workInProgress.flags |= 8192)
-            : newProps && (workInProgress.flags |= 8192)),
-        newProps && 0 !== (workInProgress.mode & 1)
-          ? 0 !== (renderLanes & 1073741824) &&
-            0 === (workInProgress.flags & 128) &&
-            (bubbleProperties(workInProgress),
-            23 !== workInProgress.tag &&
-              workInProgress.subtreeFlags & 6 &&
-              (workInProgress.flags |= 8192))
-          : bubbleProperties(workInProgress),
-        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
-        (renderLanes = null),
-        null !== current &&
-          null !== current.memoizedState &&
-          null !== current.memoizedState.cachePool &&
-          (renderLanes = current.memoizedState.cachePool.pool),
-        (newProps = null),
-        null !== workInProgress.memoizedState &&
-          null !== workInProgress.memoizedState.cachePool &&
-          (newProps = workInProgress.memoizedState.cachePool.pool),
-        newProps !== renderLanes && (workInProgress.flags |= 2048),
-        popTransition(workInProgress, current),
-        null
-      );
-    case 24:
-      return (
-        (renderLanes = null),
-        null !== current && (renderLanes = current.memoizedState.cache),
-        workInProgress.memoizedState.cache !== renderLanes &&
-          (workInProgress.flags |= 2048),
-        popProvider(CacheContext),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 25:
-      return (
-        enableTransitionTracing &&
-          (null !== workInProgress.stateNode &&
-            enableTransitionTracing &&
-            pop(markerInstanceStack),
-          bubbleProperties(workInProgress)),
-        null
-      );
+            JSCompiler_temp$jscomp$0 =
+              JSCompiler_temp$jscomp$1 &&
+              doesFiberContain(firstChild, focusedInstanceHandle);
+          }
+          JSCompiler_temp$jscomp$0 &&
+            ((shouldFireAfterActiveInstanceBlur = !0),
+            (root = firstChild),
+            (_enabled = !0),
+            dispatchBeforeDetachedBlur(selectionInformation.focusedElem, root),
+            (_enabled = !1));
+          switch (firstChild.tag) {
+            case 0:
+              if (0 !== (flags & 4)) {
+                var updateQueue = firstChild.updateQueue,
+                  eventPayloads =
+                    null !== updateQueue ? updateQueue.events : null;
+                if (null !== eventPayloads)
+                  for (root = 0; root < eventPayloads.length; root++) {
+                    var _eventPayloads$ii = eventPayloads[root];
+                    _eventPayloads$ii.ref.impl = _eventPayloads$ii.nextImpl;
+                  }
+              }
+              break;
+            case 11:
+            case 15:
+              break;
+            case 1:
+              if (0 !== (flags & 1024) && null !== current) {
+                var prevProps = current.memoizedProps,
+                  prevState = current.memoizedState,
+                  instance = firstChild.stateNode,
+                  snapshot = instance.getSnapshotBeforeUpdate(
+                    firstChild.elementType === firstChild.type
+                      ? prevProps
+                      : resolveDefaultProps(firstChild.type, prevProps),
+                    prevState
+                  );
+                instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+              }
+              break;
+            case 3:
+              0 !== (flags & 1024) &&
+                clearContainer(firstChild.stateNode.containerInfo);
+              break;
+            case 5:
+            case 26:
+            case 27:
+            case 6:
+            case 4:
+            case 17:
+              break;
+            default:
+              if (0 !== (flags & 1024))
+                throw Error(formatProdErrorMessage(163));
+          }
+        } catch (error) {
+          captureCommitPhaseError(firstChild, firstChild.return, error);
+        }
+        root = firstChild.sibling;
+        if (null !== root) {
+          root.return = firstChild.return;
+          nextEffect = root;
+          break;
+        }
+        nextEffect = firstChild.return;
+      }
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+  current = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = !1;
+  focusedInstanceHandle = null;
+  return current;
 }
-function unwindWork(current, workInProgress) {
-  popTreeContext(workInProgress);
-  switch (workInProgress.tag) {
-    case 1:
-      return (
-        isContextProvider(workInProgress.type) && popContext(),
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 3:
-      return (
-        popProvider(CacheContext),
-        enableTransitionTracing &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        enableTransitionTracing && pop(transitionStack),
-        popHostContainer(),
-        pop(didPerformWorkStackCursor),
-        pop(contextStackCursor),
-        resetWorkInProgressVersions(),
-        (current = workInProgress.flags),
-        0 !== (current & 65536) && 0 === (current & 128)
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 26:
-    case 27:
-    case 5:
-      return popHostContext(workInProgress), null;
-    case 13:
-      popSuspenseHandler(workInProgress);
-      current = workInProgress.memoizedState;
-      if (null !== current && null !== current.dehydrated) {
-        if (null === workInProgress.alternate)
-          throw Error(formatProdErrorMessage(340));
-        resetHydrationState();
+function commitHookEffectListUnmount(
+  flags,
+  finishedWork,
+  nearestMountedAncestor
+) {
+  var updateQueue = finishedWork.updateQueue;
+  updateQueue = null !== updateQueue ? updateQueue.lastEffect : null;
+  if (null !== updateQueue) {
+    var effect = (updateQueue = updateQueue.next);
+    do {
+      if ((effect.tag & flags) === flags) {
+        var destroy = effect.destroy;
+        effect.destroy = void 0;
+        void 0 !== destroy &&
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
       }
-      current = workInProgress.flags;
-      return current & 65536
-        ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-        : null;
-    case 19:
-      return pop(suspenseStackCursor), null;
-    case 4:
-      return popHostContainer(), null;
-    case 10:
-      return popProvider(workInProgress.type._context), null;
-    case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        popTransition(workInProgress, current),
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 24:
-      return popProvider(CacheContext), null;
-    case 25:
-      return (
-        enableTransitionTracing &&
-          null !== workInProgress.stateNode &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        null
-      );
-    default:
-      return null;
+      effect = effect.next;
+    } while (effect !== updateQueue);
   }
 }
-function unwindInterruptedWork(current, interruptedWork) {
-  popTreeContext(interruptedWork);
-  switch (interruptedWork.tag) {
+function commitHookEffectListMount(flags, finishedWork) {
+  finishedWork = finishedWork.updateQueue;
+  finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
+  if (null !== finishedWork) {
+    var effect = (finishedWork = finishedWork.next);
+    do {
+      if ((effect.tag & flags) === flags) {
+        var create = effect.create;
+        effect.destroy = create();
+      }
+      effect = effect.next;
+    } while (effect !== finishedWork);
+  }
+}
+function commitHookLayoutEffects(finishedWork, hookFlags) {
+  try {
+    commitHookEffectListMount(hookFlags, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+function commitClassCallbacks(finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  if (null !== updateQueue) {
+    var instance = finishedWork.stateNode;
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+function commitHostComponentMount(finishedWork) {
+  var type = finishedWork.type,
+    props = finishedWork.memoizedProps,
+    instance = finishedWork.stateNode;
+  try {
+    a: switch (type) {
+      case "button":
+      case "input":
+      case "select":
+      case "textarea":
+        props.autoFocus && instance.focus();
+        break a;
+      case "img":
+        props.src && (instance.src = props.src);
+    }
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+  var flags = finishedWork.flags;
+  switch (finishedWork.tag) {
+    case 0:
+    case 11:
+    case 15:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 && commitHookLayoutEffects(finishedWork, 5);
+      break;
     case 1:
-      current = interruptedWork.type.childContextTypes;
-      null !== current && void 0 !== current && popContext();
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      if (flags & 4)
+        if (((finishedRoot = finishedWork.stateNode), null === current))
+          try {
+            finishedRoot.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        else {
+          var prevProps =
+            finishedWork.elementType === finishedWork.type
+              ? current.memoizedProps
+              : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+          current = current.memoizedState;
+          try {
+            finishedRoot.componentDidUpdate(
+              prevProps,
+              current,
+              finishedRoot.__reactInternalSnapshotBeforeUpdate
+            );
+          } catch (error$156) {
+            captureCommitPhaseError(
+              finishedWork,
+              finishedWork.return,
+              error$156
+            );
+          }
+        }
+      flags & 64 && commitClassCallbacks(finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
       break;
     case 3:
-      popProvider(CacheContext);
-      enableTransitionTracing &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
-      enableTransitionTracing && pop(transitionStack);
-      popHostContainer();
-      pop(didPerformWorkStackCursor);
-      pop(contextStackCursor);
-      resetWorkInProgressVersions();
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      if (flags & 64 && ((flags = finishedWork.updateQueue), null !== flags)) {
+        finishedRoot = null;
+        if (null !== finishedWork.child)
+          switch (finishedWork.child.tag) {
+            case 27:
+            case 5:
+              finishedRoot = finishedWork.child.stateNode;
+              break;
+            case 1:
+              finishedRoot = finishedWork.child.stateNode;
+          }
+        try {
+          commitCallbacks(flags, finishedRoot);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+      break;
+    case 26:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
       break;
-    case 26:
     case 27:
     case 5:
-      popHostContext(interruptedWork);
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      null === current && flags & 4 && commitHostComponentMount(finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
       break;
-    case 4:
-      popHostContainer();
+    case 12:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
       break;
     case 13:
-      popSuspenseHandler(interruptedWork);
-      break;
-    case 19:
-      pop(suspenseStackCursor);
-      break;
-    case 10:
-      popProvider(interruptedWork.type._context);
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
       break;
     case 22:
-    case 23:
-      popSuspenseHandler(interruptedWork);
-      popHiddenContext();
-      popTransition(interruptedWork, current);
-      break;
-    case 24:
-      popProvider(CacheContext);
+      if (0 !== (finishedWork.mode & 1)) {
+        if (
+          ((prevProps =
+            null !== finishedWork.memoizedState || offscreenSubtreeIsHidden),
+          !prevProps)
+        ) {
+          current =
+            (null !== current && null !== current.memoizedState) ||
+            offscreenSubtreeWasHidden;
+          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
+            prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevProps;
+          (offscreenSubtreeWasHidden = current) &&
+          !prevOffscreenSubtreeWasHidden
+            ? recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                0 !== (finishedWork.subtreeFlags & 8772)
+              )
+            : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        }
+      } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 512 &&
+        ("manual" === finishedWork.memoizedProps.mode
+          ? safelyAttachRef(finishedWork, finishedWork.return)
+          : safelyDetachRef(finishedWork, finishedWork.return));
       break;
-    case 25:
-      enableTransitionTracing &&
-        null !== interruptedWork.stateNode &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
+    default:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+  }
+}
+function abortRootTransitions(
+  root,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance
+) {
+  if (enableTransitionTracing) {
+    var rootTransitions = root.incompleteTransitions;
+    deletedTransitions.forEach(function (transition) {
+      rootTransitions.has(transition) &&
+        ((transition = rootTransitions.get(transition)),
+        null === transition.aborts && (transition.aborts = []),
+        transition.aborts.push(abort),
+        null !== deletedOffscreenInstance &&
+          null !== transition.pendingBoundaries &&
+          transition.pendingBoundaries.has(deletedOffscreenInstance) &&
+          transition.pendingBoundaries.delete(deletedOffscreenInstance));
+    });
+  }
+}
+function abortTracingMarkerTransitions(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    var markerInstance = abortedFiber.stateNode,
+      markerTransitions = markerInstance.transitions,
+      pendingBoundaries = markerInstance.pendingBoundaries;
+    null !== markerTransitions &&
+      deletedTransitions.forEach(function (transition) {
+        if (
+          null !== abortedFiber &&
+          markerTransitions.has(transition) &&
+          (null === markerInstance.aborts ||
+            !markerInstance.aborts.includes(abort)) &&
+          null !== markerInstance.transitions
+        ) {
+          if (null === markerInstance.aborts) {
+            markerInstance.aborts = [abort];
+            transition = abortedFiber.memoizedProps.name;
+            var transitions = markerInstance.transitions,
+              aborts = markerInstance.aborts;
+            enableTransitionTracing &&
+              (null === currentPendingTransitionCallbacks &&
+                (currentPendingTransitionCallbacks = {
+                  transitionStart: null,
+                  transitionProgress: null,
+                  transitionComplete: null,
+                  markerProgress: null,
+                  markerIncomplete: new Map(),
+                  markerComplete: null
+                }),
+              null === currentPendingTransitionCallbacks.markerIncomplete &&
+                (currentPendingTransitionCallbacks.markerIncomplete =
+                  new Map()),
+              currentPendingTransitionCallbacks.markerIncomplete.set(
+                transition,
+                { transitions: transitions, aborts: aborts }
+              ));
+          } else markerInstance.aborts.push(abort);
+          null !== deletedOffscreenInstance &&
+            !isInDeletedTree &&
+            null !== pendingBoundaries &&
+            pendingBoundaries.has(deletedOffscreenInstance) &&
+            (pendingBoundaries.delete(deletedOffscreenInstance),
+            addMarkerProgressCallbackToPendingTransition(
+              abortedFiber.memoizedProps.name,
+              deletedTransitions,
+              pendingBoundaries
+            ));
+        }
+      });
+  }
+}
+function abortParentMarkerTransitionsForDeletedFiber(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing)
+    for (; null !== abortedFiber; ) {
+      switch (abortedFiber.tag) {
+        case 25:
+          abortTracingMarkerTransitions(
+            abortedFiber,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance,
+            isInDeletedTree
+          );
+          break;
+        case 3:
+          abortRootTransitions(
+            abortedFiber.stateNode,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance
+          );
+      }
+      abortedFiber = abortedFiber.return;
+    }
+}
+function commitTransitionProgress(offscreenFiber) {
+  if (enableTransitionTracing) {
+    var offscreenInstance = offscreenFiber.stateNode,
+      prevState = null,
+      previousFiber = offscreenFiber.alternate;
+    null !== previousFiber &&
+      null !== previousFiber.memoizedState &&
+      (prevState = previousFiber.memoizedState);
+    prevState = null !== prevState;
+    previousFiber = null !== offscreenFiber.memoizedState;
+    var pendingMarkers = offscreenInstance._pendingMarkers,
+      name = null;
+    offscreenFiber = offscreenFiber.return;
+    null !== offscreenFiber &&
+      13 === offscreenFiber.tag &&
+      offscreenFiber.memoizedProps.unstable_name &&
+      (name = offscreenFiber.memoizedProps.unstable_name);
+    !prevState && previousFiber
+      ? null !== pendingMarkers &&
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries,
+            transitions = markerInstance.transitions,
+            markerName = markerInstance.name;
+          null === pendingBoundaries ||
+            pendingBoundaries.has(offscreenInstance) ||
+            (pendingBoundaries.set(offscreenInstance, { name: name }),
+            null !== transitions &&
+              (1 === markerInstance.tag && null !== markerName
+                ? addMarkerProgressCallbackToPendingTransition(
+                    markerName,
+                    transitions,
+                    pendingBoundaries
+                  )
+                : 0 === markerInstance.tag &&
+                  transitions.forEach(function (transition) {
+                    addTransitionProgressCallbackToPendingTransition(
+                      transition,
+                      pendingBoundaries
+                    );
+                  })));
+        })
+      : prevState &&
+        !previousFiber &&
+        null !== pendingMarkers &&
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries,
+            transitions = markerInstance.transitions,
+            markerName = markerInstance.name;
+          null !== pendingBoundaries &&
+            pendingBoundaries.has(offscreenInstance) &&
+            (pendingBoundaries.delete(offscreenInstance),
+            null !== transitions &&
+              (1 === markerInstance.tag && null !== markerName
+                ? (addMarkerProgressCallbackToPendingTransition(
+                    markerName,
+                    transitions,
+                    pendingBoundaries
+                  ),
+                  0 === pendingBoundaries.size &&
+                    (null === markerInstance.aborts &&
+                      addMarkerCompleteCallbackToPendingTransition(
+                        markerName,
+                        transitions
+                      ),
+                    (markerInstance.transitions = null),
+                    (markerInstance.pendingBoundaries = null),
+                    (markerInstance.aborts = null)))
+                : 0 === markerInstance.tag &&
+                  transitions.forEach(function (transition) {
+                    addTransitionProgressCallbackToPendingTransition(
+                      transition,
+                      pendingBoundaries
+                    );
+                  })));
+        });
   }
 }
-var offscreenSubtreeIsHidden = !1,
-  offscreenSubtreeWasHidden = !1,
-  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
-  nextEffect = null;
-function safelyAttachRef(current, nearestMountedAncestor) {
-  try {
-    var ref = current.ref;
-    if (null !== ref) {
-      var instance = current.stateNode;
-      switch (current.tag) {
-        case 26:
-        case 27:
-        case 5:
-          var instanceToUse = instance;
-          break;
-        default:
-          instanceToUse = instance;
-      }
-      21 === current.tag && (instanceToUse = instance);
-      "function" === typeof ref
-        ? (current.refCleanup = ref(instanceToUse))
-        : (ref.current = instanceToUse);
+function detachFiberAfterEffects(fiber) {
+  var alternate = fiber.alternate;
+  null !== alternate &&
+    ((fiber.alternate = null), detachFiberAfterEffects(alternate));
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null;
+  5 === fiber.tag &&
+    ((alternate = fiber.stateNode),
+    null !== alternate && detachDeletedInstance(alternate));
+  fiber.stateNode = null;
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null;
+  fiber.updateQueue = null;
+}
+function isHostParent(fiber) {
+  return (
+    5 === fiber.tag ||
+    3 === fiber.tag ||
+    26 === fiber.tag ||
+    27 === fiber.tag ||
+    4 === fiber.tag
+  );
+}
+function getHostSibling(fiber) {
+  a: for (;;) {
+    for (; null === fiber.sibling; ) {
+      if (null === fiber.return || isHostParent(fiber.return)) return null;
+      fiber = fiber.return;
     }
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+    fiber.sibling.return = fiber.return;
+    for (
+      fiber = fiber.sibling;
+      5 !== fiber.tag &&
+      6 !== fiber.tag &&
+      27 !== fiber.tag &&
+      18 !== fiber.tag;
+
+    ) {
+      if (fiber.flags & 2) continue a;
+      if (null === fiber.child || 4 === fiber.tag) continue a;
+      else (fiber.child.return = fiber), (fiber = fiber.child);
+    }
+    if (!(fiber.flags & 2)) return fiber.stateNode;
   }
 }
-function safelyDetachRef(current, nearestMountedAncestor) {
-  var ref = current.ref,
-    refCleanup = current.refCleanup;
-  if (null !== ref)
-    if ("function" === typeof refCleanup)
-      try {
-        refCleanup();
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      } finally {
-        (current.refCleanup = null),
-          (current = current.alternate),
-          null != current && (current.refCleanup = null);
-      }
-    else if ("function" === typeof ref)
-      try {
-        ref(null);
-      } catch (error$169) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error$169);
-      }
-    else ref.current = null;
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  var tag = node.tag;
+  if (5 === tag || 6 === tag)
+    (node = node.stateNode),
+      before
+        ? 8 === parent.nodeType
+          ? parent.parentNode.insertBefore(node, before)
+          : parent.insertBefore(node, before)
+        : (8 === parent.nodeType
+            ? ((before = parent.parentNode), before.insertBefore(node, parent))
+            : ((before = parent), before.appendChild(node)),
+          (parent = parent._reactRootContainer),
+          (null !== parent && void 0 !== parent) ||
+            null !== before.onclick ||
+            (before.onclick = noop$1));
+  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
+    for (
+      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
+        node = node.sibling;
+      null !== node;
+
+    )
+      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
+        (node = node.sibling);
 }
-function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
-  try {
-    destroy();
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
-  }
+function insertOrAppendPlacementNode(node, before, parent) {
+  var tag = node.tag;
+  if (5 === tag || 6 === tag)
+    (node = node.stateNode),
+      before ? parent.insertBefore(node, before) : parent.appendChild(node);
+  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
+    for (
+      insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
+      null !== node;
+
+    )
+      insertOrAppendPlacementNode(node, before, parent), (node = node.sibling);
 }
-var focusedInstanceHandle = null,
-  shouldFireAfterActiveInstanceBlur = !1;
-function commitBeforeMutationEffects(root, firstChild) {
-  eventsEnabled = _enabled;
-  root = getActiveElementDeep();
-  if (hasSelectionCapabilities(root)) {
-    if ("selectionStart" in root)
-      var JSCompiler_temp = {
-        start: root.selectionStart,
-        end: root.selectionEnd
-      };
-    else
-      a: {
-        JSCompiler_temp =
-          ((JSCompiler_temp = root.ownerDocument) &&
-            JSCompiler_temp.defaultView) ||
-          window;
-        var selection =
-          JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
-        if (selection && 0 !== selection.rangeCount) {
-          JSCompiler_temp = selection.anchorNode;
-          var anchorOffset = selection.anchorOffset,
-            focusNode = selection.focusNode;
-          selection = selection.focusOffset;
-          try {
-            JSCompiler_temp.nodeType, focusNode.nodeType;
-          } catch (e) {
-            JSCompiler_temp = null;
-            break a;
-          }
-          var length = 0,
-            start = -1,
-            end = -1,
-            indexWithinAnchor = 0,
-            indexWithinFocus = 0,
-            node = root,
-            parentNode = null;
-          b: for (;;) {
-            for (var next; ; ) {
-              node !== JSCompiler_temp ||
-                (0 !== anchorOffset && 3 !== node.nodeType) ||
-                (start = length + anchorOffset);
-              node !== focusNode ||
-                (0 !== selection && 3 !== node.nodeType) ||
-                (end = length + selection);
-              3 === node.nodeType && (length += node.nodeValue.length);
-              if (null === (next = node.firstChild)) break;
-              parentNode = node;
-              node = next;
-            }
-            for (;;) {
-              if (node === root) break b;
-              parentNode === JSCompiler_temp &&
-                ++indexWithinAnchor === anchorOffset &&
-                (start = length);
-              parentNode === focusNode &&
-                ++indexWithinFocus === selection &&
-                (end = length);
-              if (null !== (next = node.nextSibling)) break;
-              node = parentNode;
-              parentNode = node.parentNode;
-            }
-            node = next;
-          }
-          JSCompiler_temp =
-            -1 === start || -1 === end ? null : { start: start, end: end };
-        } else JSCompiler_temp = null;
+var hostParent = null,
+  hostParentIsContainer = !1;
+function recursivelyTraverseDeletionEffects(
+  finishedRoot,
+  nearestMountedAncestor,
+  parent
+) {
+  for (parent = parent.child; null !== parent; )
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent),
+      (parent = parent.sibling);
+}
+function commitDeletionEffectsOnFiber(
+  finishedRoot,
+  nearestMountedAncestor,
+  deletedFiber
+) {
+  if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+    } catch (err) {}
+  switch (deletedFiber.tag) {
+    case 26:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      deletedFiber.memoizedState
+        ? deletedFiber.memoizedState.count--
+        : deletedFiber.stateNode &&
+          ((deletedFiber = deletedFiber.stateNode),
+          deletedFiber.parentNode.removeChild(deletedFiber));
+      break;
+    case 27:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      var prevHostParent = hostParent,
+        prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = deletedFiber.stateNode;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      deletedFiber = deletedFiber.stateNode;
+      for (finishedRoot = deletedFiber.attributes; finishedRoot.length; )
+        deletedFiber.removeAttributeNode(finishedRoot[0]);
+      detachDeletedInstance(deletedFiber);
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      break;
+    case 5:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+    case 6:
+      prevHostParent = hostParent;
+      prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = null;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      null !== hostParent &&
+        (hostParentIsContainer
+          ? ((finishedRoot = hostParent),
+            (deletedFiber = deletedFiber.stateNode),
+            8 === finishedRoot.nodeType
+              ? finishedRoot.parentNode.removeChild(deletedFiber)
+              : finishedRoot.removeChild(deletedFiber))
+          : hostParent.removeChild(deletedFiber.stateNode));
+      break;
+    case 18:
+      finishedRoot = finishedRoot.hydrationCallbacks;
+      null !== finishedRoot &&
+        (finishedRoot = finishedRoot.onDeleted) &&
+        finishedRoot(deletedFiber.stateNode);
+      null !== hostParent &&
+        (hostParentIsContainer
+          ? ((finishedRoot = hostParent),
+            (deletedFiber = deletedFiber.stateNode),
+            8 === finishedRoot.nodeType
+              ? clearSuspenseBoundary(finishedRoot.parentNode, deletedFiber)
+              : 1 === finishedRoot.nodeType &&
+                clearSuspenseBoundary(finishedRoot, deletedFiber),
+            retryIfBlockedOn(finishedRoot))
+          : clearSuspenseBoundary(hostParent, deletedFiber.stateNode));
+      break;
+    case 4:
+      prevHostParent = hostParent;
+      prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = deletedFiber.stateNode.containerInfo;
+      hostParentIsContainer = !0;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      break;
+    case 0:
+    case 11:
+    case 14:
+    case 15:
+      if (
+        !offscreenSubtreeWasHidden &&
+        ((prevHostParent = deletedFiber.updateQueue),
+        null !== prevHostParent &&
+          ((prevHostParent = prevHostParent.lastEffect),
+          null !== prevHostParent))
+      ) {
+        prevHostParentIsContainer = prevHostParent = prevHostParent.next;
+        do {
+          var _effect = prevHostParentIsContainer,
+            destroy = _effect.destroy;
+          _effect = _effect.tag;
+          void 0 !== destroy &&
+            (0 !== (_effect & 2)
+              ? safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy)
+              : 0 !== (_effect & 4) &&
+                safelyCallDestroy(
+                  deletedFiber,
+                  nearestMountedAncestor,
+                  destroy
+                ));
+          prevHostParentIsContainer = prevHostParentIsContainer.next;
+        } while (prevHostParentIsContainer !== prevHostParent);
       }
-    JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
-  } else JSCompiler_temp = null;
-  selectionInformation = { focusedElem: root, selectionRange: JSCompiler_temp };
-  root = null;
-  JSCompiler_temp = selectionInformation.focusedElem;
-  null !== JSCompiler_temp &&
-    (root = getClosestInstanceFromNode(JSCompiler_temp));
-  _enabled = !1;
-  focusedInstanceHandle = root;
-  for (nextEffect = firstChild; null !== nextEffect; ) {
-    firstChild = nextEffect;
-    root = firstChild.deletions;
-    if (null !== root)
-      for (
-        JSCompiler_temp = 0;
-        JSCompiler_temp < root.length;
-        JSCompiler_temp++
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      break;
+    case 1:
+      if (
+        !offscreenSubtreeWasHidden &&
+        (safelyDetachRef(deletedFiber, nearestMountedAncestor),
+        (prevHostParent = deletedFiber.stateNode),
+        "function" === typeof prevHostParent.componentWillUnmount)
       )
-        (anchorOffset = root[JSCompiler_temp]),
-          doesFiberContain(anchorOffset, focusedInstanceHandle) &&
-            ((_enabled = shouldFireAfterActiveInstanceBlur = !0),
-            dispatchBeforeDetachedBlur(
-              selectionInformation.focusedElem,
-              anchorOffset
-            ),
-            (_enabled = !1));
-    root = firstChild.child;
-    if (0 !== (firstChild.subtreeFlags & 9236) && null !== root)
-      (root.return = firstChild), (nextEffect = root);
-    else
-      for (; null !== nextEffect; ) {
-        firstChild = nextEffect;
         try {
-          var current = firstChild.alternate,
-            flags = firstChild.flags,
-            JSCompiler_temp$jscomp$0;
-          if (
-            (JSCompiler_temp$jscomp$0 =
-              !shouldFireAfterActiveInstanceBlur &&
-              null !== focusedInstanceHandle)
-          ) {
-            var JSCompiler_temp$jscomp$1;
-            if ((JSCompiler_temp$jscomp$1 = 13 === firstChild.tag))
-              a: {
-                if (null !== current) {
-                  var oldState = current.memoizedState;
-                  if (null === oldState || null !== oldState.dehydrated) {
-                    var newState = firstChild.memoizedState;
-                    JSCompiler_temp$jscomp$1 =
-                      null !== newState && null === newState.dehydrated;
-                    break a;
-                  }
-                }
-                JSCompiler_temp$jscomp$1 = !1;
-              }
-            JSCompiler_temp$jscomp$0 =
-              JSCompiler_temp$jscomp$1 &&
-              doesFiberContain(firstChild, focusedInstanceHandle);
-          }
-          JSCompiler_temp$jscomp$0 &&
-            ((shouldFireAfterActiveInstanceBlur = !0),
-            (root = firstChild),
-            (_enabled = !0),
-            dispatchBeforeDetachedBlur(selectionInformation.focusedElem, root),
-            (_enabled = !1));
-          switch (firstChild.tag) {
-            case 0:
-              if (0 !== (flags & 4)) {
-                var updateQueue = firstChild.updateQueue,
-                  eventPayloads =
-                    null !== updateQueue ? updateQueue.events : null;
-                if (null !== eventPayloads)
-                  for (root = 0; root < eventPayloads.length; root++) {
-                    var _eventPayloads$ii = eventPayloads[root];
-                    _eventPayloads$ii.ref.impl = _eventPayloads$ii.nextImpl;
-                  }
-              }
-              break;
-            case 11:
-            case 15:
-              break;
-            case 1:
-              if (0 !== (flags & 1024) && null !== current) {
-                var prevProps = current.memoizedProps,
-                  prevState = current.memoizedState,
-                  instance = firstChild.stateNode,
-                  snapshot = instance.getSnapshotBeforeUpdate(
-                    firstChild.elementType === firstChild.type
-                      ? prevProps
-                      : resolveDefaultProps(firstChild.type, prevProps),
-                    prevState
-                  );
-                instance.__reactInternalSnapshotBeforeUpdate = snapshot;
-              }
-              break;
-            case 3:
-              0 !== (flags & 1024) &&
-                clearContainer(firstChild.stateNode.containerInfo);
-              break;
-            case 5:
-            case 26:
-            case 27:
-            case 6:
-            case 4:
-            case 17:
-              break;
-            default:
-              if (0 !== (flags & 1024))
-                throw Error(formatProdErrorMessage(163));
-          }
+          (prevHostParent.props = deletedFiber.memoizedProps),
+            (prevHostParent.state = deletedFiber.memoizedState),
+            prevHostParent.componentWillUnmount();
         } catch (error) {
-          captureCommitPhaseError(firstChild, firstChild.return, error);
-        }
-        root = firstChild.sibling;
-        if (null !== root) {
-          root.return = firstChild.return;
-          nextEffect = root;
-          break;
+          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
         }
-        nextEffect = firstChild.return;
-      }
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      break;
+    case 21:
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      break;
+    case 22:
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      deletedFiber.mode & 1
+        ? ((offscreenSubtreeWasHidden =
+            (prevHostParent = offscreenSubtreeWasHidden) ||
+            null !== deletedFiber.memoizedState),
+          recursivelyTraverseDeletionEffects(
+            finishedRoot,
+            nearestMountedAncestor,
+            deletedFiber
+          ),
+          (offscreenSubtreeWasHidden = prevHostParent))
+        : recursivelyTraverseDeletionEffects(
+            finishedRoot,
+            nearestMountedAncestor,
+            deletedFiber
+          );
+      break;
+    default:
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
   }
-  current = shouldFireAfterActiveInstanceBlur;
-  shouldFireAfterActiveInstanceBlur = !1;
-  focusedInstanceHandle = null;
-  return current;
 }
-function commitHookEffectListUnmount(
-  flags,
-  finishedWork,
-  nearestMountedAncestor
-) {
-  var updateQueue = finishedWork.updateQueue;
-  updateQueue = null !== updateQueue ? updateQueue.lastEffect : null;
-  if (null !== updateQueue) {
-    var effect = (updateQueue = updateQueue.next);
-    do {
-      if ((effect.tag & flags) === flags) {
-        var destroy = effect.destroy;
-        effect.destroy = void 0;
-        void 0 !== destroy &&
-          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+  if (null === finishedWork.memoizedState) {
+    var current = finishedWork.alternate;
+    if (
+      null !== current &&
+      ((current = current.memoizedState),
+      null !== current && ((current = current.dehydrated), null !== current))
+    )
+      try {
+        retryIfBlockedOn(current);
+        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+        if (null !== hydrationCallbacks) {
+          var onHydrated = hydrationCallbacks.onHydrated;
+          onHydrated && onHydrated(current);
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
       }
-      effect = effect.next;
-    } while (effect !== updateQueue);
   }
 }
-function commitHookEffectListMount(flags, finishedWork) {
-  finishedWork = finishedWork.updateQueue;
-  finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
-  if (null !== finishedWork) {
-    var effect = (finishedWork = finishedWork.next);
-    do {
-      if ((effect.tag & flags) === flags) {
-        var create = effect.create;
-        effect.destroy = create();
-      }
-      effect = effect.next;
-    } while (effect !== finishedWork);
+function getRetryCache(finishedWork) {
+  switch (finishedWork.tag) {
+    case 13:
+    case 19:
+      var retryCache = finishedWork.stateNode;
+      null === retryCache &&
+        (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+      return retryCache;
+    case 22:
+      return (
+        (finishedWork = finishedWork.stateNode),
+        (retryCache = finishedWork._retryCache),
+        null === retryCache &&
+          (retryCache = finishedWork._retryCache = new PossiblyWeakSet()),
+        retryCache
+      );
+    default:
+      throw Error(formatProdErrorMessage(435, finishedWork.tag));
   }
 }
-function commitHookLayoutEffects(finishedWork, hookFlags) {
-  try {
-    commitHookEffectListMount(hookFlags, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+function detachOffscreenInstance(instance) {
+  var fiber = instance._current;
+  if (null === fiber) throw Error(formatProdErrorMessage(456));
+  if (0 === (instance._pendingVisibility & 2)) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root &&
+      ((instance._pendingVisibility |= 2),
+      scheduleUpdateOnFiber(root, fiber, 2, -1));
   }
 }
-function commitClassCallbacks(finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  if (null !== updateQueue) {
-    var instance = finishedWork.stateNode;
-    try {
-      commitCallbacks(updateQueue, instance);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
+function attachOffscreenInstance(instance) {
+  var fiber = instance._current;
+  if (null === fiber) throw Error(formatProdErrorMessage(456));
+  if (0 !== (instance._pendingVisibility & 2)) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root &&
+      ((instance._pendingVisibility &= -3),
+      scheduleUpdateOnFiber(root, fiber, 2, -1));
   }
 }
-function commitHostComponentMount(finishedWork) {
-  var type = finishedWork.type,
-    props = finishedWork.memoizedProps,
-    instance = finishedWork.stateNode;
-  try {
-    a: switch (type) {
-      case "button":
-      case "input":
-      case "select":
-      case "textarea":
-        props.autoFocus && instance.focus();
-        break a;
-      case "img":
-        props.src && (instance.src = props.src);
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  var retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(function (wakeable) {
+    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+    retryCache.has(wakeable) ||
+      (retryCache.add(wakeable), wakeable.then(retry, retry));
+  });
+}
+function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (null !== deletions)
+    for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i];
+      try {
+        var root = root$jscomp$0,
+          returnFiber = parentFiber,
+          parent = returnFiber;
+        a: for (; null !== parent; ) {
+          switch (parent.tag) {
+            case 27:
+            case 5:
+              hostParent = parent.stateNode;
+              hostParentIsContainer = !1;
+              break a;
+            case 3:
+              hostParent = parent.stateNode.containerInfo;
+              hostParentIsContainer = !0;
+              break a;
+            case 4:
+              hostParent = parent.stateNode.containerInfo;
+              hostParentIsContainer = !0;
+              break a;
+          }
+          parent = parent.return;
+        }
+        if (null === hostParent) throw Error(formatProdErrorMessage(160));
+        commitDeletionEffectsOnFiber(root, returnFiber, childToDelete);
+        hostParent = null;
+        hostParentIsContainer = !1;
+        var alternate = childToDelete.alternate;
+        null !== alternate && (alternate.return = null);
+        childToDelete.return = null;
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
     }
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
-  }
+  if (parentFiber.subtreeFlags & 12854)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitMutationEffectsOnFiber(parentFiber, root$jscomp$0),
+        (parentFiber = parentFiber.sibling);
 }
-function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
-  var flags = finishedWork.flags;
+var currentHoistableRoot = null;
+function commitMutationEffectsOnFiber(finishedWork, root) {
+  var current = finishedWork.alternate,
+    flags = finishedWork.flags;
   switch (finishedWork.tag) {
     case 0:
     case 11:
+    case 14:
     case 15:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 4 && commitHookLayoutEffects(finishedWork, 5);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4) {
+        try {
+          commitHookEffectListUnmount(3, finishedWork, finishedWork.return),
+            commitHookEffectListMount(3, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+        try {
+          commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
+        } catch (error$169) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$169);
+        }
+      }
       break;
     case 1:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      flags & 64 &&
+        offscreenSubtreeIsHidden &&
+        ((finishedWork = finishedWork.updateQueue),
+        null !== finishedWork &&
+          ((current = finishedWork.callbacks),
+          null !== current &&
+            ((flags = finishedWork.shared.hiddenCallbacks),
+            (finishedWork.shared.hiddenCallbacks =
+              null === flags ? current : flags.concat(current)))));
+      break;
+    case 26:
+      var hoistableRoot = currentHoistableRoot;
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
       if (flags & 4)
-        if (((finishedRoot = finishedWork.stateNode), null === current))
-          try {
-            finishedRoot.componentDidMount();
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        else {
-          var prevProps =
-            finishedWork.elementType === finishedWork.type
-              ? current.memoizedProps
-              : resolveDefaultProps(finishedWork.type, current.memoizedProps);
-          current = current.memoizedState;
+        if (
+          ((root = null !== current ? current.memoizedState : null),
+          (flags = finishedWork.memoizedState),
+          null === current)
+        )
+          if (null === flags)
+            if (null === finishedWork.stateNode) {
+              a: {
+                current = finishedWork.type;
+                flags = finishedWork.memoizedProps;
+                root = hoistableRoot.ownerDocument || hoistableRoot;
+                b: switch (current) {
+                  case "title":
+                    hoistableRoot = root.getElementsByTagName("title")[0];
+                    if (
+                      !hoistableRoot ||
+                      hoistableRoot[internalHoistableMarker] ||
+                      hoistableRoot[internalInstanceKey] ||
+                      "http://www.w3.org/2000/svg" ===
+                        hoistableRoot.namespaceURI ||
+                      hoistableRoot.hasAttribute("itemprop")
+                    )
+                      (hoistableRoot = root.createElement(current)),
+                        root.head.insertBefore(
+                          hoistableRoot,
+                          root.querySelector("head > title")
+                        );
+                    setInitialProperties(hoistableRoot, current, flags);
+                    hoistableRoot[internalInstanceKey] = finishedWork;
+                    markNodeAsHoistable(hoistableRoot);
+                    current = hoistableRoot;
+                    break a;
+                  case "link":
+                    var maybeNodes = getHydratableHoistableCache(
+                      "link",
+                      "href",
+                      root
+                    ).get(current + (flags.href || ""));
+                    if (maybeNodes)
+                      for (var i = 0; i < maybeNodes.length; i++)
+                        if (
+                          ((hoistableRoot = maybeNodes[i]),
+                          hoistableRoot.getAttribute("href") ===
+                            (null == flags.href ? null : flags.href) &&
+                            hoistableRoot.getAttribute("rel") ===
+                              (null == flags.rel ? null : flags.rel) &&
+                            hoistableRoot.getAttribute("title") ===
+                              (null == flags.title ? null : flags.title) &&
+                            hoistableRoot.getAttribute("crossorigin") ===
+                              (null == flags.crossOrigin
+                                ? null
+                                : flags.crossOrigin))
+                        ) {
+                          maybeNodes.splice(i, 1);
+                          break b;
+                        }
+                    hoistableRoot = root.createElement(current);
+                    setInitialProperties(hoistableRoot, current, flags);
+                    root.head.appendChild(hoistableRoot);
+                    break;
+                  case "meta":
+                    if (
+                      (maybeNodes = getHydratableHoistableCache(
+                        "meta",
+                        "content",
+                        root
+                      ).get(current + (flags.content || "")))
+                    )
+                      for (i = 0; i < maybeNodes.length; i++)
+                        if (
+                          ((hoistableRoot = maybeNodes[i]),
+                          hoistableRoot.getAttribute("content") ===
+                            (null == flags.content
+                              ? null
+                              : "" + flags.content) &&
+                            hoistableRoot.getAttribute("name") ===
+                              (null == flags.name ? null : flags.name) &&
+                            hoistableRoot.getAttribute("property") ===
+                              (null == flags.property
+                                ? null
+                                : flags.property) &&
+                            hoistableRoot.getAttribute("http-equiv") ===
+                              (null == flags.httpEquiv
+                                ? null
+                                : flags.httpEquiv) &&
+                            hoistableRoot.getAttribute("charset") ===
+                              (null == flags.charSet ? null : flags.charSet))
+                        ) {
+                          maybeNodes.splice(i, 1);
+                          break b;
+                        }
+                    hoistableRoot = root.createElement(current);
+                    setInitialProperties(hoistableRoot, current, flags);
+                    root.head.appendChild(hoistableRoot);
+                    break;
+                  default:
+                    throw Error(formatProdErrorMessage(468, current));
+                }
+                hoistableRoot[internalInstanceKey] = finishedWork;
+                markNodeAsHoistable(hoistableRoot);
+                current = hoistableRoot;
+              }
+              finishedWork.stateNode = current;
+            } else
+              mountHoistable(
+                hoistableRoot,
+                finishedWork.type,
+                finishedWork.stateNode
+              );
+          else
+            finishedWork.stateNode = acquireResource(
+              hoistableRoot,
+              flags,
+              finishedWork.memoizedProps
+            );
+        else if (root !== flags)
+          null === root
+            ? null !== current.stateNode &&
+              ((current = current.stateNode),
+              current.parentNode.removeChild(current))
+            : root.count--,
+            null === flags
+              ? mountHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.stateNode
+                )
+              : acquireResource(
+                  hoistableRoot,
+                  flags,
+                  finishedWork.memoizedProps
+                );
+        else if (
+          null === flags &&
+          null !== finishedWork.stateNode &&
+          ((flags = finishedWork.updateQueue),
+          (finishedWork.updateQueue = null),
+          null !== flags)
+        )
           try {
-            finishedRoot.componentDidUpdate(
-              prevProps,
-              current,
-              finishedRoot.__reactInternalSnapshotBeforeUpdate
+            var domElement = finishedWork.stateNode,
+              newProps = finishedWork.memoizedProps;
+            updateProperties(
+              domElement,
+              flags,
+              finishedWork.type,
+              current.memoizedProps,
+              newProps
             );
-          } catch (error$171) {
+            domElement[internalPropsKey] = newProps;
+          } catch (error$170) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$171
+              error$170
             );
           }
-        }
-      flags & 64 && commitClassCallbacks(finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    case 3:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      if (flags & 64 && ((flags = finishedWork.updateQueue), null !== flags)) {
-        finishedRoot = null;
-        if (null !== finishedWork.child)
-          switch (finishedWork.child.tag) {
-            case 27:
-            case 5:
-              finishedRoot = finishedWork.child.stateNode;
-              break;
-            case 1:
-              finishedRoot = finishedWork.child.stateNode;
+      break;
+    case 27:
+      if (flags & 4 && null === finishedWork.alternate) {
+        hoistableRoot = finishedWork.stateNode;
+        maybeNodes = finishedWork.memoizedProps;
+        for (i = hoistableRoot.firstChild; i; ) {
+          var nextNode = i.nextSibling,
+            nodeName = i.nodeName;
+          i[internalHoistableMarker] ||
+            "HEAD" === nodeName ||
+            "BODY" === nodeName ||
+            "STYLE" === nodeName ||
+            ("LINK" === nodeName && "stylesheet" === i.rel.toLowerCase()) ||
+            hoistableRoot.removeChild(i);
+          i = nextNode;
+        }
+        i = finishedWork.type;
+        for (nextNode = hoistableRoot.attributes; nextNode.length; )
+          hoistableRoot.removeAttributeNode(nextNode[0]);
+        setInitialProperties(hoistableRoot, i, maybeNodes);
+        hoistableRoot[internalInstanceKey] = finishedWork;
+        hoistableRoot[internalPropsKey] = maybeNodes;
+      }
+    case 5:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      if (finishedWork.flags & 32) {
+        root = finishedWork.stateNode;
+        try {
+          setTextContent(root, "");
+        } catch (error$171) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$171);
+        }
+      }
+      if (
+        flags & 4 &&
+        ((flags = finishedWork.stateNode),
+        null != flags &&
+          ((root = finishedWork.memoizedProps),
+          (current = null !== current ? current.memoizedProps : root),
+          (hoistableRoot = finishedWork.type),
+          (maybeNodes = finishedWork.updateQueue),
+          (finishedWork.updateQueue = null),
+          null !== maybeNodes))
+      )
+        try {
+          updateProperties(flags, maybeNodes, hoistableRoot, current, root),
+            (flags[internalPropsKey] = root);
+        } catch (error$174) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$174);
+        }
+      break;
+    case 6:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4) {
+        if (null === finishedWork.stateNode)
+          throw Error(formatProdErrorMessage(162));
+        current = finishedWork.stateNode;
+        flags = finishedWork.memoizedProps;
+        try {
+          current.nodeValue = flags;
+        } catch (error$175) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$175);
+        }
+      }
+      break;
+    case 3:
+      tagCaches = null;
+      hoistableRoot = currentHoistableRoot;
+      currentHoistableRoot = getHoistableRoot(root.containerInfo);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      currentHoistableRoot = hoistableRoot;
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
+        try {
+          retryIfBlockedOn(root.containerInfo);
+        } catch (error$176) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$176);
+        }
+      break;
+    case 4:
+      current = currentHoistableRoot;
+      currentHoistableRoot = getHoistableRoot(
+        finishedWork.stateNode.containerInfo
+      );
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      currentHoistableRoot = current;
+      break;
+    case 13:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      current = finishedWork.child;
+      current.flags & 8192 &&
+        null !== current.memoizedState &&
+        (null === current.alternate ||
+          null === current.alternate.memoizedState) &&
+        (globalMostRecentFallbackTime = now());
+      if (flags & 4) {
+        try {
+          if (null !== finishedWork.memoizedState) {
+            var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
+            if ("function" === typeof suspenseCallback) {
+              var wakeables = finishedWork.updateQueue;
+              null !== wakeables && suspenseCallback(new Set(wakeables));
+            }
+          }
+        } catch (error$178) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$178);
+        }
+        current = finishedWork.updateQueue;
+        null !== current &&
+          ((finishedWork.updateQueue = null),
+          attachSuspenseRetryListeners(finishedWork, current));
+      }
+      break;
+    case 22:
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      domElement = null !== finishedWork.memoizedState;
+      newProps = null !== current && null !== current.memoizedState;
+      finishedWork.mode & 1
+        ? ((suspenseCallback = offscreenSubtreeIsHidden),
+          (wakeables = offscreenSubtreeWasHidden),
+          (offscreenSubtreeIsHidden = suspenseCallback || domElement),
+          (offscreenSubtreeWasHidden = wakeables || newProps),
+          recursivelyTraverseMutationEffects(root, finishedWork),
+          (offscreenSubtreeWasHidden = wakeables),
+          (offscreenSubtreeIsHidden = suspenseCallback))
+        : recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      root = finishedWork.stateNode;
+      root._current = finishedWork;
+      root._visibility &= -3;
+      root._visibility |= root._pendingVisibility & 2;
+      if (
+        flags & 8192 &&
+        ((root._visibility = domElement
+          ? root._visibility & -2
+          : root._visibility | 1),
+        domElement &&
+          ((root = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden),
+          null === current ||
+            newProps ||
+            root ||
+            (0 !== (finishedWork.mode & 1) &&
+              recursivelyTraverseDisappearLayoutEffects(finishedWork))),
+        null === finishedWork.memoizedProps ||
+          "manual" !== finishedWork.memoizedProps.mode)
+      )
+        a: for (current = null, root = finishedWork; ; ) {
+          if (5 === root.tag || 26 === root.tag || 27 === root.tag) {
+            if (null === current) {
+              current = root;
+              try {
+                (hoistableRoot = root.stateNode),
+                  domElement
+                    ? ((maybeNodes = hoistableRoot.style),
+                      "function" === typeof maybeNodes.setProperty
+                        ? maybeNodes.setProperty("display", "none", "important")
+                        : (maybeNodes.display = "none"))
+                    : ((i = root.stateNode),
+                      (nextNode = root.memoizedProps.style),
+                      (nodeName =
+                        void 0 !== nextNode &&
+                        null !== nextNode &&
+                        nextNode.hasOwnProperty("display")
+                          ? nextNode.display
+                          : null),
+                      (i.style.display = dangerousStyleValue(
+                        "display",
+                        nodeName
+                      )));
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          } else if (6 === root.tag) {
+            if (null === current)
+              try {
+                root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
+              } catch (error$159) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error$159
+                );
+              }
+          } else if (
+            ((22 !== root.tag && 23 !== root.tag) ||
+              null === root.memoizedState ||
+              root === finishedWork) &&
+            null !== root.child
+          ) {
+            root.child.return = root;
+            root = root.child;
+            continue;
+          }
+          if (root === finishedWork) break a;
+          for (; null === root.sibling; ) {
+            if (null === root.return || root.return === finishedWork) break a;
+            current === root && (current = null);
+            root = root.return;
           }
-        try {
-          commitCallbacks(flags, finishedRoot);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          current === root && (current = null);
+          root.sibling.return = root.return;
+          root = root.sibling;
         }
-      }
-      break;
-    case 26:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    case 27:
-    case 5:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      null === current && flags & 4 && commitHostComponentMount(finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    case 12:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 &&
+        ((current = finishedWork.updateQueue),
+        null !== current &&
+          ((flags = current.wakeables),
+          null !== flags &&
+            ((current.wakeables = null),
+            attachSuspenseRetryListeners(finishedWork, flags))));
       break;
-    case 13:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+    case 19:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 4 &&
+        ((current = finishedWork.updateQueue),
+        null !== current &&
+          ((finishedWork.updateQueue = null),
+          attachSuspenseRetryListeners(finishedWork, current)));
       break;
-    case 22:
-      if (0 !== (finishedWork.mode & 1)) {
-        if (
-          ((prevProps =
-            null !== finishedWork.memoizedState || offscreenSubtreeIsHidden),
-          !prevProps)
-        ) {
-          current =
-            (null !== current && null !== current.memoizedState) ||
-            offscreenSubtreeWasHidden;
-          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
-            prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-          offscreenSubtreeIsHidden = prevProps;
-          (offscreenSubtreeWasHidden = current) &&
-          !prevOffscreenSubtreeWasHidden
-            ? recursivelyTraverseReappearLayoutEffects(
-                finishedRoot,
-                finishedWork,
-                0 !== (finishedWork.subtreeFlags & 8772)
-              )
-            : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-        }
-      } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    case 21:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
       flags & 512 &&
-        ("manual" === finishedWork.memoizedProps.mode
-          ? safelyAttachRef(finishedWork, finishedWork.return)
-          : safelyDetachRef(finishedWork, finishedWork.return));
+        (null !== current && safelyDetachRef(finishedWork, finishedWork.return),
+        safelyAttachRef(finishedWork, finishedWork.return));
+      flags & 4 && (finishedWork.stateNode[internalInstanceKey] = finishedWork);
       break;
     default:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-  }
-}
-function abortRootTransitions(
-  root,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance
-) {
-  if (enableTransitionTracing) {
-    var rootTransitions = root.incompleteTransitions;
-    deletedTransitions.forEach(function (transition) {
-      rootTransitions.has(transition) &&
-        ((transition = rootTransitions.get(transition)),
-        null === transition.aborts && (transition.aborts = []),
-        transition.aborts.push(abort),
-        null !== deletedOffscreenInstance &&
-          null !== transition.pendingBoundaries &&
-          transition.pendingBoundaries.has(deletedOffscreenInstance) &&
-          transition.pendingBoundaries.delete(deletedOffscreenInstance));
-    });
+      recursivelyTraverseMutationEffects(root, finishedWork),
+        commitReconciliationEffects(finishedWork);
   }
 }
-function abortTracingMarkerTransitions(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var markerInstance = abortedFiber.stateNode,
-      markerTransitions = markerInstance.transitions,
-      pendingBoundaries = markerInstance.pendingBoundaries;
-    null !== markerTransitions &&
-      deletedTransitions.forEach(function (transition) {
-        if (
-          null !== abortedFiber &&
-          markerTransitions.has(transition) &&
-          (null === markerInstance.aborts ||
-            !markerInstance.aborts.includes(abort)) &&
-          null !== markerInstance.transitions
-        ) {
-          if (null === markerInstance.aborts) {
-            markerInstance.aborts = [abort];
-            transition = abortedFiber.memoizedProps.name;
-            var transitions = markerInstance.transitions,
-              aborts = markerInstance.aborts;
-            enableTransitionTracing &&
-              (null === currentPendingTransitionCallbacks &&
-                (currentPendingTransitionCallbacks = {
-                  transitionStart: null,
-                  transitionProgress: null,
-                  transitionComplete: null,
-                  markerProgress: null,
-                  markerIncomplete: new Map(),
-                  markerComplete: null
-                }),
-              null === currentPendingTransitionCallbacks.markerIncomplete &&
-                (currentPendingTransitionCallbacks.markerIncomplete =
-                  new Map()),
-              currentPendingTransitionCallbacks.markerIncomplete.set(
-                transition,
-                { transitions: transitions, aborts: aborts }
-              ));
-          } else markerInstance.aborts.push(abort);
-          null !== deletedOffscreenInstance &&
-            !isInDeletedTree &&
-            null !== pendingBoundaries &&
-            pendingBoundaries.has(deletedOffscreenInstance) &&
-            (pendingBoundaries.delete(deletedOffscreenInstance),
-            addMarkerProgressCallbackToPendingTransition(
-              abortedFiber.memoizedProps.name,
-              deletedTransitions,
-              pendingBoundaries
-            ));
+function commitReconciliationEffects(finishedWork) {
+  var flags = finishedWork.flags;
+  if (flags & 2) {
+    try {
+      if (27 !== finishedWork.tag) {
+        b: {
+          for (var parent = finishedWork.return; null !== parent; ) {
+            if (isHostParent(parent)) {
+              var JSCompiler_inline_result = parent;
+              break b;
+            }
+            parent = parent.return;
+          }
+          throw Error(formatProdErrorMessage(160));
+        }
+        switch (JSCompiler_inline_result.tag) {
+          case 27:
+            var parent$jscomp$0 = JSCompiler_inline_result.stateNode,
+              before = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
+            break;
+          case 5:
+            var parent$160 = JSCompiler_inline_result.stateNode;
+            JSCompiler_inline_result.flags & 32 &&
+              (setTextContent(parent$160, ""),
+              (JSCompiler_inline_result.flags &= -33));
+            var before$161 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before$161, parent$160);
+            break;
+          case 3:
+          case 4:
+            var parent$162 = JSCompiler_inline_result.stateNode.containerInfo,
+              before$163 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNodeIntoContainer(
+              finishedWork,
+              before$163,
+              parent$162
+            );
+            break;
+          default:
+            throw Error(formatProdErrorMessage(161));
         }
-      });
-  }
-}
-function abortParentMarkerTransitionsForDeletedFiber(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing)
-    for (; null !== abortedFiber; ) {
-      switch (abortedFiber.tag) {
-        case 25:
-          abortTracingMarkerTransitions(
-            abortedFiber,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance,
-            isInDeletedTree
-          );
-          break;
-        case 3:
-          abortRootTransitions(
-            abortedFiber.stateNode,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance
-          );
       }
-      abortedFiber = abortedFiber.return;
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
+    finishedWork.flags &= -3;
+  }
+  flags & 4096 && (finishedWork.flags &= -4097);
 }
-function commitTransitionProgress(offscreenFiber) {
-  if (enableTransitionTracing) {
-    var offscreenInstance = offscreenFiber.stateNode,
-      prevState = null,
-      previousFiber = offscreenFiber.alternate;
-    null !== previousFiber &&
-      null !== previousFiber.memoizedState &&
-      (prevState = previousFiber.memoizedState);
-    prevState = null !== prevState;
-    previousFiber = null !== offscreenFiber.memoizedState;
-    var pendingMarkers = offscreenInstance._pendingMarkers,
-      name = null;
-    offscreenFiber = offscreenFiber.return;
-    null !== offscreenFiber &&
-      13 === offscreenFiber.tag &&
-      offscreenFiber.memoizedProps.unstable_name &&
-      (name = offscreenFiber.memoizedProps.unstable_name);
-    !prevState && previousFiber
-      ? null !== pendingMarkers &&
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries,
-            transitions = markerInstance.transitions,
-            markerName = markerInstance.name;
-          null === pendingBoundaries ||
-            pendingBoundaries.has(offscreenInstance) ||
-            (pendingBoundaries.set(offscreenInstance, { name: name }),
-            null !== transitions &&
-              (1 === markerInstance.tag && null !== markerName
-                ? addMarkerProgressCallbackToPendingTransition(
-                    markerName,
-                    transitions,
-                    pendingBoundaries
-                  )
-                : 0 === markerInstance.tag &&
-                  transitions.forEach(function (transition) {
-                    addTransitionProgressCallbackToPendingTransition(
-                      transition,
-                      pendingBoundaries
-                    );
-                  })));
-        })
-      : prevState &&
-        !previousFiber &&
-        null !== pendingMarkers &&
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries,
-            transitions = markerInstance.transitions,
-            markerName = markerInstance.name;
-          null !== pendingBoundaries &&
-            pendingBoundaries.has(offscreenInstance) &&
-            (pendingBoundaries.delete(offscreenInstance),
-            null !== transitions &&
-              (1 === markerInstance.tag && null !== markerName
-                ? (addMarkerProgressCallbackToPendingTransition(
-                    markerName,
-                    transitions,
-                    pendingBoundaries
-                  ),
-                  0 === pendingBoundaries.size &&
-                    (null === markerInstance.aborts &&
-                      addMarkerCompleteCallbackToPendingTransition(
-                        markerName,
-                        transitions
-                      ),
-                    (markerInstance.transitions = null),
-                    (markerInstance.pendingBoundaries = null),
-                    (markerInstance.aborts = null)))
-                : 0 === markerInstance.tag &&
-                  transitions.forEach(function (transition) {
-                    addTransitionProgressCallbackToPendingTransition(
-                      transition,
-                      pendingBoundaries
-                    );
-                  })));
-        });
+function recursivelyTraverseLayoutEffects(root, parentFiber) {
+  if (parentFiber.subtreeFlags & 8772)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber),
+        (parentFiber = parentFiber.sibling);
+}
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var finishedWork = parentFiber;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 14:
+      case 15:
+        commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 1:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        var instance = finishedWork.stateNode;
+        if ("function" === typeof instance.componentWillUnmount) {
+          var current = finishedWork,
+            nearestMountedAncestor = finishedWork.return;
+          try {
+            var current$jscomp$0 = current;
+            instance.props = current$jscomp$0.memoizedProps;
+            instance.state = current$jscomp$0.memoizedState;
+            instance.componentWillUnmount();
+          } catch (error) {
+            captureCommitPhaseError(current, nearestMountedAncestor, error);
+          }
+        }
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 26:
+      case 27:
+      case 5:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 22:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        null === finishedWork.memoizedState &&
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      default:
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+    }
+    parentFiber = parentFiber.sibling;
   }
 }
-function detachFiberAfterEffects(fiber) {
-  var alternate = fiber.alternate;
-  null !== alternate &&
-    ((fiber.alternate = null), detachFiberAfterEffects(alternate));
-  fiber.child = null;
-  fiber.deletions = null;
-  fiber.sibling = null;
-  5 === fiber.tag &&
-    ((alternate = fiber.stateNode),
-    null !== alternate && detachDeletedInstance(alternate));
-  fiber.stateNode = null;
-  fiber.return = null;
-  fiber.dependencies = null;
-  fiber.memoizedProps = null;
-  fiber.memoizedState = null;
-  fiber.pendingProps = null;
-  fiber.stateNode = null;
-  fiber.updateQueue = null;
+function recursivelyTraverseReappearLayoutEffects(
+  finishedRoot$jscomp$0,
+  parentFiber,
+  includeWorkInProgressEffects
+) {
+  includeWorkInProgressEffects =
+    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var current = parentFiber.alternate,
+      finishedRoot = finishedRoot$jscomp$0,
+      finishedWork = parentFiber,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        commitHookLayoutEffects(finishedWork, 4);
+        break;
+      case 1:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        finishedRoot = finishedWork.stateNode;
+        if ("function" === typeof finishedRoot.componentDidMount)
+          try {
+            finishedRoot.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        current = finishedWork.updateQueue;
+        if (null !== current) {
+          var hiddenCallbacks = current.shared.hiddenCallbacks;
+          if (null !== hiddenCallbacks)
+            for (
+              current.shared.hiddenCallbacks = null, current = 0;
+              current < hiddenCallbacks.length;
+              current++
+            )
+              callCallback(hiddenCallbacks[current], finishedRoot);
+        }
+        includeWorkInProgressEffects &&
+          flags & 64 &&
+          commitClassCallbacks(finishedWork);
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 26:
+      case 27:
+      case 5:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          null === current &&
+          flags & 4 &&
+          commitHostComponentMount(finishedWork);
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 12:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        break;
+      case 13:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 4 &&
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        break;
+      case 22:
+        null === finishedWork.memoizedState &&
+          recursivelyTraverseReappearLayoutEffects(
+            finishedRoot,
+            finishedWork,
+            includeWorkInProgressEffects
+          );
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      default:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+    }
+    parentFiber = parentFiber.sibling;
+  }
 }
-function isHostParent(fiber) {
-  return (
-    5 === fiber.tag ||
-    3 === fiber.tag ||
-    26 === fiber.tag ||
-    27 === fiber.tag ||
-    4 === fiber.tag
-  );
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  try {
+    commitHookEffectListMount(hookFlags, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
 }
-function getHostSibling(fiber) {
-  a: for (;;) {
-    for (; null === fiber.sibling; ) {
-      if (null === fiber.return || isHostParent(fiber.return)) return null;
-      fiber = fiber.return;
-    }
-    fiber.sibling.return = fiber.return;
-    for (
-      fiber = fiber.sibling;
-      5 !== fiber.tag &&
-      6 !== fiber.tag &&
-      27 !== fiber.tag &&
-      18 !== fiber.tag;
-
-    ) {
-      if (fiber.flags & 2) continue a;
-      if (null === fiber.child || 4 === fiber.tag) continue a;
-      else (fiber.child.return = fiber), (fiber = fiber.child);
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  var previousCache = null;
+  null !== current &&
+    null !== current.memoizedState &&
+    null !== current.memoizedState.cachePool &&
+    (previousCache = current.memoizedState.cachePool.pool);
+  current = null;
+  null !== finishedWork.memoizedState &&
+    null !== finishedWork.memoizedState.cachePool &&
+    (current = finishedWork.memoizedState.cachePool.pool);
+  current !== previousCache &&
+    (null != current && current.refCount++,
+    null != previousCache && releaseCache(previousCache));
+  if (enableTransitionTracing) {
+    current = finishedWork.updateQueue;
+    previousCache = null !== finishedWork.memoizedState;
+    if (null !== current) {
+      if (previousCache) {
+        var transitions = current.transitions;
+        null !== transitions &&
+          transitions.forEach(function (transition) {
+            null === instance._transitions &&
+              (instance._transitions = new Set());
+            instance._transitions.add(transition);
+          });
+        current = current.markerInstances;
+        null !== current &&
+          current.forEach(function (markerInstance) {
+            var markerTransitions = markerInstance.transitions;
+            null !== markerTransitions &&
+              markerTransitions.forEach(function (transition) {
+                null === instance._transitions
+                  ? (instance._transitions = new Set())
+                  : instance._transitions.has(transition) &&
+                    (null === markerInstance.pendingBoundaries &&
+                      (markerInstance.pendingBoundaries = new Map()),
+                    null === instance._pendingMarkers &&
+                      (instance._pendingMarkers = new Set()),
+                    instance._pendingMarkers.add(markerInstance));
+              });
+          });
+      }
+      finishedWork.updateQueue = null;
     }
-    if (!(fiber.flags & 2)) return fiber.stateNode;
+    commitTransitionProgress(finishedWork);
+    previousCache ||
+      ((instance._transitions = null), (instance._pendingMarkers = null));
   }
 }
-function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
-  var tag = node.tag;
-  if (5 === tag || 6 === tag)
-    (node = node.stateNode),
-      before
-        ? 8 === parent.nodeType
-          ? parent.parentNode.insertBefore(node, before)
-          : parent.insertBefore(node, before)
-        : (8 === parent.nodeType
-            ? ((before = parent.parentNode), before.insertBefore(node, parent))
-            : ((before = parent), before.appendChild(node)),
-          (parent = parent._reactRootContainer),
-          (null !== parent && void 0 !== parent) ||
-            null !== before.onclick ||
-            (before.onclick = noop$1));
-  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
-    for (
-      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
-        node = node.sibling;
-      null !== node;
-
-    )
-      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
-        (node = node.sibling);
+function commitCachePassiveMountEffect(current, finishedWork) {
+  current = null;
+  null !== finishedWork.alternate &&
+    (current = finishedWork.alternate.memoizedState.cache);
+  finishedWork = finishedWork.memoizedState.cache;
+  finishedWork !== current &&
+    (finishedWork.refCount++, null != current && releaseCache(current));
 }
-function insertOrAppendPlacementNode(node, before, parent) {
-  var tag = node.tag;
-  if (5 === tag || 6 === tag)
-    (node = node.stateNode),
-      before ? parent.insertBefore(node, before) : parent.appendChild(node);
-  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
-    for (
-      insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
-      null !== node;
-
-    )
-      insertOrAppendPlacementNode(node, before, parent), (node = node.sibling);
+function commitTracingMarkerPassiveMountEffect(finishedWork) {
+  var instance = finishedWork.stateNode;
+  null !== instance.transitions &&
+    null === instance.pendingBoundaries &&
+    (addMarkerCompleteCallbackToPendingTransition(
+      finishedWork.memoizedProps.name,
+      instance.transitions
+    ),
+    (instance.transitions = null),
+    (instance.pendingBoundaries = null),
+    (instance.aborts = null),
+    (instance.name = null));
 }
-var hostParent = null,
-  hostParentIsContainer = !1;
-function recursivelyTraverseDeletionEffects(
-  finishedRoot,
-  nearestMountedAncestor,
-  parent
+function recursivelyTraversePassiveMountEffects(
+  root,
+  parentFiber,
+  committedLanes,
+  committedTransitions
 ) {
-  for (parent = parent.child; null !== parent; )
-    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent),
-      (parent = parent.sibling);
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitPassiveMountOnFiber(
+        root,
+        parentFiber,
+        committedLanes,
+        committedTransitions
+      ),
+        (parentFiber = parentFiber.sibling);
 }
-function commitDeletionEffectsOnFiber(
+function commitPassiveMountOnFiber(
   finishedRoot,
-  nearestMountedAncestor,
-  deletedFiber
+  finishedWork,
+  committedLanes,
+  committedTransitions
 ) {
-  if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
-    try {
-      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
-    } catch (err) {}
-  switch (deletedFiber.tag) {
-    case 26:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      recursivelyTraverseDeletionEffects(
+  var flags = finishedWork.flags;
+  switch (finishedWork.tag) {
+    case 0:
+    case 11:
+    case 15:
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
-      deletedFiber.memoizedState
-        ? deletedFiber.memoizedState.count--
-        : deletedFiber.stateNode &&
-          ((deletedFiber = deletedFiber.stateNode),
-          deletedFiber.parentNode.removeChild(deletedFiber));
+      flags & 2048 && commitHookPassiveMountEffects(finishedWork, 9);
       break;
-    case 27:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      var prevHostParent = hostParent,
-        prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = deletedFiber.stateNode;
-      recursivelyTraverseDeletionEffects(
+    case 3:
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
-      deletedFiber = deletedFiber.stateNode;
-      for (finishedRoot = deletedFiber.attributes; finishedRoot.length; )
-        deletedFiber.removeAttributeNode(finishedRoot[0]);
-      detachDeletedInstance(deletedFiber);
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
+      if (flags & 2048) {
+        flags = null;
+        null !== finishedWork.alternate &&
+          (flags = finishedWork.alternate.memoizedState.cache);
+        var nextCache = finishedWork.memoizedState.cache;
+        nextCache !== flags &&
+          (nextCache.refCount++, null != flags && releaseCache(flags));
+        if (enableTransitionTracing) {
+          var incompleteTransitions =
+            finishedWork.stateNode.incompleteTransitions;
+          null !== committedTransitions &&
+            (committedTransitions.forEach(function (transition) {
+              enableTransitionTracing &&
+                (null === currentPendingTransitionCallbacks &&
+                  (currentPendingTransitionCallbacks = {
+                    transitionStart: [],
+                    transitionProgress: null,
+                    transitionComplete: null,
+                    markerProgress: null,
+                    markerIncomplete: null,
+                    markerComplete: null
+                  }),
+                null === currentPendingTransitionCallbacks.transitionStart &&
+                  (currentPendingTransitionCallbacks.transitionStart = []),
+                currentPendingTransitionCallbacks.transitionStart.push(
+                  transition
+                ));
+            }),
+            clearTransitionsForLanes(finishedRoot, committedLanes));
+          incompleteTransitions.forEach(function (markerInstance, transition) {
+            var pendingBoundaries = markerInstance.pendingBoundaries;
+            if (null === pendingBoundaries || 0 === pendingBoundaries.size)
+              null === markerInstance.aborts &&
+                enableTransitionTracing &&
+                (null === currentPendingTransitionCallbacks &&
+                  (currentPendingTransitionCallbacks = {
+                    transitionStart: null,
+                    transitionProgress: null,
+                    transitionComplete: [],
+                    markerProgress: null,
+                    markerIncomplete: null,
+                    markerComplete: null
+                  }),
+                null === currentPendingTransitionCallbacks.transitionComplete &&
+                  (currentPendingTransitionCallbacks.transitionComplete = []),
+                currentPendingTransitionCallbacks.transitionComplete.push(
+                  transition
+                )),
+                incompleteTransitions.delete(transition);
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
+        }
+      }
       break;
-    case 5:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-    case 6:
-      prevHostParent = hostParent;
-      prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = null;
-      recursivelyTraverseDeletionEffects(
+    case 23:
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
-      null !== hostParent &&
-        (hostParentIsContainer
-          ? ((finishedRoot = hostParent),
-            (deletedFiber = deletedFiber.stateNode),
-            8 === finishedRoot.nodeType
-              ? finishedRoot.parentNode.removeChild(deletedFiber)
-              : finishedRoot.removeChild(deletedFiber))
-          : hostParent.removeChild(deletedFiber.stateNode));
+      flags & 2048 &&
+        commitOffscreenPassiveMountEffects(
+          finishedWork.alternate,
+          finishedWork,
+          finishedWork.stateNode
+        );
       break;
-    case 18:
-      finishedRoot = finishedRoot.hydrationCallbacks;
-      null !== finishedRoot &&
-        (finishedRoot = finishedRoot.onDeleted) &&
-        finishedRoot(deletedFiber.stateNode);
-      null !== hostParent &&
-        (hostParentIsContainer
-          ? ((finishedRoot = hostParent),
-            (deletedFiber = deletedFiber.stateNode),
-            8 === finishedRoot.nodeType
-              ? clearSuspenseBoundary(finishedRoot.parentNode, deletedFiber)
-              : 1 === finishedRoot.nodeType &&
-                clearSuspenseBoundary(finishedRoot, deletedFiber),
-            retryIfBlockedOn(finishedRoot))
-          : clearSuspenseBoundary(hostParent, deletedFiber.stateNode));
+    case 22:
+      nextCache = finishedWork.stateNode;
+      null !== finishedWork.memoizedState
+        ? nextCache._visibility & 4
+          ? recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            )
+          : finishedWork.mode & 1
+          ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
+          : ((nextCache._visibility |= 4),
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            ))
+        : nextCache._visibility & 4
+        ? recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          )
+        : ((nextCache._visibility |= 4),
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            0 !== (finishedWork.subtreeFlags & 10256)
+          ));
+      flags & 2048 &&
+        commitOffscreenPassiveMountEffects(
+          finishedWork.alternate,
+          finishedWork,
+          nextCache
+        );
       break;
-    case 4:
-      prevHostParent = hostParent;
-      prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = deletedFiber.stateNode.containerInfo;
-      hostParentIsContainer = !0;
-      recursivelyTraverseDeletionEffects(
+    case 24:
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
+      flags & 2048 &&
+        commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
       break;
+    case 25:
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
+        break;
+      }
+    default:
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+  }
+}
+function recursivelyTraverseReconnectPassiveEffects(
+  finishedRoot$jscomp$0,
+  parentFiber,
+  committedLanes$jscomp$0,
+  committedTransitions$jscomp$0,
+  includeWorkInProgressEffects
+) {
+  includeWorkInProgressEffects =
+    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var finishedRoot = finishedRoot$jscomp$0,
+      finishedWork = parentFiber,
+      committedLanes = committedLanes$jscomp$0,
+      committedTransitions = committedTransitions$jscomp$0,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        commitHookPassiveMountEffects(finishedWork, 8);
+        break;
+      case 23:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitOffscreenPassiveMountEffects(
+            finishedWork.alternate,
+            finishedWork,
+            finishedWork.stateNode
+          );
+        break;
+      case 22:
+        var instance$188 = finishedWork.stateNode;
+        null !== finishedWork.memoizedState
+          ? instance$188._visibility & 4
+            ? recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              )
+            : finishedWork.mode & 1
+            ? recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              )
+            : ((instance$188._visibility |= 4),
+              recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              ))
+          : ((instance$188._visibility |= 4),
+            recursivelyTraverseReconnectPassiveEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions,
+              includeWorkInProgressEffects
+            ));
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitOffscreenPassiveMountEffects(
+            finishedWork.alternate,
+            finishedWork,
+            instance$188
+          );
+        break;
+      case 24:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+        break;
+      case 25:
+        if (enableTransitionTracing) {
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+          includeWorkInProgressEffects &&
+            flags & 2048 &&
+            commitTracingMarkerPassiveMountEffect(finishedWork);
+          break;
+        }
+      default:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+    }
+    parentFiber = parentFiber.sibling;
+  }
+}
+function recursivelyTraverseAtomicPassiveEffects(
+  finishedRoot$jscomp$0,
+  parentFiber
+) {
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 22:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 &&
+            commitOffscreenPassiveMountEffects(
+              finishedWork.alternate,
+              finishedWork,
+              finishedWork.stateNode
+            );
+          break;
+        case 24:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 &&
+            commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+}
+function detachAlternateSiblings(parentFiber) {
+  var previousFiber = parentFiber.alternate;
+  if (
+    null !== previousFiber &&
+    ((parentFiber = previousFiber.child), null !== parentFiber)
+  ) {
+    previousFiber.child = null;
+    do
+      (previousFiber = parentFiber.sibling),
+        (parentFiber.sibling = null),
+        (parentFiber = previousFiber);
+    while (null !== parentFiber);
+  }
+}
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (0 !== (parentFiber.flags & 16)) {
+    if (null !== deletions)
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
+    detachAlternateSiblings(parentFiber);
+  }
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitPassiveUnmountOnFiber(parentFiber),
+        (parentFiber = parentFiber.sibling);
+}
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
     case 0:
     case 11:
-    case 14:
     case 15:
-      if (
-        !offscreenSubtreeWasHidden &&
-        ((prevHostParent = deletedFiber.updateQueue),
-        null !== prevHostParent &&
-          ((prevHostParent = prevHostParent.lastEffect),
-          null !== prevHostParent))
-      ) {
-        prevHostParentIsContainer = prevHostParent = prevHostParent.next;
-        do {
-          var _effect = prevHostParentIsContainer,
-            destroy = _effect.destroy;
-          _effect = _effect.tag;
-          void 0 !== destroy &&
-            (0 !== (_effect & 2)
-              ? safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy)
-              : 0 !== (_effect & 4) &&
-                safelyCallDestroy(
-                  deletedFiber,
-                  nearestMountedAncestor,
-                  destroy
-                ));
-          prevHostParentIsContainer = prevHostParentIsContainer.next;
-        } while (prevHostParentIsContainer !== prevHostParent);
-      }
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      break;
-    case 1:
-      if (
-        !offscreenSubtreeWasHidden &&
-        (safelyDetachRef(deletedFiber, nearestMountedAncestor),
-        (prevHostParent = deletedFiber.stateNode),
-        "function" === typeof prevHostParent.componentWillUnmount)
-      )
-        try {
-          (prevHostParent.props = deletedFiber.memoizedProps),
-            (prevHostParent.state = deletedFiber.memoizedState),
-            prevHostParent.componentWillUnmount();
-        } catch (error) {
-          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
-        }
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      break;
-    case 21:
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
+      finishedWork.flags & 2048 &&
+        commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
       break;
     case 22:
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      deletedFiber.mode & 1
-        ? ((offscreenSubtreeWasHidden =
-            (prevHostParent = offscreenSubtreeWasHidden) ||
-            null !== deletedFiber.memoizedState),
-          recursivelyTraverseDeletionEffects(
-            finishedRoot,
-            nearestMountedAncestor,
-            deletedFiber
-          ),
-          (offscreenSubtreeWasHidden = prevHostParent))
-        : recursivelyTraverseDeletionEffects(
-            finishedRoot,
-            nearestMountedAncestor,
-            deletedFiber
-          );
+      var instance = finishedWork.stateNode;
+      null !== finishedWork.memoizedState &&
+      instance._visibility & 4 &&
+      (null === finishedWork.return || 13 !== finishedWork.return.tag)
+        ? ((instance._visibility &= -5),
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork))
+        : recursivelyTraversePassiveUnmountEffects(finishedWork);
       break;
     default:
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
   }
 }
-function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
-  if (null === finishedWork.memoizedState) {
-    var current = finishedWork.alternate;
-    if (
-      null !== current &&
-      ((current = current.memoizedState),
-      null !== current && ((current = current.dehydrated), null !== current))
-    )
-      try {
-        retryIfBlockedOn(current);
-        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
-        if (null !== hydrationCallbacks) {
-          var onHydrated = hydrationCallbacks.onHydrated;
-          onHydrated && onHydrated(current);
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (0 !== (parentFiber.flags & 16)) {
+    if (null !== deletions)
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
+    detachAlternateSiblings(parentFiber);
+  }
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    deletions = parentFiber;
+    switch (deletions.tag) {
+      case 0:
+      case 11:
+      case 15:
+        commitHookEffectListUnmount(8, deletions, deletions.return);
+        recursivelyTraverseDisconnectPassiveEffects(deletions);
+        break;
+      case 22:
+        i = deletions.stateNode;
+        i._visibility & 4 &&
+          ((i._visibility &= -5),
+          recursivelyTraverseDisconnectPassiveEffects(deletions));
+        break;
+      default:
+        recursivelyTraverseDisconnectPassiveEffects(deletions);
+    }
+    parentFiber = parentFiber.sibling;
+  }
+}
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+  deletedSubtreeRoot,
+  nearestMountedAncestor$jscomp$0
+) {
+  for (; null !== nextEffect; ) {
+    var fiber = nextEffect,
+      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
+    switch (fiber.tag) {
+      case 0:
+      case 11:
+      case 15:
+        commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
+        break;
+      case 23:
+      case 22:
+        null !== fiber.memoizedState &&
+          null !== fiber.memoizedState.cachePool &&
+          ((nearestMountedAncestor = fiber.memoizedState.cachePool.pool),
+          null != nearestMountedAncestor && nearestMountedAncestor.refCount++);
+        break;
+      case 13:
+        if (enableTransitionTracing) {
+          var offscreenFiber = fiber.child,
+            instance = offscreenFiber.stateNode,
+            transitions = instance._transitions;
+          if (null !== transitions) {
+            var abortReason = {
+              reason: "suspense",
+              name: fiber.memoizedProps.unstable_name || null
+            };
+            if (
+              null === fiber.memoizedState ||
+              null === fiber.memoizedState.dehydrated
+            )
+              abortParentMarkerTransitionsForDeletedFiber(
+                offscreenFiber,
+                abortReason,
+                transitions,
+                instance,
+                !0
+              ),
+                null !== nearestMountedAncestor &&
+                  abortParentMarkerTransitionsForDeletedFiber(
+                    nearestMountedAncestor,
+                    abortReason,
+                    transitions,
+                    instance,
+                    !1
+                  );
+          }
+        }
+        break;
+      case 24:
+        releaseCache(fiber.memoizedState.cache);
+        break;
+      case 25:
+        enableTransitionTracing &&
+          ((offscreenFiber = fiber.stateNode.transitions),
+          null !== offscreenFiber &&
+            ((instance = { reason: "marker", name: fiber.memoizedProps.name }),
+            abortParentMarkerTransitionsForDeletedFiber(
+              fiber,
+              instance,
+              offscreenFiber,
+              null,
+              !0
+            ),
+            null !== nearestMountedAncestor &&
+              abortParentMarkerTransitionsForDeletedFiber(
+                nearestMountedAncestor,
+                instance,
+                offscreenFiber,
+                null,
+                !1
+              )));
+    }
+    nearestMountedAncestor = fiber.child;
+    if (null !== nearestMountedAncestor)
+      (nearestMountedAncestor.return = fiber),
+        (nextEffect = nearestMountedAncestor);
+    else
+      a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
+        nearestMountedAncestor = nextEffect;
+        offscreenFiber = nearestMountedAncestor.sibling;
+        instance = nearestMountedAncestor.return;
+        detachFiberAfterEffects(nearestMountedAncestor);
+        if (nearestMountedAncestor === fiber) {
+          nextEffect = null;
+          break a;
         }
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        if (null !== offscreenFiber) {
+          offscreenFiber.return = instance;
+          nextEffect = offscreenFiber;
+          break a;
+        }
+        nextEffect = instance;
       }
   }
 }
-function getRetryCache(finishedWork) {
-  switch (finishedWork.tag) {
-    case 13:
-    case 19:
-      var retryCache = finishedWork.stateNode;
-      null === retryCache &&
-        (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
-      return retryCache;
-    case 22:
-      return (
-        (finishedWork = finishedWork.stateNode),
-        (retryCache = finishedWork._retryCache),
-        null === retryCache &&
-          (retryCache = finishedWork._retryCache = new PossiblyWeakSet()),
-        retryCache
-      );
-    default:
-      throw Error(formatProdErrorMessage(435, finishedWork.tag));
-  }
+var DefaultCacheDispatcher = {
+    getCacheSignal: function () {
+      return readContext(CacheContext).controller.signal;
+    },
+    getCacheForType: function (resourceType) {
+      var cache = readContext(CacheContext),
+        cacheForType = cache.data.get(resourceType);
+      void 0 === cacheForType &&
+        ((cacheForType = resourceType()),
+        cache.data.set(resourceType, cacheForType));
+      return cacheForType;
+    }
+  },
+  postPaintCallbackScheduled = !1,
+  callbacks = [];
+function schedulePostPaintCallback(callback) {
+  callbacks.push(callback);
+  postPaintCallbackScheduled ||
+    ((postPaintCallbackScheduled = !0),
+    requestPostPaintCallback(function (endTime) {
+      for (var i = 0; i < callbacks.length; i++) callbacks[i](endTime);
+      postPaintCallbackScheduled = !1;
+      callbacks = [];
+    }));
 }
-function detachOffscreenInstance(instance) {
-  var fiber = instance._current;
-  if (null === fiber) throw Error(formatProdErrorMessage(456));
-  if (0 === (instance._pendingVisibility & 2)) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    null !== root &&
-      ((instance._pendingVisibility |= 2),
-      scheduleUpdateOnFiber(root, fiber, 2, -1));
-  }
+var ceil = Math.ceil,
+  PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+  ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+  executionContext = 0,
+  workInProgressRoot = null,
+  workInProgress = null,
+  workInProgressRootRenderLanes = 0,
+  workInProgressSuspendedReason = 0,
+  workInProgressThrownValue = null,
+  workInProgressRootDidAttachPingListener = !1,
+  renderLanes = 0,
+  workInProgressRootExitStatus = 0,
+  workInProgressRootFatalError = null,
+  workInProgressRootSkippedLanes = 0,
+  workInProgressRootInterleavedUpdatedLanes = 0,
+  workInProgressRootPingedLanes = 0,
+  workInProgressRootConcurrentErrors = null,
+  workInProgressRootRecoverableErrors = null,
+  globalMostRecentFallbackTime = 0,
+  workInProgressRootRenderTargetTime = Infinity,
+  workInProgressTransitions = null,
+  currentPendingTransitionCallbacks = null,
+  currentEndTime = null;
+function addMarkerProgressCallbackToPendingTransition(
+  markerName,
+  transitions,
+  pendingBoundaries
+) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: new Map(),
+        markerIncomplete: null,
+        markerComplete: null
+      }),
+    null === currentPendingTransitionCallbacks.markerProgress &&
+      (currentPendingTransitionCallbacks.markerProgress = new Map()),
+    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
+      pendingBoundaries: pendingBoundaries,
+      transitions: transitions
+    }));
 }
-function attachOffscreenInstance(instance) {
-  var fiber = instance._current;
-  if (null === fiber) throw Error(formatProdErrorMessage(456));
-  if (0 !== (instance._pendingVisibility & 2)) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    null !== root &&
-      ((instance._pendingVisibility &= -3),
-      scheduleUpdateOnFiber(root, fiber, 2, -1));
-  }
+function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: new Map()
+      }),
+    null === currentPendingTransitionCallbacks.markerComplete &&
+      (currentPendingTransitionCallbacks.markerComplete = new Map()),
+    currentPendingTransitionCallbacks.markerComplete.set(
+      markerName,
+      transitions
+    ));
 }
-function attachSuspenseRetryListeners(finishedWork, wakeables) {
-  var retryCache = getRetryCache(finishedWork);
-  wakeables.forEach(function (wakeable) {
-    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
-    retryCache.has(wakeable) ||
-      (retryCache.add(wakeable), wakeable.then(retry, retry));
-  });
+function addTransitionProgressCallbackToPendingTransition(
+  transition,
+  boundaries
+) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: new Map(),
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      }),
+    null === currentPendingTransitionCallbacks.transitionProgress &&
+      (currentPendingTransitionCallbacks.transitionProgress = new Map()),
+    currentPendingTransitionCallbacks.transitionProgress.set(
+      transition,
+      boundaries
+    ));
 }
-function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (null !== deletions)
-    for (var i = 0; i < deletions.length; i++) {
-      var childToDelete = deletions[i];
-      try {
-        var root = root$jscomp$0,
-          returnFiber = parentFiber,
-          parent = returnFiber;
-        a: for (; null !== parent; ) {
-          switch (parent.tag) {
-            case 27:
-            case 5:
-              hostParent = parent.stateNode;
-              hostParentIsContainer = !1;
-              break a;
-            case 3:
-              hostParent = parent.stateNode.containerInfo;
-              hostParentIsContainer = !0;
-              break a;
-            case 4:
-              hostParent = parent.stateNode.containerInfo;
-              hostParentIsContainer = !0;
-              break a;
-          }
-          parent = parent.return;
-        }
-        if (null === hostParent) throw Error(formatProdErrorMessage(160));
-        commitDeletionEffectsOnFiber(root, returnFiber, childToDelete);
-        hostParent = null;
-        hostParentIsContainer = !1;
-        var alternate = childToDelete.alternate;
-        null !== alternate && (alternate.return = null);
-        childToDelete.return = null;
-      } catch (error) {
-        captureCommitPhaseError(childToDelete, parentFiber, error);
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now() + 500;
+}
+var hasUncaughtError = !1,
+  firstUncaughtError = null,
+  legacyErrorBoundariesThatAlreadyFailed = null,
+  rootDoesHavePassiveEffects = !1,
+  rootWithPendingPassiveEffects = null,
+  pendingPassiveEffectsLanes = 0,
+  pendingPassiveEffectsRemainingLanes = 0,
+  pendingPassiveTransitions = null,
+  nestedUpdateCount = 0,
+  rootWithNestedUpdates = null,
+  currentEventTime = -1,
+  currentEventTransitionLane = 0;
+function requestEventTime() {
+  return 0 !== (executionContext & 6)
+    ? now()
+    : -1 !== currentEventTime
+    ? currentEventTime
+    : (currentEventTime = now());
+}
+function requestUpdateLane(fiber) {
+  if (0 === (fiber.mode & 1)) return 2;
+  if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    0 !== (executionContext & 2) &&
+    0 !== workInProgressRootRenderLanes
+  )
+    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
+  if (null !== ReactCurrentBatchConfig$2.transition)
+    return (
+      0 === currentEventTransitionLane &&
+        (currentEventTransitionLane = claimNextTransitionLane()),
+      currentEventTransitionLane
+    );
+  fiber = currentUpdatePriority;
+  if (0 !== fiber) return fiber;
+  fiber = window.event;
+  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
+  return fiber;
+}
+function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+  2 === workInProgressSuspendedReason &&
+    root === workInProgressRoot &&
+    (prepareFreshStack(root, 0),
+    markRootSuspended(root, workInProgressRootRenderLanes));
+  markRootUpdated(root, lane, eventTime);
+  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig$1.transition;
+      if (
+        null !== transition &&
+        null != transition.name &&
+        (-1 === transition.startTime && (transition.startTime = now()),
+        enableTransitionTracing)
+      ) {
+        var transitionLanesMap = root.transitionLanes,
+          index$16 = 31 - clz32(lane),
+          transitions = transitionLanesMap[index$16];
+        null === transitions && (transitions = new Set());
+        transitions.add(transition);
+        transitionLanesMap[index$16] = transitions;
       }
     }
-  if (parentFiber.subtreeFlags & 12854)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitMutationEffectsOnFiber(parentFiber, root$jscomp$0),
-        (parentFiber = parentFiber.sibling);
+    if (root === workInProgressRoot) {
+      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
+        workInProgressRootInterleavedUpdatedLanes |= lane;
+      4 === workInProgressRootExitStatus &&
+        markRootSuspended(root, workInProgressRootRenderLanes);
+    }
+    ensureRootIsScheduled(root, eventTime);
+    2 === lane &&
+      0 === executionContext &&
+      0 === (fiber.mode & 1) &&
+      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
+  }
 }
-var currentHoistableRoot = null;
-function commitMutationEffectsOnFiber(finishedWork, root) {
-  var current = finishedWork.alternate,
-    flags = finishedWork.flags;
-  switch (finishedWork.tag) {
-    case 0:
-    case 11:
-    case 14:
-    case 15:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4) {
-        try {
-          commitHookEffectListUnmount(3, finishedWork, finishedWork.return),
-            commitHookEffectListMount(3, finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
-        try {
-          commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-        } catch (error$184) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$184);
-        }
-      }
-      break;
-    case 1:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      flags & 64 &&
-        offscreenSubtreeIsHidden &&
-        ((finishedWork = finishedWork.updateQueue),
-        null !== finishedWork &&
-          ((current = finishedWork.callbacks),
-          null !== current &&
-            ((flags = finishedWork.shared.hiddenCallbacks),
-            (finishedWork.shared.hiddenCallbacks =
-              null === flags ? current : flags.concat(current)))));
-      break;
-    case 26:
-      var hoistableRoot = currentHoistableRoot;
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      if (flags & 4)
-        if (
-          ((root = null !== current ? current.memoizedState : null),
-          (flags = finishedWork.memoizedState),
-          null === current)
-        )
-          if (null === flags)
-            if (null === finishedWork.stateNode) {
-              a: {
-                current = finishedWork.type;
-                flags = finishedWork.memoizedProps;
-                root = hoistableRoot.ownerDocument || hoistableRoot;
-                b: switch (current) {
-                  case "title":
-                    hoistableRoot = root.getElementsByTagName("title")[0];
-                    if (
-                      !hoistableRoot ||
-                      hoistableRoot[internalHoistableMarker] ||
-                      hoistableRoot[internalInstanceKey] ||
-                      "http://www.w3.org/2000/svg" ===
-                        hoistableRoot.namespaceURI ||
-                      hoistableRoot.hasAttribute("itemprop")
-                    )
-                      (hoistableRoot = root.createElement(current)),
-                        root.head.insertBefore(
-                          hoistableRoot,
-                          root.querySelector("head > title")
-                        );
-                    setInitialProperties(hoistableRoot, current, flags);
-                    hoistableRoot[internalInstanceKey] = finishedWork;
-                    markNodeAsHoistable(hoistableRoot);
-                    current = hoistableRoot;
-                    break a;
-                  case "link":
-                    var maybeNodes = getHydratableHoistableCache(
-                      "link",
-                      "href",
-                      root
-                    ).get(current + (flags.href || ""));
-                    if (maybeNodes)
-                      for (var i = 0; i < maybeNodes.length; i++)
-                        if (
-                          ((hoistableRoot = maybeNodes[i]),
-                          hoistableRoot.getAttribute("href") ===
-                            (null == flags.href ? null : flags.href) &&
-                            hoistableRoot.getAttribute("rel") ===
-                              (null == flags.rel ? null : flags.rel) &&
-                            hoistableRoot.getAttribute("title") ===
-                              (null == flags.title ? null : flags.title) &&
-                            hoistableRoot.getAttribute("crossorigin") ===
-                              (null == flags.crossOrigin
-                                ? null
-                                : flags.crossOrigin))
-                        ) {
-                          maybeNodes.splice(i, 1);
-                          break b;
-                        }
-                    hoistableRoot = root.createElement(current);
-                    setInitialProperties(hoistableRoot, current, flags);
-                    root.head.appendChild(hoistableRoot);
-                    break;
-                  case "meta":
-                    if (
-                      (maybeNodes = getHydratableHoistableCache(
-                        "meta",
-                        "content",
-                        root
-                      ).get(current + (flags.content || "")))
-                    )
-                      for (i = 0; i < maybeNodes.length; i++)
-                        if (
-                          ((hoistableRoot = maybeNodes[i]),
-                          hoistableRoot.getAttribute("content") ===
-                            (null == flags.content
-                              ? null
-                              : "" + flags.content) &&
-                            hoistableRoot.getAttribute("name") ===
-                              (null == flags.name ? null : flags.name) &&
-                            hoistableRoot.getAttribute("property") ===
-                              (null == flags.property
-                                ? null
-                                : flags.property) &&
-                            hoistableRoot.getAttribute("http-equiv") ===
-                              (null == flags.httpEquiv
-                                ? null
-                                : flags.httpEquiv) &&
-                            hoistableRoot.getAttribute("charset") ===
-                              (null == flags.charSet ? null : flags.charSet))
-                        ) {
-                          maybeNodes.splice(i, 1);
-                          break b;
-                        }
-                    hoistableRoot = root.createElement(current);
-                    setInitialProperties(hoistableRoot, current, flags);
-                    root.head.appendChild(hoistableRoot);
-                    break;
-                  default:
-                    throw Error(formatProdErrorMessage(468, current));
-                }
-                hoistableRoot[internalInstanceKey] = finishedWork;
-                markNodeAsHoistable(hoistableRoot);
-                current = hoistableRoot;
-              }
-              finishedWork.stateNode = current;
-            } else
-              mountHoistable(
-                hoistableRoot,
-                finishedWork.type,
-                finishedWork.stateNode
-              );
-          else
-            finishedWork.stateNode = acquireResource(
-              hoistableRoot,
-              flags,
-              finishedWork.memoizedProps
-            );
-        else if (root !== flags)
-          null === root
-            ? null !== current.stateNode &&
-              ((current = current.stateNode),
-              current.parentNode.removeChild(current))
-            : root.count--,
-            null === flags
-              ? mountHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.stateNode
-                )
-              : acquireResource(
-                  hoistableRoot,
-                  flags,
-                  finishedWork.memoizedProps
-                );
-        else if (
-          null === flags &&
-          null !== finishedWork.stateNode &&
-          ((flags = finishedWork.updateQueue),
-          (finishedWork.updateQueue = null),
-          null !== flags)
-        )
-          try {
-            var domElement = finishedWork.stateNode,
-              newProps = finishedWork.memoizedProps;
-            updateProperties(
-              domElement,
-              flags,
-              finishedWork.type,
-              current.memoizedProps,
-              newProps
+function ensureRootIsScheduled(root, currentTime) {
+  var existingCallbackNode = root.callbackNode;
+  markStarvedLanesAsExpired(root, currentTime);
+  var nextLanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+  );
+  if (0 === nextLanes)
+    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
+      (root.callbackNode = null),
+      (root.callbackPriority = 0);
+  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
+    (root.callbackPriority = 0), (root.callbackNode = null);
+  else if (
+    ((currentTime = nextLanes & -nextLanes),
+    root.callbackPriority !== currentTime)
+  ) {
+    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
+    if (0 !== (currentTime & 3))
+      0 === root.tag
+        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
+        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
+        scheduleMicrotask(function () {
+          0 === (executionContext & 6) && flushSyncCallbacks();
+        }),
+        (existingCallbackNode = null);
+    else {
+      switch (lanesToEventPriority(nextLanes)) {
+        case 2:
+          existingCallbackNode = ImmediatePriority;
+          break;
+        case 8:
+          existingCallbackNode = UserBlockingPriority;
+          break;
+        case 32:
+          existingCallbackNode = NormalPriority$1;
+          break;
+        case 536870912:
+          existingCallbackNode = IdlePriority;
+          break;
+        default:
+          existingCallbackNode = NormalPriority$1;
+      }
+      existingCallbackNode = scheduleCallback(
+        existingCallbackNode,
+        performConcurrentWorkOnRoot.bind(null, root)
+      );
+    }
+    root.callbackPriority = currentTime;
+    root.callbackNode = existingCallbackNode;
+  }
+}
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  currentEventTime = -1;
+  currentEventTransitionLane = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var originalCallbackNode = root.callbackNode;
+  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
+    return null;
+  var lanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+  );
+  if (0 === lanes) return null;
+  didTimeout =
+    includesBlockingLane(root, lanes) ||
+    0 !== (lanes & root.expiredLanes) ||
+    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
+      ? renderRootSync(root, lanes)
+      : renderRootConcurrent(root, lanes);
+  if (0 !== didTimeout) {
+    if (2 === didTimeout) {
+      var originallyAttemptedLanes = lanes,
+        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+          root,
+          originallyAttemptedLanes
+        );
+      0 !== errorRetryLanes &&
+        ((lanes = errorRetryLanes),
+        (didTimeout = recoverFromConcurrentError(
+          root,
+          originallyAttemptedLanes,
+          errorRetryLanes
+        )));
+    }
+    if (1 === didTimeout)
+      throw (
+        ((originalCallbackNode = workInProgressRootFatalError),
+        prepareFreshStack(root, 0),
+        markRootSuspended(root, lanes),
+        ensureRootIsScheduled(root, now()),
+        originalCallbackNode)
+      );
+    if (6 === didTimeout) markRootSuspended(root, lanes);
+    else {
+      errorRetryLanes = !includesBlockingLane(root, lanes);
+      originallyAttemptedLanes = root.current.alternate;
+      if (
+        errorRetryLanes &&
+        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
+      ) {
+        didTimeout = renderRootSync(root, lanes);
+        if (2 === didTimeout) {
+          errorRetryLanes = lanes;
+          var errorRetryLanes$197 = getLanesToRetrySynchronouslyOnError(
+            root,
+            errorRetryLanes
+          );
+          0 !== errorRetryLanes$197 &&
+            ((lanes = errorRetryLanes$197),
+            (didTimeout = recoverFromConcurrentError(
+              root,
+              errorRetryLanes,
+              errorRetryLanes$197
+            )));
+        }
+        if (1 === didTimeout)
+          throw (
+            ((originalCallbackNode = workInProgressRootFatalError),
+            prepareFreshStack(root, 0),
+            markRootSuspended(root, lanes),
+            ensureRootIsScheduled(root, now()),
+            originalCallbackNode)
+          );
+      }
+      root.finishedWork = originallyAttemptedLanes;
+      root.finishedLanes = lanes;
+      switch (didTimeout) {
+        case 0:
+        case 1:
+          throw Error(formatProdErrorMessage(345));
+        case 2:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 3:
+          markRootSuspended(root, lanes);
+          if (
+            (lanes & 125829120) === lanes &&
+            ((lanes = globalMostRecentFallbackTime + 500 - now()), 10 < lanes)
+          ) {
+            if (0 !== getNextLanes(root, 0)) break;
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
             );
-            domElement[internalPropsKey] = newProps;
-          } catch (error$185) {
-            captureCommitPhaseError(
-              finishedWork,
-              finishedWork.return,
-              error$185
+            break;
+          }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 4:
+          markRootSuspended(root, lanes);
+          if ((lanes & 8388480) === lanes) break;
+          didTimeout = root.eventTimes;
+          for (originallyAttemptedLanes = -1; 0 < lanes; )
+            (errorRetryLanes$197 = 31 - clz32(lanes)),
+              (errorRetryLanes = 1 << errorRetryLanes$197),
+              (errorRetryLanes$197 = didTimeout[errorRetryLanes$197]),
+              errorRetryLanes$197 > originallyAttemptedLanes &&
+                (originallyAttemptedLanes = errorRetryLanes$197),
+              (lanes &= ~errorRetryLanes);
+          lanes = originallyAttemptedLanes;
+          lanes = now() - lanes;
+          lanes =
+            (120 > lanes
+              ? 120
+              : 480 > lanes
+              ? 480
+              : 1080 > lanes
+              ? 1080
+              : 1920 > lanes
+              ? 1920
+              : 3e3 > lanes
+              ? 3e3
+              : 4320 > lanes
+              ? 4320
+              : 1960 * ceil(lanes / 1960)) - lanes;
+          if (10 < lanes) {
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
             );
+            break;
           }
-      break;
-    case 27:
-      if (flags & 4 && null === finishedWork.alternate) {
-        hoistableRoot = finishedWork.stateNode;
-        maybeNodes = finishedWork.memoizedProps;
-        for (i = hoistableRoot.firstChild; i; ) {
-          var nextNode = i.nextSibling,
-            nodeName = i.nodeName;
-          i[internalHoistableMarker] ||
-            "HEAD" === nodeName ||
-            "BODY" === nodeName ||
-            "STYLE" === nodeName ||
-            ("LINK" === nodeName && "stylesheet" === i.rel.toLowerCase()) ||
-            hoistableRoot.removeChild(i);
-          i = nextNode;
-        }
-        i = finishedWork.type;
-        for (nextNode = hoistableRoot.attributes; nextNode.length; )
-          hoistableRoot.removeAttributeNode(nextNode[0]);
-        setInitialProperties(hoistableRoot, i, maybeNodes);
-        hoistableRoot[internalInstanceKey] = finishedWork;
-        hoistableRoot[internalPropsKey] = maybeNodes;
-      }
-    case 5:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      if (finishedWork.flags & 32) {
-        root = finishedWork.stateNode;
-        try {
-          setTextContent(root, "");
-        } catch (error$186) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$186);
-        }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 5:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        default:
+          throw Error(formatProdErrorMessage(329));
       }
+    }
+  }
+  ensureRootIsScheduled(root, now());
+  return root.callbackNode === originalCallbackNode
+    ? performConcurrentWorkOnRoot.bind(null, root)
+    : null;
+}
+function recoverFromConcurrentError(
+  root,
+  originallyAttemptedLanes,
+  errorRetryLanes
+) {
+  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
+    wasRootDehydrated = root.current.memoizedState.isDehydrated;
+  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
+  errorRetryLanes = renderRootSync(root, errorRetryLanes);
+  if (2 !== errorRetryLanes) {
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
+      return (
+        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
+        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
+        4
+      );
+    root = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
+    null !== root && queueRecoverableErrors(root);
+  }
+  return errorRetryLanes;
+}
+function queueRecoverableErrors(errors) {
+  null === workInProgressRootRecoverableErrors
+    ? (workInProgressRootRecoverableErrors = errors)
+    : workInProgressRootRecoverableErrors.push.apply(
+        workInProgressRootRecoverableErrors,
+        errors
+      );
+}
+function isRenderConsistentWithExternalStores(finishedWork) {
+  for (var node = finishedWork; ; ) {
+    if (node.flags & 16384) {
+      var updateQueue = node.updateQueue;
       if (
-        flags & 4 &&
-        ((flags = finishedWork.stateNode),
-        null != flags &&
-          ((root = finishedWork.memoizedProps),
-          (current = null !== current ? current.memoizedProps : root),
-          (hoistableRoot = finishedWork.type),
-          (maybeNodes = finishedWork.updateQueue),
-          (finishedWork.updateQueue = null),
-          null !== maybeNodes))
+        null !== updateQueue &&
+        ((updateQueue = updateQueue.stores), null !== updateQueue)
       )
-        try {
-          updateProperties(flags, maybeNodes, hoistableRoot, current, root),
-            (flags[internalPropsKey] = root);
-        } catch (error$189) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$189);
-        }
-      break;
-    case 6:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4) {
-        if (null === finishedWork.stateNode)
-          throw Error(formatProdErrorMessage(162));
-        current = finishedWork.stateNode;
-        flags = finishedWork.memoizedProps;
-        try {
-          current.nodeValue = flags;
-        } catch (error$190) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$190);
+        for (var i = 0; i < updateQueue.length; i++) {
+          var check = updateQueue[i],
+            getSnapshot = check.getSnapshot;
+          check = check.value;
+          try {
+            if (!objectIs(getSnapshot(), check)) return !1;
+          } catch (error) {
+            return !1;
+          }
         }
+    }
+    updateQueue = node.child;
+    if (node.subtreeFlags & 16384 && null !== updateQueue)
+      (updateQueue.return = node), (node = updateQueue);
+    else {
+      if (node === finishedWork) break;
+      for (; null === node.sibling; ) {
+        if (null === node.return || node.return === finishedWork) return !0;
+        node = node.return;
       }
-      break;
-    case 3:
-      tagCaches = null;
-      hoistableRoot = currentHoistableRoot;
-      currentHoistableRoot = getHoistableRoot(root.containerInfo);
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      currentHoistableRoot = hoistableRoot;
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
-        try {
-          retryIfBlockedOn(root.containerInfo);
-        } catch (error$191) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$191);
-        }
-      break;
-    case 4:
-      current = currentHoistableRoot;
-      currentHoistableRoot = getHoistableRoot(
-        finishedWork.stateNode.containerInfo
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+  return !0;
+}
+function markRootSuspended(root, suspendedLanes) {
+  suspendedLanes &= ~workInProgressRootPingedLanes;
+  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes;
+  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
+    var index$13 = 31 - clz32(suspendedLanes),
+      lane = 1 << index$13;
+    root[index$13] = -1;
+    suspendedLanes &= ~lane;
+  }
+}
+function performSyncWorkOnRoot(root) {
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  flushPassiveEffects();
+  var lanes = getNextLanes(root, 0);
+  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now()), null;
+  var exitStatus = renderRootSync(root, lanes);
+  if (0 !== root.tag && 2 === exitStatus) {
+    var originallyAttemptedLanes = lanes,
+      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+        root,
+        originallyAttemptedLanes
       );
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      currentHoistableRoot = current;
-      break;
-    case 13:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      current = finishedWork.child;
-      current.flags & 8192 &&
-        null !== current.memoizedState &&
-        (null === current.alternate ||
-          null === current.alternate.memoizedState) &&
-        (globalMostRecentFallbackTime = now());
-      if (flags & 4) {
-        try {
-          if (null !== finishedWork.memoizedState) {
-            var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
-            if ("function" === typeof suspenseCallback) {
-              var wakeables = finishedWork.updateQueue;
-              null !== wakeables && suspenseCallback(new Set(wakeables));
-            }
-          }
-        } catch (error$193) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$193);
+    0 !== errorRetryLanes &&
+      ((lanes = errorRetryLanes),
+      (exitStatus = recoverFromConcurrentError(
+        root,
+        originallyAttemptedLanes,
+        errorRetryLanes
+      )));
+  }
+  if (1 === exitStatus)
+    throw (
+      ((exitStatus = workInProgressRootFatalError),
+      prepareFreshStack(root, 0),
+      markRootSuspended(root, lanes),
+      ensureRootIsScheduled(root, now()),
+      exitStatus)
+    );
+  if (6 === exitStatus)
+    return (
+      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now()), null
+    );
+  root.finishedWork = root.current.alternate;
+  root.finishedLanes = lanes;
+  commitRoot(
+    root,
+    workInProgressRootRecoverableErrors,
+    workInProgressTransitions
+  );
+  ensureRootIsScheduled(root, now());
+  return null;
+}
+function batchedUpdates$1(fn, a) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  try {
+    return fn(a);
+  } finally {
+    (executionContext = prevExecutionContext),
+      0 === executionContext &&
+        (resetRenderTimer(),
+        includesLegacySyncCallbacks && flushSyncCallbacks());
+  }
+}
+function flushSync$1(fn) {
+  null !== rootWithPendingPassiveEffects &&
+    0 === rootWithPendingPassiveEffects.tag &&
+    0 === (executionContext & 6) &&
+    flushPassiveEffects();
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
+    previousPriority = currentUpdatePriority;
+  try {
+    if (
+      ((ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      fn)
+    )
+      return fn();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (executionContext = prevExecutionContext),
+      0 === (executionContext & 6) && flushSyncCallbacks();
+  }
+}
+function resetWorkInProgressStack() {
+  if (null !== workInProgress) {
+    if (0 === workInProgressSuspendedReason)
+      var interruptedWork = workInProgress.return;
+    else
+      resetContextDependencies(),
+        resetHooksOnUnwind(),
+        (thenableState$1 = null),
+        (thenableIndexCounter$1 = 0),
+        (interruptedWork = workInProgress);
+    for (; null !== interruptedWork; )
+      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
+        (interruptedWork = interruptedWork.return);
+    workInProgress = null;
+  }
+}
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  var timeoutHandle = root.timeoutHandle;
+  -1 !== timeoutHandle &&
+    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  workInProgress = root = createWorkInProgress(root.current, null);
+  workInProgressRootRenderLanes = renderLanes = lanes;
+  workInProgressSuspendedReason = 0;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = !1;
+  workInProgressRootExitStatus = 0;
+  workInProgressRootFatalError = null;
+  workInProgressRootPingedLanes =
+    workInProgressRootInterleavedUpdatedLanes =
+    workInProgressRootSkippedLanes =
+      0;
+  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
+    null;
+  finishQueueingConcurrentUpdates();
+  return root;
+}
+function handleThrow(root, thrownValue) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  ReactCurrentOwner.current = null;
+  if (thrownValue === SuspenseException) {
+    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
+    root = suspendedThenable;
+    suspendedThenable = null;
+    thrownValue = root;
+    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
+      ? 2
+      : 3;
+  } else
+    workInProgressSuspendedReason =
+      thrownValue === SelectiveHydrationException
+        ? 6
+        : null !== thrownValue &&
+          "object" === typeof thrownValue &&
+          "function" === typeof thrownValue.then
+        ? 4
+        : 1;
+  workInProgressThrownValue = thrownValue;
+  null === workInProgress &&
+    ((workInProgressRootExitStatus = 1),
+    (workInProgressRootFatalError = thrownValue));
+}
+function shouldAttemptToSuspendUntilDataResolves() {
+  if (
+    0 !== (workInProgressRootSkippedLanes & 268435455) ||
+    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
+  )
+    return !1;
+  if (
+    (workInProgressRootRenderLanes & 8388480) ===
+    workInProgressRootRenderLanes
+  )
+    return null === shellBoundary;
+  var handler = suspenseHandlerStackCursor.current;
+  return null !== handler &&
+    (workInProgressRootRenderLanes & 125829120) ===
+      workInProgressRootRenderLanes
+    ? handler === shellBoundary
+    : !1;
+}
+function pushDispatcher(container) {
+  container = getHoistableRoot(container);
+  lastCurrentDocument = container.ownerDocument || container;
+  previousDispatcher = Dispatcher$1.current;
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  container = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+  return null === container ? ContextOnlyDispatcher : container;
+}
+function pushCacheDispatcher() {
+  var prevCacheDispatcher = ReactCurrentCache.current;
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  return prevCacheDispatcher;
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = 4;
+  null === workInProgressRoot ||
+    (0 === (workInProgressRootSkippedLanes & 268435455) &&
+      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+}
+function renderRootSync(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      prepareFreshStack(root, lanes);
+  a: do
+    try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            (workInProgressSuspendedReason = 0),
+              (workInProgressThrownValue = null),
+              unwindSuspendedUnitOfWork(lanes, thrownValue);
         }
-        current = finishedWork.updateQueue;
-        null !== current &&
-          ((finishedWork.updateQueue = null),
-          attachSuspenseRetryListeners(finishedWork, current));
       }
+      workLoopSync();
       break;
-    case 22:
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      domElement = null !== finishedWork.memoizedState;
-      newProps = null !== current && null !== current.memoizedState;
-      finishedWork.mode & 1
-        ? ((suspenseCallback = offscreenSubtreeIsHidden),
-          (wakeables = offscreenSubtreeWasHidden),
-          (offscreenSubtreeIsHidden = suspenseCallback || domElement),
-          (offscreenSubtreeWasHidden = wakeables || newProps),
-          recursivelyTraverseMutationEffects(root, finishedWork),
-          (offscreenSubtreeWasHidden = wakeables),
-          (offscreenSubtreeIsHidden = suspenseCallback))
-        : recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      root = finishedWork.stateNode;
-      root._current = finishedWork;
-      root._visibility &= -3;
-      root._visibility |= root._pendingVisibility & 2;
-      if (
-        flags & 8192 &&
-        ((root._visibility = domElement
-          ? root._visibility & -2
-          : root._visibility | 1),
-        domElement &&
-          ((root = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden),
-          null === current ||
-            newProps ||
-            root ||
-            (0 !== (finishedWork.mode & 1) &&
-              recursivelyTraverseDisappearLayoutEffects(finishedWork))),
-        null === finishedWork.memoizedProps ||
-          "manual" !== finishedWork.memoizedProps.mode)
-      )
-        a: for (current = null, root = finishedWork; ; ) {
-          if (5 === root.tag || 26 === root.tag || 27 === root.tag) {
-            if (null === current) {
-              current = root;
-              try {
-                (hoistableRoot = root.stateNode),
-                  domElement
-                    ? ((maybeNodes = hoistableRoot.style),
-                      "function" === typeof maybeNodes.setProperty
-                        ? maybeNodes.setProperty("display", "none", "important")
-                        : (maybeNodes.display = "none"))
-                    : ((i = root.stateNode),
-                      (nextNode = root.memoizedProps.style),
-                      (nodeName =
-                        void 0 !== nextNode &&
-                        null !== nextNode &&
-                        nextNode.hasOwnProperty("display")
-                          ? nextNode.display
-                          : null),
-                      (i.style.display = dangerousStyleValue(
-                        "display",
-                        nodeName
-                      )));
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          } else if (6 === root.tag) {
-            if (null === current)
-              try {
-                root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
-              } catch (error$174) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error$174
-                );
-              }
-          } else if (
-            ((22 !== root.tag && 23 !== root.tag) ||
-              null === root.memoizedState ||
-              root === finishedWork) &&
-            null !== root.child
-          ) {
-            root.child.return = root;
-            root = root.child;
-            continue;
-          }
-          if (root === finishedWork) break a;
-          for (; null === root.sibling; ) {
-            if (null === root.return || root.return === finishedWork) break a;
-            current === root && (current = null);
-            root = root.return;
-          }
-          current === root && (current = null);
-          root.sibling.return = root.return;
-          root = root.sibling;
-        }
-      flags & 4 &&
-        ((current = finishedWork.updateQueue),
-        null !== current &&
-          ((flags = current.wakeables),
-          null !== flags &&
-            ((current.wakeables = null),
-            attachSuspenseRetryListeners(finishedWork, flags))));
-      break;
-    case 19:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 4 &&
-        ((current = finishedWork.updateQueue),
-        null !== current &&
-          ((finishedWork.updateQueue = null),
-          attachSuspenseRetryListeners(finishedWork, current)));
-      break;
-    case 21:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        (null !== current && safelyDetachRef(finishedWork, finishedWork.return),
-        safelyAttachRef(finishedWork, finishedWork.return));
-      flags & 4 && (finishedWork.stateNode[internalInstanceKey] = finishedWork);
-      break;
-    default:
-      recursivelyTraverseMutationEffects(root, finishedWork),
-        commitReconciliationEffects(finishedWork);
-  }
+    } catch (thrownValue$200) {
+      handleThrow(root, thrownValue$200);
+    }
+  while (1);
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
 }
-function commitReconciliationEffects(finishedWork) {
-  var flags = finishedWork.flags;
-  if (flags & 2) {
+function workLoopSync() {
+  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+}
+function renderRootConcurrent(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      resetRenderTimer(),
+      prepareFreshStack(root, lanes);
+  a: do
     try {
-      if (27 !== finishedWork.tag) {
-        b: {
-          for (var parent = finishedWork.return; null !== parent; ) {
-            if (isHostParent(parent)) {
-              var JSCompiler_inline_result = parent;
-              break b;
-            }
-            parent = parent.return;
-          }
-          throw Error(formatProdErrorMessage(160));
-        }
-        switch (JSCompiler_inline_result.tag) {
-          case 27:
-            var parent$jscomp$0 = JSCompiler_inline_result.stateNode,
-              before = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 1:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, thrownValue);
             break;
+          case 2:
+            if (isThenableResolved(thrownValue)) {
+              workInProgressSuspendedReason = 0;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
+            }
+            lanes = function () {
+              2 === workInProgressSuspendedReason &&
+                workInProgressRoot === root &&
+                (workInProgressSuspendedReason = 5);
+              ensureRootIsScheduled(root, now());
+            };
+            thrownValue.then(lanes, lanes);
+            break a;
+          case 3:
+            workInProgressSuspendedReason = 5;
+            break a;
           case 5:
-            var parent$175 = JSCompiler_inline_result.stateNode;
-            JSCompiler_inline_result.flags & 32 &&
-              (setTextContent(parent$175, ""),
-              (JSCompiler_inline_result.flags &= -33));
-            var before$176 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before$176, parent$175);
+            isThenableResolved(thrownValue)
+              ? ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                replaySuspendedUnitOfWork(lanes))
+              : ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                unwindSuspendedUnitOfWork(lanes, thrownValue));
             break;
-          case 3:
           case 4:
-            var parent$177 = JSCompiler_inline_result.stateNode.containerInfo,
-              before$178 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNodeIntoContainer(
-              finishedWork,
-              before$178,
-              parent$177
-            );
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, thrownValue);
             break;
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
           default:
-            throw Error(formatProdErrorMessage(161));
+            throw Error(formatProdErrorMessage(462));
         }
       }
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      workLoopConcurrent();
+      break;
+    } catch (thrownValue$202) {
+      handleThrow(root, thrownValue$202);
     }
-    finishedWork.flags &= -3;
-  }
-  flags & 4096 && (finishedWork.flags &= -4097);
+  while (1);
+  resetContextDependencies();
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  executionContext = prevExecutionContext;
+  if (null !== workInProgress) return 0;
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
 }
-function recursivelyTraverseLayoutEffects(root, parentFiber) {
-  if (parentFiber.subtreeFlags & 8772)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber),
-        (parentFiber = parentFiber.sibling);
+function workLoopConcurrent() {
+  for (; null !== workInProgress && !shouldYield(); )
+    performUnitOfWork(workInProgress);
 }
-function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var finishedWork = parentFiber;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 14:
-      case 15:
-        commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 1:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        var instance = finishedWork.stateNode;
-        if ("function" === typeof instance.componentWillUnmount) {
-          var current = finishedWork,
-            nearestMountedAncestor = finishedWork.return;
-          try {
-            var current$jscomp$0 = current;
-            instance.props = current$jscomp$0.memoizedProps;
-            instance.state = current$jscomp$0.memoizedState;
-            instance.componentWillUnmount();
-          } catch (error) {
-            captureCommitPhaseError(current, nearestMountedAncestor, error);
-          }
-        }
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 26:
-      case 27:
-      case 5:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 22:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        null === finishedWork.memoizedState &&
-          recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      default:
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-    }
-    parentFiber = parentFiber.sibling;
+function performUnitOfWork(unitOfWork) {
+  var next = beginWork(unitOfWork.alternate, unitOfWork, renderLanes);
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === next ? completeUnitOfWork(unitOfWork) : (workInProgress = next);
+  ReactCurrentOwner.current = null;
+}
+function replaySuspendedUnitOfWork(unitOfWork) {
+  var current = unitOfWork.alternate;
+  switch (unitOfWork.tag) {
+    case 2:
+      unitOfWork.tag = 0;
+    case 0:
+    case 11:
+      var Component = unitOfWork.type,
+        unresolvedProps = unitOfWork.pendingProps;
+      unresolvedProps =
+        unitOfWork.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unresolvedProps,
+        Component,
+        workInProgressRootRenderLanes
+      );
+      break;
+    case 15:
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unitOfWork.pendingProps,
+        unitOfWork.type,
+        workInProgressRootRenderLanes
+      );
+      break;
+    default:
+      unwindInterruptedWork(current, unitOfWork),
+        (unitOfWork = workInProgress =
+          resetWorkInProgress(unitOfWork, renderLanes)),
+        (current = beginWork(current, unitOfWork, renderLanes));
   }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === current
+    ? completeUnitOfWork(unitOfWork)
+    : (workInProgress = current);
+  ReactCurrentOwner.current = null;
 }
-function recursivelyTraverseReappearLayoutEffects(
-  finishedRoot$jscomp$0,
-  parentFiber,
-  includeWorkInProgressEffects
-) {
-  includeWorkInProgressEffects =
-    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var current = parentFiber.alternate,
-      finishedRoot = finishedRoot$jscomp$0,
-      finishedWork = parentFiber,
-      flags = finishedWork.flags;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 15:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        commitHookLayoutEffects(finishedWork, 4);
-        break;
-      case 1:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        finishedRoot = finishedWork.stateNode;
-        if ("function" === typeof finishedRoot.componentDidMount)
-          try {
-            finishedRoot.componentDidMount();
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        current = finishedWork.updateQueue;
-        if (null !== current) {
-          var hiddenCallbacks = current.shared.hiddenCallbacks;
-          if (null !== hiddenCallbacks)
-            for (
-              current.shared.hiddenCallbacks = null, current = 0;
-              current < hiddenCallbacks.length;
-              current++
-            )
-              callCallback(hiddenCallbacks[current], finishedRoot);
-        }
-        includeWorkInProgressEffects &&
-          flags & 64 &&
-          commitClassCallbacks(finishedWork);
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      case 26:
-      case 27:
-      case 5:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        includeWorkInProgressEffects &&
-          null === current &&
-          flags & 4 &&
-          commitHostComponentMount(finishedWork);
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      case 12:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        break;
-      case 13:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        includeWorkInProgressEffects &&
-          flags & 4 &&
-          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
-        break;
-      case 22:
-        null === finishedWork.memoizedState &&
-          recursivelyTraverseReappearLayoutEffects(
-            finishedRoot,
-            finishedWork,
-            includeWorkInProgressEffects
+function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
+  resetContextDependencies();
+  resetHooksOnUnwind();
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+  var returnFiber = unitOfWork.return;
+  if (null === returnFiber || null === workInProgressRoot)
+    (workInProgressRootExitStatus = 1),
+      (workInProgressRootFatalError = thrownValue),
+      (workInProgress = null);
+  else {
+    try {
+      a: {
+        var root = workInProgressRoot,
+          value = thrownValue;
+        thrownValue = workInProgressRootRenderLanes;
+        unitOfWork.flags |= 32768;
+        if (
+          null !== value &&
+          "object" === typeof value &&
+          "function" === typeof value.then
+        ) {
+          var wakeable = value;
+          if (enableLazyContextPropagation) {
+            var currentSourceFiber = unitOfWork.alternate;
+            null !== currentSourceFiber &&
+              propagateParentContextChanges(
+                currentSourceFiber,
+                unitOfWork,
+                thrownValue,
+                !0
+              );
+          }
+          var tag = unitOfWork.tag;
+          if (
+            0 === (unitOfWork.mode & 1) &&
+            (0 === tag || 11 === tag || 15 === tag)
+          ) {
+            var currentSource = unitOfWork.alternate;
+            currentSource
+              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
+                (unitOfWork.memoizedState = currentSource.memoizedState),
+                (unitOfWork.lanes = currentSource.lanes))
+              : ((unitOfWork.updateQueue = null),
+                (unitOfWork.memoizedState = null));
+          }
+          var suspenseBoundary = suspenseHandlerStackCursor.current;
+          if (null !== suspenseBoundary) {
+            switch (suspenseBoundary.tag) {
+              case 13:
+                unitOfWork.mode & 1 &&
+                  (null === shellBoundary
+                    ? renderDidSuspendDelayIfPossible()
+                    : null === suspenseBoundary.alternate &&
+                      0 === workInProgressRootExitStatus &&
+                      (workInProgressRootExitStatus = 3));
+                suspenseBoundary.flags &= -257;
+                markSuspenseBoundaryShouldCapture(
+                  suspenseBoundary,
+                  returnFiber,
+                  unitOfWork,
+                  root,
+                  thrownValue
+                );
+                var wakeables = suspenseBoundary.updateQueue;
+                null === wakeables
+                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
+                  : wakeables.add(wakeable);
+                break;
+              case 22:
+                if (suspenseBoundary.mode & 1) {
+                  suspenseBoundary.flags |= 65536;
+                  var offscreenQueue = suspenseBoundary.updateQueue;
+                  if (null === offscreenQueue) {
+                    var newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      wakeables: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    var wakeables$84 = offscreenQueue.wakeables;
+                    null === wakeables$84
+                      ? (offscreenQueue.wakeables = new Set([wakeable]))
+                      : wakeables$84.add(wakeable);
+                  }
+                  break;
+                }
+              default:
+                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+            }
+            suspenseBoundary.mode & 1 &&
+              attachPingListener(root, wakeable, thrownValue);
+            break a;
+          } else if (1 === root.tag) {
+            attachPingListener(root, wakeable, thrownValue);
+            renderDidSuspendDelayIfPossible();
+            break a;
+          } else value = Error(formatProdErrorMessage(426));
+        } else if (
+          isHydrating &&
+          unitOfWork.mode & 1 &&
+          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
+        ) {
+          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
+          markSuspenseBoundaryShouldCapture(
+            wakeable,
+            returnFiber,
+            unitOfWork,
+            root,
+            thrownValue
           );
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      default:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
+          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
+          break a;
+        }
+        root = value = createCapturedValueAtFiber(value, unitOfWork);
+        4 !== workInProgressRootExitStatus &&
+          (workInProgressRootExitStatus = 2);
+        null === workInProgressRootConcurrentErrors
+          ? (workInProgressRootConcurrentErrors = [root])
+          : workInProgressRootConcurrentErrors.push(root);
+        root = returnFiber;
+        do {
+          switch (root.tag) {
+            case 3:
+              var errorInfo = value;
+              root.flags |= 65536;
+              thrownValue &= -thrownValue;
+              root.lanes |= thrownValue;
+              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
+              enqueueCapturedUpdate(root, update);
+              break a;
+            case 1:
+              currentSourceFiber = value;
+              var ctor = root.type,
+                instance = root.stateNode;
+              if (
+                0 === (root.flags & 128) &&
+                ("function" === typeof ctor.getDerivedStateFromError ||
+                  (null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
+              ) {
+                root.flags |= 65536;
+                update = thrownValue & -thrownValue;
+                root.lanes |= update;
+                errorInfo = createClassErrorUpdate(
+                  root,
+                  currentSourceFiber,
+                  update
+                );
+                enqueueCapturedUpdate(root, errorInfo);
+                break a;
+              }
+          }
+          root = root.return;
+        } while (null !== root);
+      }
+    } catch (error) {
+      throw ((workInProgress = returnFiber), error);
     }
-    parentFiber = parentFiber.sibling;
-  }
-}
-function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  try {
-    commitHookEffectListMount(hookFlags, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    completeUnitOfWork(unitOfWork);
   }
 }
-function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
-  var previousCache = null;
-  null !== current &&
-    null !== current.memoizedState &&
-    null !== current.memoizedState.cachePool &&
-    (previousCache = current.memoizedState.cachePool.pool);
-  current = null;
-  null !== finishedWork.memoizedState &&
-    null !== finishedWork.memoizedState.cachePool &&
-    (current = finishedWork.memoizedState.cachePool.pool);
-  current !== previousCache &&
-    (null != current && current.refCount++,
-    null != previousCache && releaseCache(previousCache));
-  if (enableTransitionTracing) {
-    current = finishedWork.updateQueue;
-    previousCache = null !== finishedWork.memoizedState;
-    if (null !== current) {
-      if (previousCache) {
-        var transitions = current.transitions;
-        null !== transitions &&
-          transitions.forEach(function (transition) {
-            null === instance._transitions &&
-              (instance._transitions = new Set());
-            instance._transitions.add(transition);
-          });
-        current = current.markerInstances;
-        null !== current &&
-          current.forEach(function (markerInstance) {
-            var markerTransitions = markerInstance.transitions;
-            null !== markerTransitions &&
-              markerTransitions.forEach(function (transition) {
-                null === instance._transitions
-                  ? (instance._transitions = new Set())
-                  : instance._transitions.has(transition) &&
-                    (null === markerInstance.pendingBoundaries &&
-                      (markerInstance.pendingBoundaries = new Map()),
-                    null === instance._pendingMarkers &&
-                      (instance._pendingMarkers = new Set()),
-                    instance._pendingMarkers.add(markerInstance));
-              });
-          });
+function completeUnitOfWork(unitOfWork) {
+  var completedWork = unitOfWork;
+  do {
+    var current = completedWork.alternate;
+    unitOfWork = completedWork.return;
+    if (0 === (completedWork.flags & 32768)) {
+      if (
+        ((current = completeWork(current, completedWork, renderLanes)),
+        null !== current)
+      ) {
+        workInProgress = current;
+        return;
+      }
+    } else {
+      current = unwindWork(current, completedWork);
+      if (null !== current) {
+        current.flags &= 16383;
+        workInProgress = current;
+        return;
+      }
+      if (null !== unitOfWork)
+        (unitOfWork.flags |= 32768),
+          (unitOfWork.subtreeFlags = 0),
+          (unitOfWork.deletions = null);
+      else {
+        workInProgressRootExitStatus = 6;
+        workInProgress = null;
+        return;
       }
-      finishedWork.updateQueue = null;
     }
-    commitTransitionProgress(finishedWork);
-    previousCache ||
-      ((instance._transitions = null), (instance._pendingMarkers = null));
-  }
-}
-function commitCachePassiveMountEffect(current, finishedWork) {
-  current = null;
-  null !== finishedWork.alternate &&
-    (current = finishedWork.alternate.memoizedState.cache);
-  finishedWork = finishedWork.memoizedState.cache;
-  finishedWork !== current &&
-    (finishedWork.refCount++, null != current && releaseCache(current));
-}
-function commitTracingMarkerPassiveMountEffect(finishedWork) {
-  var instance = finishedWork.stateNode;
-  null !== instance.transitions &&
-    null === instance.pendingBoundaries &&
-    (addMarkerCompleteCallbackToPendingTransition(
-      finishedWork.memoizedProps.name,
-      instance.transitions
-    ),
-    (instance.transitions = null),
-    (instance.pendingBoundaries = null),
-    (instance.aborts = null),
-    (instance.name = null));
-}
-function recursivelyTraversePassiveMountEffects(
-  root,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitPassiveMountOnFiber(
+    completedWork = completedWork.sibling;
+    if (null !== completedWork) {
+      workInProgress = completedWork;
+      return;
+    }
+    workInProgress = completedWork = unitOfWork;
+  } while (null !== completedWork);
+  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+}
+function commitRoot(root, recoverableErrors, transitions) {
+  var previousUpdateLanePriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig$1.transition;
+  try {
+    (ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      commitRootImpl(
         root,
-        parentFiber,
-        committedLanes,
-        committedTransitions
-      ),
-        (parentFiber = parentFiber.sibling);
+        recoverableErrors,
+        transitions,
+        previousUpdateLanePriority
+      );
+  } finally {
+    (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (currentUpdatePriority = previousUpdateLanePriority);
+  }
+  return null;
 }
-function commitPassiveMountOnFiber(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
 ) {
-  var flags = finishedWork.flags;
-  switch (finishedWork.tag) {
-    case 0:
-    case 11:
-    case 15:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-      flags & 2048 && commitHookPassiveMountEffects(finishedWork, 9);
-      break;
-    case 3:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-      if (flags & 2048) {
-        flags = null;
-        null !== finishedWork.alternate &&
-          (flags = finishedWork.alternate.memoizedState.cache);
-        var nextCache = finishedWork.memoizedState.cache;
-        nextCache !== flags &&
-          (nextCache.refCount++, null != flags && releaseCache(flags));
-        if (enableTransitionTracing) {
-          var incompleteTransitions =
-            finishedWork.stateNode.incompleteTransitions;
-          null !== committedTransitions &&
-            (committedTransitions.forEach(function (transition) {
-              enableTransitionTracing &&
-                (null === currentPendingTransitionCallbacks &&
-                  (currentPendingTransitionCallbacks = {
-                    transitionStart: [],
-                    transitionProgress: null,
-                    transitionComplete: null,
-                    markerProgress: null,
-                    markerIncomplete: null,
-                    markerComplete: null
-                  }),
-                null === currentPendingTransitionCallbacks.transitionStart &&
-                  (currentPendingTransitionCallbacks.transitionStart = []),
-                currentPendingTransitionCallbacks.transitionStart.push(
-                  transition
-                ));
-            }),
-            clearTransitionsForLanes(finishedRoot, committedLanes));
-          incompleteTransitions.forEach(function (markerInstance, transition) {
-            var pendingBoundaries = markerInstance.pendingBoundaries;
-            if (null === pendingBoundaries || 0 === pendingBoundaries.size)
-              null === markerInstance.aborts &&
-                enableTransitionTracing &&
-                (null === currentPendingTransitionCallbacks &&
-                  (currentPendingTransitionCallbacks = {
-                    transitionStart: null,
-                    transitionProgress: null,
-                    transitionComplete: [],
-                    markerProgress: null,
-                    markerIncomplete: null,
-                    markerComplete: null
-                  }),
-                null === currentPendingTransitionCallbacks.transitionComplete &&
-                  (currentPendingTransitionCallbacks.transitionComplete = []),
-                currentPendingTransitionCallbacks.transitionComplete.push(
-                  transition
-                )),
-                incompleteTransitions.delete(transition);
-          });
-          clearTransitionsForLanes(finishedRoot, committedLanes);
-        }
-      }
-      break;
-    case 23:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-      flags & 2048 &&
-        commitOffscreenPassiveMountEffects(
-          finishedWork.alternate,
-          finishedWork,
-          finishedWork.stateNode
-        );
-      break;
-    case 22:
-      nextCache = finishedWork.stateNode;
-      null !== finishedWork.memoizedState
-        ? nextCache._visibility & 4
-          ? recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            )
-          : finishedWork.mode & 1
-          ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
-          : ((nextCache._visibility |= 4),
-            recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            ))
-        : nextCache._visibility & 4
-        ? recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          )
-        : ((nextCache._visibility |= 4),
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            0 !== (finishedWork.subtreeFlags & 10256)
-          ));
-      flags & 2048 &&
-        commitOffscreenPassiveMountEffects(
-          finishedWork.alternate,
-          finishedWork,
-          nextCache
-        );
-      break;
-    case 24:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-      flags & 2048 &&
-        commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-      break;
-    case 25:
-      if (enableTransitionTracing) {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
-        );
-        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
-        break;
-      }
-    default:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+  do flushPassiveEffects();
+  while (null !== rootWithPendingPassiveEffects);
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var finishedWork = root.finishedWork,
+    lanes = root.finishedLanes;
+  if (null === finishedWork) return null;
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
+  root.callbackNode = null;
+  root.callbackPriority = 0;
+  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
+  remainingLanes |= concurrentlyUpdatedLanes;
+  markRootFinished(root, remainingLanes);
+  root === workInProgressRoot &&
+    ((workInProgress = workInProgressRoot = null),
+    (workInProgressRootRenderLanes = 0));
+  (0 === (finishedWork.subtreeFlags & 10256) &&
+    0 === (finishedWork.flags & 10256)) ||
+    rootDoesHavePassiveEffects ||
+    ((rootDoesHavePassiveEffects = !0),
+    (pendingPassiveEffectsRemainingLanes = remainingLanes),
+    (pendingPassiveTransitions = transitions),
+    scheduleCallback(NormalPriority$1, function () {
+      flushPassiveEffects();
+      return null;
+    }));
+  transitions = 0 !== (finishedWork.flags & 15990);
+  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
+    transitions = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    var prevExecutionContext = executionContext;
+    executionContext |= 4;
+    ReactCurrentOwner.current = null;
+    var shouldFireAfterActiveInstanceBlur$205 = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
+    commitMutationEffectsOnFiber(finishedWork, root);
+    shouldFireAfterActiveInstanceBlur$205 &&
+      ((_enabled = !0),
+      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
+      (_enabled = !1));
+    restoreSelection(selectionInformation);
+    _enabled = !!eventsEnabled;
+    selectionInformation = eventsEnabled = null;
+    root.current = finishedWork;
+    commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
+    requestPaint();
+    executionContext = prevExecutionContext;
+    currentUpdatePriority = previousPriority;
+    ReactCurrentBatchConfig$1.transition = transitions;
+  } else root.current = finishedWork;
+  rootDoesHavePassiveEffects
+    ? ((rootDoesHavePassiveEffects = !1),
+      (rootWithPendingPassiveEffects = root),
+      (pendingPassiveEffectsLanes = lanes))
+    : releaseRootPooledCache(root, remainingLanes);
+  remainingLanes = root.pendingLanes;
+  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  ensureRootIsScheduled(root, now());
+  if (null !== recoverableErrors)
+    for (
+      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
+      finishedWork < recoverableErrors.length;
+      finishedWork++
+    )
+      (lanes = recoverableErrors[finishedWork]),
+        (remainingLanes = {
+          digest: lanes.digest,
+          componentStack: lanes.stack
+        }),
+        renderPriorityLevel(lanes.value, remainingLanes);
+  if (hasUncaughtError)
+    throw (
+      ((hasUncaughtError = !1),
+      (root = firstUncaughtError),
+      (firstUncaughtError = null),
+      root)
+    );
+  0 !== (pendingPassiveEffectsLanes & 3) &&
+    0 !== root.tag &&
+    flushPassiveEffects();
+  remainingLanes = root.pendingLanes;
+  0 !== (remainingLanes & 3)
+    ? root === rootWithNestedUpdates
+      ? nestedUpdateCount++
+      : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root))
+    : (nestedUpdateCount = 0);
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    null !== prevRootTransitionCallbacks &&
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+        null !== prevPendingTransitionCallbacks
+          ? ((currentPendingTransitionCallbacks = null),
+            scheduleCallback(IdlePriority, function () {
+              processTransitionCallbacks(
+                prevPendingTransitionCallbacks,
+                endTime,
+                prevRootTransitionCallbacks
+              );
+            }))
+          : (currentEndTime = endTime);
+      });
+  }
+  return null;
+}
+function releaseRootPooledCache(root, remainingLanes) {
+  0 === (root.pooledCacheLanes &= remainingLanes) &&
+    ((remainingLanes = root.pooledCache),
+    null != remainingLanes &&
+      ((root.pooledCache = null), releaseCache(remainingLanes)));
+}
+function flushPassiveEffects() {
+  if (null !== rootWithPendingPassiveEffects) {
+    var root$206 = rootWithPendingPassiveEffects,
+      remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = 0;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    renderPriority = 32 > renderPriority ? 32 : renderPriority;
+    var prevTransition = ReactCurrentBatchConfig$1.transition,
+      previousPriority = currentUpdatePriority;
+    try {
+      return (
+        (ReactCurrentBatchConfig$1.transition = null),
+        (currentUpdatePriority = renderPriority),
+        flushPassiveEffectsImpl()
       );
+    } finally {
+      (currentUpdatePriority = previousPriority),
+        (ReactCurrentBatchConfig$1.transition = prevTransition),
+        releaseRootPooledCache(root$206, remainingLanes);
+    }
   }
+  return !1;
 }
-function recursivelyTraverseReconnectPassiveEffects(
-  finishedRoot$jscomp$0,
-  parentFiber,
-  committedLanes$jscomp$0,
-  committedTransitions$jscomp$0,
-  includeWorkInProgressEffects
-) {
-  includeWorkInProgressEffects =
-    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var finishedRoot = finishedRoot$jscomp$0,
-      finishedWork = parentFiber,
-      committedLanes = committedLanes$jscomp$0,
-      committedTransitions = committedTransitions$jscomp$0,
-      flags = finishedWork.flags;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 15:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+function flushPassiveEffectsImpl() {
+  if (null === rootWithPendingPassiveEffects) return !1;
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects,
+    lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null;
+  pendingPassiveEffectsLanes = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
+  var prevExecutionContext = executionContext;
+  executionContext |= 4;
+  commitPassiveUnmountOnFiber(root.current);
+  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
+      prevRootTransitionCallbacks = root.transitionCallbacks,
+      prevEndTime = currentEndTime;
+    null !== prevPendingTransitionCallbacks &&
+      null !== prevRootTransitionCallbacks &&
+      null !== prevEndTime &&
+      ((currentEndTime = currentPendingTransitionCallbacks = null),
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
         );
-        commitHookPassiveMountEffects(finishedWork, 8);
-        break;
-      case 23:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+      }));
+  }
+  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {}
+  return !0;
+}
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
+  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+  sourceFiber = requestEventTime();
+  null !== rootFiber &&
+    (markRootUpdated(rootFiber, 2, sourceFiber),
+    ensureRootIsScheduled(rootFiber, sourceFiber));
+}
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+  if (3 === sourceFiber.tag)
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+  else
+    for (
+      nearestMountedAncestor = skipUnmountedBoundaries
+        ? nearestMountedAncestor
+        : sourceFiber.return;
+      null !== nearestMountedAncestor;
+
+    ) {
+      if (3 === nearestMountedAncestor.tag) {
+        captureCommitPhaseErrorOnRoot(
+          nearestMountedAncestor,
+          sourceFiber,
+          error
         );
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitOffscreenPassiveMountEffects(
-            finishedWork.alternate,
-            finishedWork,
-            finishedWork.stateNode
-          );
         break;
-      case 22:
-        var instance$203 = finishedWork.stateNode;
-        null !== finishedWork.memoizedState
-          ? instance$203._visibility & 4
-            ? recursivelyTraverseReconnectPassiveEffects(
-                finishedRoot,
-                finishedWork,
-                committedLanes,
-                committedTransitions,
-                includeWorkInProgressEffects
-              )
-            : finishedWork.mode & 1
-            ? recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              )
-            : ((instance$203._visibility |= 4),
-              recursivelyTraverseReconnectPassiveEffects(
-                finishedRoot,
-                finishedWork,
-                committedLanes,
-                committedTransitions,
-                includeWorkInProgressEffects
-              ))
-          : ((instance$203._visibility |= 4),
-            recursivelyTraverseReconnectPassiveEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions,
-              includeWorkInProgressEffects
-            ));
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitOffscreenPassiveMountEffects(
-            finishedWork.alternate,
-            finishedWork,
-            instance$203
+      } else if (1 === nearestMountedAncestor.tag) {
+        var instance = nearestMountedAncestor.stateNode;
+        if (
+          "function" ===
+            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
+          ("function" === typeof instance.componentDidCatch &&
+            (null === legacyErrorBoundariesThatAlreadyFailed ||
+              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
+        ) {
+          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+          sourceFiber = createClassErrorUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
           );
-        break;
-      case 24:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-        break;
-      case 25:
-        if (enableTransitionTracing) {
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
+          nearestMountedAncestor = enqueueUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
           );
-          includeWorkInProgressEffects &&
-            flags & 2048 &&
-            commitTracingMarkerPassiveMountEffect(finishedWork);
+          sourceFiber = requestEventTime();
+          null !== nearestMountedAncestor &&
+            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
+            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
           break;
         }
-      default:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
+      }
+      nearestMountedAncestor = nearestMountedAncestor.return;
     }
-    parentFiber = parentFiber.sibling;
+}
+function attachPingListener(root, wakeable, lanes) {
+  var pingCache = root.pingCache;
+  if (null === pingCache) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    var threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else
+    (threadIDs = pingCache.get(wakeable)),
+      void 0 === threadIDs &&
+        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
+  threadIDs.has(lanes) ||
+    ((workInProgressRootDidAttachPingListener = !0),
+    threadIDs.add(lanes),
+    (root = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
+    wakeable.then(root, root));
+}
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
+  null !== pingCache && pingCache.delete(wakeable);
+  wakeable = requestEventTime();
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+  workInProgressRoot === root &&
+    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
+    (4 === workInProgressRootExitStatus ||
+    (3 === workInProgressRootExitStatus &&
+      (workInProgressRootRenderLanes & 125829120) ===
+        workInProgressRootRenderLanes &&
+      500 > now() - globalMostRecentFallbackTime)
+      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
+      : (workInProgressRootPingedLanes |= pingedLanes));
+  ensureRootIsScheduled(root, wakeable);
+}
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  0 === retryLane &&
+    (0 === (boundaryFiber.mode & 1)
+      ? (retryLane = 2)
+      : ((retryLane = nextRetryLane),
+        (nextRetryLane <<= 1),
+        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
+  var eventTime = requestEventTime();
+  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+  null !== boundaryFiber &&
+    (markRootUpdated(boundaryFiber, retryLane, eventTime),
+    ensureRootIsScheduled(boundaryFiber, eventTime));
+}
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState,
+    retryLane = 0;
+  null !== suspenseState && (retryLane = suspenseState.retryLane);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = 0;
+  switch (boundaryFiber.tag) {
+    case 13:
+      var retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
+      null !== suspenseState && (retryLane = suspenseState.retryLane);
+      break;
+    case 19:
+      retryCache = boundaryFiber.stateNode;
+      break;
+    case 22:
+      retryCache = boundaryFiber.stateNode._retryCache;
+      break;
+    default:
+      throw Error(formatProdErrorMessage(314));
   }
+  null !== retryCache && retryCache.delete(wakeable);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
 }
-function recursivelyTraverseAtomicPassiveEffects(
-  finishedRoot$jscomp$0,
-  parentFiber
-) {
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-      var finishedRoot = finishedRoot$jscomp$0,
-        finishedWork = parentFiber,
-        flags = finishedWork.flags;
-      switch (finishedWork.tag) {
-        case 22:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-          flags & 2048 &&
-            commitOffscreenPassiveMountEffects(
-              finishedWork.alternate,
-              finishedWork,
-              finishedWork.stateNode
+var beginWork;
+beginWork = function (current, workInProgress, renderLanes) {
+  if (null !== current)
+    if (
+      current.memoizedProps !== workInProgress.pendingProps ||
+      didPerformWorkStackCursor.current
+    )
+      didReceiveUpdate = !0;
+    else {
+      if (
+        !checkScheduledUpdateOrContext(current, renderLanes) &&
+        0 === (workInProgress.flags & 128)
+      )
+        return (
+          (didReceiveUpdate = !1),
+          attemptEarlyBailoutIfNoScheduledUpdate(
+            current,
+            workInProgress,
+            renderLanes
+          )
+        );
+      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+    }
+  else
+    (didReceiveUpdate = !1),
+      isHydrating &&
+        0 !== (workInProgress.flags & 1048576) &&
+        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
+  workInProgress.lanes = 0;
+  switch (workInProgress.tag) {
+    case 2:
+      var Component = workInProgress.type;
+      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+      current = workInProgress.pendingProps;
+      var context = getMaskedContext(
+        workInProgress,
+        contextStackCursor.current
+      );
+      prepareToReadContext(workInProgress, renderLanes);
+      current = renderWithHooks(
+        null,
+        workInProgress,
+        Component,
+        current,
+        context,
+        renderLanes
+      );
+      Component = checkDidRenderIdHook();
+      workInProgress.flags |= 1;
+      workInProgress.tag = 0;
+      isHydrating && Component && pushMaterializedTreeId(workInProgress);
+      reconcileChildren(null, workInProgress, current, renderLanes);
+      workInProgress = workInProgress.child;
+      return workInProgress;
+    case 16:
+      Component = workInProgress.elementType;
+      a: {
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+        current = workInProgress.pendingProps;
+        context = Component._init;
+        Component = context(Component._payload);
+        workInProgress.type = Component;
+        context = workInProgress.tag = resolveLazyComponentTag(Component);
+        current = resolveDefaultProps(Component, current);
+        switch (context) {
+          case 0:
+            workInProgress = updateFunctionComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 1:
+            workInProgress = updateClassComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 11:
+            workInProgress = updateForwardRef(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 14:
+            workInProgress = updateMemoComponent(
+              null,
+              workInProgress,
+              Component,
+              resolveDefaultProps(Component.type, current),
+              renderLanes
+            );
+            break a;
+        }
+        throw Error(formatProdErrorMessage(306, Component, ""));
+      }
+      return workInProgress;
+    case 0:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        updateFunctionComponent(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
+    case 1:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        updateClassComponent(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
+    case 3:
+      a: {
+        pushHostRootContext(workInProgress);
+        if (null === current) throw Error(formatProdErrorMessage(387));
+        Component = workInProgress.pendingProps;
+        var prevState = workInProgress.memoizedState;
+        context = prevState.element;
+        cloneUpdateQueue(current, workInProgress);
+        processUpdateQueue(workInProgress, Component, null, renderLanes);
+        var nextState = workInProgress.memoizedState,
+          root = workInProgress.stateNode;
+        enableTransitionTracing &&
+          push(transitionStack, workInProgressTransitions);
+        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+        Component = nextState.cache;
+        pushProvider(workInProgress, CacheContext, Component);
+        Component !== prevState.cache &&
+          propagateContextChange(workInProgress, CacheContext, renderLanes);
+        Component = nextState.element;
+        if (prevState.isDehydrated)
+          if (
+            ((prevState = {
+              element: Component,
+              isDehydrated: !1,
+              cache: nextState.cache
+            }),
+            (workInProgress.updateQueue.baseState = prevState),
+            (workInProgress.memoizedState = prevState),
+            workInProgress.flags & 256)
+          ) {
+            context = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(423)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              context
             );
-          break;
-        case 24:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-          flags & 2048 &&
-            commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-          break;
-        default:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+            break a;
+          } else if (Component !== context) {
+            context = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(424)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              context
+            );
+            break a;
+          } else {
+            nextHydratableInstance = getNextHydratable(
+              workInProgress.stateNode.containerInfo.firstChild
+            );
+            hydrationParentFiber = workInProgress;
+            isHydrating = !0;
+            hydrationErrors = null;
+            rootOrSingletonContext = !0;
+            current = root.mutableSourceEagerHydrationData;
+            if (null != current)
+              for (context = 0; context < current.length; context += 2)
+                (prevState = current[context]),
+                  (prevState._workInProgressVersionPrimary =
+                    current[context + 1]),
+                  workInProgressSources.push(prevState);
+            renderLanes = mountChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            );
+            for (workInProgress.child = renderLanes; renderLanes; )
+              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
+                (renderLanes = renderLanes.sibling);
+          }
+        else {
+          resetHydrationState();
+          if (Component === context) {
+            workInProgress = bailoutOnAlreadyFinishedWork(
+              current,
+              workInProgress,
+              renderLanes
+            );
+            break a;
+          }
+          reconcileChildren(current, workInProgress, Component, renderLanes);
+        }
+        workInProgress = workInProgress.child;
       }
-      parentFiber = parentFiber.sibling;
-    }
-}
-function detachAlternateSiblings(parentFiber) {
-  var previousFiber = parentFiber.alternate;
-  if (
-    null !== previousFiber &&
-    ((parentFiber = previousFiber.child), null !== parentFiber)
-  ) {
-    previousFiber.child = null;
-    do
-      (previousFiber = parentFiber.sibling),
-        (parentFiber.sibling = null),
-        (parentFiber = previousFiber);
-    while (null !== parentFiber);
-  }
-}
-function recursivelyTraversePassiveUnmountEffects(parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (0 !== (parentFiber.flags & 16)) {
-    if (null !== deletions)
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i];
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
+      return workInProgress;
+    case 26:
+      return (
+        markRef$1(current, workInProgress),
+        (renderLanes = workInProgress.memoizedState =
+          getResource(
+            workInProgress.type,
+            null === current ? null : current.memoizedProps,
+            workInProgress.pendingProps
+          )),
+        null !== current ||
+          isHydrating ||
+          null !== renderLanes ||
+          ((renderLanes = workInProgress.type),
+          (current = workInProgress.pendingProps),
+          (Component = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          )),
+          (Component = createHTMLElement(renderLanes, current, Component)),
+          (Component[internalInstanceKey] = workInProgress),
+          (Component[internalPropsKey] = current),
+          setInitialProperties(Component, renderLanes, current),
+          markNodeAsHoistable(Component),
+          (workInProgress.stateNode = Component)),
+        null
+      );
+    case 27:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          ((Component = workInProgress.stateNode =
+            resolveSingletonInstance(
+              workInProgress.type,
+              workInProgress.pendingProps,
+              rootInstanceStackCursor.current
+            )),
+          (hydrationParentFiber = workInProgress),
+          (rootOrSingletonContext = !0),
+          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
+        (Component = workInProgress.pendingProps.children),
+        null !== current || isHydrating
+          ? reconcileChildren(current, workInProgress, Component, renderLanes)
+          : (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            )),
+        markRef$1(current, workInProgress),
+        workInProgress.child
+      );
+    case 5:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          (((Component = workInProgress.pendingProps),
+          "script" === workInProgress.type
+            ? ((context = Component.onLoad),
+              (prevState = Component.onError),
+              (Component = !(Component.async && (context || prevState))))
+            : (Component = !0),
+          Component)
+            ? ((Component = nextHydratableInstance),
+              rootOrSingletonContext &&
+                advanceToFirstAttemptableInstance(workInProgress),
+              (context = nextHydratableInstance),
+              context)
+              ? tryHydrateInstance(workInProgress, context) ||
+                (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                (nextHydratableInstance = getNextHydratable(
+                  context.nextSibling
+                )),
+                (prevState = hydrationParentFiber),
+                rootOrSingletonContext &&
+                  advanceToFirstAttemptableInstance(workInProgress),
+                nextHydratableInstance &&
+                tryHydrateInstance(workInProgress, nextHydratableInstance)
+                  ? deleteHydratableInstance(prevState, context)
+                  : (insertNonHydratedInstance(
+                      hydrationParentFiber,
+                      workInProgress
+                    ),
+                    (isHydrating = !1),
+                    (hydrationParentFiber = workInProgress),
+                    (nextHydratableInstance = Component)))
+              : (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = Component))
+            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress))),
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (prevState = null !== current ? current.memoizedProps : null),
+        (root = context.children),
+        shouldSetTextContent(Component, context)
+          ? (root = null)
+          : null !== prevState &&
+            shouldSetTextContent(Component, prevState) &&
+            (workInProgress.flags |= 32),
+        markRef$1(current, workInProgress),
+        reconcileChildren(current, workInProgress, root, renderLanes),
+        workInProgress.child
+      );
+    case 6:
+      return (
+        null === current &&
+          isHydrating &&
+          (((renderLanes = "" !== workInProgress.pendingProps),
+          (current = nextHydratableInstance),
+          rootOrSingletonContext &&
+            renderLanes &&
+            advanceToFirstAttemptableTextInstance(),
+          (Component = nextHydratableInstance),
+          Component && renderLanes)
+            ? tryHydrateText(workInProgress, Component) ||
+              (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              (nextHydratableInstance = getNextHydratable(
+                Component.nextSibling
+              )),
+              (context = hydrationParentFiber),
+              rootOrSingletonContext &&
+                renderLanes &&
+                advanceToFirstAttemptableTextInstance(),
+              nextHydratableInstance &&
+              tryHydrateText(workInProgress, nextHydratableInstance)
+                ? deleteHydratableInstance(context, Component)
+                : (insertNonHydratedInstance(
+                    hydrationParentFiber,
+                    workInProgress
+                  ),
+                  (isHydrating = !1),
+                  (hydrationParentFiber = workInProgress),
+                  (nextHydratableInstance = current)))
+            : (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress),
+              (nextHydratableInstance = current))),
+        null
+      );
+    case 13:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+    case 4:
+      return (
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        ),
+        (Component = workInProgress.pendingProps),
+        null === current
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            ))
+          : reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 11:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        updateForwardRef(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
+    case 7:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 8:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 12:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 10:
+      a: {
+        Component = workInProgress.type._context;
+        context = workInProgress.pendingProps;
+        prevState = workInProgress.memoizedProps;
+        root = context.value;
+        pushProvider(workInProgress, Component, root);
+        if (!enableLazyContextPropagation && null !== prevState)
+          if (objectIs(prevState.value, root)) {
+            if (
+              prevState.children === context.children &&
+              !didPerformWorkStackCursor.current
+            ) {
+              workInProgress = bailoutOnAlreadyFinishedWork(
+                current,
+                workInProgress,
+                renderLanes
+              );
+              break a;
+            }
+          } else propagateContextChange(workInProgress, Component, renderLanes);
+        reconcileChildren(
+          current,
+          workInProgress,
+          context.children,
+          renderLanes
         );
+        workInProgress = workInProgress.child;
       }
-    detachAlternateSiblings(parentFiber);
-  }
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitPassiveUnmountOnFiber(parentFiber),
-        (parentFiber = parentFiber.sibling);
-}
-function commitPassiveUnmountOnFiber(finishedWork) {
-  switch (finishedWork.tag) {
-    case 0:
-    case 11:
+      return workInProgress;
+    case 9:
+      return (
+        (context = workInProgress.type),
+        (Component = workInProgress.pendingProps.children),
+        prepareToReadContext(workInProgress, renderLanes),
+        (context = readContext(context)),
+        (Component = Component(context)),
+        (workInProgress.flags |= 1),
+        reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 14:
+      return (
+        (Component = workInProgress.type),
+        (context = resolveDefaultProps(Component, workInProgress.pendingProps)),
+        (context = resolveDefaultProps(Component.type, context)),
+        updateMemoComponent(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
     case 15:
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-      finishedWork.flags & 2048 &&
-        commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
-      break;
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        workInProgress.pendingProps,
+        renderLanes
+      );
+    case 17:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+        (workInProgress.tag = 1),
+        isContextProvider(Component)
+          ? ((current = !0), pushContextProvider(workInProgress))
+          : (current = !1),
+        prepareToReadContext(workInProgress, renderLanes),
+        constructClassInstance(workInProgress, Component, context),
+        mountClassInstance(workInProgress, Component, context, renderLanes),
+        finishClassComponent(
+          null,
+          workInProgress,
+          Component,
+          !0,
+          current,
+          renderLanes
+        )
+      );
+    case 19:
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    case 21:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
     case 22:
-      var instance = finishedWork.stateNode;
-      null !== finishedWork.memoizedState &&
-      instance._visibility & 4 &&
-      (null === finishedWork.return || 13 !== finishedWork.return.tag)
-        ? ((instance._visibility &= -5),
-          recursivelyTraverseDisconnectPassiveEffects(finishedWork))
-        : recursivelyTraversePassiveUnmountEffects(finishedWork);
-      break;
-    default:
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-  }
-}
-function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (0 !== (parentFiber.flags & 16)) {
-    if (null !== deletions)
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i];
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    detachAlternateSiblings(parentFiber);
-  }
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    deletions = parentFiber;
-    switch (deletions.tag) {
-      case 0:
-      case 11:
-      case 15:
-        commitHookEffectListUnmount(8, deletions, deletions.return);
-        recursivelyTraverseDisconnectPassiveEffects(deletions);
-        break;
-      case 22:
-        i = deletions.stateNode;
-        i._visibility & 4 &&
-          ((i._visibility &= -5),
-          recursivelyTraverseDisconnectPassiveEffects(deletions));
-        break;
-      default:
-        recursivelyTraverseDisconnectPassiveEffects(deletions);
-    }
-    parentFiber = parentFiber.sibling;
-  }
-}
-function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-  deletedSubtreeRoot,
-  nearestMountedAncestor$jscomp$0
-) {
-  for (; null !== nextEffect; ) {
-    var fiber = nextEffect,
-      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
-    switch (fiber.tag) {
-      case 0:
-      case 11:
-      case 15:
-        commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
-        break;
-      case 23:
-      case 22:
-        null !== fiber.memoizedState &&
-          null !== fiber.memoizedState.cachePool &&
-          ((nearestMountedAncestor = fiber.memoizedState.cachePool.pool),
-          null != nearestMountedAncestor && nearestMountedAncestor.refCount++);
-        break;
-      case 13:
-        if (enableTransitionTracing) {
-          var offscreenFiber = fiber.child,
-            instance = offscreenFiber.stateNode,
-            transitions = instance._transitions;
-          if (null !== transitions) {
-            var abortReason = {
-              reason: "suspense",
-              name: fiber.memoizedProps.unstable_name || null
-            };
-            if (
-              null === fiber.memoizedState ||
-              null === fiber.memoizedState.dehydrated
-            )
-              abortParentMarkerTransitionsForDeletedFiber(
-                offscreenFiber,
-                abortReason,
-                transitions,
-                instance,
-                !0
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 23:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 24:
+      return (
+        prepareToReadContext(workInProgress, renderLanes),
+        (Component = readContext(CacheContext)),
+        null === current
+          ? ((context = peekCacheFromPool()),
+            null === context &&
+              ((context = workInProgressRoot),
+              (prevState = createCache()),
+              (context.pooledCache = prevState),
+              prevState.refCount++,
+              null !== prevState && (context.pooledCacheLanes |= renderLanes),
+              (context = prevState)),
+            (workInProgress.memoizedState = {
+              parent: Component,
+              cache: context
+            }),
+            initializeUpdateQueue(workInProgress),
+            pushProvider(workInProgress, CacheContext, context))
+          : (0 !== (current.lanes & renderLanes) &&
+              (cloneUpdateQueue(current, workInProgress),
+              processUpdateQueue(workInProgress, null, null, renderLanes)),
+            (context = current.memoizedState),
+            (prevState = workInProgress.memoizedState),
+            context.parent !== Component
+              ? ((context = { parent: Component, cache: Component }),
+                (workInProgress.memoizedState = context),
+                0 === workInProgress.lanes &&
+                  (workInProgress.memoizedState =
+                    workInProgress.updateQueue.baseState =
+                      context),
+                pushProvider(workInProgress, CacheContext, Component))
+              : ((Component = prevState.cache),
+                pushProvider(workInProgress, CacheContext, Component),
+                Component !== context.cache &&
+                  propagateContextChange(
+                    workInProgress,
+                    CacheContext,
+                    renderLanes
+                  ))),
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 25:
+      if (enableTransitionTracing)
+        return (
+          enableTransitionTracing
+            ? (null === current &&
+                ((Component = enableTransitionTracing
+                  ? transitionStack.current
+                  : null),
+                null !== Component &&
+                  ((Component = {
+                    tag: 1,
+                    transitions: new Set(Component),
+                    pendingBoundaries: null,
+                    name: workInProgress.pendingProps.name,
+                    aborts: null
+                  }),
+                  (workInProgress.stateNode = Component),
+                  (workInProgress.flags |= 2048))),
+              (Component = workInProgress.stateNode),
+              null !== Component &&
+                pushMarkerInstance(workInProgress, Component),
+              reconcileChildren(
+                current,
+                workInProgress,
+                workInProgress.pendingProps.children,
+                renderLanes
               ),
-                null !== nearestMountedAncestor &&
-                  abortParentMarkerTransitionsForDeletedFiber(
-                    nearestMountedAncestor,
-                    abortReason,
-                    transitions,
-                    instance,
-                    !1
-                  );
-          }
-        }
-        break;
-      case 24:
-        releaseCache(fiber.memoizedState.cache);
-        break;
-      case 25:
-        enableTransitionTracing &&
-          ((offscreenFiber = fiber.stateNode.transitions),
-          null !== offscreenFiber &&
-            ((instance = { reason: "marker", name: fiber.memoizedProps.name }),
-            abortParentMarkerTransitionsForDeletedFiber(
-              fiber,
-              instance,
-              offscreenFiber,
-              null,
-              !0
-            ),
-            null !== nearestMountedAncestor &&
-              abortParentMarkerTransitionsForDeletedFiber(
-                nearestMountedAncestor,
-                instance,
-                offscreenFiber,
-                null,
-                !1
-              )));
-    }
-    nearestMountedAncestor = fiber.child;
-    if (null !== nearestMountedAncestor)
-      (nearestMountedAncestor.return = fiber),
-        (nextEffect = nearestMountedAncestor);
-    else
-      a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
-        nearestMountedAncestor = nextEffect;
-        offscreenFiber = nearestMountedAncestor.sibling;
-        instance = nearestMountedAncestor.return;
-        detachFiberAfterEffects(nearestMountedAncestor);
-        if (nearestMountedAncestor === fiber) {
-          nextEffect = null;
-          break a;
-        }
-        if (null !== offscreenFiber) {
-          offscreenFiber.return = instance;
-          nextEffect = offscreenFiber;
-          break a;
-        }
-        nextEffect = instance;
-      }
+              (workInProgress = workInProgress.child))
+            : (workInProgress = null),
+          workInProgress
+        );
   }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+};
+function scheduleCallback(priorityLevel, callback) {
+  return scheduleCallback$2(priorityLevel, callback);
 }
-var DefaultCacheDispatcher = {
-    getCacheSignal: function () {
-      return readContext(CacheContext).controller.signal;
-    },
-    getCacheForType: function (resourceType) {
-      var cache = readContext(CacheContext),
-        cacheForType = cache.data.get(resourceType);
-      void 0 === cacheForType &&
-        ((cacheForType = resourceType()),
-        cache.data.set(resourceType, cacheForType));
-      return cacheForType;
-    }
-  },
-  postPaintCallbackScheduled = !1,
-  callbacks = [];
-function schedulePostPaintCallback(callback) {
-  callbacks.push(callback);
-  postPaintCallbackScheduled ||
-    ((postPaintCallbackScheduled = !0),
-    requestPostPaintCallback(function (endTime) {
-      for (var i = 0; i < callbacks.length; i++) callbacks[i](endTime);
-      postPaintCallbackScheduled = !1;
-      callbacks = [];
-    }));
-}
-var ceil = Math.ceil,
-  PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
-  ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
-  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
-  executionContext = 0,
-  workInProgressRoot = null,
-  workInProgress = null,
-  workInProgressRootRenderLanes = 0,
-  workInProgressSuspendedReason = 0,
-  workInProgressThrownValue = null,
-  workInProgressRootDidAttachPingListener = !1,
-  renderLanes = 0,
-  workInProgressRootExitStatus = 0,
-  workInProgressRootFatalError = null,
-  workInProgressRootSkippedLanes = 0,
-  workInProgressRootInterleavedUpdatedLanes = 0,
-  workInProgressRootPingedLanes = 0,
-  workInProgressRootConcurrentErrors = null,
-  workInProgressRootRecoverableErrors = null,
-  globalMostRecentFallbackTime = 0,
-  workInProgressRootRenderTargetTime = Infinity,
-  workInProgressTransitions = null,
-  currentPendingTransitionCallbacks = null,
-  currentEndTime = null;
-function addMarkerProgressCallbackToPendingTransition(
-  markerName,
-  transitions,
-  pendingBoundaries
-) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: new Map(),
-        markerIncomplete: null,
-        markerComplete: null
-      }),
-    null === currentPendingTransitionCallbacks.markerProgress &&
-      (currentPendingTransitionCallbacks.markerProgress = new Map()),
-    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
-      pendingBoundaries: pendingBoundaries,
-      transitions: transitions
-    }));
-}
-function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: new Map()
-      }),
-    null === currentPendingTransitionCallbacks.markerComplete &&
-      (currentPendingTransitionCallbacks.markerComplete = new Map()),
-    currentPendingTransitionCallbacks.markerComplete.set(
-      markerName,
-      transitions
-    ));
-}
-function addTransitionProgressCallbackToPendingTransition(
-  transition,
-  boundaries
-) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: new Map(),
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      }),
-    null === currentPendingTransitionCallbacks.transitionProgress &&
-      (currentPendingTransitionCallbacks.transitionProgress = new Map()),
-    currentPendingTransitionCallbacks.transitionProgress.set(
-      transition,
-      boundaries
-    ));
+function FiberNode(tag, pendingProps, key, mode) {
+  this.tag = tag;
+  this.key = key;
+  this.sibling =
+    this.child =
+    this.return =
+    this.stateNode =
+    this.type =
+    this.elementType =
+      null;
+  this.index = 0;
+  this.refCleanup = this.ref = null;
+  this.pendingProps = pendingProps;
+  this.dependencies =
+    this.memoizedState =
+    this.updateQueue =
+    this.memoizedProps =
+      null;
+  this.mode = mode;
+  this.subtreeFlags = this.flags = 0;
+  this.deletions = null;
+  this.childLanes = this.lanes = 0;
+  this.alternate = null;
 }
-function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now() + 500;
+function createFiber(tag, pendingProps, key, mode) {
+  return new FiberNode(tag, pendingProps, key, mode);
 }
-var hasUncaughtError = !1,
-  firstUncaughtError = null,
-  legacyErrorBoundariesThatAlreadyFailed = null,
-  rootDoesHavePassiveEffects = !1,
-  rootWithPendingPassiveEffects = null,
-  pendingPassiveEffectsLanes = 0,
-  pendingPassiveEffectsRemainingLanes = 0,
-  pendingPassiveTransitions = null,
-  nestedUpdateCount = 0,
-  rootWithNestedUpdates = null,
-  currentEventTime = -1,
-  currentEventTransitionLane = 0;
-function requestEventTime() {
-  return 0 !== (executionContext & 6)
-    ? now()
-    : -1 !== currentEventTime
-    ? currentEventTime
-    : (currentEventTime = now());
+function shouldConstruct(Component) {
+  Component = Component.prototype;
+  return !(!Component || !Component.isReactComponent);
 }
-function requestUpdateLane(fiber) {
-  if (0 === (fiber.mode & 1)) return 2;
-  if (
-    !deferRenderPhaseUpdateToNextBatch &&
-    0 !== (executionContext & 2) &&
-    0 !== workInProgressRootRenderLanes
-  )
-    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
-  if (null !== ReactCurrentBatchConfig$1.transition)
-    return (
-      0 === currentEventTransitionLane &&
-        (currentEventTransitionLane = claimNextTransitionLane()),
-      currentEventTransitionLane
-    );
-  fiber = currentUpdatePriority;
-  if (0 !== fiber) return fiber;
-  fiber = window.event;
-  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
-  return fiber;
+function resolveLazyComponentTag(Component) {
+  if ("function" === typeof Component)
+    return shouldConstruct(Component) ? 1 : 0;
+  if (void 0 !== Component && null !== Component) {
+    Component = Component.$$typeof;
+    if (Component === REACT_FORWARD_REF_TYPE) return 11;
+    if (Component === REACT_MEMO_TYPE) return 14;
+  }
+  return 2;
 }
-function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
-  2 === workInProgressSuspendedReason &&
-    root === workInProgressRoot &&
-    (prepareFreshStack(root, 0),
-    markRootSuspended(root, workInProgressRootRenderLanes));
-  markRootUpdated(root, lane, eventTime);
-  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
-    if (enableTransitionTracing) {
-      var transition = ReactCurrentBatchConfig.transition;
-      if (
-        null !== transition &&
-        null != transition.name &&
-        (-1 === transition.startTime && (transition.startTime = now()),
-        enableTransitionTracing)
-      ) {
-        var transitionLanesMap = root.transitionLanes,
-          index$16 = 31 - clz32(lane),
-          transitions = transitionLanesMap[index$16];
-        null === transitions && (transitions = new Set());
-        transitions.add(transition);
-        transitionLanesMap[index$16] = transitions;
-      }
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
+  null === workInProgress
+    ? ((workInProgress = createFiber(
+        current.tag,
+        pendingProps,
+        current.key,
+        current.mode
+      )),
+      (workInProgress.elementType = current.elementType),
+      (workInProgress.type = current.type),
+      (workInProgress.stateNode = current.stateNode),
+      (workInProgress.alternate = current),
+      (current.alternate = workInProgress))
+    : ((workInProgress.pendingProps = pendingProps),
+      (workInProgress.type = current.type),
+      (workInProgress.flags = 0),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null));
+  workInProgress.flags = current.flags & 14680064;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue;
+  pendingProps = current.dependencies;
+  workInProgress.dependencies =
+    null === pendingProps
+      ? null
+      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+  return workInProgress;
+}
+function resetWorkInProgress(workInProgress, renderLanes) {
+  workInProgress.flags &= 14680066;
+  var current = workInProgress.alternate;
+  null === current
+    ? ((workInProgress.childLanes = 0),
+      (workInProgress.lanes = renderLanes),
+      (workInProgress.child = null),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.memoizedProps = null),
+      (workInProgress.memoizedState = null),
+      (workInProgress.updateQueue = null),
+      (workInProgress.dependencies = null),
+      (workInProgress.stateNode = null))
+    : ((workInProgress.childLanes = current.childLanes),
+      (workInProgress.lanes = current.lanes),
+      (workInProgress.child = current.child),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null),
+      (workInProgress.memoizedProps = current.memoizedProps),
+      (workInProgress.memoizedState = current.memoizedState),
+      (workInProgress.updateQueue = current.updateQueue),
+      (workInProgress.type = current.type),
+      (renderLanes = current.dependencies),
+      (workInProgress.dependencies =
+        null === renderLanes
+          ? null
+          : {
+              lanes: renderLanes.lanes,
+              firstContext: renderLanes.firstContext
+            }));
+  return workInProgress;
+}
+function createFiberFromTypeAndProps(
+  type,
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
+) {
+  var fiberTag = 2;
+  owner = type;
+  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
+  else if ("string" === typeof type)
+    fiberTag = isHostHoistableType(
+      type,
+      pendingProps,
+      contextStackCursor$1.current
+    )
+      ? 26
+      : "html" === type || "head" === type || "body" === type
+      ? 27
+      : 5;
+  else
+    a: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = 8;
+        mode |= 8;
+        0 !== (mode & 1) && (mode |= 16);
+        break;
+      case REACT_PROFILER_TYPE:
+        return (
+          (type = createFiber(12, pendingProps, key, mode | 2)),
+          (type.elementType = REACT_PROFILER_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_SUSPENSE_TYPE:
+        return (
+          (type = createFiber(13, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_SUSPENSE_LIST_TYPE:
+        return (
+          (type = createFiber(19, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+      case REACT_LEGACY_HIDDEN_TYPE:
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      case REACT_SCOPE_TYPE:
+        return (
+          (pendingProps = createFiber(21, pendingProps, key, mode)),
+          (pendingProps.type = type),
+          (pendingProps.elementType = type),
+          (pendingProps.lanes = lanes),
+          pendingProps
+        );
+      case REACT_CACHE_TYPE:
+        return (
+          (type = createFiber(24, pendingProps, key, mode)),
+          (type.elementType = REACT_CACHE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing)
+          return (
+            (type = createFiber(25, pendingProps, key, mode)),
+            (type.elementType = REACT_TRACING_MARKER_TYPE),
+            (type.lanes = lanes),
+            (type.stateNode = {
+              tag: 1,
+              transitions: null,
+              pendingBoundaries: null,
+              aborts: null,
+              name: pendingProps.name
+            }),
+            type
+          );
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = 8;
+          mode |= 4;
+          break;
+        }
+      default:
+        if ("object" === typeof type && null !== type)
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = 10;
+              break a;
+            case REACT_CONTEXT_TYPE:
+              fiberTag = 9;
+              break a;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = 11;
+              break a;
+            case REACT_MEMO_TYPE:
+              fiberTag = 14;
+              break a;
+            case REACT_LAZY_TYPE:
+              fiberTag = 16;
+              owner = null;
+              break a;
+          }
+        throw Error(
+          formatProdErrorMessage(130, null == type ? type : typeof type, "")
+        );
     }
-    if (root === workInProgressRoot) {
-      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
-        workInProgressRootInterleavedUpdatedLanes |= lane;
-      4 === workInProgressRootExitStatus &&
-        markRootSuspended(root, workInProgressRootRenderLanes);
+  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
+  pendingProps.elementType = type;
+  pendingProps.type = owner;
+  pendingProps.lanes = lanes;
+  return pendingProps;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  elements = createFiber(7, elements, key, mode);
+  elements.lanes = lanes;
+  return elements;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(22, pendingProps, key, mode);
+  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
+  pendingProps.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
     }
-    ensureRootIsScheduled(root, eventTime);
-    2 === lane &&
-      0 === executionContext &&
-      0 === (fiber.mode & 1) &&
-      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
-  }
+  };
+  pendingProps.stateNode = primaryChildInstance;
+  return pendingProps;
 }
-function ensureRootIsScheduled(root, currentTime) {
-  var existingCallbackNode = root.callbackNode;
-  markStarvedLanesAsExpired(root, currentTime);
-  var nextLanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
-  );
-  if (0 === nextLanes)
-    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
-      (root.callbackNode = null),
-      (root.callbackPriority = 0);
-  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
-    (root.callbackPriority = 0), (root.callbackNode = null);
-  else if (
-    ((currentTime = nextLanes & -nextLanes),
-    root.callbackPriority !== currentTime)
-  ) {
-    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
-    if (0 !== (currentTime & 3))
-      0 === root.tag
-        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
-        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
-        scheduleMicrotask(function () {
-          0 === (executionContext & 6) && flushSyncCallbacks();
-        }),
-        (existingCallbackNode = null);
-    else {
-      switch (lanesToEventPriority(nextLanes)) {
-        case 2:
-          existingCallbackNode = ImmediatePriority;
-          break;
-        case 8:
-          existingCallbackNode = UserBlockingPriority;
-          break;
-        case 32:
-          existingCallbackNode = NormalPriority$1;
-          break;
-        case 536870912:
-          existingCallbackNode = IdlePriority;
-          break;
-        default:
-          existingCallbackNode = NormalPriority$1;
-      }
-      existingCallbackNode = scheduleCallback(
-        existingCallbackNode,
-        performConcurrentWorkOnRoot.bind(null, root)
-      );
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(23, pendingProps, key, mode);
+  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  pendingProps.lanes = lanes;
+  var instance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
     }
-    root.callbackPriority = currentTime;
-    root.callbackNode = existingCallbackNode;
-  }
+  };
+  pendingProps.stateNode = instance;
+  return pendingProps;
 }
-function performConcurrentWorkOnRoot(root, didTimeout) {
-  currentEventTime = -1;
-  currentEventTransitionLane = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var originalCallbackNode = root.callbackNode;
-  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
-    return null;
-  var lanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+function createFiberFromText(content, mode, lanes) {
+  content = createFiber(6, content, null, mode);
+  content.lanes = lanes;
+  return content;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  mode = createFiber(
+    4,
+    null !== portal.children ? portal.children : [],
+    portal.key,
+    mode
   );
-  if (0 === lanes) return null;
-  didTimeout =
-    includesBlockingLane(root, lanes) ||
-    0 !== (lanes & root.expiredLanes) ||
-    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
-      ? renderRootSync(root, lanes)
-      : renderRootConcurrent(root, lanes);
-  if (0 !== didTimeout) {
-    if (2 === didTimeout) {
-      var originallyAttemptedLanes = lanes,
-        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-          root,
-          originallyAttemptedLanes
-        );
-      0 !== errorRetryLanes &&
-        ((lanes = errorRetryLanes),
-        (didTimeout = recoverFromConcurrentError(
-          root,
-          originallyAttemptedLanes,
-          errorRetryLanes
-        )));
-    }
-    if (1 === didTimeout)
-      throw (
-        ((originalCallbackNode = workInProgressRootFatalError),
-        prepareFreshStack(root, 0),
-        markRootSuspended(root, lanes),
-        ensureRootIsScheduled(root, now()),
-        originalCallbackNode)
-      );
-    if (6 === didTimeout) markRootSuspended(root, lanes);
-    else {
-      errorRetryLanes = !includesBlockingLane(root, lanes);
-      originallyAttemptedLanes = root.current.alternate;
-      if (
-        errorRetryLanes &&
-        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
-      ) {
-        didTimeout = renderRootSync(root, lanes);
-        if (2 === didTimeout) {
-          errorRetryLanes = lanes;
-          var errorRetryLanes$212 = getLanesToRetrySynchronouslyOnError(
-            root,
-            errorRetryLanes
-          );
-          0 !== errorRetryLanes$212 &&
-            ((lanes = errorRetryLanes$212),
-            (didTimeout = recoverFromConcurrentError(
-              root,
-              errorRetryLanes,
-              errorRetryLanes$212
-            )));
-        }
-        if (1 === didTimeout)
-          throw (
-            ((originalCallbackNode = workInProgressRootFatalError),
-            prepareFreshStack(root, 0),
-            markRootSuspended(root, lanes),
-            ensureRootIsScheduled(root, now()),
-            originalCallbackNode)
-          );
-      }
-      root.finishedWork = originallyAttemptedLanes;
-      root.finishedLanes = lanes;
-      switch (didTimeout) {
-        case 0:
-        case 1:
-          throw Error(formatProdErrorMessage(345));
-        case 2:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
+  mode.lanes = lanes;
+  mode.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    implementation: portal.implementation
+  };
+  return mode;
+}
+function FiberRootNode(
+  containerInfo,
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
+) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.finishedWork =
+    this.pingCache =
+    this.current =
+    this.pendingChildren =
+      null;
+  this.timeoutHandle = -1;
+  this.callbackNode = this.pendingContext = this.context = null;
+  this.callbackPriority = 0;
+  this.eventTimes = createLaneMap(0);
+  this.expirationTimes = createLaneMap(-1);
+  this.entangledLanes =
+    this.errorRecoveryDisabledLanes =
+    this.finishedLanes =
+    this.mutableReadLanes =
+    this.expiredLanes =
+    this.pingedLanes =
+    this.suspendedLanes =
+    this.pendingLanes =
+      0;
+  this.entanglements = createLaneMap(0);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+  this.pooledCache = null;
+  this.pooledCacheLanes = 0;
+  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
+  this.incompleteTransitions = new Map();
+  if (enableTransitionTracing)
+    for (
+      this.transitionCallbacks = null,
+        containerInfo = this.transitionLanes = [],
+        tag = 0;
+      31 > tag;
+      tag++
+    )
+      containerInfo.push(null);
+}
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  containerInfo = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
+  );
+  containerInfo.hydrationCallbacks = hydrationCallbacks;
+  enableTransitionTracing &&
+    (containerInfo.transitionCallbacks = transitionCallbacks);
+  1 === tag
+    ? ((tag = 1),
+      !0 === isStrictMode && (tag |= 24),
+      concurrentUpdatesByDefaultOverride && (tag |= 32))
+    : (tag = 0);
+  isStrictMode = createFiber(3, null, null, tag);
+  containerInfo.current = isStrictMode;
+  isStrictMode.stateNode = containerInfo;
+  concurrentUpdatesByDefaultOverride = createCache();
+  concurrentUpdatesByDefaultOverride.refCount++;
+  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
+  concurrentUpdatesByDefaultOverride.refCount++;
+  isStrictMode.memoizedState = {
+    element: initialChildren,
+    isDehydrated: hydrate,
+    cache: concurrentUpdatesByDefaultOverride
+  };
+  initializeUpdateQueue(isStrictMode);
+  return containerInfo;
+}
+function createPortal$1(children, containerInfo, implementation) {
+  var key =
+    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+  return {
+    $$typeof: REACT_PORTAL_TYPE,
+    key: null == key ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
+}
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) return emptyContextObject;
+  parentComponent = parentComponent._reactInternals;
+  a: {
+    if (
+      getNearestMountedFiber(parentComponent) !== parentComponent ||
+      1 !== parentComponent.tag
+    )
+      throw Error(formatProdErrorMessage(170));
+    var JSCompiler_inline_result = parentComponent;
+    do {
+      switch (JSCompiler_inline_result.tag) {
         case 3:
-          markRootSuspended(root, lanes);
-          if (
-            (lanes & 125829120) === lanes &&
-            ((lanes = globalMostRecentFallbackTime + 500 - now()), 10 < lanes)
-          ) {
-            if (0 !== getNextLanes(root, 0)) break;
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
-          }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 4:
-          markRootSuspended(root, lanes);
-          if ((lanes & 8388480) === lanes) break;
-          didTimeout = root.eventTimes;
-          for (originallyAttemptedLanes = -1; 0 < lanes; )
-            (errorRetryLanes$212 = 31 - clz32(lanes)),
-              (errorRetryLanes = 1 << errorRetryLanes$212),
-              (errorRetryLanes$212 = didTimeout[errorRetryLanes$212]),
-              errorRetryLanes$212 > originallyAttemptedLanes &&
-                (originallyAttemptedLanes = errorRetryLanes$212),
-              (lanes &= ~errorRetryLanes);
-          lanes = originallyAttemptedLanes;
-          lanes = now() - lanes;
-          lanes =
-            (120 > lanes
-              ? 120
-              : 480 > lanes
-              ? 480
-              : 1080 > lanes
-              ? 1080
-              : 1920 > lanes
-              ? 1920
-              : 3e3 > lanes
-              ? 3e3
-              : 4320 > lanes
-              ? 4320
-              : 1960 * ceil(lanes / 1960)) - lanes;
-          if (10 < lanes) {
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
+          JSCompiler_inline_result = JSCompiler_inline_result.stateNode.context;
+          break a;
+        case 1:
+          if (isContextProvider(JSCompiler_inline_result.type)) {
+            JSCompiler_inline_result =
+              JSCompiler_inline_result.stateNode
+                .__reactInternalMemoizedMergedChildContext;
+            break a;
           }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 5:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        default:
-          throw Error(formatProdErrorMessage(329));
       }
-    }
+      JSCompiler_inline_result = JSCompiler_inline_result.return;
+    } while (null !== JSCompiler_inline_result);
+    throw Error(formatProdErrorMessage(171));
   }
-  ensureRootIsScheduled(root, now());
-  return root.callbackNode === originalCallbackNode
-    ? performConcurrentWorkOnRoot.bind(null, root)
-    : null;
-}
-function recoverFromConcurrentError(
-  root,
-  originallyAttemptedLanes,
-  errorRetryLanes
-) {
-  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
-    wasRootDehydrated = root.current.memoizedState.isDehydrated;
-  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
-  errorRetryLanes = renderRootSync(root, errorRetryLanes);
-  if (2 !== errorRetryLanes) {
-    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
-      return (
-        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
-        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
-        4
+  if (1 === parentComponent.tag) {
+    var Component = parentComponent.type;
+    if (isContextProvider(Component))
+      return processChildContext(
+        parentComponent,
+        Component,
+        JSCompiler_inline_result
       );
-    root = workInProgressRootRecoverableErrors;
-    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
-    null !== root && queueRecoverableErrors(root);
   }
-  return errorRetryLanes;
+  return JSCompiler_inline_result;
 }
-function queueRecoverableErrors(errors) {
-  null === workInProgressRootRecoverableErrors
-    ? (workInProgressRootRecoverableErrors = errors)
-    : workInProgressRootRecoverableErrors.push.apply(
-        workInProgressRootRecoverableErrors,
-        errors
-      );
+function createHydrationContainer(
+  initialChildren,
+  callback,
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  initialChildren = createFiberRoot(
+    containerInfo,
+    tag,
+    !0,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
+  );
+  initialChildren.context = getContextForSubtree(null);
+  containerInfo = initialChildren.current;
+  tag = requestUpdateLane(containerInfo);
+  hydrationCallbacks = createUpdate(tag);
+  hydrationCallbacks.callback =
+    void 0 !== callback && null !== callback ? callback : null;
+  callback = requestEventTime();
+  enqueueUpdate(containerInfo, hydrationCallbacks, tag);
+  initialChildren.current.lanes = tag;
+  markRootUpdated(initialChildren, tag, callback);
+  ensureRootIsScheduled(initialChildren, callback);
+  return initialChildren;
+}
+function updateContainer(element, container, parentComponent, callback) {
+  var current = container.current,
+    lane = requestUpdateLane(current);
+  parentComponent = getContextForSubtree(parentComponent);
+  null === container.context
+    ? (container.context = parentComponent)
+    : (container.pendingContext = parentComponent);
+  container = createUpdate(lane);
+  container.payload = { element: element };
+  callback = void 0 === callback ? null : callback;
+  null !== callback && (container.callback = callback);
+  element = enqueueUpdate(current, container, lane);
+  null !== element &&
+    ((callback = requestEventTime()),
+    scheduleUpdateOnFiber(element, current, lane, callback),
+    entangleTransitions(element, current, lane));
+  return lane;
+}
+function getPublicRootInstance(container) {
+  container = container.current;
+  if (!container.child) return null;
+  switch (container.child.tag) {
+    case 27:
+    case 5:
+      return container.child.stateNode;
+    default:
+      return container.child.stateNode;
+  }
 }
-function isRenderConsistentWithExternalStores(finishedWork) {
-  for (var node = finishedWork; ; ) {
-    if (node.flags & 16384) {
-      var updateQueue = node.updateQueue;
-      if (
-        null !== updateQueue &&
-        ((updateQueue = updateQueue.stores), null !== updateQueue)
-      )
-        for (var i = 0; i < updateQueue.length; i++) {
-          var check = updateQueue[i],
-            getSnapshot = check.getSnapshot;
-          check = check.value;
-          try {
-            if (!objectIs(getSnapshot(), check)) return !1;
-          } catch (error) {
-            return !1;
-          }
-        }
-    }
-    updateQueue = node.child;
-    if (node.subtreeFlags & 16384 && null !== updateQueue)
-      (updateQueue.return = node), (node = updateQueue);
-    else {
-      if (node === finishedWork) break;
-      for (; null === node.sibling; ) {
-        if (null === node.return || node.return === finishedWork) return !0;
-        node = node.return;
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case 3:
+      var root$208 = fiber.stateNode;
+      if (root$208.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$208.pendingLanes);
+        0 !== lanes &&
+          (markRootEntangled(root$208, lanes | 2),
+          ensureRootIsScheduled(root$208, now()),
+          0 === (executionContext & 6) &&
+            (resetRenderTimer(), flushSyncCallbacks()));
       }
-      node.sibling.return = node.return;
-      node = node.sibling;
-    }
+      break;
+    case 13:
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, 2);
+        if (null !== root) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
+        }
+      }),
+        markRetryLaneIfNotHydrated(fiber, 2);
   }
-  return !0;
 }
-function markRootSuspended(root, suspendedLanes) {
-  suspendedLanes &= ~workInProgressRootPingedLanes;
-  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
-  root.suspendedLanes |= suspendedLanes;
-  root.pingedLanes &= ~suspendedLanes;
-  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
-    var index$13 = 31 - clz32(suspendedLanes),
-      lane = 1 << index$13;
-    root[index$13] = -1;
-    suspendedLanes &= ~lane;
+function markRetryLaneImpl(fiber, retryLane) {
+  fiber = fiber.memoizedState;
+  if (null !== fiber && null !== fiber.dehydrated) {
+    var a = fiber.retryLane;
+    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
   }
 }
-function performSyncWorkOnRoot(root) {
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  flushPassiveEffects();
-  var lanes = getNextLanes(root, 0);
-  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now()), null;
-  var exitStatus = renderRootSync(root, lanes);
-  if (0 !== root.tag && 2 === exitStatus) {
-    var originallyAttemptedLanes = lanes,
-      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-        root,
-        originallyAttemptedLanes
-      );
-    0 !== errorRetryLanes &&
-      ((lanes = errorRetryLanes),
-      (exitStatus = recoverFromConcurrentError(
-        root,
-        originallyAttemptedLanes,
-        errorRetryLanes
-      )));
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
+}
+function attemptContinuousHydration(fiber) {
+  if (13 === fiber.tag) {
+    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
+    if (null !== root) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
+    }
+    markRetryLaneIfNotHydrated(fiber, 134217728);
   }
-  if (1 === exitStatus)
-    throw (
-      ((exitStatus = workInProgressRootFatalError),
-      prepareFreshStack(root, 0),
-      markRootSuspended(root, lanes),
-      ensureRootIsScheduled(root, now()),
-      exitStatus)
-    );
-  if (6 === exitStatus)
-    return (
-      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now()), null
-    );
-  root.finishedWork = root.current.alternate;
-  root.finishedLanes = lanes;
-  commitRoot(
-    root,
-    workInProgressRootRecoverableErrors,
-    workInProgressTransitions
-  );
-  ensureRootIsScheduled(root, now());
+}
+function emptyFindFiberByHostInstance() {
   return null;
 }
-function batchedUpdates(fn, a) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
+var isInsideEventHandler = !1;
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) return fn(a, b);
+  isInsideEventHandler = !0;
   try {
-    return fn(a);
+    return batchedUpdates$1(fn, a, b);
   } finally {
-    (executionContext = prevExecutionContext),
-      0 === executionContext &&
-        (resetRenderTimer(),
-        includesLegacySyncCallbacks && flushSyncCallbacks());
-  }
-}
-function flushSync$1(fn) {
-  null !== rootWithPendingPassiveEffects &&
-    0 === rootWithPendingPassiveEffects.tag &&
-    0 === (executionContext & 6) &&
-    flushPassiveEffects();
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
-    previousPriority = currentUpdatePriority;
-  try {
     if (
-      ((ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      fn)
+      ((isInsideEventHandler = !1),
+      null !== restoreTarget || null !== restoreQueue)
     )
-      return fn();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
-      (executionContext = prevExecutionContext),
-      0 === (executionContext & 6) && flushSyncCallbacks();
+      flushSync$1(), restoreStateIfNeeded();
   }
 }
-function resetWorkInProgressStack() {
-  if (null !== workInProgress) {
-    if (0 === workInProgressSuspendedReason)
-      var interruptedWork = workInProgress.return;
-    else
-      resetContextDependencies(),
-        resetHooksOnUnwind(),
-        (thenableState$1 = null),
-        (thenableIndexCounter$1 = 0),
-        (interruptedWork = workInProgress);
-    for (; null !== interruptedWork; )
-      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
-        (interruptedWork = interruptedWork.return);
-    workInProgress = null;
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
+  if (null === stateNode) return null;
+  var props = getFiberCurrentPropsFromNode(stateNode);
+  if (null === props) return null;
+  stateNode = props[registrationName];
+  a: switch (registrationName) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      (props = !props.disabled) ||
+        ((inst = inst.type),
+        (props = !(
+          "button" === inst ||
+          "input" === inst ||
+          "select" === inst ||
+          "textarea" === inst
+        )));
+      inst = !props;
+      break a;
+    default:
+      inst = !1;
   }
+  if (inst) return null;
+  if (stateNode && "function" !== typeof stateNode)
+    throw Error(
+      formatProdErrorMessage(231, registrationName, typeof stateNode)
+    );
+  return stateNode;
 }
-function prepareFreshStack(root, lanes) {
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  var timeoutHandle = root.timeoutHandle;
-  -1 !== timeoutHandle &&
-    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
-  resetWorkInProgressStack();
-  workInProgressRoot = root;
-  workInProgress = root = createWorkInProgress(root.current, null);
-  workInProgressRootRenderLanes = renderLanes = lanes;
-  workInProgressSuspendedReason = 0;
-  workInProgressThrownValue = null;
-  workInProgressRootDidAttachPingListener = !1;
-  workInProgressRootExitStatus = 0;
-  workInProgressRootFatalError = null;
-  workInProgressRootPingedLanes =
-    workInProgressRootInterleavedUpdatedLanes =
-    workInProgressRootSkippedLanes =
-      0;
-  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
-    null;
-  finishQueueingConcurrentUpdates();
-  return root;
-}
-function handleThrow(root, thrownValue) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  ReactCurrentOwner.current = null;
-  if (thrownValue === SuspenseException) {
-    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
-    root = suspendedThenable;
-    suspendedThenable = null;
-    thrownValue = root;
-    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
-      ? 2
-      : 3;
-  } else
-    workInProgressSuspendedReason =
-      thrownValue === SelectiveHydrationException
-        ? 6
-        : null !== thrownValue &&
-          "object" === typeof thrownValue &&
-          "function" === typeof thrownValue.then
-        ? 4
-        : 1;
-  workInProgressThrownValue = thrownValue;
-  null === workInProgress &&
-    ((workInProgressRootExitStatus = 1),
-    (workInProgressRootFatalError = thrownValue));
+var passiveBrowserEventsSupported = !1;
+if (canUseDOM)
+  try {
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = !0;
+      }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = !1;
+  }
+var EventListenerWWW = require("EventListener"),
+  root = null,
+  startText = null,
+  fallbackText = null;
+function getData() {
+  if (fallbackText) return fallbackText;
+  var start,
+    startValue = startText,
+    startLength = startValue.length,
+    end,
+    endValue = "value" in root ? root.value : root.textContent,
+    endLength = endValue.length;
+  for (
+    start = 0;
+    start < startLength && startValue[start] === endValue[start];
+    start++
+  );
+  var minEnd = startLength - start;
+  for (
+    end = 1;
+    end <= minEnd &&
+    startValue[startLength - end] === endValue[endLength - end];
+    end++
+  );
+  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
 }
-function shouldAttemptToSuspendUntilDataResolves() {
-  if (
-    0 !== (workInProgressRootSkippedLanes & 268435455) ||
-    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
-  )
-    return !1;
-  if (
-    (workInProgressRootRenderLanes & 8388480) ===
-    workInProgressRootRenderLanes
-  )
-    return null === shellBoundary;
-  var handler = suspenseHandlerStackCursor.current;
-  return null !== handler &&
-    (workInProgressRootRenderLanes & 125829120) ===
-      workInProgressRootRenderLanes
-    ? handler === shellBoundary
-    : !1;
+function getEventCharCode(nativeEvent) {
+  var keyCode = nativeEvent.keyCode;
+  "charCode" in nativeEvent
+    ? ((nativeEvent = nativeEvent.charCode),
+      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
+    : (nativeEvent = keyCode);
+  10 === nativeEvent && (nativeEvent = 13);
+  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
 }
-function pushDispatcher(container) {
-  container = getHoistableRoot(container);
-  lastCurrentDocument = container.ownerDocument || container;
-  previousDispatcher = Dispatcher$1.current;
-  Dispatcher$1.current = ReactDOMClientDispatcher;
-  container = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
-  return null === container ? ContextOnlyDispatcher : container;
+function functionThatReturnsTrue() {
+  return !0;
 }
-function pushCacheDispatcher() {
-  var prevCacheDispatcher = ReactCurrentCache.current;
-  ReactCurrentCache.current = DefaultCacheDispatcher;
-  return prevCacheDispatcher;
+function functionThatReturnsFalse() {
+  return !1;
 }
-function renderDidSuspendDelayIfPossible() {
-  workInProgressRootExitStatus = 4;
-  null === workInProgressRoot ||
-    (0 === (workInProgressRootSkippedLanes & 268435455) &&
-      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
-    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+function createSyntheticEvent(Interface) {
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  ) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+    for (var propName in Interface)
+      Interface.hasOwnProperty(propName) &&
+        ((reactName = Interface[propName]),
+        (this[propName] = reactName
+          ? reactName(nativeEvent)
+          : nativeEvent[propName]));
+    this.isDefaultPrevented = (
+      null != nativeEvent.defaultPrevented
+        ? nativeEvent.defaultPrevented
+        : !1 === nativeEvent.returnValue
+    )
+      ? functionThatReturnsTrue
+      : functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  }
+  assign(SyntheticBaseEvent.prototype, {
+    preventDefault: function () {
+      this.defaultPrevented = !0;
+      var event = this.nativeEvent;
+      event &&
+        (event.preventDefault
+          ? event.preventDefault()
+          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
+        (this.isDefaultPrevented = functionThatReturnsTrue));
+    },
+    stopPropagation: function () {
+      var event = this.nativeEvent;
+      event &&
+        (event.stopPropagation
+          ? event.stopPropagation()
+          : "unknown" !== typeof event.cancelBubble &&
+            (event.cancelBubble = !0),
+        (this.isPropagationStopped = functionThatReturnsTrue));
+    },
+    persist: function () {},
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
 }
-function renderRootSync(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
-      prepareFreshStack(root, lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
-        lanes = workInProgress;
-        var thrownValue = workInProgressThrownValue;
-        switch (workInProgressSuspendedReason) {
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            (workInProgressSuspendedReason = 0),
-              (workInProgressThrownValue = null),
-              unwindSuspendedUnitOfWork(lanes, thrownValue);
-        }
-      }
-      workLoopSync();
-      break;
-    } catch (thrownValue$215) {
-      handleThrow(root, thrownValue$215);
+var EventInterface = {
+    eventPhase: 0,
+    bubbles: 0,
+    cancelable: 0,
+    timeStamp: function (event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: 0,
+    isTrusted: 0
+  },
+  SyntheticEvent = createSyntheticEvent(EventInterface),
+  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
+  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
+  lastMovementX,
+  lastMovementY,
+  lastMouseEvent,
+  MouseEventInterface = assign({}, UIEventInterface, {
+    screenX: 0,
+    screenY: 0,
+    clientX: 0,
+    clientY: 0,
+    pageX: 0,
+    pageY: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    getModifierState: getEventModifierState,
+    button: 0,
+    buttons: 0,
+    relatedTarget: function (event) {
+      return void 0 === event.relatedTarget
+        ? event.fromElement === event.srcElement
+          ? event.toElement
+          : event.fromElement
+        : event.relatedTarget;
+    },
+    movementX: function (event) {
+      if ("movementX" in event) return event.movementX;
+      event !== lastMouseEvent &&
+        (lastMouseEvent && "mousemove" === event.type
+          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
+            (lastMovementY = event.screenY - lastMouseEvent.screenY))
+          : (lastMovementY = lastMovementX = 0),
+        (lastMouseEvent = event));
+      return lastMovementX;
+    },
+    movementY: function (event) {
+      return "movementY" in event ? event.movementY : lastMovementY;
     }
-  while (1);
-  resetContextDependencies();
-  executionContext = prevExecutionContext;
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
+  }),
+  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
+  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
+  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
+  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
+  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
+  AnimationEventInterface = assign({}, EventInterface, {
+    animationName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
+  ClipboardEventInterface = assign({}, EventInterface, {
+    clipboardData: function (event) {
+      return "clipboardData" in event
+        ? event.clipboardData
+        : window.clipboardData;
+    }
+  }),
+  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
+  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
+  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
+  normalizeKey = {
+    Esc: "Escape",
+    Spacebar: " ",
+    Left: "ArrowLeft",
+    Up: "ArrowUp",
+    Right: "ArrowRight",
+    Down: "ArrowDown",
+    Del: "Delete",
+    Win: "OS",
+    Menu: "ContextMenu",
+    Apps: "ContextMenu",
+    Scroll: "ScrollLock",
+    MozPrintableKey: "Unidentified"
+  },
+  translateToKey = {
+    8: "Backspace",
+    9: "Tab",
+    12: "Clear",
+    13: "Enter",
+    16: "Shift",
+    17: "Control",
+    18: "Alt",
+    19: "Pause",
+    20: "CapsLock",
+    27: "Escape",
+    32: " ",
+    33: "PageUp",
+    34: "PageDown",
+    35: "End",
+    36: "Home",
+    37: "ArrowLeft",
+    38: "ArrowUp",
+    39: "ArrowRight",
+    40: "ArrowDown",
+    45: "Insert",
+    46: "Delete",
+    112: "F1",
+    113: "F2",
+    114: "F3",
+    115: "F4",
+    116: "F5",
+    117: "F6",
+    118: "F7",
+    119: "F8",
+    120: "F9",
+    121: "F10",
+    122: "F11",
+    123: "F12",
+    144: "NumLock",
+    145: "ScrollLock",
+    224: "Meta"
+  },
+  modifierKeyToProp = {
+    Alt: "altKey",
+    Control: "ctrlKey",
+    Meta: "metaKey",
+    Shift: "shiftKey"
+  };
+function modifierStateGetter(keyArg) {
+  var nativeEvent = this.nativeEvent;
+  return nativeEvent.getModifierState
+    ? nativeEvent.getModifierState(keyArg)
+    : (keyArg = modifierKeyToProp[keyArg])
+    ? !!nativeEvent[keyArg]
+    : !1;
 }
-function workLoopSync() {
-  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+function getEventModifierState() {
+  return modifierStateGetter;
 }
-function renderRootConcurrent(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
-      resetRenderTimer(),
-      prepareFreshStack(root, lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
-        lanes = workInProgress;
-        var thrownValue = workInProgressThrownValue;
-        switch (workInProgressSuspendedReason) {
-          case 1:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, thrownValue);
-            break;
-          case 2:
-            if (isThenableResolved(thrownValue)) {
-              workInProgressSuspendedReason = 0;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(lanes);
-              break;
-            }
-            lanes = function () {
-              2 === workInProgressSuspendedReason &&
-                workInProgressRoot === root &&
-                (workInProgressSuspendedReason = 5);
-              ensureRootIsScheduled(root, now());
-            };
-            thrownValue.then(lanes, lanes);
-            break a;
-          case 3:
-            workInProgressSuspendedReason = 5;
-            break a;
-          case 5:
-            isThenableResolved(thrownValue)
-              ? ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                replaySuspendedUnitOfWork(lanes))
-              : ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                unwindSuspendedUnitOfWork(lanes, thrownValue));
-            break;
-          case 4:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, thrownValue);
-            break;
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            throw Error(formatProdErrorMessage(462));
-        }
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+    key: function (nativeEvent) {
+      if (nativeEvent.key) {
+        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+        if ("Unidentified" !== key) return key;
       }
-      workLoopConcurrent();
-      break;
-    } catch (thrownValue$217) {
-      handleThrow(root, thrownValue$217);
+      return "keypress" === nativeEvent.type
+        ? ((nativeEvent = getEventCharCode(nativeEvent)),
+          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
+        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
+        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
+        : "";
+    },
+    code: 0,
+    location: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    repeat: 0,
+    locale: 0,
+    getModifierState: getEventModifierState,
+    charCode: function (event) {
+      return "keypress" === event.type ? getEventCharCode(event) : 0;
+    },
+    keyCode: function (event) {
+      return "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
+    },
+    which: function (event) {
+      return "keypress" === event.type
+        ? getEventCharCode(event)
+        : "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
     }
-  while (1);
-  resetContextDependencies();
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  executionContext = prevExecutionContext;
-  if (null !== workInProgress) return 0;
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
-}
-function workLoopConcurrent() {
-  for (; null !== workInProgress && !shouldYield(); )
-    performUnitOfWork(workInProgress);
-}
-function performUnitOfWork(unitOfWork) {
-  var next = beginWork(unitOfWork.alternate, unitOfWork, renderLanes);
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === next ? completeUnitOfWork(unitOfWork) : (workInProgress = next);
-  ReactCurrentOwner.current = null;
-}
-function replaySuspendedUnitOfWork(unitOfWork) {
-  var current = unitOfWork.alternate;
-  switch (unitOfWork.tag) {
-    case 2:
-      unitOfWork.tag = 0;
-    case 0:
-    case 11:
-      var Component = unitOfWork.type,
-        unresolvedProps = unitOfWork.pendingProps;
-      unresolvedProps =
-        unitOfWork.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unresolvedProps,
-        Component,
-        workInProgressRootRenderLanes
-      );
-      break;
-    case 15:
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unitOfWork.pendingProps,
-        unitOfWork.type,
-        workInProgressRootRenderLanes
+  }),
+  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
+  PointerEventInterface = assign({}, MouseEventInterface, {
+    pointerId: 0,
+    width: 0,
+    height: 0,
+    pressure: 0,
+    tangentialPressure: 0,
+    tiltX: 0,
+    tiltY: 0,
+    twist: 0,
+    pointerType: 0,
+    isPrimary: 0
+  }),
+  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
+  TouchEventInterface = assign({}, UIEventInterface, {
+    touches: 0,
+    targetTouches: 0,
+    changedTouches: 0,
+    altKey: 0,
+    metaKey: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    getModifierState: getEventModifierState
+  }),
+  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
+  TransitionEventInterface = assign({}, EventInterface, {
+    propertyName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
+  WheelEventInterface = assign({}, MouseEventInterface, {
+    deltaX: function (event) {
+      return "deltaX" in event
+        ? event.deltaX
+        : "wheelDeltaX" in event
+        ? -event.wheelDeltaX
+        : 0;
+    },
+    deltaY: function (event) {
+      return "deltaY" in event
+        ? event.deltaY
+        : "wheelDeltaY" in event
+        ? -event.wheelDeltaY
+        : "wheelDelta" in event
+        ? -event.wheelDelta
+        : 0;
+    },
+    deltaZ: 0,
+    deltaMode: 0
+  }),
+  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
+  END_KEYCODES = [9, 13, 27, 32],
+  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
+  documentMode = null;
+canUseDOM &&
+  "documentMode" in document &&
+  (documentMode = document.documentMode);
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
+  useFallbackCompositionData =
+    canUseDOM &&
+    (!canUseCompositionEvent ||
+      (documentMode && 8 < documentMode && 11 >= documentMode)),
+  SPACEBAR_CHAR = String.fromCharCode(32),
+  hasSpaceKeypress = !1;
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
+    case "keydown":
+      return 229 !== nativeEvent.keyCode;
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function getDataFromCustomEvent(nativeEvent) {
+  nativeEvent = nativeEvent.detail;
+  return "object" === typeof nativeEvent && "data" in nativeEvent
+    ? nativeEvent.data
+    : null;
+}
+var isComposing = !1;
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
+    case "keypress":
+      if (32 !== nativeEvent.which) return null;
+      hasSpaceKeypress = !0;
+      return SPACEBAR_CHAR;
+    case "textInput":
+      return (
+        (domEventName = nativeEvent.data),
+        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
       );
-      break;
     default:
-      unwindInterruptedWork(current, unitOfWork),
-        (unitOfWork = workInProgress =
-          resetWorkInProgress(unitOfWork, renderLanes)),
-        (current = beginWork(current, unitOfWork, renderLanes));
+      return null;
   }
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === current
-    ? completeUnitOfWork(unitOfWork)
-    : (workInProgress = current);
-  ReactCurrentOwner.current = null;
 }
-function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
-  resetContextDependencies();
-  resetHooksOnUnwind();
-  thenableState$1 = null;
-  thenableIndexCounter$1 = 0;
-  var returnFiber = unitOfWork.return;
-  if (null === returnFiber || null === workInProgressRoot)
-    (workInProgressRootExitStatus = 1),
-      (workInProgressRootFatalError = thrownValue),
-      (workInProgress = null);
-  else {
-    try {
-      a: {
-        var root = workInProgressRoot,
-          value = thrownValue;
-        thrownValue = workInProgressRootRenderLanes;
-        unitOfWork.flags |= 32768;
-        if (
-          null !== value &&
-          "object" === typeof value &&
-          "function" === typeof value.then
-        ) {
-          var wakeable = value;
-          if (enableLazyContextPropagation) {
-            var currentSourceFiber = unitOfWork.alternate;
-            null !== currentSourceFiber &&
-              propagateParentContextChanges(
-                currentSourceFiber,
-                unitOfWork,
-                thrownValue,
-                !0
-              );
-          }
-          var tag = unitOfWork.tag;
-          if (
-            0 === (unitOfWork.mode & 1) &&
-            (0 === tag || 11 === tag || 15 === tag)
-          ) {
-            var currentSource = unitOfWork.alternate;
-            currentSource
-              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
-                (unitOfWork.memoizedState = currentSource.memoizedState),
-                (unitOfWork.lanes = currentSource.lanes))
-              : ((unitOfWork.updateQueue = null),
-                (unitOfWork.memoizedState = null));
-          }
-          var suspenseBoundary = suspenseHandlerStackCursor.current;
-          if (null !== suspenseBoundary) {
-            switch (suspenseBoundary.tag) {
-              case 13:
-                unitOfWork.mode & 1 &&
-                  (null === shellBoundary
-                    ? renderDidSuspendDelayIfPossible()
-                    : null === suspenseBoundary.alternate &&
-                      0 === workInProgressRootExitStatus &&
-                      (workInProgressRootExitStatus = 3));
-                suspenseBoundary.flags &= -257;
-                markSuspenseBoundaryShouldCapture(
-                  suspenseBoundary,
-                  returnFiber,
-                  unitOfWork,
-                  root,
-                  thrownValue
-                );
-                var wakeables = suspenseBoundary.updateQueue;
-                null === wakeables
-                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
-                  : wakeables.add(wakeable);
-                break;
-              case 22:
-                if (suspenseBoundary.mode & 1) {
-                  suspenseBoundary.flags |= 65536;
-                  var offscreenQueue = suspenseBoundary.updateQueue;
-                  if (null === offscreenQueue) {
-                    var newOffscreenQueue = {
-                      transitions: null,
-                      markerInstances: null,
-                      wakeables: new Set([wakeable])
-                    };
-                    suspenseBoundary.updateQueue = newOffscreenQueue;
-                  } else {
-                    var wakeables$99 = offscreenQueue.wakeables;
-                    null === wakeables$99
-                      ? (offscreenQueue.wakeables = new Set([wakeable]))
-                      : wakeables$99.add(wakeable);
-                  }
-                  break;
-                }
-              default:
-                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
-            }
-            suspenseBoundary.mode & 1 &&
-              attachPingListener(root, wakeable, thrownValue);
-            break a;
-          } else if (1 === root.tag) {
-            attachPingListener(root, wakeable, thrownValue);
-            renderDidSuspendDelayIfPossible();
-            break a;
-          } else value = Error(formatProdErrorMessage(426));
-        } else if (
-          isHydrating &&
-          unitOfWork.mode & 1 &&
-          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
-        ) {
-          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
-          markSuspenseBoundaryShouldCapture(
-            wakeable,
-            returnFiber,
-            unitOfWork,
-            root,
-            thrownValue
-          );
-          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
-          break a;
-        }
-        root = value = createCapturedValueAtFiber(value, unitOfWork);
-        4 !== workInProgressRootExitStatus &&
-          (workInProgressRootExitStatus = 2);
-        null === workInProgressRootConcurrentErrors
-          ? (workInProgressRootConcurrentErrors = [root])
-          : workInProgressRootConcurrentErrors.push(root);
-        root = returnFiber;
-        do {
-          switch (root.tag) {
-            case 3:
-              var errorInfo = value;
-              root.flags |= 65536;
-              thrownValue &= -thrownValue;
-              root.lanes |= thrownValue;
-              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
-              enqueueCapturedUpdate(root, update);
-              break a;
-            case 1:
-              currentSourceFiber = value;
-              var ctor = root.type,
-                instance = root.stateNode;
-              if (
-                0 === (root.flags & 128) &&
-                ("function" === typeof ctor.getDerivedStateFromError ||
-                  (null !== instance &&
-                    "function" === typeof instance.componentDidCatch &&
-                    (null === legacyErrorBoundariesThatAlreadyFailed ||
-                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
-              ) {
-                root.flags |= 65536;
-                update = thrownValue & -thrownValue;
-                root.lanes |= update;
-                errorInfo = createClassErrorUpdate(
-                  root,
-                  currentSourceFiber,
-                  update
-                );
-                enqueueCapturedUpdate(root, errorInfo);
-                break a;
-              }
-          }
-          root = root.return;
-        } while (null !== root);
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  if (isComposing)
+    return "compositionend" === domEventName ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+      ? ((domEventName = getData()),
+        (fallbackText = startText = root = null),
+        (isComposing = !1),
+        domEventName)
+      : null;
+  switch (domEventName) {
+    case "paste":
+      return null;
+    case "keypress":
+      if (
+        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
+        (nativeEvent.ctrlKey && nativeEvent.altKey)
+      ) {
+        if (nativeEvent.char && 1 < nativeEvent.char.length)
+          return nativeEvent.char;
+        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
       }
-    } catch (error) {
-      throw ((workInProgress = returnFiber), error);
+      return null;
+    case "compositionend":
+      return useFallbackCompositionData && "ko" !== nativeEvent.locale
+        ? null
+        : nativeEvent.data;
+    default:
+      return null;
+  }
+}
+var supportedInputTypes = {
+  color: !0,
+  date: !0,
+  datetime: !0,
+  "datetime-local": !0,
+  email: !0,
+  month: !0,
+  number: !0,
+  password: !0,
+  range: !0,
+  search: !0,
+  tel: !0,
+  text: !0,
+  time: !0,
+  url: !0,
+  week: !0
+};
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return "input" === nodeName
+    ? !!supportedInputTypes[elem.type]
+    : "textarea" === nodeName
+    ? !0
+    : !1;
+}
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
+) {
+  enqueueStateRestore(target);
+  inst = accumulateTwoPhaseListeners(inst, "onChange");
+  0 < inst.length &&
+    ((nativeEvent = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    )),
+    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+}
+var activeElement$1 = null,
+  activeElementInst$1 = null;
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
+  if (updateValueIfChanged(targetNode)) return targetInst;
+}
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if ("change" === domEventName) return targetInst;
+}
+var isInputEventSupported = !1;
+if (canUseDOM) {
+  var JSCompiler_inline_result$jscomp$309;
+  if (canUseDOM) {
+    var isSupported$jscomp$inline_1570 = "oninput" in document;
+    if (!isSupported$jscomp$inline_1570) {
+      var element$jscomp$inline_1571 = document.createElement("div");
+      element$jscomp$inline_1571.setAttribute("oninput", "return;");
+      isSupported$jscomp$inline_1570 =
+        "function" === typeof element$jscomp$inline_1571.oninput;
     }
-    completeUnitOfWork(unitOfWork);
+    JSCompiler_inline_result$jscomp$309 = isSupported$jscomp$inline_1570;
+  } else JSCompiler_inline_result$jscomp$309 = !1;
+  isInputEventSupported =
+    JSCompiler_inline_result$jscomp$309 &&
+    (!document.documentMode || 9 < document.documentMode);
+}
+function stopWatchingForValueChange() {
+  activeElement$1 &&
+    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
+    (activeElementInst$1 = activeElement$1 = null));
+}
+function handlePropertyChange(nativeEvent) {
+  if (
+    "value" === nativeEvent.propertyName &&
+    getInstIfValueChanged(activeElementInst$1)
+  ) {
+    var dispatchQueue = [];
+    createAndAccumulateChangeEvent(
+      dispatchQueue,
+      activeElementInst$1,
+      nativeEvent,
+      getEventTarget(nativeEvent)
+    );
+    batchedUpdates(runEventInBatch, dispatchQueue);
   }
 }
-function completeUnitOfWork(unitOfWork) {
-  var completedWork = unitOfWork;
-  do {
-    var current = completedWork.alternate;
-    unitOfWork = completedWork.return;
-    if (0 === (completedWork.flags & 32768)) {
-      if (
-        ((current = completeWork(current, completedWork, renderLanes)),
-        null !== current)
-      ) {
-        workInProgress = current;
-        return;
-      }
-    } else {
-      current = unwindWork(current, completedWork);
-      if (null !== current) {
-        current.flags &= 16383;
-        workInProgress = current;
-        return;
-      }
-      if (null !== unitOfWork)
-        (unitOfWork.flags |= 32768),
-          (unitOfWork.subtreeFlags = 0),
-          (unitOfWork.deletions = null);
-      else {
-        workInProgressRootExitStatus = 6;
-        workInProgress = null;
-        return;
-      }
-    }
-    completedWork = completedWork.sibling;
-    if (null !== completedWork) {
-      workInProgress = completedWork;
-      return;
-    }
-    workInProgress = completedWork = unitOfWork;
-  } while (null !== completedWork);
-  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  "focusin" === domEventName
+    ? (stopWatchingForValueChange(),
+      (activeElement$1 = target),
+      (activeElementInst$1 = targetInst),
+      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
+    : "focusout" === domEventName && stopWatchingForValueChange();
+}
+function getTargetInstForInputEventPolyfill(domEventName) {
+  if (
+    "selectionchange" === domEventName ||
+    "keyup" === domEventName ||
+    "keydown" === domEventName
+  )
+    return getInstIfValueChanged(activeElementInst$1);
+}
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
+}
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if ("input" === domEventName || "change" === domEventName)
+    return getInstIfValueChanged(targetInst);
+}
+var skipSelectionChangeEvent =
+    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
+  activeElement = null,
+  activeElementInst = null,
+  lastSelection = null,
+  mouseDown = !1;
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  var doc =
+    nativeEventTarget.window === nativeEventTarget
+      ? nativeEventTarget.document
+      : 9 === nativeEventTarget.nodeType
+      ? nativeEventTarget
+      : nativeEventTarget.ownerDocument;
+  mouseDown ||
+    null == activeElement ||
+    activeElement !== getActiveElement(doc) ||
+    ((doc = activeElement),
+    "selectionStart" in doc && hasSelectionCapabilities(doc)
+      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
+      : ((doc = (
+          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
+          window
+        ).getSelection()),
+        (doc = {
+          anchorNode: doc.anchorNode,
+          anchorOffset: doc.anchorOffset,
+          focusNode: doc.focusNode,
+          focusOffset: doc.focusOffset
+        })),
+    (lastSelection && shallowEqual(lastSelection, doc)) ||
+      ((lastSelection = doc),
+      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
+      0 < doc.length &&
+        ((nativeEvent = new SyntheticEvent(
+          "onSelect",
+          "select",
+          null,
+          nativeEvent,
+          nativeEventTarget
+        )),
+        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
+        (nativeEvent.target = activeElement))));
+}
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
+}
+var vendorPrefixes = {
+    animationend: makePrefixMap("Animation", "AnimationEnd"),
+    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+    animationstart: makePrefixMap("Animation", "AnimationStart"),
+    transitionend: makePrefixMap("Transition", "TransitionEnd")
+  },
+  prefixedEventNames = {},
+  style = {};
+canUseDOM &&
+  ((style = document.createElement("div").style),
+  "AnimationEvent" in window ||
+    (delete vendorPrefixes.animationend.animation,
+    delete vendorPrefixes.animationiteration.animation,
+    delete vendorPrefixes.animationstart.animation),
+  "TransitionEvent" in window ||
+    delete vendorPrefixes.transitionend.transition);
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
+  if (!vendorPrefixes[eventName]) return eventName;
+  var prefixMap = vendorPrefixes[eventName],
+    styleProp;
+  for (styleProp in prefixMap)
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
+  return eventName;
+}
+var ANIMATION_END = getVendorPrefixedEventName("animationend"),
+  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
+  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
+  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
+  topLevelEventsToReactNames = new Map(),
+  simpleEventPluginEvents =
+    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
+      " "
+    );
+topLevelEventsToReactNames.set("beforeblur", null);
+topLevelEventsToReactNames.set("afterblur", null);
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
+for (
+  var i$jscomp$inline_1583 = 0;
+  i$jscomp$inline_1583 < simpleEventPluginEvents.length;
+  i$jscomp$inline_1583++
+) {
+  var eventName$jscomp$inline_1584 =
+      simpleEventPluginEvents[i$jscomp$inline_1583],
+    domEventName$jscomp$inline_1585 =
+      eventName$jscomp$inline_1584.toLowerCase(),
+    capitalizedEvent$jscomp$inline_1586 =
+      eventName$jscomp$inline_1584[0].toUpperCase() +
+      eventName$jscomp$inline_1584.slice(1);
+  registerSimpleEvent(
+    domEventName$jscomp$inline_1585,
+    "on" + capitalizedEvent$jscomp$inline_1586
+  );
+}
+registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+registerSimpleEvent("dblclick", "onDoubleClick");
+registerSimpleEvent("focusin", "onFocus");
+registerSimpleEvent("focusout", "onBlur");
+registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+registerTwoPhaseEvent(
+  "onChange",
+  "change click focusin focusout input keydown keyup selectionchange".split(" ")
+);
+registerTwoPhaseEvent(
+  "onSelect",
+  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
+    " "
+  )
+);
+registerTwoPhaseEvent("onBeforeInput", [
+  "compositionend",
+  "keypress",
+  "textInput",
+  "paste"
+]);
+registerTwoPhaseEvent(
+  "onCompositionEnd",
+  "compositionend focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionStart",
+  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionUpdate",
+  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
+);
+var mediaEventTypes =
+    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
+      " "
+    ),
+  nonDelegatedEvents = new Set(
+    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
+  );
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+  event.currentTarget = null;
 }
-function commitRoot(root, recoverableErrors, transitions) {
-  var previousUpdateLanePriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig.transition;
-  try {
-    (ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      commitRootImpl(
-        root,
-        recoverableErrors,
-        transitions,
-        previousUpdateLanePriority
-      );
-  } finally {
-    (ReactCurrentBatchConfig.transition = prevTransition),
-      (currentUpdatePriority = previousUpdateLanePriority);
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  eventSystemFlags = 0 !== (eventSystemFlags & 4);
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event;
+    _dispatchQueue$i = _dispatchQueue$i.listeners;
+    a: {
+      var previousInstance = void 0;
+      if (eventSystemFlags)
+        for (
+          var i$jscomp$0 = _dispatchQueue$i.length - 1;
+          0 <= i$jscomp$0;
+          i$jscomp$0--
+        ) {
+          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
+        }
+      else
+        for (
+          i$jscomp$0 = 0;
+          i$jscomp$0 < _dispatchQueue$i.length;
+          i$jscomp$0++
+        ) {
+          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
+          instance = _dispatchListeners$i.instance;
+          currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
+        }
+    }
   }
-  return null;
-}
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
-) {
-  do flushPassiveEffects();
-  while (null !== rootWithPendingPassiveEffects);
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var finishedWork = root.finishedWork,
-    lanes = root.finishedLanes;
-  if (null === finishedWork) return null;
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
-  root.callbackNode = null;
-  root.callbackPriority = 0;
-  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
-  remainingLanes |= concurrentlyUpdatedLanes;
-  markRootFinished(root, remainingLanes);
-  root === workInProgressRoot &&
-    ((workInProgress = workInProgressRoot = null),
-    (workInProgressRootRenderLanes = 0));
-  (0 === (finishedWork.subtreeFlags & 10256) &&
-    0 === (finishedWork.flags & 10256)) ||
-    rootDoesHavePassiveEffects ||
-    ((rootDoesHavePassiveEffects = !0),
-    (pendingPassiveEffectsRemainingLanes = remainingLanes),
-    (pendingPassiveTransitions = transitions),
-    scheduleCallback(NormalPriority$1, function () {
-      flushPassiveEffects();
-      return null;
-    }));
-  transitions = 0 !== (finishedWork.flags & 15990);
-  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
-    transitions = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    var prevExecutionContext = executionContext;
-    executionContext |= 4;
-    ReactCurrentOwner.current = null;
-    var shouldFireAfterActiveInstanceBlur$220 = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
-    commitMutationEffectsOnFiber(finishedWork, root);
-    shouldFireAfterActiveInstanceBlur$220 &&
-      ((_enabled = !0),
-      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
-      (_enabled = !1));
-    restoreSelection(selectionInformation);
-    _enabled = !!eventsEnabled;
-    selectionInformation = eventsEnabled = null;
-    root.current = finishedWork;
-    commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
-    requestPaint();
-    executionContext = prevExecutionContext;
-    currentUpdatePriority = previousPriority;
-    ReactCurrentBatchConfig.transition = transitions;
-  } else root.current = finishedWork;
-  rootDoesHavePassiveEffects
-    ? ((rootDoesHavePassiveEffects = !1),
-      (rootWithPendingPassiveEffects = root),
-      (pendingPassiveEffectsLanes = lanes))
-    : releaseRootPooledCache(root, remainingLanes);
-  remainingLanes = root.pendingLanes;
-  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
-  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
-  ensureRootIsScheduled(root, now());
-  if (null !== recoverableErrors)
-    for (
-      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
-      finishedWork < recoverableErrors.length;
-      finishedWork++
-    )
-      (lanes = recoverableErrors[finishedWork]),
-        (remainingLanes = {
-          digest: lanes.digest,
-          componentStack: lanes.stack
-        }),
-        renderPriorityLevel(lanes.value, remainingLanes);
-  if (hasUncaughtError)
+  if (hasRethrowError)
     throw (
-      ((hasUncaughtError = !1),
-      (root = firstUncaughtError),
-      (firstUncaughtError = null),
-      root)
+      ((dispatchQueue = rethrowError),
+      (hasRethrowError = !1),
+      (rethrowError = null),
+      dispatchQueue)
     );
-  0 !== (pendingPassiveEffectsLanes & 3) &&
-    0 !== root.tag &&
-    flushPassiveEffects();
-  remainingLanes = root.pendingLanes;
-  0 !== (remainingLanes & 3)
-    ? root === rootWithNestedUpdates
-      ? nestedUpdateCount++
-      : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root))
-    : (nestedUpdateCount = 0);
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    null !== prevRootTransitionCallbacks &&
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-        null !== prevPendingTransitionCallbacks
-          ? ((currentPendingTransitionCallbacks = null),
-            scheduleCallback(IdlePriority, function () {
-              processTransitionCallbacks(
-                prevPendingTransitionCallbacks,
-                endTime,
-                prevRootTransitionCallbacks
-              );
-            }))
-          : (currentEndTime = endTime);
-      });
-  }
-  return null;
 }
-function releaseRootPooledCache(root, remainingLanes) {
-  0 === (root.pooledCacheLanes &= remainingLanes) &&
-    ((remainingLanes = root.pooledCache),
-    null != remainingLanes &&
-      ((root.pooledCache = null), releaseCache(remainingLanes)));
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+  var listenerSet = getEventListenerSet(targetElement),
+    listenerSetKey = domEventName + "__bubble";
+  listenerSet.has(listenerSetKey) ||
+    (addTrappedEventListener(targetElement, domEventName, 2, !1),
+    listenerSet.add(listenerSetKey));
 }
-function flushPassiveEffects() {
-  if (null !== rootWithPendingPassiveEffects) {
-    var root$221 = rootWithPendingPassiveEffects,
-      remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = 0;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    renderPriority = 32 > renderPriority ? 32 : renderPriority;
-    var prevTransition = ReactCurrentBatchConfig.transition,
-      previousPriority = currentUpdatePriority;
-    try {
-      return (
-        (ReactCurrentBatchConfig.transition = null),
-        (currentUpdatePriority = renderPriority),
-        flushPassiveEffectsImpl()
-      );
-    } finally {
-      (currentUpdatePriority = previousPriority),
-        (ReactCurrentBatchConfig.transition = prevTransition),
-        releaseRootPooledCache(root$221, remainingLanes);
-    }
-  }
-  return !1;
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+  var eventSystemFlags = 0;
+  isCapturePhaseListener && (eventSystemFlags |= 4);
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
 }
-function flushPassiveEffectsImpl() {
-  if (null === rootWithPendingPassiveEffects) return !1;
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects,
-    lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null;
-  pendingPassiveEffectsLanes = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
-  var prevExecutionContext = executionContext;
-  executionContext |= 4;
-  commitPassiveUnmountOnFiber(root.current);
-  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
-      prevRootTransitionCallbacks = root.transitionCallbacks,
-      prevEndTime = currentEndTime;
-    null !== prevPendingTransitionCallbacks &&
-      null !== prevRootTransitionCallbacks &&
-      null !== prevEndTime &&
-      ((currentEndTime = currentPendingTransitionCallbacks = null),
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
-        );
-      }));
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = !0;
+    allNativeEvents.forEach(function (domEventName) {
+      "selectionchange" !== domEventName &&
+        (nonDelegatedEvents.has(domEventName) ||
+          listenToNativeEvent(domEventName, !1, rootContainerElement),
+        listenToNativeEvent(domEventName, !0, rootContainerElement));
+    });
+    var ownerDocument =
+      9 === rootContainerElement.nodeType
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
+    null === ownerDocument ||
+      ownerDocument[listeningMarker] ||
+      ((ownerDocument[listeningMarker] = !0),
+      listenToNativeEvent("selectionchange", !1, ownerDocument));
   }
-  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
-    try {
-      injectedHook.onPostCommitFiberRoot(rendererID, root);
-    } catch (err) {}
-  return !0;
 }
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
-  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
-  sourceFiber = requestEventTime();
-  null !== rootFiber &&
-    (markRootUpdated(rootFiber, 2, sourceFiber),
-    ensureRootIsScheduled(rootFiber, sourceFiber));
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  eventSystemFlags = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  );
+  var isPassiveListener = void 0;
+  !passiveBrowserEventsSupported ||
+    ("touchstart" !== domEventName &&
+      "touchmove" !== domEventName &&
+      "wheel" !== domEventName) ||
+    (isPassiveListener = !0);
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = eventSystemFlags;
+    eventSystemFlags = function () {
+      unsubscribeListener.remove();
+      for (
+        var _len = arguments.length, p = Array(_len), _key = 0;
+        _key < _len;
+        _key++
+      )
+        p[_key] = arguments[_key];
+      return originalListener.apply(this, p);
+    };
+  }
+  var unsubscribeListener = isCapturePhaseListener
+    ? void 0 !== isPassiveListener
+      ? EventListenerWWW.captureWithPassiveFlag(
+          targetContainer,
+          domEventName,
+          eventSystemFlags,
+          isPassiveListener
+        )
+      : EventListenerWWW.capture(
+          targetContainer,
+          domEventName,
+          eventSystemFlags
+        )
+    : void 0 !== isPassiveListener
+    ? EventListenerWWW.bubbleWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        eventSystemFlags,
+        isPassiveListener
+      )
+    : EventListenerWWW.listen(targetContainer, domEventName, eventSystemFlags);
 }
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
-  if (3 === sourceFiber.tag)
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
-  else
-    for (
-      nearestMountedAncestor = skipUnmountedBoundaries
-        ? nearestMountedAncestor
-        : sourceFiber.return;
-      null !== nearestMountedAncestor;
-
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst$jscomp$0,
+  targetContainer
+) {
+  var ancestorInst = targetInst$jscomp$0;
+  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+    if (
+      enableLegacyFBSupport &&
+      "click" === domEventName &&
+      0 === (eventSystemFlags & 20) &&
+      nativeEvent !== currentReplayingEvent
     ) {
-      if (3 === nearestMountedAncestor.tag) {
-        captureCommitPhaseErrorOnRoot(
-          nearestMountedAncestor,
-          sourceFiber,
-          error
-        );
-        break;
-      } else if (1 === nearestMountedAncestor.tag) {
-        var instance = nearestMountedAncestor.stateNode;
-        if (
-          "function" ===
-            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
-          ("function" === typeof instance.componentDidCatch &&
-            (null === legacyErrorBoundariesThatAlreadyFailed ||
-              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
-        ) {
-          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-          sourceFiber = createClassErrorUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          nearestMountedAncestor = enqueueUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          sourceFiber = requestEventTime();
-          null !== nearestMountedAncestor &&
-            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
-            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
-          break;
+      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
+      return;
+    }
+    if (null !== targetInst$jscomp$0)
+      a: for (;;) {
+        if (null === targetInst$jscomp$0) return;
+        var nodeTag = targetInst$jscomp$0.tag;
+        if (3 === nodeTag || 4 === nodeTag) {
+          var container = targetInst$jscomp$0.stateNode.containerInfo;
+          if (
+            container === targetContainer ||
+            (8 === container.nodeType &&
+              container.parentNode === targetContainer)
+          )
+            break;
+          if (4 === nodeTag)
+            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
+              var grandTag = nodeTag.tag;
+              if (3 === grandTag || 4 === grandTag)
+                if (
+                  ((grandTag = nodeTag.stateNode.containerInfo),
+                  grandTag === targetContainer ||
+                    (8 === grandTag.nodeType &&
+                      grandTag.parentNode === targetContainer))
+                )
+                  return;
+              nodeTag = nodeTag.return;
+            }
+          for (; null !== container; ) {
+            nodeTag = getClosestInstanceFromNode(container);
+            if (null === nodeTag) return;
+            grandTag = nodeTag.tag;
+            if (
+              5 === grandTag ||
+              6 === grandTag ||
+              26 === grandTag ||
+              27 === grandTag
+            ) {
+              targetInst$jscomp$0 = ancestorInst = nodeTag;
+              continue a;
+            }
+            container = container.parentNode;
+          }
+        }
+        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+      }
+  }
+  batchedUpdates(function () {
+    var targetInst = ancestorInst,
+      nativeEventTarget = getEventTarget(nativeEvent),
+      dispatchQueue = [];
+    a: {
+      var reactName = topLevelEventsToReactNames.get(domEventName);
+      if (void 0 !== reactName) {
+        var SyntheticEventCtor = SyntheticEvent,
+          reactEventType = domEventName;
+        switch (domEventName) {
+          case "keypress":
+            if (0 === getEventCharCode(nativeEvent)) break a;
+          case "keydown":
+          case "keyup":
+            SyntheticEventCtor = SyntheticKeyboardEvent;
+            break;
+          case "focusin":
+            reactEventType = "focus";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "focusout":
+            reactEventType = "blur";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "beforeblur":
+          case "afterblur":
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "click":
+            if (2 === nativeEvent.button) break a;
+          case "auxclick":
+          case "dblclick":
+          case "mousedown":
+          case "mousemove":
+          case "mouseup":
+          case "mouseout":
+          case "mouseover":
+          case "contextmenu":
+            SyntheticEventCtor = SyntheticMouseEvent;
+            break;
+          case "drag":
+          case "dragend":
+          case "dragenter":
+          case "dragexit":
+          case "dragleave":
+          case "dragover":
+          case "dragstart":
+          case "drop":
+            SyntheticEventCtor = SyntheticDragEvent;
+            break;
+          case "touchcancel":
+          case "touchend":
+          case "touchmove":
+          case "touchstart":
+            SyntheticEventCtor = SyntheticTouchEvent;
+            break;
+          case ANIMATION_END:
+          case ANIMATION_ITERATION:
+          case ANIMATION_START:
+            SyntheticEventCtor = SyntheticAnimationEvent;
+            break;
+          case TRANSITION_END:
+            SyntheticEventCtor = SyntheticTransitionEvent;
+            break;
+          case "scroll":
+            SyntheticEventCtor = SyntheticUIEvent;
+            break;
+          case "wheel":
+            SyntheticEventCtor = SyntheticWheelEvent;
+            break;
+          case "copy":
+          case "cut":
+          case "paste":
+            SyntheticEventCtor = SyntheticClipboardEvent;
+            break;
+          case "gotpointercapture":
+          case "lostpointercapture":
+          case "pointercancel":
+          case "pointerdown":
+          case "pointermove":
+          case "pointerout":
+          case "pointerover":
+          case "pointerup":
+            SyntheticEventCtor = SyntheticPointerEvent;
         }
+        var inCapturePhase = 0 !== (eventSystemFlags & 4);
+        eventSystemFlags & 1
+          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
+              reactEventType,
+              targetContainer,
+              inCapturePhase
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })))
+          : ((inCapturePhase = accumulateSinglePhaseListeners(
+              targetInst,
+              reactName,
+              nativeEvent.type,
+              inCapturePhase,
+              !inCapturePhase && "scroll" === domEventName,
+              nativeEvent
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })));
       }
-      nearestMountedAncestor = nearestMountedAncestor.return;
-    }
-}
-function attachPingListener(root, wakeable, lanes) {
-  var pingCache = root.pingCache;
-  if (null === pingCache) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    var threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else
-    (threadIDs = pingCache.get(wakeable)),
-      void 0 === threadIDs &&
-        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
-  threadIDs.has(lanes) ||
-    ((workInProgressRootDidAttachPingListener = !0),
-    threadIDs.add(lanes),
-    (root = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
-    wakeable.then(root, root));
-}
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
-  null !== pingCache && pingCache.delete(wakeable);
-  wakeable = requestEventTime();
-  root.pingedLanes |= root.suspendedLanes & pingedLanes;
-  workInProgressRoot === root &&
-    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
-    (4 === workInProgressRootExitStatus ||
-    (3 === workInProgressRootExitStatus &&
-      (workInProgressRootRenderLanes & 125829120) ===
-        workInProgressRootRenderLanes &&
-      500 > now() - globalMostRecentFallbackTime)
-      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
-      : (workInProgressRootPingedLanes |= pingedLanes));
-  ensureRootIsScheduled(root, wakeable);
-}
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  0 === retryLane &&
-    (0 === (boundaryFiber.mode & 1)
-      ? (retryLane = 2)
-      : ((retryLane = nextRetryLane),
-        (nextRetryLane <<= 1),
-        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
-  var eventTime = requestEventTime();
-  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
-  null !== boundaryFiber &&
-    (markRootUpdated(boundaryFiber, retryLane, eventTime),
-    ensureRootIsScheduled(boundaryFiber, eventTime));
-}
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState,
-    retryLane = 0;
-  null !== suspenseState && (retryLane = suspenseState.retryLane);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-}
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = 0;
-  switch (boundaryFiber.tag) {
-    case 13:
-      var retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
-      null !== suspenseState && (retryLane = suspenseState.retryLane);
-      break;
-    case 19:
-      retryCache = boundaryFiber.stateNode;
-      break;
-    case 22:
-      retryCache = boundaryFiber.stateNode._retryCache;
-      break;
-    default:
-      throw Error(formatProdErrorMessage(314));
-  }
-  null !== retryCache && retryCache.delete(wakeable);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-}
-var beginWork;
-beginWork = function (current, workInProgress, renderLanes) {
-  if (null !== current)
-    if (
-      current.memoizedProps !== workInProgress.pendingProps ||
-      didPerformWorkStackCursor.current
-    )
-      didReceiveUpdate = !0;
-    else {
-      if (
-        !checkScheduledUpdateOrContext(current, renderLanes) &&
-        0 === (workInProgress.flags & 128)
-      )
-        return (
-          (didReceiveUpdate = !1),
-          attemptEarlyBailoutIfNoScheduledUpdate(
-            current,
-            workInProgress,
-            renderLanes
-          )
-        );
-      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
     }
-  else
-    (didReceiveUpdate = !1),
-      isHydrating &&
-        0 !== (workInProgress.flags & 1048576) &&
-        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
-  workInProgress.lanes = 0;
-  switch (workInProgress.tag) {
-    case 2:
-      var Component = workInProgress.type;
-      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-      current = workInProgress.pendingProps;
-      var context = getMaskedContext(
-        workInProgress,
-        contextStackCursor.current
-      );
-      prepareToReadContext(workInProgress, renderLanes);
-      current = renderWithHooks(
-        null,
-        workInProgress,
-        Component,
-        current,
-        context,
-        renderLanes
-      );
-      Component = checkDidRenderIdHook();
-      workInProgress.flags |= 1;
-      workInProgress.tag = 0;
-      isHydrating && Component && pushMaterializedTreeId(workInProgress);
-      reconcileChildren(null, workInProgress, current, renderLanes);
-      workInProgress = workInProgress.child;
-      return workInProgress;
-    case 16:
-      Component = workInProgress.elementType;
+    if (0 === (eventSystemFlags & 7)) {
       a: {
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-        current = workInProgress.pendingProps;
-        context = Component._init;
-        Component = context(Component._payload);
-        workInProgress.type = Component;
-        context = workInProgress.tag = resolveLazyComponentTag(Component);
-        current = resolveDefaultProps(Component, current);
-        switch (context) {
-          case 0:
-            workInProgress = updateFunctionComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 1:
-            workInProgress = updateClassComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 11:
-            workInProgress = updateForwardRef(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 14:
-            workInProgress = updateMemoComponent(
-              null,
-              workInProgress,
-              Component,
-              resolveDefaultProps(Component.type, current),
-              renderLanes
+        reactName =
+          "mouseover" === domEventName || "pointerover" === domEventName;
+        SyntheticEventCtor =
+          "mouseout" === domEventName || "pointerout" === domEventName;
+        if (
+          reactName &&
+          nativeEvent !== currentReplayingEvent &&
+          (reactEventType =
+            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
+          (getClosestInstanceFromNode(reactEventType) ||
+            reactEventType[internalContainerInstanceKey])
+        )
+          break a;
+        if (SyntheticEventCtor || reactName) {
+          reactName =
+            nativeEventTarget.window === nativeEventTarget
+              ? nativeEventTarget
+              : (reactName = nativeEventTarget.ownerDocument)
+              ? reactName.defaultView || reactName.parentWindow
+              : window;
+          if (SyntheticEventCtor) {
+            if (
+              ((reactEventType =
+                nativeEvent.relatedTarget || nativeEvent.toElement),
+              (SyntheticEventCtor = targetInst),
+              (reactEventType = reactEventType
+                ? getClosestInstanceFromNode(reactEventType)
+                : null),
+              null !== reactEventType)
+            ) {
+              inCapturePhase = getNearestMountedFiber(reactEventType);
+              var tag = reactEventType.tag;
+              if (
+                reactEventType !== inCapturePhase ||
+                (5 !== tag && 27 !== tag && 6 !== tag)
+              )
+                reactEventType = null;
+            }
+          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
+          if (SyntheticEventCtor !== reactEventType) {
+            tag = SyntheticMouseEvent;
+            var leaveEventType = "onMouseLeave",
+              enterEventType = "onMouseEnter",
+              eventTypePrefix = "mouse";
+            if ("pointerout" === domEventName || "pointerover" === domEventName)
+              (tag = SyntheticPointerEvent),
+                (leaveEventType = "onPointerLeave"),
+                (enterEventType = "onPointerEnter"),
+                (eventTypePrefix = "pointer");
+            inCapturePhase =
+              null == SyntheticEventCtor
+                ? reactName
+                : getNodeFromInstance(SyntheticEventCtor);
+            var toNode =
+              null == reactEventType
+                ? reactName
+                : getNodeFromInstance(reactEventType);
+            reactName = new tag(
+              leaveEventType,
+              eventTypePrefix + "leave",
+              SyntheticEventCtor,
+              nativeEvent,
+              nativeEventTarget
             );
-            break a;
+            reactName.target = inCapturePhase;
+            reactName.relatedTarget = toNode;
+            leaveEventType = null;
+            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
+              ((tag = new tag(
+                enterEventType,
+                eventTypePrefix + "enter",
+                reactEventType,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              (tag.target = toNode),
+              (tag.relatedTarget = inCapturePhase),
+              (leaveEventType = tag));
+            inCapturePhase = leaveEventType;
+            if (SyntheticEventCtor && reactEventType)
+              b: {
+                tag = SyntheticEventCtor;
+                enterEventType = reactEventType;
+                eventTypePrefix = 0;
+                for (toNode = tag; toNode; toNode = getParent(toNode))
+                  eventTypePrefix++;
+                toNode = 0;
+                for (
+                  leaveEventType = enterEventType;
+                  leaveEventType;
+                  leaveEventType = getParent(leaveEventType)
+                )
+                  toNode++;
+                for (; 0 < eventTypePrefix - toNode; )
+                  (tag = getParent(tag)), eventTypePrefix--;
+                for (; 0 < toNode - eventTypePrefix; )
+                  (enterEventType = getParent(enterEventType)), toNode--;
+                for (; eventTypePrefix--; ) {
+                  if (
+                    tag === enterEventType ||
+                    (null !== enterEventType &&
+                      tag === enterEventType.alternate)
+                  )
+                    break b;
+                  tag = getParent(tag);
+                  enterEventType = getParent(enterEventType);
+                }
+                tag = null;
+              }
+            else tag = null;
+            null !== SyntheticEventCtor &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                reactName,
+                SyntheticEventCtor,
+                tag,
+                !1
+              );
+            null !== reactEventType &&
+              null !== inCapturePhase &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                inCapturePhase,
+                reactEventType,
+                tag,
+                !0
+              );
+          }
         }
-        throw Error(formatProdErrorMessage(306, Component, ""));
       }
-      return workInProgress;
-    case 0:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        updateFunctionComponent(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 1:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        updateClassComponent(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 3:
       a: {
-        pushHostRootContext(workInProgress);
-        if (null === current) throw Error(formatProdErrorMessage(387));
-        Component = workInProgress.pendingProps;
-        var prevState = workInProgress.memoizedState;
-        context = prevState.element;
-        cloneUpdateQueue(current, workInProgress);
-        processUpdateQueue(workInProgress, Component, null, renderLanes);
-        var nextState = workInProgress.memoizedState,
-          root = workInProgress.stateNode;
-        enableTransitionTracing &&
-          push(transitionStack, workInProgressTransitions);
-        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-        Component = nextState.cache;
-        pushProvider(workInProgress, CacheContext, Component);
-        Component !== prevState.cache &&
-          propagateContextChange(workInProgress, CacheContext, renderLanes);
-        Component = nextState.element;
-        if (prevState.isDehydrated)
-          if (
-            ((prevState = {
-              element: Component,
-              isDehydrated: !1,
-              cache: nextState.cache
-            }),
-            (workInProgress.updateQueue.baseState = prevState),
-            (workInProgress.memoizedState = prevState),
-            workInProgress.flags & 256)
-          ) {
-            context = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(423)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              context
-            );
-            break a;
-          } else if (Component !== context) {
-            context = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(424)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              context
-            );
-            break a;
-          } else {
-            nextHydratableInstance = getNextHydratable(
-              workInProgress.stateNode.containerInfo.firstChild
-            );
-            hydrationParentFiber = workInProgress;
-            isHydrating = !0;
-            hydrationErrors = null;
-            rootOrSingletonContext = !0;
-            current = root.mutableSourceEagerHydrationData;
-            if (null != current)
-              for (context = 0; context < current.length; context += 2)
-                (prevState = current[context]),
-                  (prevState._workInProgressVersionPrimary =
-                    current[context + 1]),
-                  workInProgressSources.push(prevState);
-            renderLanes = mountChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            );
-            for (workInProgress.child = renderLanes; renderLanes; )
-              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
-                (renderLanes = renderLanes.sibling);
+        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
+        SyntheticEventCtor =
+          reactName.nodeName && reactName.nodeName.toLowerCase();
+        if (
+          "select" === SyntheticEventCtor ||
+          ("input" === SyntheticEventCtor && "file" === reactName.type)
+        )
+          var getTargetInstFunc = getTargetInstForChangeEvent;
+        else if (isTextInputElement(reactName))
+          if (isInputEventSupported)
+            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+          else {
+            getTargetInstFunc = getTargetInstForInputEventPolyfill;
+            var handleEventFunc = handleEventsForInputEventPolyfill;
           }
-        else {
-          resetHydrationState();
-          if (Component === context) {
-            workInProgress = bailoutOnAlreadyFinishedWork(
-              current,
-              workInProgress,
-              renderLanes
-            );
-            break a;
+        else
+          (SyntheticEventCtor = reactName.nodeName),
+            !SyntheticEventCtor ||
+            "input" !== SyntheticEventCtor.toLowerCase() ||
+            ("checkbox" !== reactName.type && "radio" !== reactName.type)
+              ? enableCustomElementPropertySupport &&
+                targetInst &&
+                isCustomComponent(
+                  targetInst.elementType,
+                  targetInst.memoizedProps
+                ) &&
+                (getTargetInstFunc = getTargetInstForChangeEvent)
+              : (getTargetInstFunc = getTargetInstForClickEvent);
+        if (
+          getTargetInstFunc &&
+          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
+        ) {
+          createAndAccumulateChangeEvent(
+            dispatchQueue,
+            getTargetInstFunc,
+            nativeEvent,
+            nativeEventTarget
+          );
+          break a;
+        }
+        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
+        "focusout" === domEventName &&
+          (handleEventFunc = reactName._wrapperState) &&
+          handleEventFunc.controlled &&
+          "number" === reactName.type &&
+          (disableInputAttributeSyncing ||
+            setDefaultValue(reactName, "number", reactName.value));
+      }
+      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
+      switch (domEventName) {
+        case "focusin":
+          if (
+            isTextInputElement(handleEventFunc) ||
+            "true" === handleEventFunc.contentEditable
+          )
+            (activeElement = handleEventFunc),
+              (activeElementInst = targetInst),
+              (lastSelection = null);
+          break;
+        case "focusout":
+          lastSelection = activeElementInst = activeElement = null;
+          break;
+        case "mousedown":
+          mouseDown = !0;
+          break;
+        case "contextmenu":
+        case "mouseup":
+        case "dragend":
+          mouseDown = !1;
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+          break;
+        case "selectionchange":
+          if (skipSelectionChangeEvent) break;
+        case "keydown":
+        case "keyup":
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      }
+      var fallbackData;
+      if (canUseCompositionEvent)
+        b: {
+          switch (domEventName) {
+            case "compositionstart":
+              var eventType = "onCompositionStart";
+              break b;
+            case "compositionend":
+              eventType = "onCompositionEnd";
+              break b;
+            case "compositionupdate":
+              eventType = "onCompositionUpdate";
+              break b;
           }
-          reconcileChildren(current, workInProgress, Component, renderLanes);
+          eventType = void 0;
         }
-        workInProgress = workInProgress.child;
-      }
-      return workInProgress;
-    case 26:
-      return (
-        markRef$1(current, workInProgress),
-        (renderLanes = workInProgress.memoizedState =
-          getResource(
-            workInProgress.type,
-            null === current ? null : current.memoizedProps,
-            workInProgress.pendingProps
-          )),
-        null !== current ||
-          isHydrating ||
-          null !== renderLanes ||
-          ((renderLanes = workInProgress.type),
-          (current = workInProgress.pendingProps),
-          (Component = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
+      else
+        isComposing
+          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
+            (eventType = "onCompositionEnd")
+          : "keydown" === domEventName &&
+            229 === nativeEvent.keyCode &&
+            (eventType = "onCompositionStart");
+      eventType &&
+        (useFallbackCompositionData &&
+          "ko" !== nativeEvent.locale &&
+          (isComposing || "onCompositionStart" !== eventType
+            ? "onCompositionEnd" === eventType &&
+              isComposing &&
+              (fallbackData = getData())
+            : ((root = nativeEventTarget),
+              (startText = "value" in root ? root.value : root.textContent),
+              (isComposing = !0))),
+        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
+        0 < handleEventFunc.length &&
+          ((eventType = new SyntheticCompositionEvent(
+            eventType,
+            domEventName,
+            null,
+            nativeEvent,
+            nativeEventTarget
           )),
-          (Component = createHTMLElement(renderLanes, current, Component)),
-          (Component[internalInstanceKey] = workInProgress),
-          (Component[internalPropsKey] = current),
-          setInitialProperties(Component, renderLanes, current),
-          markNodeAsHoistable(Component),
-          (workInProgress.stateNode = Component)),
-        null
-      );
-    case 27:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          ((Component = workInProgress.stateNode =
-            resolveSingletonInstance(
-              workInProgress.type,
-              workInProgress.pendingProps,
-              rootInstanceStackCursor.current
-            )),
-          (hydrationParentFiber = workInProgress),
-          (rootOrSingletonContext = !0),
-          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
-        (Component = workInProgress.pendingProps.children),
-        null !== current || isHydrating
-          ? reconcileChildren(current, workInProgress, Component, renderLanes)
-          : (workInProgress.child = reconcileChildFibers(
-              workInProgress,
+          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
+          fallbackData
+            ? (eventType.data = fallbackData)
+            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
+              null !== fallbackData && (eventType.data = fallbackData))));
+      if (
+        (fallbackData = canUseTextInputEvent
+          ? getNativeBeforeInputChars(domEventName, nativeEvent)
+          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+      )
+        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
+          0 < targetInst.length &&
+            ((nativeEventTarget = new SyntheticCompositionEvent(
+              "onBeforeInput",
+              "beforeinput",
               null,
-              Component,
-              renderLanes
+              nativeEvent,
+              nativeEventTarget
             )),
-        markRef$1(current, workInProgress),
-        workInProgress.child
-      );
-    case 5:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          (((Component = workInProgress.pendingProps),
-          "script" === workInProgress.type
-            ? ((context = Component.onLoad),
-              (prevState = Component.onError),
-              (Component = !(Component.async && (context || prevState))))
-            : (Component = !0),
-          Component)
-            ? ((Component = nextHydratableInstance),
-              rootOrSingletonContext &&
-                advanceToFirstAttemptableInstance(workInProgress),
-              (context = nextHydratableInstance),
-              context)
-              ? tryHydrateInstance(workInProgress, context) ||
-                (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                (nextHydratableInstance = getNextHydratable(
-                  context.nextSibling
-                )),
-                (prevState = hydrationParentFiber),
-                rootOrSingletonContext &&
-                  advanceToFirstAttemptableInstance(workInProgress),
-                nextHydratableInstance &&
-                tryHydrateInstance(workInProgress, nextHydratableInstance)
-                  ? deleteHydratableInstance(prevState, context)
-                  : (insertNonHydratedInstance(
-                      hydrationParentFiber,
-                      workInProgress
-                    ),
-                    (isHydrating = !1),
-                    (hydrationParentFiber = workInProgress),
-                    (nextHydratableInstance = Component)))
-              : (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = Component))
-            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress))),
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (prevState = null !== current ? current.memoizedProps : null),
-        (root = context.children),
-        shouldSetTextContent(Component, context)
-          ? (root = null)
-          : null !== prevState &&
-            shouldSetTextContent(Component, prevState) &&
-            (workInProgress.flags |= 32),
-        markRef$1(current, workInProgress),
-        reconcileChildren(current, workInProgress, root, renderLanes),
-        workInProgress.child
-      );
-    case 6:
-      return (
-        null === current &&
-          isHydrating &&
-          (((renderLanes = "" !== workInProgress.pendingProps),
-          (current = nextHydratableInstance),
-          rootOrSingletonContext &&
-            renderLanes &&
-            advanceToFirstAttemptableTextInstance(),
-          (Component = nextHydratableInstance),
-          Component && renderLanes)
-            ? tryHydrateText(workInProgress, Component) ||
-              (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              (nextHydratableInstance = getNextHydratable(
-                Component.nextSibling
-              )),
-              (context = hydrationParentFiber),
-              rootOrSingletonContext &&
-                renderLanes &&
-                advanceToFirstAttemptableTextInstance(),
-              nextHydratableInstance &&
-              tryHydrateText(workInProgress, nextHydratableInstance)
-                ? deleteHydratableInstance(context, Component)
-                : (insertNonHydratedInstance(
-                    hydrationParentFiber,
-                    workInProgress
-                  ),
-                  (isHydrating = !1),
-                  (hydrationParentFiber = workInProgress),
-                  (nextHydratableInstance = current)))
-            : (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress),
-              (nextHydratableInstance = current))),
-        null
-      );
-    case 13:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
-    case 4:
-      return (
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
+            dispatchQueue.push({
+              event: nativeEventTarget,
+              listeners: targetInst
+            }),
+            (nativeEventTarget.data = fallbackData));
+    }
+    processDispatchQueue(dispatchQueue, eventSystemFlags);
+  });
+}
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  reactName = inCapturePhase
+    ? null !== reactName
+      ? reactName + "Capture"
+      : null
+    : reactName;
+  for (
+    var listeners = [], instance = targetFiber, lastHostComponent = null;
+    null !== instance;
+
+  ) {
+    var _instance = instance;
+    targetFiber = _instance.stateNode;
+    _instance = _instance.tag;
+    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
+    null === targetFiber
+      ? 21 === _instance &&
+        null !== lastHostComponent &&
+        null !== targetFiber &&
+        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }))
+      : ((lastHostComponent = targetFiber),
+        (targetFiber =
+          lastHostComponent[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }),
+        null !== reactName &&
+          ((targetFiber = getListener(instance, reactName)),
+          null != targetFiber &&
+            listeners.push(
+              createDispatchListener(instance, targetFiber, lastHostComponent)
+            )));
+    if (accumulateTargetOnly) break;
+    "beforeblur" === nativeEvent.type &&
+      ((targetFiber = nativeEvent._detachedInterceptFiber),
+      null === targetFiber ||
+        (targetFiber !== instance && targetFiber !== instance.alternate) ||
+        (listeners = []));
+    instance = instance.return;
+  }
+  return listeners;
+}
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  for (
+    var captureName = reactName + "Capture", listeners = [];
+    null !== targetFiber;
+
+  ) {
+    var _instance2 = targetFiber,
+      stateNode = _instance2.stateNode;
+    _instance2 = _instance2.tag;
+    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
+      null === stateNode ||
+      ((_instance2 = getListener(targetFiber, captureName)),
+      null != _instance2 &&
+        listeners.unshift(
+          createDispatchListener(targetFiber, _instance2, stateNode)
         ),
-        (Component = workInProgress.pendingProps),
-        null === current
-          ? (workInProgress.child = reconcileChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
+      (_instance2 = getListener(targetFiber, reactName)),
+      null != _instance2 &&
+        listeners.push(
+          createDispatchListener(targetFiber, _instance2, stateNode)
+        ));
+    targetFiber = targetFiber.return;
+  }
+  return listeners;
+}
+function getParent(inst) {
+  if (null === inst) return null;
+  do inst = inst.return;
+  while (inst && 5 !== inst.tag && 27 !== inst.tag);
+  return inst ? inst : null;
+}
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
+) {
+  for (
+    var registrationName = event._reactName, listeners = [];
+    null !== target && target !== common;
+
+  ) {
+    var _instance3 = target,
+      alternate = _instance3.alternate,
+      stateNode = _instance3.stateNode;
+    _instance3 = _instance3.tag;
+    if (null !== alternate && alternate === common) break;
+    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
+      null === stateNode ||
+      ((alternate = stateNode),
+      inCapturePhase
+        ? ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.unshift(
+              createDispatchListener(target, stateNode, alternate)
             ))
-          : reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 11:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        updateForwardRef(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 7:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 8:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 12:
+        : inCapturePhase ||
+          ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.push(
+              createDispatchListener(target, stateNode, alternate)
+            )));
+    target = target.return;
+  }
+  0 !== listeners.length &&
+    dispatchQueue.push({ event: event, listeners: listeners });
+}
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
+) {
+  var listeners = [],
+    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
+  null !== eventListeners &&
+    eventListeners.forEach(function (entry) {
+      entry.type === reactEventType &&
+        entry.capture === inCapturePhase &&
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
+        );
+    });
+  return listeners;
+}
+var hasScheduledReplayAttempt = !1,
+  queuedDiscreteEvents = [],
+  queuedFocus = null,
+  queuedDrag = null,
+  queuedMouse = null,
+  queuedPointers = new Map(),
+  queuedPointerCaptures = new Map(),
+  queuedExplicitHydrationTargets = [],
+  discreteReplayableEvents =
+    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
+      " "
+    );
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return {
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
+  };
+}
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
+    ((blockedOn = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )),
+    queuedDiscreteEvents.push(blockedOn),
+    1 === queuedDiscreteEvents.length)
+  )
+    for (; null !== blockedOn.blockedOn; ) {
+      domEventName = getInstanceFromNode(blockedOn.blockedOn);
+      if (null === domEventName) break;
+      attemptSynchronousHydration(domEventName);
+      if (null === blockedOn.blockedOn) replayUnblockedEvents();
+      else break;
+    }
+}
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
+    case "pointerover":
+    case "pointerout":
+      queuedPointers.delete(nativeEvent.pointerId);
+      break;
+    case "gotpointercapture":
+    case "lostpointercapture":
+      queuedPointerCaptures.delete(nativeEvent.pointerId);
+  }
+}
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    null === existingQueuedEvent ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
+  )
+    return (
+      (existingQueuedEvent = createQueuedReplayableEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )),
+      null !== blockedOn &&
+        ((blockedOn = getInstanceFromNode(blockedOn)),
+        null !== blockedOn && attemptContinuousHydration(blockedOn)),
+      existingQueuedEvent
+    );
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  blockedOn = existingQueuedEvent.targetContainers;
+  null !== targetContainer &&
+    -1 === blockedOn.indexOf(targetContainer) &&
+    blockedOn.push(targetContainer);
+  return existingQueuedEvent;
+}
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  switch (domEventName) {
+    case "focusin":
       return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
+        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedFocus,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
       );
-    case 10:
-      a: {
-        Component = workInProgress.type._context;
-        context = workInProgress.pendingProps;
-        prevState = workInProgress.memoizedProps;
-        root = context.value;
-        pushProvider(workInProgress, Component, root);
-        if (!enableLazyContextPropagation && null !== prevState)
-          if (objectIs(prevState.value, root)) {
-            if (
-              prevState.children === context.children &&
-              !didPerformWorkStackCursor.current
-            ) {
-              workInProgress = bailoutOnAlreadyFinishedWork(
-                current,
-                workInProgress,
-                renderLanes
-              );
-              break a;
-            }
-          } else propagateContextChange(workInProgress, Component, renderLanes);
-        reconcileChildren(
-          current,
-          workInProgress,
-          context.children,
-          renderLanes
-        );
-        workInProgress = workInProgress.child;
-      }
-      return workInProgress;
-    case 9:
+    case "dragenter":
       return (
-        (context = workInProgress.type),
-        (Component = workInProgress.pendingProps.children),
-        prepareToReadContext(workInProgress, renderLanes),
-        (context = readContext(context)),
-        (Component = Component(context)),
-        (workInProgress.flags |= 1),
-        reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
+        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedDrag,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
       );
-    case 14:
+    case "mouseover":
       return (
-        (Component = workInProgress.type),
-        (context = resolveDefaultProps(Component, workInProgress.pendingProps)),
-        (context = resolveDefaultProps(Component.type, context)),
-        updateMemoComponent(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 15:
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
+        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedMouse,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
       );
-    case 17:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-        (workInProgress.tag = 1),
-        isContextProvider(Component)
-          ? ((current = !0), pushContextProvider(workInProgress))
-          : (current = !1),
-        prepareToReadContext(workInProgress, renderLanes),
-        constructClassInstance(workInProgress, Component, context),
-        mountClassInstance(workInProgress, Component, context, renderLanes),
-        finishClassComponent(
-          null,
-          workInProgress,
-          Component,
-          !0,
-          current,
-          renderLanes
+    case "pointerover":
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
         )
       );
-    case 19:
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    case 21:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 22:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 23:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 24:
+      return !0;
+    case "gotpointercapture":
       return (
-        prepareToReadContext(workInProgress, renderLanes),
-        (Component = readContext(CacheContext)),
-        null === current
-          ? ((context = peekCacheFromPool()),
-            null === context &&
-              ((context = workInProgressRoot),
-              (prevState = createCache()),
-              (context.pooledCache = prevState),
-              prevState.refCount++,
-              null !== prevState && (context.pooledCacheLanes |= renderLanes),
-              (context = prevState)),
-            (workInProgress.memoizedState = {
-              parent: Component,
-              cache: context
-            }),
-            initializeUpdateQueue(workInProgress),
-            pushProvider(workInProgress, CacheContext, context))
-          : (0 !== (current.lanes & renderLanes) &&
-              (cloneUpdateQueue(current, workInProgress),
-              processUpdateQueue(workInProgress, null, null, renderLanes)),
-            (context = current.memoizedState),
-            (prevState = workInProgress.memoizedState),
-            context.parent !== Component
-              ? ((context = { parent: Component, cache: Component }),
-                (workInProgress.memoizedState = context),
-                0 === workInProgress.lanes &&
-                  (workInProgress.memoizedState =
-                    workInProgress.updateQueue.baseState =
-                      context),
-                pushProvider(workInProgress, CacheContext, Component))
-              : ((Component = prevState.cache),
-                pushProvider(workInProgress, CacheContext, Component),
-                Component !== context.cache &&
-                  propagateContextChange(
-                    workInProgress,
-                    CacheContext,
-                    renderLanes
-                  ))),
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
+        (pointerId = nativeEvent.pointerId),
+        queuedPointerCaptures.set(
+          pointerId,
+          accumulateOrCreateContinuousQueuedReplayableEvent(
+            queuedPointerCaptures.get(pointerId) || null,
+            blockedOn,
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          )
         ),
-        workInProgress.child
+        !0
       );
-    case 25:
-      if (enableTransitionTracing)
-        return (
-          enableTransitionTracing
-            ? (null === current &&
-                ((Component = enableTransitionTracing
-                  ? transitionStack.current
-                  : null),
-                null !== Component &&
-                  ((Component = {
-                    tag: 1,
-                    transitions: new Set(Component),
-                    pendingBoundaries: null,
-                    name: workInProgress.pendingProps.name,
-                    aborts: null
-                  }),
-                  (workInProgress.stateNode = Component),
-                  (workInProgress.flags |= 2048))),
-              (Component = workInProgress.stateNode),
-              null !== Component &&
-                pushMarkerInstance(workInProgress, Component),
-              reconcileChildren(
-                current,
-                workInProgress,
-                workInProgress.pendingProps.children,
-                renderLanes
-              ),
-              (workInProgress = workInProgress.child))
-            : (workInProgress = null),
-          workInProgress
-        );
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
-};
-function scheduleCallback(priorityLevel, callback) {
-  return scheduleCallback$2(priorityLevel, callback);
-}
-function FiberNode(tag, pendingProps, key, mode) {
-  this.tag = tag;
-  this.key = key;
-  this.sibling =
-    this.child =
-    this.return =
-    this.stateNode =
-    this.type =
-    this.elementType =
-      null;
-  this.index = 0;
-  this.refCleanup = this.ref = null;
-  this.pendingProps = pendingProps;
-  this.dependencies =
-    this.memoizedState =
-    this.updateQueue =
-    this.memoizedProps =
-      null;
-  this.mode = mode;
-  this.subtreeFlags = this.flags = 0;
-  this.deletions = null;
-  this.childLanes = this.lanes = 0;
-  this.alternate = null;
-}
-function createFiber(tag, pendingProps, key, mode) {
-  return new FiberNode(tag, pendingProps, key, mode);
-}
-function shouldConstruct(Component) {
-  Component = Component.prototype;
-  return !(!Component || !Component.isReactComponent);
+  return !1;
 }
-function resolveLazyComponentTag(Component) {
-  if ("function" === typeof Component)
-    return shouldConstruct(Component) ? 1 : 0;
-  if (void 0 !== Component && null !== Component) {
-    Component = Component.$$typeof;
-    if (Component === REACT_FORWARD_REF_TYPE) return 11;
-    if (Component === REACT_MEMO_TYPE) return 14;
+function attemptExplicitHydrationTarget(queuedTarget) {
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
+  if (null !== targetInst) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
+    if (null !== nearestMounted)
+      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
+        if (
+          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
+          null !== targetInst)
+        ) {
+          queuedTarget.blockedOn = targetInst;
+          runWithPriority(queuedTarget.priority, function () {
+            if (13 === nearestMounted.tag) {
+              var lane = requestUpdateLane(nearestMounted),
+                root = enqueueConcurrentRenderForLane(nearestMounted, lane);
+              if (null !== root) {
+                var eventTime = requestEventTime();
+                scheduleUpdateOnFiber(root, nearestMounted, lane, eventTime);
+              }
+              markRetryLaneIfNotHydrated(nearestMounted, lane);
+            }
+          });
+          return;
+        }
+      } else if (
+        3 === targetInst &&
+        nearestMounted.stateNode.current.memoizedState.isDehydrated
+      ) {
+        queuedTarget.blockedOn =
+          3 === nearestMounted.tag
+            ? nearestMounted.stateNode.containerInfo
+            : null;
+        return;
+      }
   }
-  return 2;
+  queuedTarget.blockedOn = null;
 }
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
-  null === workInProgress
-    ? ((workInProgress = createFiber(
-        current.tag,
-        pendingProps,
-        current.key,
-        current.mode
-      )),
-      (workInProgress.elementType = current.elementType),
-      (workInProgress.type = current.type),
-      (workInProgress.stateNode = current.stateNode),
-      (workInProgress.alternate = current),
-      (current.alternate = workInProgress))
-    : ((workInProgress.pendingProps = pendingProps),
-      (workInProgress.type = current.type),
-      (workInProgress.flags = 0),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null));
-  workInProgress.flags = current.flags & 14680064;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue;
-  pendingProps = current.dependencies;
-  workInProgress.dependencies =
-    null === pendingProps
-      ? null
-      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
-  return workInProgress;
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (null !== queuedEvent.blockedOn) return !1;
+  for (
+    var targetContainers = queuedEvent.targetContainers;
+    0 < targetContainers.length;
+
+  ) {
+    var targetContainer = targetContainers[0],
+      nextBlockedOn = findInstanceBlockingEvent(
+        queuedEvent.domEventName,
+        queuedEvent.eventSystemFlags,
+        targetContainer,
+        queuedEvent.nativeEvent
+      );
+    if (null === nextBlockedOn)
+      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
+        ? ((nextBlockedOn = queuedEvent.nativeEvent),
+          (currentReplayingEvent = targetContainer =
+            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
+          nextBlockedOn.target.dispatchEvent(targetContainer))
+        : ((currentReplayingEvent = queuedEvent.nativeEvent),
+          dispatchEventForPluginEventSystem(
+            queuedEvent.domEventName,
+            queuedEvent.eventSystemFlags,
+            queuedEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          )),
+        (currentReplayingEvent = null);
+    else
+      return (
+        (targetContainers = getInstanceFromNode(nextBlockedOn)),
+        null !== targetContainers &&
+          attemptContinuousHydration(targetContainers),
+        (queuedEvent.blockedOn = nextBlockedOn),
+        !1
+      );
+    targetContainers.shift();
+  }
+  return !0;
 }
-function resetWorkInProgress(workInProgress, renderLanes) {
-  workInProgress.flags &= 14680066;
-  var current = workInProgress.alternate;
-  null === current
-    ? ((workInProgress.childLanes = 0),
-      (workInProgress.lanes = renderLanes),
-      (workInProgress.child = null),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.memoizedProps = null),
-      (workInProgress.memoizedState = null),
-      (workInProgress.updateQueue = null),
-      (workInProgress.dependencies = null),
-      (workInProgress.stateNode = null))
-    : ((workInProgress.childLanes = current.childLanes),
-      (workInProgress.lanes = current.lanes),
-      (workInProgress.child = current.child),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null),
-      (workInProgress.memoizedProps = current.memoizedProps),
-      (workInProgress.memoizedState = current.memoizedState),
-      (workInProgress.updateQueue = current.updateQueue),
-      (workInProgress.type = current.type),
-      (renderLanes = current.dependencies),
-      (workInProgress.dependencies =
-        null === renderLanes
-          ? null
-          : {
-              lanes: renderLanes.lanes,
-              firstContext: renderLanes.firstContext
-            }));
-  return workInProgress;
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
 }
-function createFiberFromTypeAndProps(
-  type,
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = 2;
-  owner = type;
-  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
-  else if ("string" === typeof type)
-    fiberTag = isHostHoistableType(
-      type,
-      pendingProps,
-      contextStackCursor$1.current
-    )
-      ? 26
-      : "html" === type || "head" === type || "body" === type
-      ? 27
-      : 5;
-  else
-    a: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = 8;
-        mode |= 8;
-        0 !== (mode & 1) && (mode |= 16);
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = !1;
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
+    for (; 0 < queuedDiscreteEvents.length; ) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
+      if (null !== nextDiscreteEvent.blockedOn) {
+        nextDiscreteEvent = getInstanceFromNode(nextDiscreteEvent.blockedOn);
+        if (null !== nextDiscreteEvent && 13 === nextDiscreteEvent.tag) {
+          var root = enqueueConcurrentRenderForLane(nextDiscreteEvent, 2);
+          if (null !== root) {
+            var eventTime = requestEventTime();
+            scheduleUpdateOnFiber(root, nextDiscreteEvent, 2, eventTime);
+          }
+          markRetryLaneIfNotHydrated(nextDiscreteEvent, 2);
+        }
         break;
-      case REACT_PROFILER_TYPE:
-        return (
-          (type = createFiber(12, pendingProps, key, mode | 2)),
-          (type.elementType = REACT_PROFILER_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_TYPE:
-        return (
-          (type = createFiber(13, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_LIST_TYPE:
-        return (
-          (type = createFiber(19, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
-      case REACT_LEGACY_HIDDEN_TYPE:
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      case REACT_SCOPE_TYPE:
-        return (
-          (pendingProps = createFiber(21, pendingProps, key, mode)),
-          (pendingProps.type = type),
-          (pendingProps.elementType = type),
-          (pendingProps.lanes = lanes),
-          pendingProps
-        );
-      case REACT_CACHE_TYPE:
-        return (
-          (type = createFiber(24, pendingProps, key, mode)),
-          (type.elementType = REACT_CACHE_TYPE),
-          (type.lanes = lanes),
-          type
+      }
+      for (root = nextDiscreteEvent.targetContainers; 0 < root.length; ) {
+        eventTime = root[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          eventTime,
+          nextDiscreteEvent.nativeEvent
         );
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing)
-          return (
-            (type = createFiber(25, pendingProps, key, mode)),
-            (type.elementType = REACT_TRACING_MARKER_TYPE),
-            (type.lanes = lanes),
-            (type.stateNode = {
-              tag: 1,
-              transitions: null,
-              pendingBoundaries: null,
-              aborts: null,
-              name: pendingProps.name
-            }),
-            type
-          );
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = 8;
-          mode |= 4;
+        if (null === nextBlockedOn)
+          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
+            dispatchEventForPluginEventSystem(
+              nextDiscreteEvent.domEventName,
+              nextDiscreteEvent.eventSystemFlags,
+              nextDiscreteEvent.nativeEvent,
+              return_targetInst,
+              eventTime
+            ),
+            (currentReplayingEvent = null);
+        else {
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
           break;
         }
-      default:
-        if ("object" === typeof type && null !== type)
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = 10;
-              break a;
-            case REACT_CONTEXT_TYPE:
-              fiberTag = 9;
-              break a;
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = 11;
-              break a;
-            case REACT_MEMO_TYPE:
-              fiberTag = 14;
-              break a;
-            case REACT_LAZY_TYPE:
-              fiberTag = 16;
-              owner = null;
-              break a;
-          }
-        throw Error(
-          formatProdErrorMessage(130, null == type ? type : typeof type, "")
-        );
+        root.shift();
+      }
+      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
     }
-  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
-  pendingProps.elementType = type;
-  pendingProps.type = owner;
-  pendingProps.lanes = lanes;
-  return pendingProps;
-}
-function createFiberFromFragment(elements, mode, lanes, key) {
-  elements = createFiber(7, elements, key, mode);
-  elements.lanes = lanes;
-  return elements;
+  null !== queuedFocus &&
+    attemptReplayContinuousQueuedEvent(queuedFocus) &&
+    (queuedFocus = null);
+  null !== queuedDrag &&
+    attemptReplayContinuousQueuedEvent(queuedDrag) &&
+    (queuedDrag = null);
+  null !== queuedMouse &&
+    attemptReplayContinuousQueuedEvent(queuedMouse) &&
+    (queuedMouse = null);
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
 }
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(22, pendingProps, key, mode);
-  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
-  pendingProps.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
-    }
-  };
-  pendingProps.stateNode = primaryChildInstance;
-  return pendingProps;
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  queuedEvent.blockedOn === unblocked &&
+    ((queuedEvent.blockedOn = null),
+    hasScheduledReplayAttempt ||
+      ((hasScheduledReplayAttempt = !0),
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      )));
 }
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(23, pendingProps, key, mode);
-  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  pendingProps.lanes = lanes;
-  var instance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
+function retryIfBlockedOn(unblocked) {
+  function unblock(queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  }
+  if (0 < queuedDiscreteEvents.length) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
     }
-  };
-  pendingProps.stateNode = instance;
-  return pendingProps;
-}
-function createFiberFromText(content, mode, lanes) {
-  content = createFiber(6, content, null, mode);
-  content.lanes = lanes;
-  return content;
-}
-function createFiberFromPortal(portal, mode, lanes) {
-  mode = createFiber(
-    4,
-    null !== portal.children ? portal.children : [],
-    portal.key,
-    mode
-  );
-  mode.lanes = lanes;
-  mode.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    implementation: portal.implementation
-  };
-  return mode;
-}
-function FiberRootNode(
-  containerInfo,
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
-) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.finishedWork =
-    this.pingCache =
-    this.current =
-    this.pendingChildren =
-      null;
-  this.timeoutHandle = -1;
-  this.callbackNode = this.pendingContext = this.context = null;
-  this.callbackPriority = 0;
-  this.eventTimes = createLaneMap(0);
-  this.expirationTimes = createLaneMap(-1);
-  this.entangledLanes =
-    this.errorRecoveryDisabledLanes =
-    this.finishedLanes =
-    this.mutableReadLanes =
-    this.expiredLanes =
-    this.pingedLanes =
-    this.suspendedLanes =
-    this.pendingLanes =
-      0;
-  this.entanglements = createLaneMap(0);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
-  this.pooledCache = null;
-  this.pooledCacheLanes = 0;
-  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
-  this.incompleteTransitions = new Map();
-  if (enableTransitionTracing)
-    for (
-      this.transitionCallbacks = null,
-        containerInfo = this.transitionLanes = [],
-        tag = 0;
-      31 > tag;
-      tag++
-    )
-      containerInfo.push(null);
+  }
+  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
+    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
+  for (
+    ;
+    0 < queuedExplicitHydrationTargets.length &&
+    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
+
+  )
+    attemptExplicitHydrationTarget(i),
+      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
 }
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
+  _enabled = !0;
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
 ) {
-  containerInfo = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
+  switch (getEventPriority(domEventName)) {
+    case 2:
+      var listenerWrapper = dispatchDiscreteEvent;
+      break;
+    case 8:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+    default:
+      listenerWrapper = dispatchEvent;
+  }
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
   );
-  containerInfo.hydrationCallbacks = hydrationCallbacks;
-  enableTransitionTracing &&
-    (containerInfo.transitionCallbacks = transitionCallbacks);
-  1 === tag
-    ? ((tag = 1),
-      !0 === isStrictMode && (tag |= 24),
-      concurrentUpdatesByDefaultOverride && (tag |= 32))
-    : (tag = 0);
-  isStrictMode = createFiber(3, null, null, tag);
-  containerInfo.current = isStrictMode;
-  isStrictMode.stateNode = containerInfo;
-  concurrentUpdatesByDefaultOverride = createCache();
-  concurrentUpdatesByDefaultOverride.refCount++;
-  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
-  concurrentUpdatesByDefaultOverride.refCount++;
-  isStrictMode.memoizedState = {
-    element: initialChildren,
-    isDehydrated: hydrate,
-    cache: concurrentUpdatesByDefaultOverride
-  };
-  initializeUpdateQueue(isStrictMode);
-  return containerInfo;
 }
-function createPortal$1(children, containerInfo, implementation) {
-  var key =
-    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
-  return {
-    $$typeof: REACT_PORTAL_TYPE,
-    key: null == key ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
-  };
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 2),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
+  }
 }
-function getContextForSubtree(parentComponent) {
-  if (!parentComponent) return emptyContextObject;
-  parentComponent = parentComponent._reactInternals;
-  a: {
-    if (
-      getNearestMountedFiber(parentComponent) !== parentComponent ||
-      1 !== parentComponent.tag
-    )
-      throw Error(formatProdErrorMessage(170));
-    var JSCompiler_inline_result = parentComponent;
-    do {
-      switch (JSCompiler_inline_result.tag) {
-        case 3:
-          JSCompiler_inline_result = JSCompiler_inline_result.stateNode.context;
-          break a;
-        case 1:
-          if (isContextProvider(JSCompiler_inline_result.type)) {
-            JSCompiler_inline_result =
-              JSCompiler_inline_result.stateNode
-                .__reactInternalMemoizedMergedChildContext;
-            break a;
-          }
-      }
-      JSCompiler_inline_result = JSCompiler_inline_result.return;
-    } while (null !== JSCompiler_inline_result);
-    throw Error(formatProdErrorMessage(171));
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 8),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
   }
-  if (1 === parentComponent.tag) {
-    var Component = parentComponent.type;
-    if (isContextProvider(Component))
-      return processChildContext(
-        parentComponent,
-        Component,
-        JSCompiler_inline_result
+}
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (_enabled)
+    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+      var blockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
       );
-  }
-  return JSCompiler_inline_result;
+      if (null === blockedOn)
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          clearIfContinuousEvent(domEventName, nativeEvent);
+      else if (
+        queueIfContinuousEvent(
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
+      )
+        nativeEvent.stopPropagation();
+      else if (
+        (clearIfContinuousEvent(domEventName, nativeEvent),
+        eventSystemFlags & 4 &&
+          -1 < discreteReplayableEvents.indexOf(domEventName))
+      ) {
+        for (; null !== blockedOn; ) {
+          var fiber = getInstanceFromNode(blockedOn);
+          null !== fiber && attemptSynchronousHydration(fiber);
+          fiber = findInstanceBlockingEvent(
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          );
+          null === fiber &&
+            dispatchEventForPluginEventSystem(
+              domEventName,
+              eventSystemFlags,
+              nativeEvent,
+              return_targetInst,
+              targetContainer
+            );
+          if (fiber === blockedOn) break;
+          blockedOn = fiber;
+        }
+        null !== blockedOn && nativeEvent.stopPropagation();
+      } else
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+    } else
+      a: if (
+        (blockedOn = 0 === (eventSystemFlags & 4)) &&
+        0 < queuedDiscreteEvents.length &&
+        -1 < discreteReplayableEvents.indexOf(domEventName)
+      )
+        queueDiscreteEvent(
+          null,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        );
+      else if (
+        ((fiber = findInstanceBlockingEvent(
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        null === fiber)
+      )
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
+      else {
+        if (blockedOn) {
+          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
+            queueDiscreteEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            );
+            break a;
+          }
+          if (
+            queueIfContinuousEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            )
+          )
+            break a;
+          clearIfContinuousEvent(domEventName, nativeEvent);
+        }
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+      }
 }
-function createHydrationContainer(
-  initialChildren,
-  callback,
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+var return_targetInst = null;
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
 ) {
-  initialChildren = createFiberRoot(
-    containerInfo,
-    tag,
-    !0,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
-  );
-  initialChildren.context = getContextForSubtree(null);
-  containerInfo = initialChildren.current;
-  tag = requestUpdateLane(containerInfo);
-  hydrationCallbacks = createUpdate(tag);
-  hydrationCallbacks.callback =
-    void 0 !== callback && null !== callback ? callback : null;
-  callback = requestEventTime();
-  enqueueUpdate(containerInfo, hydrationCallbacks, tag);
-  initialChildren.current.lanes = tag;
-  markRootUpdated(initialChildren, tag, callback);
-  ensureRootIsScheduled(initialChildren, callback);
-  return initialChildren;
-}
-function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current,
-    lane = requestUpdateLane(current);
-  parentComponent = getContextForSubtree(parentComponent);
-  null === container.context
-    ? (container.context = parentComponent)
-    : (container.pendingContext = parentComponent);
-  container = createUpdate(lane);
-  container.payload = { element: element };
-  callback = void 0 === callback ? null : callback;
-  null !== callback && (container.callback = callback);
-  element = enqueueUpdate(current, container, lane);
-  null !== element &&
-    ((callback = requestEventTime()),
-    scheduleUpdateOnFiber(element, current, lane, callback),
-    entangleTransitions(element, current, lane));
-  return lane;
+  return_targetInst = null;
+  domEventName = getEventTarget(nativeEvent);
+  domEventName = getClosestInstanceFromNode(domEventName);
+  if (null !== domEventName)
+    if (
+      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
+      null === eventSystemFlags)
+    )
+      domEventName = null;
+    else if (
+      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
+    ) {
+      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
+      if (null !== domEventName) return domEventName;
+      domEventName = null;
+    } else if (3 === targetContainer) {
+      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
+        return 3 === eventSystemFlags.tag
+          ? eventSystemFlags.stateNode.containerInfo
+          : null;
+      domEventName = null;
+    } else eventSystemFlags !== domEventName && (domEventName = null);
+  return_targetInst = domEventName;
+  return null;
 }
-function getPublicRootInstance(container) {
-  container = container.current;
-  if (!container.child) return null;
-  switch (container.child.tag) {
-    case 27:
-    case 5:
-      return container.child.stateNode;
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange":
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate":
+    case "beforeblur":
+    case "afterblur":
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return 2;
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel":
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return 8;
+    case "message":
+      switch (getCurrentPriorityLevel()) {
+        case ImmediatePriority:
+          return 2;
+        case UserBlockingPriority:
+          return 8;
+        case NormalPriority$1:
+        case LowPriority:
+          return 32;
+        case IdlePriority:
+          return 536870912;
+        default:
+          return 32;
+      }
     default:
-      return container.child.stateNode;
-  }
-}
-function markRetryLaneImpl(fiber, retryLane) {
-  fiber = fiber.memoizedState;
-  if (null !== fiber && null !== fiber.dehydrated) {
-    var a = fiber.retryLane;
-    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+      return 32;
   }
 }
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
-}
-function emptyFindFiberByHostInstance() {
-  return null;
-}
 var Dispatcher = Internals.Dispatcher,
   defaultOnRecoverableError =
     "function" === typeof reportError
@@ -15474,7 +15544,7 @@ function ReactDOMHydrationRoot(internalRoot) {
 }
 ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
   if (target) {
-    var updatePriority = getCurrentUpdatePriority();
+    var updatePriority = currentUpdatePriority;
     target = { blockedOn: null, target: target, priority: updatePriority };
     for (
       var i = 0;
@@ -15519,11 +15589,11 @@ function legacyCreateRootFromDOMContainer(
     if ("function" === typeof callback) {
       var originalCallback = callback;
       callback = function () {
-        var instance = getPublicRootInstance(root$224);
+        var instance = getPublicRootInstance(root$223);
         originalCallback.call(instance);
       };
     }
-    var root$224 = createHydrationContainer(
+    var root$223 = createHydrationContainer(
       initialChildren,
       callback,
       container,
@@ -15535,23 +15605,23 @@ function legacyCreateRootFromDOMContainer(
       noopOnRecoverableError,
       null
     );
-    container._reactRootContainer = root$224;
-    container[internalContainerInstanceKey] = root$224.current;
+    container._reactRootContainer = root$223;
+    container[internalContainerInstanceKey] = root$223.current;
     listenToAllSupportedEvents(
       8 === container.nodeType ? container.parentNode : container
     );
     flushSync$1();
-    return root$224;
+    return root$223;
   }
   clearContainer(container);
   if ("function" === typeof callback) {
-    var originalCallback$225 = callback;
+    var originalCallback$224 = callback;
     callback = function () {
-      var instance = getPublicRootInstance(root$226);
-      originalCallback$225.call(instance);
+      var instance = getPublicRootInstance(root$225);
+      originalCallback$224.call(instance);
     };
   }
-  var root$226 = createFiberRoot(
+  var root$225 = createFiberRoot(
     container,
     0,
     !1,
@@ -15563,15 +15633,15 @@ function legacyCreateRootFromDOMContainer(
     noopOnRecoverableError,
     null
   );
-  container._reactRootContainer = root$226;
-  container[internalContainerInstanceKey] = root$226.current;
+  container._reactRootContainer = root$225;
+  container[internalContainerInstanceKey] = root$225.current;
   listenToAllSupportedEvents(
     8 === container.nodeType ? container.parentNode : container
   );
   flushSync$1(function () {
-    updateContainer(initialChildren, root$226, parentComponent, callback);
+    updateContainer(initialChildren, root$225, parentComponent, callback);
   });
-  return root$226;
+  return root$225;
 }
 function legacyRenderSubtreeIntoContainer(
   parentComponent,
@@ -15622,115 +15692,25 @@ function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
         listenerSet.add(listenerSetKey));
     } else throw Error(formatProdErrorMessage(369));
 }
-_attemptSynchronousHydration = function (fiber) {
-  switch (fiber.tag) {
-    case 3:
-      var root$223 = fiber.stateNode;
-      if (root$223.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$223.pendingLanes);
-        0 !== lanes &&
-          (markRootEntangled(root$223, lanes | 2),
-          ensureRootIsScheduled(root$223, now()),
-          0 === (executionContext & 6) &&
-            (resetRenderTimer(), flushSyncCallbacks()));
-      }
-      break;
-    case 13:
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        if (null !== root) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-        }
-      }),
-        markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptDiscreteHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptContinuousHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 134217728);
-  }
-};
-attemptHydrationAtCurrentPriority$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var lane = requestUpdateLane(fiber),
-      root = enqueueConcurrentRenderForLane(fiber, lane);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, lane);
-  }
-};
-getCurrentUpdatePriority = function () {
-  return currentUpdatePriority;
-};
-attemptHydrationAtPriority = runWithPriority;
-restoreImpl = function (domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, props);
-      tag = props.name;
-      if ("radio" === props.type && null != tag) {
-        for (props = domElement; props.parentNode; ) props = props.parentNode;
-        props = props.querySelectorAll(
-          "input[name=" + JSON.stringify("" + tag) + '][type="radio"]'
-        );
-        for (tag = 0; tag < props.length; tag++) {
-          var otherNode = props[tag];
-          if (otherNode !== domElement && otherNode.form === domElement.form) {
-            var otherProps = getFiberCurrentPropsFromNode(otherNode);
-            if (!otherProps) throw Error(formatProdErrorMessage(90));
-            updateValueIfChanged(otherNode);
-            updateWrapper$1(otherNode, otherProps);
-          }
-        }
-      }
-      break;
-    case "textarea":
-      updateWrapper(domElement, props);
-      break;
-    case "select":
-      (tag = props.value),
-        null != tag && updateOptions(domElement, !!props.multiple, tag, !1);
-  }
-};
-batchedUpdatesImpl = batchedUpdates;
-flushSyncImpl = flushSync$1;
 Internals.Events = [
   getInstanceFromNode,
   getNodeFromInstance,
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
-var devToolsConfig$jscomp$inline_1761 = {
+var devToolsConfig$jscomp$inline_1739 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-classic-2e575bbb",
+  version: "18.3.0-www-classic-0ef1f7ef",
   rendererPackageName: "react-dom"
 };
-var internals$jscomp$inline_2151 = {
-  bundleType: devToolsConfig$jscomp$inline_1761.bundleType,
-  version: devToolsConfig$jscomp$inline_1761.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1761.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1761.rendererConfig,
+var internals$jscomp$inline_2127 = {
+  bundleType: devToolsConfig$jscomp$inline_1739.bundleType,
+  version: devToolsConfig$jscomp$inline_1739.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1739.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1739.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -15746,26 +15726,26 @@ var internals$jscomp$inline_2151 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1761.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1739.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-classic-2e575bbb"
+  reconcilerVersion: "18.3.0-www-classic-0ef1f7ef"
 };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
-  var hook$jscomp$inline_2152 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  var hook$jscomp$inline_2128 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
   if (
-    !hook$jscomp$inline_2152.isDisabled &&
-    hook$jscomp$inline_2152.supportsFiber
+    !hook$jscomp$inline_2128.isDisabled &&
+    hook$jscomp$inline_2128.supportsFiber
   )
     try {
-      (rendererID = hook$jscomp$inline_2152.inject(
-        internals$jscomp$inline_2151
+      (rendererID = hook$jscomp$inline_2128.inject(
+        internals$jscomp$inline_2127
       )),
-        (injectedHook = hook$jscomp$inline_2152);
+        (injectedHook = hook$jscomp$inline_2128);
     } catch (err) {}
 }
 assign(Internals, {
@@ -15944,7 +15924,7 @@ exports.unmountComponentAtNode = function (container) {
       !0)
     : !1;
 };
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = function (type, options) {
   function eventHandle(target, callback) {
     if ("function" !== typeof callback)
@@ -15977,15 +15957,15 @@ exports.unstable_createEventHandle = function (type, options) {
 exports.unstable_flushControlled = function (fn) {
   var prevExecutionContext = executionContext;
   executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
     previousPriority = currentUpdatePriority;
   try {
-    (ReactCurrentBatchConfig.transition = null),
+    (ReactCurrentBatchConfig$1.transition = null),
       (currentUpdatePriority = 2),
       fn();
   } finally {
     (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
       (executionContext = prevExecutionContext),
       0 === executionContext && (resetRenderTimer(), flushSyncCallbacks());
   }
@@ -16009,4 +15989,4 @@ exports.unstable_renderSubtreeIntoContainer = function (
   );
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-classic-2e575bbb";
+exports.version = "18.3.0-www-classic-0ef1f7ef";
diff --git a/compiled/facebook-www/ReactDOM-prod.modern.js b/compiled/facebook-www/ReactDOM-prod.modern.js
index f16f5e8a4cdbd..626c89f7fd643 100644
--- a/compiled/facebook-www/ReactDOM-prod.modern.js
+++ b/compiled/facebook-www/ReactDOM-prod.modern.js
@@ -14,8 +14,8 @@
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
 "use strict";
-var Scheduler = require("scheduler"),
-  React = require("react"),
+var React = require("react"),
+  Scheduler = require("scheduler"),
   Internals = {
     usingClientEntryPoint: !1,
     Events: null,
@@ -40,6 +40,7 @@ function formatProdErrorMessage(code) {
 var dynamicFeatureFlags = require("ReactFeatureFlags"),
   disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   enableFilterEmptyStringAttributesDOM =
@@ -1115,17 +1116,46 @@ function getEventTarget(nativeEvent) {
     (nativeEvent = nativeEvent.correspondingUseElement);
   return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;
 }
-var restoreImpl = null,
-  restoreTarget = null,
+var restoreTarget = null,
   restoreQueue = null;
 function restoreStateOfTarget(target) {
-  if ((target = getInstanceFromNode$1(target))) {
-    if ("function" !== typeof restoreImpl)
-      throw Error(formatProdErrorMessage(280));
-    var stateNode = target.stateNode;
-    stateNode &&
-      ((stateNode = getFiberCurrentPropsFromNode(stateNode)),
-      restoreImpl(target.stateNode, target.type, stateNode));
+  var internalInstance = getInstanceFromNode$1(target);
+  if (internalInstance && (target = internalInstance.stateNode)) {
+    var props = getFiberCurrentPropsFromNode(target);
+    a: switch (((target = internalInstance.stateNode), internalInstance.type)) {
+      case "input":
+        updateWrapper$1(target, props);
+        internalInstance = props.name;
+        if ("radio" === props.type && null != internalInstance) {
+          for (props = target; props.parentNode; ) props = props.parentNode;
+          props = props.querySelectorAll(
+            "input[name=" +
+              JSON.stringify("" + internalInstance) +
+              '][type="radio"]'
+          );
+          for (
+            internalInstance = 0;
+            internalInstance < props.length;
+            internalInstance++
+          ) {
+            var otherNode = props[internalInstance];
+            if (otherNode !== target && otherNode.form === target.form) {
+              var otherProps = getFiberCurrentPropsFromNode(otherNode);
+              if (!otherProps) throw Error(formatProdErrorMessage(90));
+              updateValueIfChanged(otherNode);
+              updateWrapper$1(otherNode, otherProps);
+            }
+          }
+        }
+        break a;
+      case "textarea":
+        updateWrapper(target, props);
+        break a;
+      case "select":
+        (internalInstance = props.value),
+          null != internalInstance &&
+            updateOptions(target, !!props.multiple, internalInstance, !1);
+    }
   }
 }
 function enqueueStateRestore(target) {
@@ -1146,118 +1176,6 @@ function restoreStateIfNeeded() {
         restoreStateOfTarget(queuedTargets[target]);
   }
 }
-function batchedUpdatesImpl(fn, bookkeeping) {
-  return fn(bookkeeping);
-}
-function flushSyncImpl() {}
-var isInsideEventHandler = !1;
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) return fn(a, b);
-  isInsideEventHandler = !0;
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    if (
-      ((isInsideEventHandler = !1),
-      null !== restoreTarget || null !== restoreQueue)
-    )
-      flushSyncImpl(), restoreStateIfNeeded();
-  }
-}
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-  if (null === stateNode) return null;
-  var props = getFiberCurrentPropsFromNode(stateNode);
-  if (null === props) return null;
-  stateNode = props[registrationName];
-  a: switch (registrationName) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      (props = !props.disabled) ||
-        ((inst = inst.type),
-        (props = !(
-          "button" === inst ||
-          "input" === inst ||
-          "select" === inst ||
-          "textarea" === inst
-        )));
-      inst = !props;
-      break a;
-    default:
-      inst = !1;
-  }
-  if (inst) return null;
-  if (stateNode && "function" !== typeof stateNode)
-    throw Error(
-      formatProdErrorMessage(231, registrationName, typeof stateNode)
-    );
-  return stateNode;
-}
-var passiveBrowserEventsSupported = !1;
-if (canUseDOM)
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = !0;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = !1;
-  }
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
-  throw Error(formatProdErrorMessage(255));
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
-}
-var hasError = !1,
-  caughtError = null,
-  hasRethrowError = !1,
-  rethrowError = null,
-  reporter = {
-    onError: function (error) {
-      hasError = !0;
-      caughtError = error;
-    }
-  };
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = !1;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
-}
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
-  if (hasError) {
-    if (hasError) {
-      var error = caughtError;
-      hasError = !1;
-      caughtError = null;
-    } else throw Error(formatProdErrorMessage(198));
-    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
-  }
-}
 function getNearestMountedFiber(fiber) {
   var node = fiber,
     nearestMounted = fiber;
@@ -1384,31 +1302,22 @@ function doesFiberContain(parentFiber, childFiber) {
   }
   return !1;
 }
-var scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
-  cancelCallback$1 = Scheduler.unstable_cancelCallback,
-  shouldYield = Scheduler.unstable_shouldYield,
-  requestPaint = Scheduler.unstable_requestPaint,
-  now = Scheduler.unstable_now,
-  getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
-  ImmediatePriority = Scheduler.unstable_ImmediatePriority,
-  UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
-  NormalPriority$1 = Scheduler.unstable_NormalPriority,
-  LowPriority = Scheduler.unstable_LowPriority,
-  IdlePriority = Scheduler.unstable_IdlePriority,
-  rendererID = null,
-  injectedHook = null;
-function onCommitRoot(root) {
-  if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
-    try {
-      injectedHook.onCommitFiberRoot(
-        rendererID,
-        root,
-        void 0,
-        128 === (root.current.flags & 128)
-      );
-    } catch (err) {}
+var valueStack = [],
+  index = -1;
+function createCursor(defaultValue) {
+  return { current: defaultValue };
 }
-var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
+function pop(cursor) {
+  0 > index ||
+    ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
+}
+function push(cursor, value) {
+  index++;
+  valueStack[index] = cursor.current;
+  cursor.current = value;
+}
+var emptyContextObject = {},
+  clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
   log = Math.log,
   LN2 = Math.LN2;
 function clz32Fallback(x) {
@@ -1684,1231 +1593,765 @@ function lanesToEventPriority(lanes) {
       : 8
     : 2;
 }
-var _attemptSynchronousHydration,
-  attemptDiscreteHydration$1,
-  attemptContinuousHydration$1,
-  attemptHydrationAtCurrentPriority$1,
-  getCurrentUpdatePriority,
-  attemptHydrationAtPriority,
-  hasScheduledReplayAttempt = !1,
-  queuedDiscreteEvents = [],
-  queuedFocus = null,
-  queuedDrag = null,
-  queuedMouse = null,
-  queuedPointers = new Map(),
-  queuedPointerCaptures = new Map(),
-  queuedExplicitHydrationTargets = [],
-  discreteReplayableEvents =
-    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
-      " "
-    );
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
+var scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
+  cancelCallback$1 = Scheduler.unstable_cancelCallback,
+  shouldYield = Scheduler.unstable_shouldYield,
+  requestPaint = Scheduler.unstable_requestPaint,
+  now = Scheduler.unstable_now,
+  getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
+  ImmediatePriority = Scheduler.unstable_ImmediatePriority,
+  UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
+  NormalPriority$1 = Scheduler.unstable_NormalPriority,
+  LowPriority = Scheduler.unstable_LowPriority,
+  IdlePriority = Scheduler.unstable_IdlePriority,
+  rendererID = null,
+  injectedHook = null;
+function onCommitRoot(root) {
+  if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
+    try {
+      injectedHook.onCommitFiberRoot(
+        rendererID,
+        root,
+        void 0,
+        128 === (root.current.flags & 128)
+      );
+    } catch (err) {}
 }
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
-    ((blockedOn = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )),
-    queuedDiscreteEvents.push(blockedOn),
-    1 === queuedDiscreteEvents.length)
-  )
-    for (; null !== blockedOn.blockedOn; ) {
-      domEventName = getInstanceFromNode$1(blockedOn.blockedOn);
-      if (null === domEventName) break;
-      _attemptSynchronousHydration(domEventName);
-      if (null === blockedOn.blockedOn) replayUnblockedEvents();
-      else break;
-    }
+function is(x, y) {
+  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
 }
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
-    case "pointerover":
-    case "pointerout":
-      queuedPointers.delete(nativeEvent.pointerId);
-      break;
-    case "gotpointercapture":
-    case "lostpointercapture":
-      queuedPointerCaptures.delete(nativeEvent.pointerId);
-  }
+var objectIs = "function" === typeof Object.is ? Object.is : is,
+  syncQueue = null,
+  includesLegacySyncCallbacks = !1,
+  isFlushingSyncQueue = !1;
+function scheduleSyncCallback(callback) {
+  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
 }
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    null === existingQueuedEvent ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
-  )
-    return (
-      (existingQueuedEvent = createQueuedReplayableEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )),
-      null !== blockedOn &&
-        ((blockedOn = getInstanceFromNode$1(blockedOn)),
-        null !== blockedOn && attemptContinuousHydration$1(blockedOn)),
-      existingQueuedEvent
-    );
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  blockedOn = existingQueuedEvent.targetContainers;
-  null !== targetContainer &&
-    -1 === blockedOn.indexOf(targetContainer) &&
-    blockedOn.push(targetContainer);
-  return existingQueuedEvent;
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = !0;
+  scheduleSyncCallback(callback);
 }
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  switch (domEventName) {
-    case "focusin":
-      return (
-        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedFocus,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "dragenter":
-      return (
-        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedDrag,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "mouseover":
-      return (
-        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedMouse,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "pointerover":
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && null !== syncQueue) {
+    isFlushingSyncQueue = !0;
+    var previousUpdatePriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
+      var callback = queue[i];
+      try {
+        do callback = callback(!0);
+        while (null !== callback);
+      } catch (error) {
+        null === errors ? (errors = [error]) : errors.push(error);
+      }
+    }
+    syncQueue = null;
+    includesLegacySyncCallbacks = !1;
+    currentUpdatePriority = previousUpdatePriority;
+    isFlushingSyncQueue = !1;
+    if (null !== errors) {
+      if (1 < errors.length) {
+        if ("function" === typeof AggregateError)
+          throw new AggregateError(errors);
+        for (
+          previousUpdatePriority = 1;
+          previousUpdatePriority < errors.length;
+          previousUpdatePriority++
         )
-      );
-      return !0;
-    case "gotpointercapture":
-      return (
-        (pointerId = nativeEvent.pointerId),
-        queuedPointerCaptures.set(
-          pointerId,
-          accumulateOrCreateContinuousQueuedReplayableEvent(
-            queuedPointerCaptures.get(pointerId) || null,
-            blockedOn,
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          )
-        ),
-        !0
-      );
-  }
-  return !1;
-}
-function attemptExplicitHydrationTarget(queuedTarget) {
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
-  if (null !== targetInst) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-    if (null !== nearestMounted)
-      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
-        if (
-          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
-          null !== targetInst)
-        ) {
-          queuedTarget.blockedOn = targetInst;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (
-        3 === targetInst &&
-        nearestMounted.stateNode.current.memoizedState.isDehydrated
-      ) {
-        queuedTarget.blockedOn =
-          3 === nearestMounted.tag
-            ? nearestMounted.stateNode.containerInfo
-            : null;
-        return;
+          scheduleCallback$2(
+            ImmediatePriority,
+            throwError.bind(null, errors[previousUpdatePriority])
+          );
       }
+      throw errors[0];
+    }
   }
-  queuedTarget.blockedOn = null;
+  return null;
 }
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (null !== queuedEvent.blockedOn) return !1;
-  for (
-    var targetContainers = queuedEvent.targetContainers;
-    0 < targetContainers.length;
-
-  ) {
-    var targetContainer = targetContainers[0],
-      nextBlockedOn = findInstanceBlockingEvent(
-        queuedEvent.domEventName,
-        queuedEvent.eventSystemFlags,
-        targetContainer,
-        queuedEvent.nativeEvent
-      );
-    if (null === nextBlockedOn)
-      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
-        ? ((nextBlockedOn = queuedEvent.nativeEvent),
-          (currentReplayingEvent = targetContainer =
-            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
-          nextBlockedOn.target.dispatchEvent(targetContainer))
-        : ((currentReplayingEvent = queuedEvent.nativeEvent),
-          dispatchEventForPluginEventSystem(
-            queuedEvent.domEventName,
-            queuedEvent.eventSystemFlags,
-            queuedEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          )),
-        (currentReplayingEvent = null);
-    else
-      return (
-        (targetContainers = getInstanceFromNode$1(nextBlockedOn)),
-        null !== targetContainers &&
-          attemptContinuousHydration$1(targetContainers),
-        (queuedEvent.blockedOn = nextBlockedOn),
-        !1
-      );
-    targetContainers.shift();
-  }
-  return !0;
+function throwError(error) {
+  throw error;
 }
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+var forkStack = [],
+  forkStackIndex = 0,
+  treeForkProvider = null,
+  treeForkCount = 0,
+  idStack = [],
+  idStackIndex = 0,
+  treeContextProvider = null,
+  treeContextId = 1,
+  treeContextOverflow = "";
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
 }
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = !1;
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
-    for (; 0 < queuedDiscreteEvents.length; ) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
-      if (null !== nextDiscreteEvent.blockedOn) {
-        nextDiscreteEvent = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
-        null !== nextDiscreteEvent &&
-          attemptDiscreteHydration$1(nextDiscreteEvent);
-        break;
-      }
-      for (
-        var targetContainers = nextDiscreteEvent.targetContainers;
-        0 < targetContainers.length;
-
-      ) {
-        var targetContainer = targetContainers[0],
-          nextBlockedOn = findInstanceBlockingEvent(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            targetContainer,
-            nextDiscreteEvent.nativeEvent
-          );
-        if (null === nextBlockedOn)
-          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
-            dispatchEventForPluginEventSystem(
-              nextDiscreteEvent.domEventName,
-              nextDiscreteEvent.eventSystemFlags,
-              nextDiscreteEvent.nativeEvent,
-              return_targetInst,
-              targetContainer
-            ),
-            (currentReplayingEvent = null);
-        else {
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        }
-        targetContainers.shift();
-      }
-      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
-    }
-  null !== queuedFocus &&
-    attemptReplayContinuousQueuedEvent(queuedFocus) &&
-    (queuedFocus = null);
-  null !== queuedDrag &&
-    attemptReplayContinuousQueuedEvent(queuedDrag) &&
-    (queuedDrag = null);
-  null !== queuedMouse &&
-    attemptReplayContinuousQueuedEvent(queuedMouse) &&
-    (queuedMouse = null);
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  workInProgress = treeContextOverflow;
+  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
+  baseIdWithLeadingBit &= ~(1 << baseLength);
+  index += 1;
+  var length = 32 - clz32(totalChildren) + baseLength;
+  if (30 < length) {
+    var numberOfOverflowBits = baseLength - (baseLength % 5);
+    length = (
+      baseIdWithLeadingBit &
+      ((1 << numberOfOverflowBits) - 1)
+    ).toString(32);
+    baseIdWithLeadingBit >>= numberOfOverflowBits;
+    baseLength -= numberOfOverflowBits;
+    treeContextId =
+      (1 << (32 - clz32(totalChildren) + baseLength)) |
+      (index << baseLength) |
+      baseIdWithLeadingBit;
+    treeContextOverflow = length + workInProgress;
+  } else
+    (treeContextId =
+      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
+      (treeContextOverflow = workInProgress);
 }
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  queuedEvent.blockedOn === unblocked &&
-    ((queuedEvent.blockedOn = null),
-    hasScheduledReplayAttempt ||
-      ((hasScheduledReplayAttempt = !0),
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      )));
+function pushMaterializedTreeId(workInProgress) {
+  null !== workInProgress.return &&
+    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
 }
-function retryIfBlockedOn(unblocked) {
-  function unblock(queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+function popTreeContext(workInProgress) {
+  for (; workInProgress === treeForkProvider; )
+    (treeForkProvider = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null),
+      (treeForkCount = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null);
+  for (; workInProgress === treeContextProvider; )
+    (treeContextProvider = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextOverflow = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextId = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null);
+}
+var contextStackCursor = createCursor(null),
+  contextFiberStackCursor = createCursor(null),
+  rootInstanceStackCursor = createCursor(null);
+function pushHostContainer(fiber, nextRootInstance) {
+  push(rootInstanceStackCursor, nextRootInstance);
+  push(contextFiberStackCursor, fiber);
+  push(contextStackCursor, null);
+  fiber = nextRootInstance.nodeType;
+  switch (fiber) {
+    case 9:
+    case 11:
+      nextRootInstance = (nextRootInstance = nextRootInstance.documentElement)
+        ? nextRootInstance.namespaceURI
+        : getChildNamespace(null, "");
+      break;
+    default:
+      (fiber = 8 === fiber ? nextRootInstance.parentNode : nextRootInstance),
+        (nextRootInstance = fiber.namespaceURI || null),
+        (fiber = fiber.tagName),
+        (nextRootInstance = getChildNamespace(nextRootInstance, fiber));
   }
-  if (0 < queuedDiscreteEvents.length) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
-    }
+  pop(contextStackCursor);
+  push(contextStackCursor, nextRootInstance);
+}
+function popHostContainer() {
+  pop(contextStackCursor);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
+}
+function pushHostContext(fiber) {
+  var context = contextStackCursor.current;
+  var JSCompiler_inline_result = getChildNamespace(context, fiber.type);
+  context !== JSCompiler_inline_result &&
+    (push(contextFiberStackCursor, fiber),
+    push(contextStackCursor, JSCompiler_inline_result));
+}
+function popHostContext(fiber) {
+  contextFiberStackCursor.current === fiber &&
+    (pop(contextStackCursor), pop(contextFiberStackCursor));
+}
+var hydrationParentFiber = null,
+  nextHydratableInstance = null,
+  isHydrating = !1,
+  hydrationErrors = null,
+  rootOrSingletonContext = !1;
+function deleteHydratableInstance(returnFiber, instance) {
+  var fiber = createFiber(5, null, null, 0);
+  fiber.elementType = "DELETED";
+  fiber.stateNode = instance;
+  fiber.return = returnFiber;
+  instance = returnFiber.deletions;
+  null === instance
+    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
+    : instance.push(fiber);
+}
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & -4097) | 2;
+}
+function tryHydrateInstance(fiber, nextInstance) {
+  var type = fiber.type;
+  nextInstance =
+    1 !== nextInstance.nodeType ||
+    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
+      (rootOrSingletonContext = !1),
+      !0)
+    : !1;
+}
+function tryHydrateText(fiber, nextInstance) {
+  nextInstance =
+    "" === fiber.pendingProps
+      ? null
+      : 3 !== nextInstance.nodeType
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = null),
+      !0)
+    : !1;
+}
+function tryHydrateSuspense(fiber, nextInstance) {
+  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
+  if (null !== nextInstance) {
+    var JSCompiler_inline_result =
+      null !== treeContextProvider
+        ? { id: treeContextId, overflow: treeContextOverflow }
+        : null;
+    fiber.memoizedState = {
+      dehydrated: nextInstance,
+      treeContext: JSCompiler_inline_result,
+      retryLane: 1073741824
+    };
+    JSCompiler_inline_result = createFiber(18, null, null, 0);
+    JSCompiler_inline_result.stateNode = nextInstance;
+    JSCompiler_inline_result.return = fiber;
+    fiber.child = JSCompiler_inline_result;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = null;
+    return !0;
   }
-  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
-  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
-  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
-    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
+  return !1;
+}
+function shouldClientRenderOnMismatch(fiber) {
+  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
+}
+function throwOnHydrationMismatch() {
+  throw Error(formatProdErrorMessage(418));
+}
+function advanceToFirstAttemptableInstance(fiber) {
   for (
     ;
-    0 < queuedExplicitHydrationTargets.length &&
-    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    );
 
   )
-    attemptExplicitHydrationTarget(i),
-      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
-  _enabled = !0;
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  switch (getEventPriority(domEventName)) {
-    case 2:
-      var listenerWrapper = dispatchDiscreteEvent;
-      break;
-    case 8:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
-    default:
-      listenerWrapper = dispatchEvent;
-  }
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
+function advanceToFirstAttemptableTextInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 2),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
-  }
+function advanceToFirstAttemptableSuspenseInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 8),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
+function prepareToHydrateHostInstance(fiber) {
+  var instance = fiber.stateNode,
+    type = fiber.type,
+    props = fiber.memoizedProps;
+  instance[internalInstanceKey] = fiber;
+  instance[internalPropsKey] = props;
+  switch (type) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", instance);
+      listenToNonDelegatedEvent("close", instance);
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "video":
+    case "audio":
+      for (var i = 0; i < mediaEventTypes.length; i++)
+        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", instance);
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", instance);
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", instance);
+      break;
+    case "input":
+      initWrapperState$2(instance, props);
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "select":
+      instance._wrapperState = { wasMultiple: !!props.multiple };
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "textarea":
+      initWrapperState(instance, props),
+        listenToNonDelegatedEvent("invalid", instance);
+  }
+  assertValidProps(type, props);
+  var updatePayload = null,
+    propKey;
+  for (propKey in props)
+    props.hasOwnProperty(propKey) &&
+      ((i = props[propKey]),
+      "children" === propKey
+        ? "string" === typeof i
+          ? instance.textContent !== i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", i]))
+          : "number" === typeof i &&
+            instance.textContent !== "" + i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", "" + i]))
+        : registrationNameDependencies.hasOwnProperty(propKey) &&
+          null != i &&
+          "onScroll" === propKey &&
+          listenToNonDelegatedEvent("scroll", instance));
+  switch (type) {
+    case "input":
+      track(instance);
+      postMountWrapper$3(instance, props, !0);
+      break;
+    case "textarea":
+      track(instance);
+      postMountWrapper(instance);
+      break;
+    case "select":
+    case "option":
+      break;
+    default:
+      "function" === typeof props.onClick && (instance.onclick = noop);
   }
+  instance = updatePayload;
+  fiber.updateQueue = instance;
+  return null !== instance ? !0 : !1;
 }
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (_enabled)
-    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-      var blockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
-      if (null === blockedOn)
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          clearIfContinuousEvent(domEventName, nativeEvent);
-      else if (
-        queueIfContinuousEvent(
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
-      )
-        nativeEvent.stopPropagation();
-      else if (
-        (clearIfContinuousEvent(domEventName, nativeEvent),
-        eventSystemFlags & 4 &&
-          -1 < discreteReplayableEvents.indexOf(domEventName))
-      ) {
-        for (; null !== blockedOn; ) {
-          var fiber = getInstanceFromNode$1(blockedOn);
-          null !== fiber && _attemptSynchronousHydration(fiber);
-          fiber = findInstanceBlockingEvent(
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          );
-          null === fiber &&
-            dispatchEventForPluginEventSystem(
-              domEventName,
-              eventSystemFlags,
-              nativeEvent,
-              return_targetInst,
-              targetContainer
-            );
-          if (fiber === blockedOn) break;
-          blockedOn = fiber;
-        }
-        null !== blockedOn && nativeEvent.stopPropagation();
-      } else
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-    } else
-      a: if (
-        (blockedOn = 0 === (eventSystemFlags & 4)) &&
-        0 < queuedDiscreteEvents.length &&
-        -1 < discreteReplayableEvents.indexOf(domEventName)
-      )
-        queueDiscreteEvent(
-          null,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        );
-      else if (
-        ((fiber = findInstanceBlockingEvent(
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        null === fiber)
-      )
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
-      else {
-        if (blockedOn) {
-          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
-            queueDiscreteEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            );
-            break a;
-          }
-          if (
-            queueIfContinuousEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            )
-          )
-            break a;
-          clearIfContinuousEvent(domEventName, nativeEvent);
-        }
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-      }
+function popToNextHostParent(fiber) {
+  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
+    switch (hydrationParentFiber.tag) {
+      case 3:
+      case 27:
+        rootOrSingletonContext = !0;
+        return;
+      case 5:
+      case 13:
+        rootOrSingletonContext = !1;
+        return;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
 }
-var return_targetInst = null;
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return_targetInst = null;
-  domEventName = getEventTarget(nativeEvent);
-  domEventName = getClosestInstanceFromNode(domEventName);
-  if (null !== domEventName)
-    if (
-      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
-      null === eventSystemFlags)
-    )
-      domEventName = null;
-    else if (
-      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
-    ) {
-      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
-      if (null !== domEventName) return domEventName;
-      domEventName = null;
-    } else if (3 === targetContainer) {
-      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
-        return 3 === eventSystemFlags.tag
-          ? eventSystemFlags.stateNode.containerInfo
-          : null;
-      domEventName = null;
-    } else eventSystemFlags !== domEventName && (domEventName = null);
-  return_targetInst = domEventName;
-  return null;
-}
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange":
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate":
-    case "beforeblur":
-    case "afterblur":
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return 2;
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel":
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return 8;
-    case "message":
-      switch (getCurrentPriorityLevel()) {
-        case ImmediatePriority:
-          return 2;
-        case UserBlockingPriority:
-          return 8;
-        case NormalPriority$1:
-        case LowPriority:
-          return 32;
-        case IdlePriority:
-          return 536870912;
-        default:
-          return 32;
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) return !1;
+  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
+  var shouldClear = !1;
+  3 === fiber.tag ||
+    27 === fiber.tag ||
+    (5 === fiber.tag &&
+      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
+    (shouldClear = !0);
+  if (shouldClear && (shouldClear = nextHydratableInstance))
+    if (shouldClientRenderOnMismatch(fiber))
+      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
+    else
+      for (; shouldClear; )
+        deleteHydratableInstance(fiber, shouldClear),
+          (shouldClear = getNextHydratable(shouldClear.nextSibling));
+  popToNextHostParent(fiber);
+  if (13 === fiber.tag) {
+    fiber = fiber.memoizedState;
+    fiber = null !== fiber ? fiber.dehydrated : null;
+    if (!fiber) throw Error(formatProdErrorMessage(317));
+    a: {
+      fiber = fiber.nextSibling;
+      for (shouldClear = 0; fiber; ) {
+        if (8 === fiber.nodeType) {
+          var data = fiber.data;
+          if ("/$" === data) {
+            if (0 === shouldClear) {
+              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
+              break a;
+            }
+            shouldClear--;
+          } else
+            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
+        }
+        fiber = fiber.nextSibling;
       }
-    default:
-      return 32;
-  }
-}
-function addEventBubbleListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, !1);
-  return listener;
+      nextHydratableInstance = null;
+    }
+  } else
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratable(fiber.stateNode.nextSibling)
+      : null;
+  return !0;
 }
-function addEventCaptureListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, !0);
-  return listener;
+function warnIfUnhydratedTailNodes() {
+  for (var nextInstance = nextHydratableInstance; nextInstance; )
+    nextInstance = getNextHydratable(nextInstance.nextSibling);
 }
-function addEventCaptureListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, {
-    capture: !0,
-    passive: passive
-  });
-  return listener;
+function resetHydrationState() {
+  nextHydratableInstance = hydrationParentFiber = null;
+  isHydrating = !1;
 }
-function addEventBubbleListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, { passive: passive });
-  return listener;
+function queueHydrationError(error) {
+  null === hydrationErrors
+    ? (hydrationErrors = [error])
+    : hydrationErrors.push(error);
 }
-var root = null,
-  startText = null,
-  fallbackText = null;
-function getData() {
-  if (fallbackText) return fallbackText;
-  var start,
-    startValue = startText,
-    startLength = startValue.length,
-    end,
-    endValue = "value" in root ? root.value : root.textContent,
-    endLength = endValue.length;
-  for (
-    start = 0;
-    start < startLength && startValue[start] === endValue[start];
-    start++
-  );
-  var minEnd = startLength - start;
+var concurrentQueues = [],
+  concurrentQueuesIndex = 0,
+  concurrentlyUpdatedLanes = 0;
+function finishQueueingConcurrentUpdates() {
   for (
-    end = 1;
-    end <= minEnd &&
-    startValue[startLength - end] === endValue[endLength - end];
-    end++
-  );
-  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
+    var endIndex = concurrentQueuesIndex,
+      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
+    i < endIndex;
+
+  ) {
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    if (null !== queue && null !== update) {
+      var pending = queue.pending;
+      null === pending
+        ? (update.next = update)
+        : ((update.next = pending.next), (pending.next = update));
+      queue.pending = update;
+    }
+    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+  }
 }
-function getEventCharCode(nativeEvent) {
-  var keyCode = nativeEvent.keyCode;
-  "charCode" in nativeEvent
-    ? ((nativeEvent = nativeEvent.charCode),
-      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
-    : (nativeEvent = keyCode);
-  10 === nativeEvent && (nativeEvent = 13);
-  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes |= lane;
+  fiber.lanes |= lane;
+  fiber = fiber.alternate;
+  null !== fiber && (fiber.lanes |= lane);
 }
-function functionThatReturnsTrue() {
-  return !0;
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
 }
-function functionThatReturnsFalse() {
-  return !1;
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  sourceFiber.lanes |= lane;
+  var alternate = sourceFiber.alternate;
+  null !== alternate && (alternate.lanes |= lane);
+  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
+    (parent.childLanes |= lane),
+      (alternate = parent.alternate),
+      null !== alternate && (alternate.childLanes |= lane),
+      22 === parent.tag &&
+        ((sourceFiber = parent.stateNode),
+        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
+      (sourceFiber = parent),
+      (parent = parent.return);
+  isHidden &&
+    null !== update &&
+    3 === sourceFiber.tag &&
+    ((parent = sourceFiber.stateNode),
+    (isHidden = 31 - clz32(lane)),
+    (parent = parent.hiddenUpdates),
+    (sourceFiber = parent[isHidden]),
+    null === sourceFiber
+      ? (parent[isHidden] = [update])
+      : sourceFiber.push(update),
+    (update.lane = lane | 1073741824));
 }
-function createSyntheticEvent(Interface) {
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-    for (var propName in Interface)
-      Interface.hasOwnProperty(propName) &&
-        ((reactName = Interface[propName]),
-        (this[propName] = reactName
-          ? reactName(nativeEvent)
-          : nativeEvent[propName]));
-    this.isDefaultPrevented = (
-      null != nativeEvent.defaultPrevented
-        ? nativeEvent.defaultPrevented
-        : !1 === nativeEvent.returnValue
-    )
-      ? functionThatReturnsTrue
-      : functionThatReturnsFalse;
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  }
-  assign(SyntheticBaseEvent.prototype, {
-    preventDefault: function () {
-      this.defaultPrevented = !0;
-      var event = this.nativeEvent;
-      event &&
-        (event.preventDefault
-          ? event.preventDefault()
-          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
-        (this.isDefaultPrevented = functionThatReturnsTrue));
-    },
-    stopPropagation: function () {
-      var event = this.nativeEvent;
-      event &&
-        (event.stopPropagation
-          ? event.stopPropagation()
-          : "unknown" !== typeof event.cancelBubble &&
-            (event.cancelBubble = !0),
-        (this.isPropagationStopped = functionThatReturnsTrue));
-    },
-    persist: function () {},
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
+function getRootForUpdatedFiber(sourceFiber) {
+  if (50 < nestedUpdateCount)
+    throw (
+      ((nestedUpdateCount = 0),
+      (rootWithNestedUpdates = null),
+      Error(formatProdErrorMessage(185)))
+    );
+  for (var parent = sourceFiber.return; null !== parent; )
+    (sourceFiber = parent), (parent = sourceFiber.return);
+  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
 }
-var EventInterface = {
-    eventPhase: 0,
-    bubbles: 0,
-    cancelable: 0,
-    timeStamp: function (event) {
-      return event.timeStamp || Date.now();
-    },
-    defaultPrevented: 0,
-    isTrusted: 0
-  },
-  SyntheticEvent = createSyntheticEvent(EventInterface),
-  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
-  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
-  lastMovementX,
-  lastMovementY,
-  lastMouseEvent,
-  MouseEventInterface = assign({}, UIEventInterface, {
-    screenX: 0,
-    screenY: 0,
-    clientX: 0,
-    clientY: 0,
-    pageX: 0,
-    pageY: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    getModifierState: getEventModifierState,
-    button: 0,
-    buttons: 0,
-    relatedTarget: function (event) {
-      return void 0 === event.relatedTarget
-        ? event.fromElement === event.srcElement
-          ? event.toElement
-          : event.fromElement
-        : event.relatedTarget;
-    },
-    movementX: function (event) {
-      if ("movementX" in event) return event.movementX;
-      event !== lastMouseEvent &&
-        (lastMouseEvent && "mousemove" === event.type
-          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
-            (lastMovementY = event.screenY - lastMouseEvent.screenY))
-          : (lastMovementY = lastMovementX = 0),
-        (lastMouseEvent = event));
-      return lastMovementX;
-    },
-    movementY: function (event) {
-      return "movementY" in event ? event.movementY : lastMovementY;
-    }
-  }),
-  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
-  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
-  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
-  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
-  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
-  AnimationEventInterface = assign({}, EventInterface, {
-    animationName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
-  ClipboardEventInterface = assign({}, EventInterface, {
-    clipboardData: function (event) {
-      return "clipboardData" in event
-        ? event.clipboardData
-        : window.clipboardData;
-    }
-  }),
-  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
-  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
-  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
-  normalizeKey = {
-    Esc: "Escape",
-    Spacebar: " ",
-    Left: "ArrowLeft",
-    Up: "ArrowUp",
-    Right: "ArrowRight",
-    Down: "ArrowDown",
-    Del: "Delete",
-    Win: "OS",
-    Menu: "ContextMenu",
-    Apps: "ContextMenu",
-    Scroll: "ScrollLock",
-    MozPrintableKey: "Unidentified"
-  },
-  translateToKey = {
-    8: "Backspace",
-    9: "Tab",
-    12: "Clear",
-    13: "Enter",
-    16: "Shift",
-    17: "Control",
-    18: "Alt",
-    19: "Pause",
-    20: "CapsLock",
-    27: "Escape",
-    32: " ",
-    33: "PageUp",
-    34: "PageDown",
-    35: "End",
-    36: "Home",
-    37: "ArrowLeft",
-    38: "ArrowUp",
-    39: "ArrowRight",
-    40: "ArrowDown",
-    45: "Insert",
-    46: "Delete",
-    112: "F1",
-    113: "F2",
-    114: "F3",
-    115: "F4",
-    116: "F5",
-    117: "F6",
-    118: "F7",
-    119: "F8",
-    120: "F9",
-    121: "F10",
-    122: "F11",
-    123: "F12",
-    144: "NumLock",
-    145: "ScrollLock",
-    224: "Meta"
-  },
-  modifierKeyToProp = {
-    Alt: "altKey",
-    Control: "ctrlKey",
-    Meta: "metaKey",
-    Shift: "shiftKey"
+var hasForceUpdate = !1;
+function initializeUpdateQueue(fiber) {
+  fiber.updateQueue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
+    callbacks: null
   };
-function modifierStateGetter(keyArg) {
-  var nativeEvent = this.nativeEvent;
-  return nativeEvent.getModifierState
-    ? nativeEvent.getModifierState(keyArg)
-    : (keyArg = modifierKeyToProp[keyArg])
-    ? !!nativeEvent[keyArg]
-    : !1;
 }
-function getEventModifierState() {
-  return modifierStateGetter;
+function cloneUpdateQueue(current, workInProgress) {
+  current = current.updateQueue;
+  workInProgress.updateQueue === current &&
+    (workInProgress.updateQueue = {
+      baseState: current.baseState,
+      firstBaseUpdate: current.firstBaseUpdate,
+      lastBaseUpdate: current.lastBaseUpdate,
+      shared: current.shared,
+      callbacks: null
+    });
 }
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-    key: function (nativeEvent) {
-      if (nativeEvent.key) {
-        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
-        if ("Unidentified" !== key) return key;
-      }
-      return "keypress" === nativeEvent.type
-        ? ((nativeEvent = getEventCharCode(nativeEvent)),
-          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
-        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
-        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
-        : "";
-    },
-    code: 0,
-    location: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    repeat: 0,
-    locale: 0,
-    getModifierState: getEventModifierState,
-    charCode: function (event) {
-      return "keypress" === event.type ? getEventCharCode(event) : 0;
-    },
-    keyCode: function (event) {
-      return "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    },
-    which: function (event) {
-      return "keypress" === event.type
-        ? getEventCharCode(event)
-        : "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    }
-  }),
-  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
-  PointerEventInterface = assign({}, MouseEventInterface, {
-    pointerId: 0,
-    width: 0,
-    height: 0,
-    pressure: 0,
-    tangentialPressure: 0,
-    tiltX: 0,
-    tiltY: 0,
-    twist: 0,
-    pointerType: 0,
-    isPrimary: 0
-  }),
-  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
-  TouchEventInterface = assign({}, UIEventInterface, {
-    touches: 0,
-    targetTouches: 0,
-    changedTouches: 0,
-    altKey: 0,
-    metaKey: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    getModifierState: getEventModifierState
-  }),
-  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
-  TransitionEventInterface = assign({}, EventInterface, {
-    propertyName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
-  WheelEventInterface = assign({}, MouseEventInterface, {
-    deltaX: function (event) {
-      return "deltaX" in event
-        ? event.deltaX
-        : "wheelDeltaX" in event
-        ? -event.wheelDeltaX
-        : 0;
-    },
-    deltaY: function (event) {
-      return "deltaY" in event
-        ? event.deltaY
-        : "wheelDeltaY" in event
-        ? -event.wheelDeltaY
-        : "wheelDelta" in event
-        ? -event.wheelDelta
-        : 0;
-    },
-    deltaZ: 0,
-    deltaMode: 0
-  }),
-  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
-  END_KEYCODES = [9, 13, 27, 32],
-  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
-  documentMode = null;
-canUseDOM &&
-  "documentMode" in document &&
-  (documentMode = document.documentMode);
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
-  useFallbackCompositionData =
-    canUseDOM &&
-    (!canUseCompositionEvent ||
-      (documentMode && 8 < documentMode && 11 >= documentMode)),
-  SPACEBAR_CHAR = String.fromCharCode(32),
-  hasSpaceKeypress = !1;
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
-    case "keydown":
-      return 229 !== nativeEvent.keyCode;
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      return !0;
-    default:
-      return !1;
-  }
+function createUpdate(lane) {
+  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
 }
-function getDataFromCustomEvent(nativeEvent) {
-  nativeEvent = nativeEvent.detail;
-  return "object" === typeof nativeEvent && "data" in nativeEvent
-    ? nativeEvent.data
-    : null;
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
+  if (null === updateQueue) return null;
+  updateQueue = updateQueue.shared;
+  if (
+    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
+    0 === (executionContext & 2)
+  )
+    return (
+      enqueueUpdate$1(fiber, updateQueue, update, lane),
+      getRootForUpdatedFiber(fiber)
+    );
+  var pending = updateQueue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  updateQueue.pending = update;
+  update = getRootForUpdatedFiber(fiber);
+  markUpdateLaneFromFiberToRoot(fiber, null, lane);
+  return update;
 }
-var isComposing = !1;
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
-    case "keypress":
-      if (32 !== nativeEvent.which) return null;
-      hasSpaceKeypress = !0;
-      return SPACEBAR_CHAR;
-    case "textInput":
-      return (
-        (domEventName = nativeEvent.data),
-        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
-      );
-    default:
-      return null;
+function entangleTransitions(root, fiber, lane) {
+  fiber = fiber.updateQueue;
+  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
+    var queueLanes = fiber.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    fiber.lanes = lane;
+    markRootEntangled(root, lane);
   }
 }
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  if (isComposing)
-    return "compositionend" === domEventName ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-      ? ((domEventName = getData()),
-        (fallbackText = startText = root = null),
-        (isComposing = !1),
-        domEventName)
-      : null;
-  switch (domEventName) {
-    case "paste":
-      return null;
-    case "keypress":
-      if (
-        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
-        (nativeEvent.ctrlKey && nativeEvent.altKey)
-      ) {
-        if (nativeEvent.char && 1 < nativeEvent.char.length)
-          return nativeEvent.char;
-        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
-      }
-      return null;
-    case "compositionend":
-      return useFallbackCompositionData && "ko" !== nativeEvent.locale
-        ? null
-        : nativeEvent.data;
-    default:
-      return null;
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  var queue = workInProgress.updateQueue,
+    current = workInProgress.alternate;
+  if (
+    null !== current &&
+    ((current = current.updateQueue), queue === current)
+  ) {
+    var newFirst = null,
+      newLast = null;
+    queue = queue.firstBaseUpdate;
+    if (null !== queue) {
+      do {
+        var clone = {
+          lane: queue.lane,
+          tag: queue.tag,
+          payload: queue.payload,
+          callback: null,
+          next: null
+        };
+        null === newLast
+          ? (newFirst = newLast = clone)
+          : (newLast = newLast.next = clone);
+        queue = queue.next;
+      } while (null !== queue);
+      null === newLast
+        ? (newFirst = newLast = capturedUpdate)
+        : (newLast = newLast.next = capturedUpdate);
+    } else newFirst = newLast = capturedUpdate;
+    queue = {
+      baseState: current.baseState,
+      firstBaseUpdate: newFirst,
+      lastBaseUpdate: newLast,
+      shared: current.shared,
+      callbacks: current.callbacks
+    };
+    workInProgress.updateQueue = queue;
+    return;
   }
+  workInProgress = queue.lastBaseUpdate;
+  null === workInProgress
+    ? (queue.firstBaseUpdate = capturedUpdate)
+    : (workInProgress.next = capturedUpdate);
+  queue.lastBaseUpdate = capturedUpdate;
 }
-var supportedInputTypes = {
-  color: !0,
-  date: !0,
-  datetime: !0,
-  "datetime-local": !0,
-  email: !0,
-  month: !0,
-  number: !0,
-  password: !0,
-  range: !0,
-  search: !0,
-  tel: !0,
-  text: !0,
-  time: !0,
-  url: !0,
-  week: !0
-};
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return "input" === nodeName
-    ? !!supportedInputTypes[elem.type]
-    : "textarea" === nodeName
-    ? !0
-    : !1;
-}
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
+function processUpdateQueue(
+  workInProgress$jscomp$0,
+  props,
+  instance$jscomp$0,
+  renderLanes
 ) {
-  enqueueStateRestore(target);
-  inst = accumulateTwoPhaseListeners(inst, "onChange");
-  0 < inst.length &&
-    ((nativeEvent = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    )),
-    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
-}
-var activeElement$1 = null,
-  activeElementInst$1 = null;
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
-}
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
-  if (updateValueIfChanged(targetNode)) return targetInst;
-}
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if ("change" === domEventName) return targetInst;
-}
-var isInputEventSupported = !1;
-if (canUseDOM) {
-  var JSCompiler_inline_result$jscomp$242;
-  if (canUseDOM) {
-    var isSupported$jscomp$inline_398 = "oninput" in document;
-    if (!isSupported$jscomp$inline_398) {
-      var element$jscomp$inline_399 = document.createElement("div");
-      element$jscomp$inline_399.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_398 =
-        "function" === typeof element$jscomp$inline_399.oninput;
-    }
-    JSCompiler_inline_result$jscomp$242 = isSupported$jscomp$inline_398;
-  } else JSCompiler_inline_result$jscomp$242 = !1;
-  isInputEventSupported =
-    JSCompiler_inline_result$jscomp$242 &&
-    (!document.documentMode || 9 < document.documentMode);
-}
-function stopWatchingForValueChange() {
-  activeElement$1 &&
-    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
-    (activeElementInst$1 = activeElement$1 = null));
-}
-function handlePropertyChange(nativeEvent) {
-  if (
-    "value" === nativeEvent.propertyName &&
-    getInstIfValueChanged(activeElementInst$1)
-  ) {
-    var dispatchQueue = [];
-    createAndAccumulateChangeEvent(
-      dispatchQueue,
-      activeElementInst$1,
-      nativeEvent,
-      getEventTarget(nativeEvent)
-    );
-    batchedUpdates$1(runEventInBatch, dispatchQueue);
+  var queue = workInProgress$jscomp$0.updateQueue;
+  hasForceUpdate = !1;
+  var firstBaseUpdate = queue.firstBaseUpdate,
+    lastBaseUpdate = queue.lastBaseUpdate,
+    pendingQueue = queue.shared.pending;
+  if (null !== pendingQueue) {
+    queue.shared.pending = null;
+    var lastPendingUpdate = pendingQueue,
+      firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null;
+    null === lastBaseUpdate
+      ? (firstBaseUpdate = firstPendingUpdate)
+      : (lastBaseUpdate.next = firstPendingUpdate);
+    lastBaseUpdate = lastPendingUpdate;
+    var current = workInProgress$jscomp$0.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      (pendingQueue = current.lastBaseUpdate),
+      pendingQueue !== lastBaseUpdate &&
+        (null === pendingQueue
+          ? (current.firstBaseUpdate = firstPendingUpdate)
+          : (pendingQueue.next = firstPendingUpdate),
+        (current.lastBaseUpdate = lastPendingUpdate)));
+  }
+  if (null !== firstBaseUpdate) {
+    var newState = queue.baseState;
+    lastBaseUpdate = 0;
+    current = firstPendingUpdate = lastPendingUpdate = null;
+    pendingQueue = firstBaseUpdate;
+    do {
+      var updateLane = pendingQueue.lane & -1073741825,
+        isHiddenUpdate = updateLane !== pendingQueue.lane;
+      if (
+        isHiddenUpdate
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes & updateLane) === updateLane
+      ) {
+        null !== current &&
+          (current = current.next =
+            {
+              lane: 0,
+              tag: pendingQueue.tag,
+              payload: pendingQueue.payload,
+              callback: null,
+              next: null
+            });
+        a: {
+          var workInProgress = workInProgress$jscomp$0,
+            update = pendingQueue;
+          updateLane = props;
+          var instance = instance$jscomp$0;
+          switch (update.tag) {
+            case 1:
+              workInProgress = update.payload;
+              if ("function" === typeof workInProgress) {
+                newState = workInProgress.call(instance, newState, updateLane);
+                break a;
+              }
+              newState = workInProgress;
+              break a;
+            case 3:
+              workInProgress.flags = (workInProgress.flags & -65537) | 128;
+            case 0:
+              workInProgress = update.payload;
+              updateLane =
+                "function" === typeof workInProgress
+                  ? workInProgress.call(instance, newState, updateLane)
+                  : workInProgress;
+              if (null === updateLane || void 0 === updateLane) break a;
+              newState = assign({}, newState, updateLane);
+              break a;
+            case 2:
+              hasForceUpdate = !0;
+          }
+        }
+        updateLane = pendingQueue.callback;
+        null !== updateLane &&
+          ((workInProgress$jscomp$0.flags |= 64),
+          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
+          (isHiddenUpdate = queue.callbacks),
+          null === isHiddenUpdate
+            ? (queue.callbacks = [updateLane])
+            : isHiddenUpdate.push(updateLane));
+      } else
+        (isHiddenUpdate = {
+          lane: updateLane,
+          tag: pendingQueue.tag,
+          payload: pendingQueue.payload,
+          callback: pendingQueue.callback,
+          next: null
+        }),
+          null === current
+            ? ((firstPendingUpdate = current = isHiddenUpdate),
+              (lastPendingUpdate = newState))
+            : (current = current.next = isHiddenUpdate),
+          (lastBaseUpdate |= updateLane);
+      pendingQueue = pendingQueue.next;
+      if (null === pendingQueue)
+        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
+          break;
+        else
+          (isHiddenUpdate = pendingQueue),
+            (pendingQueue = isHiddenUpdate.next),
+            (isHiddenUpdate.next = null),
+            (queue.lastBaseUpdate = isHiddenUpdate),
+            (queue.shared.pending = null);
+    } while (1);
+    null === current && (lastPendingUpdate = newState);
+    queue.baseState = lastPendingUpdate;
+    queue.firstBaseUpdate = firstPendingUpdate;
+    queue.lastBaseUpdate = current;
+    null === firstBaseUpdate && (queue.shared.lanes = 0);
+    workInProgressRootSkippedLanes |= lastBaseUpdate;
+    workInProgress$jscomp$0.lanes = lastBaseUpdate;
+    workInProgress$jscomp$0.memoizedState = newState;
   }
 }
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  "focusin" === domEventName
-    ? (stopWatchingForValueChange(),
-      (activeElement$1 = target),
-      (activeElementInst$1 = targetInst),
-      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
-    : "focusout" === domEventName && stopWatchingForValueChange();
-}
-function getTargetInstForInputEventPolyfill(domEventName) {
-  if (
-    "selectionchange" === domEventName ||
-    "keyup" === domEventName ||
-    "keydown" === domEventName
-  )
-    return getInstIfValueChanged(activeElementInst$1);
-}
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
-}
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if ("input" === domEventName || "change" === domEventName)
-    return getInstIfValueChanged(targetInst);
+function callCallback(callback, context) {
+  if ("function" !== typeof callback)
+    throw Error(formatProdErrorMessage(191, callback));
+  callback.call(context);
 }
-function is(x, y) {
-  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
+  if (null !== callbacks)
+    for (
+      updateQueue.callbacks = null, updateQueue = 0;
+      updateQueue < callbacks.length;
+      updateQueue++
+    )
+      callCallback(callbacks[updateQueue], context);
 }
-var objectIs = "function" === typeof Object.is ? Object.is : is;
 function shallowEqual(objA, objB) {
   if (objectIs(objA, objB)) return !0;
   if (
@@ -2931,6889 +2374,4699 @@ function shallowEqual(objA, objB) {
   }
   return !0;
 }
-function getLeafNode(node) {
-  for (; node && node.firstChild; ) node = node.firstChild;
-  return node;
-}
-function getNodeForCharacterOffset(root, offset) {
-  var node = getLeafNode(root);
-  root = 0;
-  for (var nodeEnd; node; ) {
-    if (3 === node.nodeType) {
-      nodeEnd = root + node.textContent.length;
-      if (root <= offset && nodeEnd >= offset)
-        return { node: node, offset: offset - root };
-      root = nodeEnd;
-    }
-    a: {
-      for (; node; ) {
-        if (node.nextSibling) {
-          node = node.nextSibling;
-          break a;
-        }
-        node = node.parentNode;
-      }
-      node = void 0;
-    }
-    node = getLeafNode(node);
-  }
-}
-function containsNode$1(outerNode, innerNode) {
-  return outerNode && innerNode
-    ? outerNode === innerNode
-      ? !0
-      : outerNode && 3 === outerNode.nodeType
-      ? !1
-      : innerNode && 3 === innerNode.nodeType
-      ? containsNode$1(outerNode, innerNode.parentNode)
-      : "contains" in outerNode
-      ? outerNode.contains(innerNode)
-      : outerNode.compareDocumentPosition
-      ? !!(outerNode.compareDocumentPosition(innerNode) & 16)
-      : !1
-    : !1;
+var SuspenseException = Error(formatProdErrorMessage(460));
+function isThenableResolved(thenable) {
+  thenable = thenable.status;
+  return "fulfilled" === thenable || "rejected" === thenable;
 }
-function getActiveElementDeep() {
-  for (
-    var win = window, element = getActiveElement();
-    element instanceof win.HTMLIFrameElement;
-
-  ) {
-    try {
-      var JSCompiler_inline_result =
-        "string" === typeof element.contentWindow.location.href;
-    } catch (err) {
-      JSCompiler_inline_result = !1;
-    }
-    if (JSCompiler_inline_result) win = element.contentWindow;
-    else break;
-    element = getActiveElement(win.document);
+function noop$1() {}
+function trackUsedThenable(thenableState, thenable, index) {
+  index = thenableState[index];
+  void 0 === index
+    ? thenableState.push(thenable)
+    : index !== thenable && (thenable.then(noop$1, noop$1), (thenable = index));
+  switch (thenable.status) {
+    case "fulfilled":
+      return thenable.value;
+    case "rejected":
+      throw thenable.reason;
+    default:
+      "string" === typeof thenable.status
+        ? thenable.then(noop$1, noop$1)
+        : ((thenableState = thenable),
+          (thenableState.status = "pending"),
+          thenableState.then(
+            function (fulfilledValue) {
+              if ("pending" === thenable.status) {
+                var fulfilledThenable = thenable;
+                fulfilledThenable.status = "fulfilled";
+                fulfilledThenable.value = fulfilledValue;
+              }
+            },
+            function (error) {
+              if ("pending" === thenable.status) {
+                var rejectedThenable = thenable;
+                rejectedThenable.status = "rejected";
+                rejectedThenable.reason = error;
+              }
+            }
+          ));
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+      }
+      suspendedThenable = thenable;
+      throw SuspenseException;
   }
-  return element;
 }
-function hasSelectionCapabilities(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName &&
-    (("input" === nodeName &&
-      ("text" === elem.type ||
-        "search" === elem.type ||
-        "tel" === elem.type ||
-        "url" === elem.type ||
-        "password" === elem.type)) ||
-      "textarea" === nodeName ||
-      "true" === elem.contentEditable)
-  );
+var suspendedThenable = null,
+  thenableState$1 = null,
+  thenableIndexCounter$1 = 0;
+function unwrapThenable(thenable) {
+  var index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+  null === thenableState$1 && (thenableState$1 = []);
+  return trackUsedThenable(thenableState$1, thenable, index);
 }
-function restoreSelection(priorSelectionInformation) {
-  var curFocusedElem = getActiveElementDeep(),
-    priorFocusedElem = priorSelectionInformation.focusedElem,
-    priorSelectionRange = priorSelectionInformation.selectionRange;
+function coerceRef(returnFiber, current, element) {
+  returnFiber = element.ref;
   if (
-    curFocusedElem !== priorFocusedElem &&
-    priorFocusedElem &&
-    priorFocusedElem.ownerDocument &&
-    containsNode$1(
-      priorFocusedElem.ownerDocument.documentElement,
-      priorFocusedElem
-    )
+    null !== returnFiber &&
+    "function" !== typeof returnFiber &&
+    "object" !== typeof returnFiber
   ) {
-    if (
-      null !== priorSelectionRange &&
-      hasSelectionCapabilities(priorFocusedElem)
-    )
+    if (element._owner) {
+      element = element._owner;
+      if (element) {
+        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
+        var inst = element.stateNode;
+      }
+      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
+      var resolvedInst = inst,
+        stringRef = "" + returnFiber;
       if (
-        ((curFocusedElem = priorSelectionRange.start),
-        (priorSelectionInformation = priorSelectionRange.end),
-        void 0 === priorSelectionInformation &&
-          (priorSelectionInformation = curFocusedElem),
-        "selectionStart" in priorFocusedElem)
+        null !== current &&
+        null !== current.ref &&
+        "function" === typeof current.ref &&
+        current.ref._stringRef === stringRef
       )
-        (priorFocusedElem.selectionStart = curFocusedElem),
-          (priorFocusedElem.selectionEnd = Math.min(
-            priorSelectionInformation,
-            priorFocusedElem.value.length
-          ));
-      else if (
-        ((priorSelectionInformation =
-          ((curFocusedElem = priorFocusedElem.ownerDocument || document) &&
-            curFocusedElem.defaultView) ||
-          window),
-        priorSelectionInformation.getSelection)
-      ) {
-        priorSelectionInformation = priorSelectionInformation.getSelection();
-        var length = priorFocusedElem.textContent.length,
-          start = Math.min(priorSelectionRange.start, length);
-        priorSelectionRange =
-          void 0 === priorSelectionRange.end
-            ? start
-            : Math.min(priorSelectionRange.end, length);
-        !priorSelectionInformation.extend &&
-          start > priorSelectionRange &&
-          ((length = priorSelectionRange),
-          (priorSelectionRange = start),
-          (start = length));
-        length = getNodeForCharacterOffset(priorFocusedElem, start);
-        var endMarker = getNodeForCharacterOffset(
-          priorFocusedElem,
-          priorSelectionRange
-        );
-        length &&
-          endMarker &&
-          (1 !== priorSelectionInformation.rangeCount ||
-            priorSelectionInformation.anchorNode !== length.node ||
-            priorSelectionInformation.anchorOffset !== length.offset ||
-            priorSelectionInformation.focusNode !== endMarker.node ||
-            priorSelectionInformation.focusOffset !== endMarker.offset) &&
-          ((curFocusedElem = curFocusedElem.createRange()),
-          curFocusedElem.setStart(length.node, length.offset),
-          priorSelectionInformation.removeAllRanges(),
-          start > priorSelectionRange
-            ? (priorSelectionInformation.addRange(curFocusedElem),
-              priorSelectionInformation.extend(
-                endMarker.node,
-                endMarker.offset
-              ))
-            : (curFocusedElem.setEnd(endMarker.node, endMarker.offset),
-              priorSelectionInformation.addRange(curFocusedElem)));
-      }
-    curFocusedElem = [];
-    for (
-      priorSelectionInformation = priorFocusedElem;
-      (priorSelectionInformation = priorSelectionInformation.parentNode);
-
-    )
-      1 === priorSelectionInformation.nodeType &&
-        curFocusedElem.push({
-          element: priorSelectionInformation,
-          left: priorSelectionInformation.scrollLeft,
-          top: priorSelectionInformation.scrollTop
-        });
-    "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
-    for (
-      priorFocusedElem = 0;
-      priorFocusedElem < curFocusedElem.length;
-      priorFocusedElem++
-    )
-      (priorSelectionInformation = curFocusedElem[priorFocusedElem]),
-        (priorSelectionInformation.element.scrollLeft =
-          priorSelectionInformation.left),
-        (priorSelectionInformation.element.scrollTop =
-          priorSelectionInformation.top);
+        return current.ref;
+      current = function (value) {
+        var refs = resolvedInst.refs;
+        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
+      };
+      current._stringRef = stringRef;
+      return current;
+    }
+    if ("string" !== typeof returnFiber)
+      throw Error(formatProdErrorMessage(284));
+    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
   }
+  return returnFiber;
 }
-var skipSelectionChangeEvent =
-    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
-  activeElement = null,
-  activeElementInst = null,
-  lastSelection = null,
-  mouseDown = !1;
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  var doc =
-    nativeEventTarget.window === nativeEventTarget
-      ? nativeEventTarget.document
-      : 9 === nativeEventTarget.nodeType
-      ? nativeEventTarget
-      : nativeEventTarget.ownerDocument;
-  mouseDown ||
-    null == activeElement ||
-    activeElement !== getActiveElement(doc) ||
-    ((doc = activeElement),
-    "selectionStart" in doc && hasSelectionCapabilities(doc)
-      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
-      : ((doc = (
-          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
-          window
-        ).getSelection()),
-        (doc = {
-          anchorNode: doc.anchorNode,
-          anchorOffset: doc.anchorOffset,
-          focusNode: doc.focusNode,
-          focusOffset: doc.focusOffset
-        })),
-    (lastSelection && shallowEqual(lastSelection, doc)) ||
-      ((lastSelection = doc),
-      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
-      0 < doc.length &&
-        ((nativeEvent = new SyntheticEvent(
-          "onSelect",
-          "select",
-          null,
-          nativeEvent,
-          nativeEventTarget
-        )),
-        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
-        (nativeEvent.target = activeElement))));
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  returnFiber = Object.prototype.toString.call(newChild);
+  throw Error(
+    formatProdErrorMessage(
+      31,
+      "[object Object]" === returnFiber
+        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
+        : returnFiber
+    )
+  );
 }
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
+function resolveLazy(lazyType) {
+  var init = lazyType._init;
+  return init(lazyType._payload);
 }
-var vendorPrefixes = {
-    animationend: makePrefixMap("Animation", "AnimationEnd"),
-    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-    animationstart: makePrefixMap("Animation", "AnimationStart"),
-    transitionend: makePrefixMap("Transition", "TransitionEnd")
-  },
-  prefixedEventNames = {},
-  style = {};
-canUseDOM &&
-  ((style = document.createElement("div").style),
-  "AnimationEvent" in window ||
-    (delete vendorPrefixes.animationend.animation,
-    delete vendorPrefixes.animationiteration.animation,
-    delete vendorPrefixes.animationstart.animation),
-  "TransitionEvent" in window ||
-    delete vendorPrefixes.transitionend.transition);
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
-  if (!vendorPrefixes[eventName]) return eventName;
-  var prefixMap = vendorPrefixes[eventName],
-    styleProp;
-  for (styleProp in prefixMap)
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
-  return eventName;
-}
-var ANIMATION_END = getVendorPrefixedEventName("animationend"),
-  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
-  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
-  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
-  topLevelEventsToReactNames = new Map(),
-  simpleEventPluginEvents =
-    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
-      " "
-    );
-topLevelEventsToReactNames.set("beforeblur", null);
-topLevelEventsToReactNames.set("afterblur", null);
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
-}
-for (
-  var i$jscomp$inline_439 = 0;
-  i$jscomp$inline_439 < simpleEventPluginEvents.length;
-  i$jscomp$inline_439++
-) {
-  var eventName$jscomp$inline_440 =
-      simpleEventPluginEvents[i$jscomp$inline_439],
-    domEventName$jscomp$inline_441 = eventName$jscomp$inline_440.toLowerCase(),
-    capitalizedEvent$jscomp$inline_442 =
-      eventName$jscomp$inline_440[0].toUpperCase() +
-      eventName$jscomp$inline_440.slice(1);
-  registerSimpleEvent(
-    domEventName$jscomp$inline_441,
-    "on" + capitalizedEvent$jscomp$inline_442
-  );
-}
-registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-registerSimpleEvent("dblclick", "onDoubleClick");
-registerSimpleEvent("focusin", "onFocus");
-registerSimpleEvent("focusout", "onBlur");
-registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
-registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
-registerTwoPhaseEvent(
-  "onChange",
-  "change click focusin focusout input keydown keyup selectionchange".split(" ")
-);
-registerTwoPhaseEvent(
-  "onSelect",
-  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
-    " "
-  )
-);
-registerTwoPhaseEvent("onBeforeInput", [
-  "compositionend",
-  "keypress",
-  "textInput",
-  "paste"
-]);
-registerTwoPhaseEvent(
-  "onCompositionEnd",
-  "compositionend focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionStart",
-  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionUpdate",
-  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
-);
-var mediaEventTypes =
-    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
-      " "
-    ),
-  nonDelegatedEvents = new Set(
-    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
-  );
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
-  event.currentTarget = null;
-}
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  eventSystemFlags = 0 !== (eventSystemFlags & 4);
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event;
-    _dispatchQueue$i = _dispatchQueue$i.listeners;
-    a: {
-      var previousInstance = void 0;
-      if (eventSystemFlags)
-        for (
-          var i$jscomp$0 = _dispatchQueue$i.length - 1;
-          0 <= i$jscomp$0;
-          i$jscomp$0--
-        ) {
-          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
-            instance = _dispatchListeners$i.instance,
-            currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
-      else
-        for (
-          i$jscomp$0 = 0;
-          i$jscomp$0 < _dispatchQueue$i.length;
-          i$jscomp$0++
-        ) {
-          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
-          instance = _dispatchListeners$i.instance;
-          currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (shouldTrackSideEffects) {
+      var deletions = returnFiber.deletions;
+      null === deletions
+        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
+        : deletions.push(childToDelete);
     }
   }
-  if (hasRethrowError)
-    throw (
-      ((dispatchQueue = rethrowError),
-      (hasRethrowError = !1),
-      (rethrowError = null),
-      dispatchQueue)
-    );
-}
-function listenToNonDelegatedEvent(domEventName, targetElement) {
-  var listenerSet = getEventListenerSet(targetElement),
-    listenerSetKey = domEventName + "__bubble";
-  listenerSet.has(listenerSetKey) ||
-    (addTrappedEventListener(targetElement, domEventName, 2, !1),
-    listenerSet.add(listenerSetKey));
-}
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
-  var eventSystemFlags = 0;
-  isCapturePhaseListener && (eventSystemFlags |= 4);
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
-}
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = !0;
-    allNativeEvents.forEach(function (domEventName) {
-      "selectionchange" !== domEventName &&
-        (nonDelegatedEvents.has(domEventName) ||
-          listenToNativeEvent(domEventName, !1, rootContainerElement),
-        listenToNativeEvent(domEventName, !0, rootContainerElement));
-    });
-    var ownerDocument =
-      9 === rootContainerElement.nodeType
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
-    null === ownerDocument ||
-      ownerDocument[listeningMarker] ||
-      ((ownerDocument[listeningMarker] = !0),
-      listenToNativeEvent("selectionchange", !1, ownerDocument));
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) return null;
+    for (; null !== currentFirstChild; )
+      deleteChild(returnFiber, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return null;
   }
-}
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  eventSystemFlags = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  );
-  var isPassiveListener = void 0;
-  !passiveBrowserEventsSupported ||
-    ("touchstart" !== domEventName &&
-      "touchmove" !== domEventName &&
-      "wheel" !== domEventName) ||
-    (isPassiveListener = !0);
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = eventSystemFlags;
-    eventSystemFlags = function () {
-      targetContainer.removeEventListener(
-        domEventName,
-        unsubscribeListener,
-        isCapturePhaseListener
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    for (returnFiber = new Map(); null !== currentFirstChild; )
+      null !== currentFirstChild.key
+        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
+        : returnFiber.set(currentFirstChild.index, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return returnFiber;
+  }
+  function useFiber(fiber, pendingProps) {
+    fiber = createWorkInProgress(fiber, pendingProps);
+    fiber.index = 0;
+    fiber.sibling = null;
+    return fiber;
+  }
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+    if (!shouldTrackSideEffects)
+      return (newFiber.flags |= 1048576), lastPlacedIndex;
+    newIndex = newFiber.alternate;
+    if (null !== newIndex)
+      return (
+        (newIndex = newIndex.index),
+        newIndex < lastPlacedIndex
+          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
+          : newIndex
       );
-      for (
-        var _len = arguments.length, p = Array(_len), _key = 0;
-        _key < _len;
-        _key++
-      )
-        p[_key] = arguments[_key];
-      return originalListener.apply(this, p);
-    };
+    newFiber.flags |= 16777218;
+    return lastPlacedIndex;
   }
-  var unsubscribeListener = isCapturePhaseListener
-    ? void 0 !== isPassiveListener
-      ? addEventCaptureListenerWithPassiveFlag(
-          targetContainer,
-          domEventName,
-          eventSystemFlags,
-          isPassiveListener
-        )
-      : addEventCaptureListener(targetContainer, domEventName, eventSystemFlags)
-    : void 0 !== isPassiveListener
-    ? addEventBubbleListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        eventSystemFlags,
-        isPassiveListener
-      )
-    : addEventBubbleListener(targetContainer, domEventName, eventSystemFlags);
-}
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst$jscomp$0,
-  targetContainer
-) {
-  var ancestorInst = targetInst$jscomp$0;
-  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+  function placeSingleChild(newFiber) {
+    shouldTrackSideEffects &&
+      null === newFiber.alternate &&
+      (newFiber.flags |= 16777218);
+    return newFiber;
+  }
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (null === current || 6 !== current.tag)
+      return (
+        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, textContent);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateElement(returnFiber, current, element, lanes) {
+    var elementType = element.type;
+    if (elementType === REACT_FRAGMENT_TYPE)
+      return updateFragment(
+        returnFiber,
+        current,
+        element.props.children,
+        lanes,
+        element.key
+      );
     if (
-      enableLegacyFBSupport &&
-      "click" === domEventName &&
-      0 === (eventSystemFlags & 20) &&
-      nativeEvent !== currentReplayingEvent
-    ) {
-      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
-      return;
-    }
-    if (null !== targetInst$jscomp$0)
-      a: for (;;) {
-        if (null === targetInst$jscomp$0) return;
-        var nodeTag = targetInst$jscomp$0.tag;
-        if (3 === nodeTag || 4 === nodeTag) {
-          var container = targetInst$jscomp$0.stateNode.containerInfo;
-          if (
-            container === targetContainer ||
-            (8 === container.nodeType &&
-              container.parentNode === targetContainer)
-          )
-            break;
-          if (4 === nodeTag)
-            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
-              var grandTag = nodeTag.tag;
-              if (3 === grandTag || 4 === grandTag)
-                if (
-                  ((grandTag = nodeTag.stateNode.containerInfo),
-                  grandTag === targetContainer ||
-                    (8 === grandTag.nodeType &&
-                      grandTag.parentNode === targetContainer))
-                )
-                  return;
-              nodeTag = nodeTag.return;
-            }
-          for (; null !== container; ) {
-            nodeTag = getClosestInstanceFromNode(container);
-            if (null === nodeTag) return;
-            grandTag = nodeTag.tag;
-            if (
-              5 === grandTag ||
-              6 === grandTag ||
-              26 === grandTag ||
-              27 === grandTag
-            ) {
-              targetInst$jscomp$0 = ancestorInst = nodeTag;
-              continue a;
-            }
-            container = container.parentNode;
-          }
-        }
-        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+      null !== current &&
+      (current.elementType === elementType ||
+        ("object" === typeof elementType &&
+          null !== elementType &&
+          elementType.$$typeof === REACT_LAZY_TYPE &&
+          resolveLazy(elementType) === current.type))
+    )
+      return (
+        (lanes = useFiber(current, element.props)),
+        (lanes.ref = coerceRef(returnFiber, current, element)),
+        (lanes.return = returnFiber),
+        lanes
+      );
+    lanes = createFiberFromTypeAndProps(
+      element.type,
+      element.key,
+      element.props,
+      null,
+      returnFiber.mode,
+      lanes
+    );
+    lanes.ref = coerceRef(returnFiber, current, element);
+    lanes.return = returnFiber;
+    return lanes;
+  }
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (
+      null === current ||
+      4 !== current.tag ||
+      current.stateNode.containerInfo !== portal.containerInfo ||
+      current.stateNode.implementation !== portal.implementation
+    )
+      return (
+        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, portal.children || []);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (null === current || 7 !== current.tag)
+      return (
+        (current = createFiberFromFragment(
+          fragment,
+          returnFiber.mode,
+          lanes,
+          key
+        )),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, fragment);
+    current.return = returnFiber;
+    return current;
+  }
+  function createChild(returnFiber, newChild, lanes) {
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return (
+        (newChild = createFiberFromText(
+          "" + newChild,
+          returnFiber.mode,
+          lanes
+        )),
+        (newChild.return = returnFiber),
+        newChild
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (lanes = createFiberFromTypeAndProps(
+              newChild.type,
+              newChild.key,
+              newChild.props,
+              null,
+              returnFiber.mode,
+              lanes
+            )),
+            (lanes.ref = coerceRef(returnFiber, null, newChild)),
+            (lanes.return = returnFiber),
+            lanes
+          );
+        case REACT_PORTAL_TYPE:
+          return (
+            (newChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
+            )),
+            (newChild.return = returnFiber),
+            newChild
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return createChild(returnFiber, init(newChild._payload), lanes);
       }
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (newChild = createFiberFromFragment(
+            newChild,
+            returnFiber.mode,
+            lanes,
+            null
+          )),
+          (newChild.return = returnFiber),
+          newChild
+        );
+      if ("function" === typeof newChild.then)
+        return createChild(returnFiber, unwrapThenable(newChild), lanes);
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return createChild(
+          returnFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return null;
   }
-  batchedUpdates$1(function () {
-    var targetInst = ancestorInst,
-      nativeEventTarget = getEventTarget(nativeEvent),
-      dispatchQueue = [];
-    a: {
-      var reactName = topLevelEventsToReactNames.get(domEventName);
-      if (void 0 !== reactName) {
-        var SyntheticEventCtor = SyntheticEvent,
-          reactEventType = domEventName;
-        switch (domEventName) {
-          case "keypress":
-            if (0 === getEventCharCode(nativeEvent)) break a;
-          case "keydown":
-          case "keyup":
-            SyntheticEventCtor = SyntheticKeyboardEvent;
-            break;
-          case "focusin":
-            reactEventType = "focus";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "focusout":
-            reactEventType = "blur";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "beforeblur":
-          case "afterblur":
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "click":
-            if (2 === nativeEvent.button) break a;
-          case "auxclick":
-          case "dblclick":
-          case "mousedown":
-          case "mousemove":
-          case "mouseup":
-          case "mouseout":
-          case "mouseover":
-          case "contextmenu":
-            SyntheticEventCtor = SyntheticMouseEvent;
-            break;
-          case "drag":
-          case "dragend":
-          case "dragenter":
-          case "dragexit":
-          case "dragleave":
-          case "dragover":
-          case "dragstart":
-          case "drop":
-            SyntheticEventCtor = SyntheticDragEvent;
-            break;
-          case "touchcancel":
-          case "touchend":
-          case "touchmove":
-          case "touchstart":
-            SyntheticEventCtor = SyntheticTouchEvent;
-            break;
-          case ANIMATION_END:
-          case ANIMATION_ITERATION:
-          case ANIMATION_START:
-            SyntheticEventCtor = SyntheticAnimationEvent;
-            break;
-          case TRANSITION_END:
-            SyntheticEventCtor = SyntheticTransitionEvent;
-            break;
-          case "scroll":
-            SyntheticEventCtor = SyntheticUIEvent;
-            break;
-          case "wheel":
-            SyntheticEventCtor = SyntheticWheelEvent;
-            break;
-          case "copy":
-          case "cut":
-          case "paste":
-            SyntheticEventCtor = SyntheticClipboardEvent;
-            break;
-          case "gotpointercapture":
-          case "lostpointercapture":
-          case "pointercancel":
-          case "pointerdown":
-          case "pointermove":
-          case "pointerout":
-          case "pointerover":
-          case "pointerup":
-            SyntheticEventCtor = SyntheticPointerEvent;
-        }
-        var inCapturePhase = 0 !== (eventSystemFlags & 4);
-        eventSystemFlags & 1
-          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
-              reactEventType,
-              targetContainer,
-              inCapturePhase
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })))
-          : ((inCapturePhase = accumulateSinglePhaseListeners(
-              targetInst,
-              reactName,
-              nativeEvent.type,
-              inCapturePhase,
-              !inCapturePhase && "scroll" === domEventName,
-              nativeEvent
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })));
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    var key = null !== oldFiber ? oldFiber.key : null;
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return null !== key
+        ? null
+        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return newChild.key === key
+            ? updateElement(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_PORTAL_TYPE:
+          return newChild.key === key
+            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_LAZY_TYPE:
+          return (
+            (key = newChild._init),
+            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
+          );
       }
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return null !== key
+          ? null
+          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      if ("function" === typeof newChild.then)
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-    if (0 === (eventSystemFlags & 7)) {
-      a: {
-        reactName =
-          "mouseover" === domEventName || "pointerover" === domEventName;
-        SyntheticEventCtor =
-          "mouseout" === domEventName || "pointerout" === domEventName;
-        if (
-          reactName &&
-          nativeEvent !== currentReplayingEvent &&
-          (reactEventType =
-            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
-          (getClosestInstanceFromNode(reactEventType) ||
-            reactEventType[internalContainerInstanceKey])
-        )
-          break a;
-        if (SyntheticEventCtor || reactName) {
-          reactName =
-            nativeEventTarget.window === nativeEventTarget
-              ? nativeEventTarget
-              : (reactName = nativeEventTarget.ownerDocument)
-              ? reactName.defaultView || reactName.parentWindow
-              : window;
-          if (SyntheticEventCtor) {
-            if (
-              ((reactEventType =
-                nativeEvent.relatedTarget || nativeEvent.toElement),
-              (SyntheticEventCtor = targetInst),
-              (reactEventType = reactEventType
-                ? getClosestInstanceFromNode(reactEventType)
-                : null),
-              null !== reactEventType)
-            ) {
-              inCapturePhase = getNearestMountedFiber(reactEventType);
-              var tag = reactEventType.tag;
-              if (
-                reactEventType !== inCapturePhase ||
-                (5 !== tag && 27 !== tag && 6 !== tag)
-              )
-                reactEventType = null;
-            }
-          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
-          if (SyntheticEventCtor !== reactEventType) {
-            tag = SyntheticMouseEvent;
-            var leaveEventType = "onMouseLeave",
-              enterEventType = "onMouseEnter",
-              eventTypePrefix = "mouse";
-            if ("pointerout" === domEventName || "pointerover" === domEventName)
-              (tag = SyntheticPointerEvent),
-                (leaveEventType = "onPointerLeave"),
-                (enterEventType = "onPointerEnter"),
-                (eventTypePrefix = "pointer");
-            inCapturePhase =
-              null == SyntheticEventCtor
-                ? reactName
-                : getNodeFromInstance(SyntheticEventCtor);
-            var toNode =
-              null == reactEventType
-                ? reactName
-                : getNodeFromInstance(reactEventType);
-            reactName = new tag(
-              leaveEventType,
-              eventTypePrefix + "leave",
-              SyntheticEventCtor,
-              nativeEvent,
-              nativeEventTarget
-            );
-            reactName.target = inCapturePhase;
-            reactName.relatedTarget = toNode;
-            leaveEventType = null;
-            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
-              ((tag = new tag(
-                enterEventType,
-                eventTypePrefix + "enter",
-                reactEventType,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              (tag.target = toNode),
-              (tag.relatedTarget = inCapturePhase),
-              (leaveEventType = tag));
-            inCapturePhase = leaveEventType;
-            if (SyntheticEventCtor && reactEventType)
-              b: {
-                tag = SyntheticEventCtor;
-                enterEventType = reactEventType;
-                eventTypePrefix = 0;
-                for (toNode = tag; toNode; toNode = getParent(toNode))
-                  eventTypePrefix++;
-                toNode = 0;
-                for (
-                  leaveEventType = enterEventType;
-                  leaveEventType;
-                  leaveEventType = getParent(leaveEventType)
-                )
-                  toNode++;
-                for (; 0 < eventTypePrefix - toNode; )
-                  (tag = getParent(tag)), eventTypePrefix--;
-                for (; 0 < toNode - eventTypePrefix; )
-                  (enterEventType = getParent(enterEventType)), toNode--;
-                for (; eventTypePrefix--; ) {
-                  if (
-                    tag === enterEventType ||
-                    (null !== enterEventType &&
-                      tag === enterEventType.alternate)
-                  )
-                    break b;
-                  tag = getParent(tag);
-                  enterEventType = getParent(enterEventType);
-                }
-                tag = null;
-              }
-            else tag = null;
-            null !== SyntheticEventCtor &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                reactName,
-                SyntheticEventCtor,
-                tag,
-                !1
-              );
-            null !== reactEventType &&
-              null !== inCapturePhase &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                inCapturePhase,
-                reactEventType,
-                tag,
-                !0
-              );
-          }
-        }
-      }
-      a: {
-        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
-        SyntheticEventCtor =
-          reactName.nodeName && reactName.nodeName.toLowerCase();
-        if (
-          "select" === SyntheticEventCtor ||
-          ("input" === SyntheticEventCtor && "file" === reactName.type)
-        )
-          var getTargetInstFunc = getTargetInstForChangeEvent;
-        else if (isTextInputElement(reactName))
-          if (isInputEventSupported)
-            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-          else {
-            getTargetInstFunc = getTargetInstForInputEventPolyfill;
-            var handleEventFunc = handleEventsForInputEventPolyfill;
-          }
-        else
-          (SyntheticEventCtor = reactName.nodeName),
-            !SyntheticEventCtor ||
-            "input" !== SyntheticEventCtor.toLowerCase() ||
-            ("checkbox" !== reactName.type && "radio" !== reactName.type)
-              ? enableCustomElementPropertySupport &&
-                targetInst &&
-                isCustomComponent(
-                  targetInst.elementType,
-                  targetInst.memoizedProps
-                ) &&
-                (getTargetInstFunc = getTargetInstForChangeEvent)
-              : (getTargetInstFunc = getTargetInstForClickEvent);
-        if (
-          getTargetInstFunc &&
-          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
-        ) {
-          createAndAccumulateChangeEvent(
-            dispatchQueue,
-            getTargetInstFunc,
-            nativeEvent,
-            nativeEventTarget
+    return null;
+  }
+  function updateFromMap(
+    existingChildren,
+    returnFiber,
+    newIdx,
+    newChild,
+    lanes
+  ) {
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return (
+        (existingChildren = existingChildren.get(newIdx) || null),
+        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updateElement(returnFiber, existingChildren, newChild, lanes)
+          );
+        case REACT_PORTAL_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updatePortal(returnFiber, existingChildren, newChild, lanes)
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return updateFromMap(
+            existingChildren,
+            returnFiber,
+            newIdx,
+            init(newChild._payload),
+            lanes
           );
-          break a;
-        }
-        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
-        "focusout" === domEventName &&
-          (handleEventFunc = reactName._wrapperState) &&
-          handleEventFunc.controlled &&
-          "number" === reactName.type &&
-          (disableInputAttributeSyncing ||
-            setDefaultValue(reactName, "number", reactName.value));
-      }
-      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
-      switch (domEventName) {
-        case "focusin":
-          if (
-            isTextInputElement(handleEventFunc) ||
-            "true" === handleEventFunc.contentEditable
-          )
-            (activeElement = handleEventFunc),
-              (activeElementInst = targetInst),
-              (lastSelection = null);
-          break;
-        case "focusout":
-          lastSelection = activeElementInst = activeElement = null;
-          break;
-        case "mousedown":
-          mouseDown = !0;
-          break;
-        case "contextmenu":
-        case "mouseup":
-        case "dragend":
-          mouseDown = !1;
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-          break;
-        case "selectionchange":
-          if (skipSelectionChangeEvent) break;
-        case "keydown":
-        case "keyup":
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
       }
-      var fallbackData;
-      if (canUseCompositionEvent)
-        b: {
-          switch (domEventName) {
-            case "compositionstart":
-              var eventType = "onCompositionStart";
-              break b;
-            case "compositionend":
-              eventType = "onCompositionEnd";
-              break b;
-            case "compositionupdate":
-              eventType = "onCompositionUpdate";
-              break b;
-          }
-          eventType = void 0;
-        }
-      else
-        isComposing
-          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
-            (eventType = "onCompositionEnd")
-          : "keydown" === domEventName &&
-            229 === nativeEvent.keyCode &&
-            (eventType = "onCompositionStart");
-      eventType &&
-        (useFallbackCompositionData &&
-          "ko" !== nativeEvent.locale &&
-          (isComposing || "onCompositionStart" !== eventType
-            ? "onCompositionEnd" === eventType &&
-              isComposing &&
-              (fallbackData = getData())
-            : ((root = nativeEventTarget),
-              (startText = "value" in root ? root.value : root.textContent),
-              (isComposing = !0))),
-        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
-        0 < handleEventFunc.length &&
-          ((eventType = new SyntheticCompositionEvent(
-            eventType,
-            domEventName,
-            null,
-            nativeEvent,
-            nativeEventTarget
-          )),
-          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
-          fallbackData
-            ? (eventType.data = fallbackData)
-            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
-              null !== fallbackData && (eventType.data = fallbackData))));
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (existingChildren = existingChildren.get(newIdx) || null),
+          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
+        );
+      if ("function" === typeof newChild.then)
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          unwrapThenable(newChild),
+          lanes
+        );
       if (
-        (fallbackData = canUseTextInputEvent
-          ? getNativeBeforeInputChars(domEventName, nativeEvent)
-          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
       )
-        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
-          0 < targetInst.length &&
-            ((nativeEventTarget = new SyntheticCompositionEvent(
-              "onBeforeInput",
-              "beforeinput",
-              null,
-              nativeEvent,
-              nativeEventTarget
-            )),
-            dispatchQueue.push({
-              event: nativeEventTarget,
-              listeners: targetInst
-            }),
-            (nativeEventTarget.data = fallbackData));
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-    processDispatchQueue(dispatchQueue, eventSystemFlags);
-  });
-}
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
-}
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  reactName = inCapturePhase
-    ? null !== reactName
-      ? reactName + "Capture"
-      : null
-    : reactName;
-  for (
-    var listeners = [], instance = targetFiber, lastHostComponent = null;
-    null !== instance;
-
+    return null;
+  }
+  function reconcileChildrenArray(
+    returnFiber,
+    currentFirstChild,
+    newChildren,
+    lanes
   ) {
-    var _instance = instance;
-    targetFiber = _instance.stateNode;
-    _instance = _instance.tag;
-    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
-    null === targetFiber
-      ? 21 === _instance &&
-        null !== lastHostComponent &&
-        null !== targetFiber &&
-        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }))
-      : ((lastHostComponent = targetFiber),
-        (targetFiber =
-          lastHostComponent[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }),
-        null !== reactName &&
-          ((targetFiber = getListener(instance, reactName)),
-          null != targetFiber &&
-            listeners.push(
-              createDispatchListener(instance, targetFiber, lastHostComponent)
-            )));
-    if (accumulateTargetOnly) break;
-    "beforeblur" === nativeEvent.type &&
-      ((targetFiber = nativeEvent._detachedInterceptFiber),
-      null === targetFiber ||
-        (targetFiber !== instance && targetFiber !== instance.alternate) ||
-        (listeners = []));
-    instance = instance.return;
+    for (
+      var resultingFirstChild = null,
+        previousNewFiber = null,
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null;
+      null !== oldFiber && newIdx < newChildren.length;
+      newIdx++
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(
+        returnFiber,
+        oldFiber,
+        newChildren[newIdx],
+        lanes
+      );
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
+        break;
+      }
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (resultingFirstChild = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+    if (newIdx === newChildren.length)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        resultingFirstChild
+      );
+    if (null === oldFiber) {
+      for (; newIdx < newChildren.length; newIdx++)
+        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
+          null !== oldFiber &&
+            ((currentFirstChild = placeChild(
+              oldFiber,
+              currentFirstChild,
+              newIdx
+            )),
+            null === previousNewFiber
+              ? (resultingFirstChild = oldFiber)
+              : (previousNewFiber.sibling = oldFiber),
+            (previousNewFiber = oldFiber));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return resultingFirstChild;
+    }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      newIdx < newChildren.length;
+      newIdx++
+    )
+      (nextOldFiber = updateFromMap(
+        oldFiber,
+        returnFiber,
+        newIdx,
+        newChildren[newIdx],
+        lanes
+      )),
+        null !== nextOldFiber &&
+          (shouldTrackSideEffects &&
+            null !== nextOldFiber.alternate &&
+            oldFiber.delete(
+              null === nextOldFiber.key ? newIdx : nextOldFiber.key
+            ),
+          (currentFirstChild = placeChild(
+            nextOldFiber,
+            currentFirstChild,
+            newIdx
+          )),
+          null === previousNewFiber
+            ? (resultingFirstChild = nextOldFiber)
+            : (previousNewFiber.sibling = nextOldFiber),
+          (previousNewFiber = nextOldFiber));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return resultingFirstChild;
   }
-  return listeners;
-}
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  for (
-    var captureName = reactName + "Capture", listeners = [];
-    null !== targetFiber;
-
+  function reconcileChildrenIterator(
+    returnFiber,
+    currentFirstChild,
+    newChildrenIterable,
+    lanes
   ) {
-    var _instance2 = targetFiber,
-      stateNode = _instance2.stateNode;
-    _instance2 = _instance2.tag;
-    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
-      null === stateNode ||
-      ((_instance2 = getListener(targetFiber, captureName)),
-      null != _instance2 &&
-        listeners.unshift(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ),
-      (_instance2 = getListener(targetFiber, reactName)),
-      null != _instance2 &&
-        listeners.push(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ));
-    targetFiber = targetFiber.return;
+    var iteratorFn = getIteratorFn(newChildrenIterable);
+    if ("function" !== typeof iteratorFn)
+      throw Error(formatProdErrorMessage(150));
+    newChildrenIterable = iteratorFn.call(newChildrenIterable);
+    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
+    for (
+      var previousNewFiber = (iteratorFn = null),
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null,
+        step = newChildrenIterable.next();
+      null !== oldFiber && !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
+        break;
+      }
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (iteratorFn = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+    if (step.done)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        iteratorFn
+      );
+    if (null === oldFiber) {
+      for (; !step.done; newIdx++, step = newChildrenIterable.next())
+        (step = createChild(returnFiber, step.value, lanes)),
+          null !== step &&
+            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+            null === previousNewFiber
+              ? (iteratorFn = step)
+              : (previousNewFiber.sibling = step),
+            (previousNewFiber = step));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return iteratorFn;
+    }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    )
+      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
+        null !== step &&
+          (shouldTrackSideEffects &&
+            null !== step.alternate &&
+            oldFiber.delete(null === step.key ? newIdx : step.key),
+          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+          null === previousNewFiber
+            ? (iteratorFn = step)
+            : (previousNewFiber.sibling = step),
+          (previousNewFiber = step));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return iteratorFn;
   }
-  return listeners;
-}
-function getParent(inst) {
-  if (null === inst) return null;
-  do inst = inst.return;
-  while (inst && 5 !== inst.tag && 27 !== inst.tag);
-  return inst ? inst : null;
-}
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  for (
-    var registrationName = event._reactName, listeners = [];
-    null !== target && target !== common;
-
-  ) {
-    var _instance3 = target,
-      alternate = _instance3.alternate,
-      stateNode = _instance3.stateNode;
-    _instance3 = _instance3.tag;
-    if (null !== alternate && alternate === common) break;
-    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
-      null === stateNode ||
-      ((alternate = stateNode),
-      inCapturePhase
-        ? ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.unshift(
-              createDispatchListener(target, stateNode, alternate)
-            ))
-        : inCapturePhase ||
-          ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.push(
-              createDispatchListener(target, stateNode, alternate)
-            )));
-    target = target.return;
+  function reconcileChildFibersImpl(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    "object" === typeof newChild &&
+      null !== newChild &&
+      newChild.type === REACT_FRAGMENT_TYPE &&
+      null === newChild.key &&
+      (newChild = newChild.props.children);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          a: {
+            for (
+              var key = newChild.key, child = currentFirstChild;
+              null !== child;
+
+            ) {
+              if (child.key === key) {
+                key = newChild.type;
+                if (key === REACT_FRAGMENT_TYPE) {
+                  if (7 === child.tag) {
+                    deleteRemainingChildren(returnFiber, child.sibling);
+                    currentFirstChild = useFiber(
+                      child,
+                      newChild.props.children
+                    );
+                    currentFirstChild.return = returnFiber;
+                    returnFiber = currentFirstChild;
+                    break a;
+                  }
+                } else if (
+                  child.elementType === key ||
+                  ("object" === typeof key &&
+                    null !== key &&
+                    key.$$typeof === REACT_LAZY_TYPE &&
+                    resolveLazy(key) === child.type)
+                ) {
+                  deleteRemainingChildren(returnFiber, child.sibling);
+                  currentFirstChild = useFiber(child, newChild.props);
+                  currentFirstChild.ref = coerceRef(
+                    returnFiber,
+                    child,
+                    newChild
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                }
+                deleteRemainingChildren(returnFiber, child);
+                break;
+              } else deleteChild(returnFiber, child);
+              child = child.sibling;
+            }
+            newChild.type === REACT_FRAGMENT_TYPE
+              ? ((currentFirstChild = createFiberFromFragment(
+                  newChild.props.children,
+                  returnFiber.mode,
+                  lanes,
+                  newChild.key
+                )),
+                (currentFirstChild.return = returnFiber),
+                (returnFiber = currentFirstChild))
+              : ((lanes = createFiberFromTypeAndProps(
+                  newChild.type,
+                  newChild.key,
+                  newChild.props,
+                  null,
+                  returnFiber.mode,
+                  lanes
+                )),
+                (lanes.ref = coerceRef(
+                  returnFiber,
+                  currentFirstChild,
+                  newChild
+                )),
+                (lanes.return = returnFiber),
+                (returnFiber = lanes));
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_PORTAL_TYPE:
+          a: {
+            for (child = newChild.key; null !== currentFirstChild; ) {
+              if (currentFirstChild.key === child)
+                if (
+                  4 === currentFirstChild.tag &&
+                  currentFirstChild.stateNode.containerInfo ===
+                    newChild.containerInfo &&
+                  currentFirstChild.stateNode.implementation ===
+                    newChild.implementation
+                ) {
+                  deleteRemainingChildren(
+                    returnFiber,
+                    currentFirstChild.sibling
+                  );
+                  currentFirstChild = useFiber(
+                    currentFirstChild,
+                    newChild.children || []
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                } else {
+                  deleteRemainingChildren(returnFiber, currentFirstChild);
+                  break;
+                }
+              else deleteChild(returnFiber, currentFirstChild);
+              currentFirstChild = currentFirstChild.sibling;
+            }
+            currentFirstChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
+            );
+            currentFirstChild.return = returnFiber;
+            returnFiber = currentFirstChild;
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_LAZY_TYPE:
+          return (
+            (child = newChild._init),
+            reconcileChildFibers(
+              returnFiber,
+              currentFirstChild,
+              child(newChild._payload),
+              lanes
+            )
+          );
+      }
+      if (isArrayImpl(newChild))
+        return reconcileChildrenArray(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if (getIteratorFn(newChild))
+        return reconcileChildrenIterator(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if ("function" === typeof newChild.then)
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+      ? ((newChild = "" + newChild),
+        null !== currentFirstChild && 6 === currentFirstChild.tag
+          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
+            (currentFirstChild = useFiber(currentFirstChild, newChild)),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild))
+          : (deleteRemainingChildren(returnFiber, currentFirstChild),
+            (currentFirstChild = createFiberFromText(
+              newChild,
+              returnFiber.mode,
+              lanes
+            )),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild)),
+        placeSingleChild(returnFiber))
+      : deleteRemainingChildren(returnFiber, currentFirstChild);
   }
-  0 !== listeners.length &&
-    dispatchQueue.push({ event: event, listeners: listeners });
+  function reconcileChildFibers(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    thenableIndexCounter$1 = 0;
+    returnFiber = reconcileChildFibersImpl(
+      returnFiber,
+      currentFirstChild,
+      newChild,
+      lanes
+    );
+    thenableState$1 = null;
+    return returnFiber;
+  }
+  return reconcileChildFibers;
 }
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [],
-    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
-  null !== eventListeners &&
-    eventListeners.forEach(function (entry) {
-      entry.type === reactEventType &&
-        entry.capture === inCapturePhase &&
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
-        );
-    });
-  return listeners;
+var reconcileChildFibers = createChildReconciler(!0),
+  mountChildFibers = createChildReconciler(!1),
+  currentTreeHiddenStackCursor = createCursor(null),
+  prevRenderLanesStackCursor = createCursor(0);
+function pushHiddenContext(fiber, context) {
+  fiber = renderLanes;
+  push(prevRenderLanesStackCursor, fiber);
+  push(currentTreeHiddenStackCursor, context);
+  renderLanes = fiber | context.baseLanes;
 }
-var NORMALIZE_NEWLINES_REGEX = /\r\n?/g,
-  NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
-function normalizeMarkupForTextOrAttribute(markup) {
-  return ("string" === typeof markup ? markup : "" + markup)
-    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
-    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
+function reuseHiddenContextOnStack() {
+  push(prevRenderLanesStackCursor, renderLanes);
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
 }
-function getOwnerDocumentFromRootContainer(rootContainerElement) {
-  return 9 === rootContainerElement.nodeType
-    ? rootContainerElement
-    : rootContainerElement.ownerDocument;
+function popHiddenContext() {
+  renderLanes = prevRenderLanesStackCursor.current;
+  pop(currentTreeHiddenStackCursor);
+  pop(prevRenderLanesStackCursor);
 }
-function noop$1() {}
-function createHTMLElement(type, props, ownerDocument) {
-  return "string" === typeof props.is
-    ? ownerDocument.createElement(type, { is: props.is })
-    : ownerDocument.createElement(type);
+var suspenseHandlerStackCursor = createCursor(null),
+  shellBoundary = null;
+function pushPrimaryTreeSuspenseHandler(handler) {
+  var current = handler.alternate;
+  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
+  (null !== current && null === currentTreeHiddenStackCursor.current)
+    ? (push(suspenseHandlerStackCursor, handler),
+      null === shellBoundary &&
+        (null === current || null !== currentTreeHiddenStackCursor.current
+          ? (shellBoundary = handler)
+          : null !== current.memoizedState && (shellBoundary = handler)))
+    : null === shellBoundary
+    ? push(suspenseHandlerStackCursor, handler)
+    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
 }
-function setInitialProperties(domElement, tag, rawProps) {
-  var isCustomComponentTag = isCustomComponent(tag, rawProps);
-  switch (tag) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", domElement);
-      listenToNonDelegatedEvent("close", domElement);
-      var props = rawProps;
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
-    case "video":
-    case "audio":
-      for (props = 0; props < mediaEventTypes.length; props++)
-        listenToNonDelegatedEvent(mediaEventTypes[props], domElement);
-      props = rawProps;
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", domElement);
-      props = rawProps;
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", domElement);
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", domElement);
-      props = rawProps;
-      break;
-    case "input":
-      initWrapperState$2(domElement, rawProps);
-      props = getHostProps$2(domElement, rawProps);
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    case "option":
-      props = rawProps;
-      break;
-    case "select":
-      domElement._wrapperState = { wasMultiple: !!rawProps.multiple };
-      props = assign({}, rawProps, { value: void 0 });
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    case "textarea":
-      initWrapperState(domElement, rawProps);
-      props = getHostProps(domElement, rawProps);
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    default:
-      props = rawProps;
-  }
-  assertValidProps(tag, props);
-  var nextProps = props,
-    propKey;
-  for (propKey in nextProps)
-    if (nextProps.hasOwnProperty(propKey)) {
-      var nextProp = nextProps[propKey];
-      "style" === propKey
-        ? setValueForStyles(domElement, nextProp)
-        : "dangerouslySetInnerHTML" === propKey
-        ? ((nextProp = nextProp ? nextProp.__html : void 0),
-          null != nextProp && setInnerHTML$1(domElement, nextProp))
-        : "children" === propKey
-        ? "string" === typeof nextProp
-          ? "body" === tag ||
-            ("textarea" === tag && "" === nextProp) ||
-            setTextContent(domElement, nextProp)
-          : "number" === typeof nextProp &&
-            "body" !== tag &&
-            setTextContent(domElement, "" + nextProp)
-        : "suppressContentEditableWarning" !== propKey &&
-          "suppressHydrationWarning" !== propKey &&
-          "autoFocus" !== propKey &&
-          (registrationNameDependencies.hasOwnProperty(propKey)
-            ? null != nextProp &&
-              "onScroll" === propKey &&
-              listenToNonDelegatedEvent("scroll", domElement)
-            : null != nextProp &&
-              setValueForProperty(
-                domElement,
-                propKey,
-                nextProp,
-                isCustomComponentTag
-              ));
+function pushOffscreenSuspenseHandler(fiber) {
+  if (22 === fiber.tag) {
+    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
+      var current = fiber.alternate;
+      null !== current &&
+        null !== current.memoizedState &&
+        (shellBoundary = fiber);
     }
-  switch (tag) {
-    case "input":
-      track(domElement);
-      postMountWrapper$3(domElement, rawProps, !1);
-      break;
-    case "textarea":
-      track(domElement);
-      postMountWrapper(domElement);
-      break;
-    case "option":
-      null != rawProps.value &&
-        domElement.setAttribute("value", "" + getToStringValue(rawProps.value));
-      break;
-    case "select":
-      domElement.multiple = !!rawProps.multiple;
-      tag = rawProps.value;
-      null != tag
-        ? updateOptions(domElement, !!rawProps.multiple, tag, !1)
-        : null != rawProps.defaultValue &&
-          updateOptions(
-            domElement,
-            !!rawProps.multiple,
-            rawProps.defaultValue,
-            !0
-          );
-      break;
-    default:
-      "function" === typeof props.onClick && (domElement.onclick = noop$1);
-  }
+  } else reuseSuspenseHandlerOnStack();
 }
-function updateProperties(
-  domElement,
-  updatePayload,
-  tag,
-  lastRawProps,
-  nextRawProps
-) {
-  "input" === tag &&
-    "radio" === nextRawProps.type &&
-    null != nextRawProps.name &&
-    updateChecked(domElement, nextRawProps);
-  isCustomComponent(tag, lastRawProps);
-  lastRawProps = isCustomComponent(tag, nextRawProps);
-  for (var i = 0; i < updatePayload.length; i += 2) {
-    var propKey = updatePayload[i],
-      propValue = updatePayload[i + 1];
-    "style" === propKey
-      ? setValueForStyles(domElement, propValue)
-      : "dangerouslySetInnerHTML" === propKey
-      ? setInnerHTML$1(domElement, propValue)
-      : "children" === propKey
-      ? setTextContent(domElement, propValue)
-      : setValueForProperty(domElement, propKey, propValue, lastRawProps);
-  }
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, nextRawProps);
-      break;
-    case "textarea":
-      updateWrapper(domElement, nextRawProps);
-      break;
-    case "select":
-      (updatePayload = domElement._wrapperState.wasMultiple),
-        (domElement._wrapperState.wasMultiple = !!nextRawProps.multiple),
-        (tag = nextRawProps.value),
-        null != tag
-          ? updateOptions(domElement, !!nextRawProps.multiple, tag, !1)
-          : updatePayload !== !!nextRawProps.multiple &&
-            (null != nextRawProps.defaultValue
-              ? updateOptions(
-                  domElement,
-                  !!nextRawProps.multiple,
-                  nextRawProps.defaultValue,
-                  !0
-                )
-              : updateOptions(
-                  domElement,
-                  !!nextRawProps.multiple,
-                  nextRawProps.multiple ? [] : "",
-                  !1
-                ));
-  }
+function reuseSuspenseHandlerOnStack() {
+  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
 }
-var valueStack = [],
-  index = -1;
-function createCursor(defaultValue) {
-  return { current: defaultValue };
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+  shellBoundary === fiber && (shellBoundary = null);
 }
-function pop(cursor) {
-  0 > index ||
-    ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
+var suspenseStackCursor = createCursor(0);
+function findFirstSuspended(row) {
+  for (var node = row; null !== node; ) {
+    if (13 === node.tag) {
+      var state = node.memoizedState;
+      if (
+        null !== state &&
+        ((state = state.dehydrated),
+        null === state || "$?" === state.data || "$!" === state.data)
+      )
+        return node;
+    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+      if (0 !== (node.flags & 128)) return node;
+    } else if (null !== node.child) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+    if (node === row) break;
+    for (; null === node.sibling; ) {
+      if (null === node.return || node.return === row) return null;
+      node = node.return;
+    }
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+  return null;
 }
-function push(cursor, value) {
-  index++;
-  valueStack[index] = cursor.current;
-  cursor.current = value;
+var workInProgressSources = [];
+function resetWorkInProgressVersions() {
+  for (var i = 0; i < workInProgressSources.length; i++)
+    workInProgressSources[i]._workInProgressVersionPrimary = null;
+  workInProgressSources.length = 0;
 }
-var contextStackCursor = createCursor(null),
-  contextFiberStackCursor = createCursor(null),
-  rootInstanceStackCursor = createCursor(null);
-function pushHostContainer(fiber, nextRootInstance) {
-  push(rootInstanceStackCursor, nextRootInstance);
-  push(contextFiberStackCursor, fiber);
-  push(contextStackCursor, null);
-  fiber = nextRootInstance.nodeType;
-  switch (fiber) {
-    case 9:
-    case 11:
-      nextRootInstance = (nextRootInstance = nextRootInstance.documentElement)
-        ? nextRootInstance.namespaceURI
-        : getChildNamespace(null, "");
-      break;
-    default:
-      (fiber = 8 === fiber ? nextRootInstance.parentNode : nextRootInstance),
-        (nextRootInstance = fiber.namespaceURI || null),
-        (fiber = fiber.tagName),
-        (nextRootInstance = getChildNamespace(nextRootInstance, fiber));
-  }
-  pop(contextStackCursor);
-  push(contextStackCursor, nextRootInstance);
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
+  renderLanes$1 = 0,
+  currentlyRenderingFiber$1 = null,
+  currentHook = null,
+  workInProgressHook = null,
+  didScheduleRenderPhaseUpdate = !1,
+  didScheduleRenderPhaseUpdateDuringThisPass = !1,
+  shouldDoubleInvokeUserFnsInHooksDEV = !1,
+  localIdCounter = 0,
+  thenableIndexCounter = 0,
+  thenableState = null,
+  globalClientIdCounter = 0;
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
 }
-function popHostContainer() {
-  pop(contextStackCursor);
-  pop(contextFiberStackCursor);
-  pop(rootInstanceStackCursor);
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (null === prevDeps) return !1;
+  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
+    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+  return !0;
 }
-function pushHostContext(fiber) {
-  var context = contextStackCursor.current;
-  var JSCompiler_inline_result = getChildNamespace(context, fiber.type);
-  context !== JSCompiler_inline_result &&
-    (push(contextFiberStackCursor, fiber),
-    push(contextStackCursor, JSCompiler_inline_result));
+function renderWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg,
+  nextRenderLanes
+) {
+  renderLanes$1 = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = 0;
+  ReactCurrentDispatcher$1.current =
+    null === current || null === current.memoizedState
+      ? HooksDispatcherOnMount
+      : HooksDispatcherOnUpdate;
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  nextRenderLanes = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  didScheduleRenderPhaseUpdateDuringThisPass &&
+    (nextRenderLanes = renderWithHooksAgain(
+      workInProgress,
+      Component,
+      props,
+      secondArg
+    ));
+  finishRenderingHooks(current);
+  return nextRenderLanes;
 }
-function popHostContext(fiber) {
-  contextFiberStackCursor.current === fiber &&
-    (pop(contextStackCursor), pop(contextFiberStackCursor));
+function finishRenderingHooks(current) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdate = !1;
+  thenableIndexCounter = 0;
+  thenableState = null;
+  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
+  enableLazyContextPropagation &&
+    null !== current &&
+    !didReceiveUpdate &&
+    ((current = current.dependencies),
+    null !== current &&
+      checkIfContextChanged(current) &&
+      (didReceiveUpdate = !0));
 }
-var Dispatcher$1 = Internals.Dispatcher,
-  lastCurrentDocument = null,
-  previousDispatcher = null,
-  ReactDOMClientDispatcher = {
-    prefetchDNS: prefetchDNS$1,
-    preconnect: preconnect$1,
-    preload: preload$1,
-    preinit: preinit$1
-  },
-  preloadPropsMap = new Map(),
-  preconnectsSet = new Set();
-function getHoistableRoot(container) {
-  return "function" === typeof container.getRootNode
-    ? container.getRootNode()
-    : container.ownerDocument;
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  var numberOfReRenders = 0;
+  do {
+    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = !1;
+    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
+    numberOfReRenders += 1;
+    workInProgressHook = currentHook = null;
+    workInProgress.updateQueue = null;
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    var children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+  return children;
 }
-function getCurrentResourceRoot() {
-  var currentContainer = rootInstanceStackCursor.current;
-  return currentContainer ? getHoistableRoot(currentContainer) : null;
+function checkDidRenderIdHook() {
+  var didRenderIdHook = 0 !== localIdCounter;
+  localIdCounter = 0;
+  return didRenderIdHook;
 }
-function getDocumentForPreloads() {
-  var root = getCurrentResourceRoot();
-  if (root) return root.ownerDocument || root;
-  try {
-    return lastCurrentDocument || window.document;
-  } catch (error) {
-    return null;
-  }
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue;
+  workInProgress.flags &= -2053;
+  current.lanes &= ~lanes;
 }
-function preconnectAs(rel, crossOrigin, href) {
-  var ownerDocument = getDocumentForPreloads();
-  if ("string" === typeof href && href && ownerDocument) {
-    var limitedEscapedHref =
-      escapeSelectorAttributeValueInsideDoubleQuotes(href);
-    limitedEscapedHref =
-      'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
-    "string" === typeof crossOrigin &&
-      (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
-    preconnectsSet.has(limitedEscapedHref) ||
-      (preconnectsSet.add(limitedEscapedHref),
-      (rel = { rel: rel, crossOrigin: crossOrigin, href: href }),
-      null === ownerDocument.querySelector(limitedEscapedHref) &&
-        ((crossOrigin = ownerDocument.createElement("link")),
-        setInitialProperties(crossOrigin, "link", rel),
-        markNodeAsHoistable(crossOrigin),
-        ownerDocument.head.appendChild(crossOrigin)));
+function resetHooksOnUnwind() {
+  if (didScheduleRenderPhaseUpdate) {
+    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
+      var queue = hook.queue;
+      null !== queue && (queue.pending = null);
+      hook = hook.next;
+    }
+    didScheduleRenderPhaseUpdate = !1;
   }
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdateDuringThisPass = !1;
+  thenableIndexCounter = localIdCounter = 0;
+  thenableState = null;
 }
-function prefetchDNS$1(href) {
-  preconnectAs("dns-prefetch", null, href);
-}
-function preconnect$1(href, options) {
-  preconnectAs(
-    "preconnect",
-    null == options || "string" !== typeof options.crossOrigin
-      ? null
-      : "use-credentials" === options.crossOrigin
-      ? "use-credentials"
-      : "",
-    href
-  );
+function mountWorkInProgressHook() {
+  var hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+  null === workInProgressHook
+    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
+    : (workInProgressHook = workInProgressHook.next = hook);
+  return workInProgressHook;
 }
-function preload$1(href, options) {
-  var ownerDocument = getDocumentForPreloads();
-  if (
-    "string" === typeof href &&
-    href &&
-    "object" === typeof options &&
-    null !== options &&
-    ownerDocument
-  ) {
-    var as = options.as,
-      limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href),
-      key = (limitedEscapedHref =
-        'link[rel="preload"][as="' +
-        as +
-        '"][href="' +
-        limitedEscapedHref +
-        '"]');
-    switch (as) {
-      case "style":
-        key = getStyleKey(href);
-        break;
-      case "script":
-        key = getScriptKey(href);
+function updateWorkInProgressHook() {
+  if (null === currentHook) {
+    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
+    nextCurrentHook =
+      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+  } else nextCurrentHook = currentHook.next;
+  var nextWorkInProgressHook =
+    null === workInProgressHook
+      ? currentlyRenderingFiber$1.memoizedState
+      : workInProgressHook.next;
+  if (null !== nextWorkInProgressHook)
+    (workInProgressHook = nextWorkInProgressHook),
+      (currentHook = nextCurrentHook);
+  else {
+    if (null === nextCurrentHook) {
+      if (null === currentlyRenderingFiber$1.alternate)
+        throw Error(formatProdErrorMessage(467));
+      throw Error(formatProdErrorMessage(310));
     }
-    preloadPropsMap.has(key) ||
-      ((href = {
-        href: href,
-        rel: "preload",
-        as: as,
-        crossOrigin: "font" === as ? "" : options.crossOrigin,
-        integrity: options.integrity,
-        type: options.type
-      }),
-      preloadPropsMap.set(key, href),
-      null === ownerDocument.querySelector(limitedEscapedHref) &&
-        ((options = ownerDocument.createElement("link")),
-        setInitialProperties(options, "link", href),
-        markNodeAsHoistable(options),
-        ownerDocument.head.appendChild(options)));
-  }
-}
-function preinit$1(href, options) {
-  if (
-    "string" === typeof href &&
-    href &&
-    "object" === typeof options &&
-    null !== options
-  ) {
-    var resourceRoot = getCurrentResourceRoot(),
-      as = options.as;
-    if (resourceRoot)
-      switch (as) {
-        case "style":
-          as = getResourcesFromRoot(resourceRoot).hoistableStyles;
-          var key$34 = getStyleKey(href),
-            precedence = options.precedence || "default",
-            resource = as.get(key$34);
-          if (resource) break;
-          resource = resourceRoot.querySelector(
-            getStylesheetSelectorFromKey(key$34)
-          );
-          resource ||
-            ((href = {
-              rel: "stylesheet",
-              href: href,
-              "data-precedence": precedence,
-              crossOrigin: options.crossOrigin
-            }),
-            (options = preloadPropsMap.get(key$34)) &&
-              adoptPreloadPropsForStylesheet(href, options),
-            (resource = (
-              resourceRoot.ownerDocument || resourceRoot
-            ).createElement("link")),
-            markNodeAsHoistable(resource),
-            setInitialProperties(resource, "link", href),
-            insertStylesheet(resource, precedence, resourceRoot));
-          resource = { type: "stylesheet", instance: resource, count: 1 };
-          as.set(key$34, resource);
-          break;
-        case "script":
-          (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
-            (key$34 = getScriptKey(href)),
-            (precedence = as.get(key$34)),
-            precedence ||
-              ((precedence = resourceRoot.querySelector(
-                "script[async]" + key$34
-              )),
-              precedence ||
-                ((href = {
-                  src: href,
-                  async: !0,
-                  crossOrigin: options.crossOrigin,
-                  integrity: options.integrity
-                }),
-                (options = preloadPropsMap.get(key$34)) &&
-                  adoptPreloadPropsForScript(href, options),
-                (options = resourceRoot.ownerDocument || resourceRoot),
-                (precedence = options.createElement("script")),
-                markNodeAsHoistable(precedence),
-                setInitialProperties(precedence, "link", href),
-                options.head.appendChild(precedence)),
-              (precedence = { type: "script", instance: precedence, count: 1 }),
-              as.set(key$34, precedence));
-      }
-    else if ("style" === as || "script" === as)
-      if ((resourceRoot = getDocumentForPreloads())) {
-        key$34 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
-        precedence = key$34 =
-          'link[rel="preload"][as="' + as + '"][href="' + key$34 + '"]';
-        switch (as) {
-          case "style":
-            precedence = getStyleKey(href);
-            break;
-          case "script":
-            precedence = getScriptKey(href);
-        }
-        preloadPropsMap.has(precedence) ||
-          ((href = {
-            href: href,
-            rel: "preload",
-            as: as,
-            crossOrigin: "font" === as ? "" : options.crossOrigin,
-            integrity: options.integrity
-          }),
-          preloadPropsMap.set(precedence, href),
-          null === resourceRoot.querySelector(key$34) &&
-            ((options = resourceRoot.createElement("link")),
-            setInitialProperties(options, "link", href),
-            markNodeAsHoistable(options),
-            resourceRoot.head.appendChild(options)));
-      }
+    currentHook = nextCurrentHook;
+    nextCurrentHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+    null === workInProgressHook
+      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
+          nextCurrentHook)
+      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
   }
+  return workInProgressHook;
 }
-function getResource(type, currentProps, pendingProps) {
-  currentProps = getCurrentResourceRoot();
-  if (!currentProps) throw Error(formatProdErrorMessage(446));
-  switch (type) {
-    case "meta":
-    case "title":
-      return null;
-    case "style":
-      return "string" === typeof pendingProps.precedence &&
-        "string" === typeof pendingProps.href
-        ? ((pendingProps = getStyleKey(pendingProps.href)),
-          (currentProps = getResourcesFromRoot(currentProps).hoistableStyles),
-          (type = currentProps.get(pendingProps)),
-          type ||
-            ((type = { type: "style", instance: null, count: 0 }),
-            currentProps.set(pendingProps, type)),
-          type)
-        : { type: "void", instance: null, count: 0 };
-    case "link":
-      if (
-        "stylesheet" === pendingProps.rel &&
-        "string" === typeof pendingProps.href &&
-        "string" === typeof pendingProps.precedence
-      ) {
-        var key$41 = getStyleKey(pendingProps.href),
-          styles$42 = getResourcesFromRoot(currentProps).hoistableStyles;
-        type = styles$42.get(key$41);
-        type ||
-          ((currentProps = currentProps.ownerDocument || currentProps),
-          (type = { type: "stylesheet", instance: null, count: 0 }),
-          styles$42.set(key$41, type),
-          preloadPropsMap.has(key$41) ||
-            ((pendingProps = {
-              rel: "preload",
-              as: "style",
-              href: pendingProps.href,
-              crossOrigin: pendingProps.crossOrigin,
-              integrity: pendingProps.integrity,
-              media: pendingProps.media,
-              hrefLang: pendingProps.hrefLang,
-              referrerPolicy: pendingProps.referrerPolicy
-            }),
-            preloadPropsMap.set(key$41, pendingProps),
-            currentProps.querySelector(getStylesheetSelectorFromKey(key$41)) ||
-              null !==
-                currentProps.querySelector(
-                  'link[rel="preload"][as="style"][' + key$41 + "]"
-                ) ||
-              ((key$41 = currentProps.createElement("link")),
-              setInitialProperties(key$41, "link", pendingProps),
-              markNodeAsHoistable(key$41),
-              currentProps.head.appendChild(key$41))));
-        return type;
-      }
-      return null;
-    case "script":
-      return "string" === typeof pendingProps.src && !0 === pendingProps.async
-        ? ((pendingProps = getScriptKey(pendingProps.src)),
-          (currentProps = getResourcesFromRoot(currentProps).hoistableScripts),
-          (type = currentProps.get(pendingProps)),
-          type ||
-            ((type = { type: "script", instance: null, count: 0 }),
-            currentProps.set(pendingProps, type)),
-          type)
-        : { type: "void", instance: null, count: 0 };
-    default:
-      throw Error(formatProdErrorMessage(444, type));
+var createFunctionComponentUpdateQueue;
+createFunctionComponentUpdateQueue = function () {
+  return { lastEffect: null, events: null, stores: null, memoCache: null };
+};
+function use(usable) {
+  if (null !== usable && "object" === typeof usable) {
+    if ("function" === typeof usable.then) {
+      var index$45 = thenableIndexCounter;
+      thenableIndexCounter += 1;
+      null === thenableState && (thenableState = []);
+      usable = trackUsedThenable(thenableState, usable, index$45);
+      null === currentlyRenderingFiber$1.alternate &&
+        (null === workInProgressHook
+          ? null === currentlyRenderingFiber$1.memoizedState
+          : null === workInProgressHook.next) &&
+        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
+      return usable;
+    }
+    if (
+      usable.$$typeof === REACT_CONTEXT_TYPE ||
+      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    )
+      return readContext(usable);
   }
+  throw Error(formatProdErrorMessage(438, String(usable)));
 }
-function getStyleKey(href) {
-  return 'href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
-}
-function getStylesheetSelectorFromKey(key) {
-  return 'link[rel="stylesheet"][' + key + "]";
+function useMemoCache(size) {
+  var memoCache = null,
+    updateQueue = currentlyRenderingFiber$1.updateQueue;
+  null !== updateQueue && (memoCache = updateQueue.memoCache);
+  if (null == memoCache) {
+    var current = currentlyRenderingFiber$1.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      null !== current &&
+        ((current = current.memoCache),
+        null != current &&
+          (memoCache = {
+            data: current.data.map(function (array) {
+              return array.slice();
+            }),
+            index: 0
+          })));
+  }
+  null == memoCache && (memoCache = { data: [], index: 0 });
+  null === updateQueue &&
+    ((updateQueue = createFunctionComponentUpdateQueue()),
+    (currentlyRenderingFiber$1.updateQueue = updateQueue));
+  updateQueue.memoCache = memoCache;
+  updateQueue = memoCache.data[memoCache.index];
+  if (void 0 === updateQueue)
+    for (
+      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
+      current < size;
+      current++
+    )
+      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
+  memoCache.index++;
+  return updateQueue;
 }
-function getScriptKey(src) {
-  return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
+function basicStateReducer(state, action) {
+  return "function" === typeof action ? action(state) : action;
 }
-function acquireResource(hoistableRoot, resource, props) {
-  resource.count++;
-  if (null === resource.instance)
-    switch (resource.type) {
-      case "style":
-        var key = getStyleKey(props.href);
-        if ((key = hoistableRoot.querySelector("style[data-" + key + "]")))
-          return (resource.instance = key), markNodeAsHoistable(key), key;
-        var styleProps = assign({}, props, {
-          "data-href": props.href,
-          "data-precedence": props.precedence,
-          href: null,
-          precedence: null
-        });
-        key = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
-          "style"
-        );
-        markNodeAsHoistable(key);
-        setInitialProperties(key, "style", styleProps);
-        insertStylesheet(key, props.precedence, hoistableRoot);
-        return (resource.instance = key);
-      case "stylesheet":
-        styleProps = getStyleKey(props.href);
-        var instance$48 = hoistableRoot.querySelector(
-          getStylesheetSelectorFromKey(styleProps)
-        );
-        if (instance$48)
-          return (
-            (resource.instance = instance$48),
-            markNodeAsHoistable(instance$48),
-            instance$48
-          );
-        key = assign({}, props, {
-          "data-precedence": props.precedence,
-          precedence: null
-        });
-        (styleProps = preloadPropsMap.get(styleProps)) &&
-          adoptPreloadPropsForStylesheet(key, styleProps);
-        instance$48 = (
-          hoistableRoot.ownerDocument || hoistableRoot
-        ).createElement("link");
-        markNodeAsHoistable(instance$48);
-        var linkInstance = instance$48;
-        linkInstance._p = new Promise(function (resolve, reject) {
-          linkInstance.onload = resolve;
-          linkInstance.onerror = reject;
-        }).then(
-          function () {
-            return (linkInstance._p.s = "l");
-          },
-          function () {
-            return (linkInstance._p.s = "e");
-          }
-        );
-        setInitialProperties(instance$48, "link", key);
-        insertStylesheet(instance$48, props.precedence, hoistableRoot);
-        return (resource.instance = instance$48);
-      case "script":
-        instance$48 = getScriptKey(props.src);
-        if (
-          (styleProps = hoistableRoot.querySelector(
-            "script[async]" + instance$48
-          ))
-        )
-          return (
-            (resource.instance = styleProps),
-            markNodeAsHoistable(styleProps),
-            styleProps
-          );
-        key = props;
-        if ((styleProps = preloadPropsMap.get(instance$48)))
-          (key = assign({}, props)),
-            adoptPreloadPropsForScript(key, styleProps);
-        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
-        styleProps = hoistableRoot.createElement("script");
-        markNodeAsHoistable(styleProps);
-        setInitialProperties(styleProps, "link", key);
-        hoistableRoot.head.appendChild(styleProps);
-        return (resource.instance = styleProps);
-      case "void":
-        return null;
-      default:
-        throw Error(formatProdErrorMessage(443, resource.type));
+function updateReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var current = currentHook,
+    baseQueue = current.baseQueue,
+    pendingQueue = queue.pending;
+  if (null !== pendingQueue) {
+    if (null !== baseQueue) {
+      var baseFirst = baseQueue.next;
+      baseQueue.next = pendingQueue.next;
+      pendingQueue.next = baseFirst;
     }
-  return resource.instance;
-}
-function insertStylesheet(instance, precedence, root) {
-  for (
-    var nodes = root.querySelectorAll(
-        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
-      ),
-      last = nodes.length ? nodes[nodes.length - 1] : null,
-      prior = last,
-      i = 0;
-    i < nodes.length;
-    i++
-  ) {
-    var node = nodes[i];
-    if (node.dataset.precedence === precedence) prior = node;
-    else if (prior !== last) break;
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
   }
-  prior
-    ? prior.parentNode.insertBefore(instance, prior.nextSibling)
-    : ((precedence = 9 === root.nodeType ? root.head : root),
-      precedence.insertBefore(instance, precedence.firstChild));
-}
-function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
-  null == stylesheetProps.crossOrigin &&
-    (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
-  null == stylesheetProps.referrerPolicy &&
-    (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
-  null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
-}
-function adoptPreloadPropsForScript(scriptProps, preloadProps) {
-  null == scriptProps.crossOrigin &&
-    (scriptProps.crossOrigin = preloadProps.crossOrigin);
-  null == scriptProps.referrerPolicy &&
-    (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
-  null == scriptProps.integrity &&
-    (scriptProps.referrerPolicy = preloadProps.integrity);
-}
-var tagCaches = null;
-function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
-  if (null === tagCaches) {
-    var cache = new Map();
-    var caches = (tagCaches = new Map());
-    caches.set(ownerDocument, cache);
-  } else
-    (caches = tagCaches),
-      (cache = caches.get(ownerDocument)),
-      cache || ((cache = new Map()), caches.set(ownerDocument, cache));
-  if (cache.has(type)) return cache;
-  cache.set(type, null);
-  ownerDocument = ownerDocument.getElementsByTagName(type);
-  for (caches = 0; caches < ownerDocument.length; caches++) {
-    var node = ownerDocument[caches];
-    if (
-      !(
-        node[internalHoistableMarker] ||
-        node[internalInstanceKey] ||
-        ("link" === type && "stylesheet" === node.getAttribute("rel"))
-      ) &&
-      "http://www.w3.org/2000/svg" !== node.namespaceURI
-    ) {
-      var nodeKey = node.getAttribute(keyAttribute) || "";
-      nodeKey = type + nodeKey;
-      var existing = cache.get(nodeKey);
-      existing ? existing.push(node) : cache.set(nodeKey, [node]);
-    }
+  if (null !== baseQueue) {
+    pendingQueue = baseQueue.next;
+    current = current.baseState;
+    var newBaseQueueFirst = (baseFirst = null),
+      newBaseQueueLast = null,
+      update = pendingQueue;
+    do {
+      var updateLane = update.lane & -1073741825;
+      if (
+        updateLane !== update.lane
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes$1 & updateLane) === updateLane
+      )
+        null !== newBaseQueueLast &&
+          (newBaseQueueLast = newBaseQueueLast.next =
+            {
+              lane: 0,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            }),
+          (updateLane = update.action),
+          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
+          (current = update.hasEagerState
+            ? update.eagerState
+            : reducer(current, updateLane));
+      else {
+        var clone = {
+          lane: updateLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+        null === newBaseQueueLast
+          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
+            (baseFirst = current))
+          : (newBaseQueueLast = newBaseQueueLast.next = clone);
+        currentlyRenderingFiber$1.lanes |= updateLane;
+        workInProgressRootSkippedLanes |= updateLane;
+      }
+      update = update.next;
+    } while (null !== update && update !== pendingQueue);
+    null === newBaseQueueLast
+      ? (baseFirst = current)
+      : (newBaseQueueLast.next = newBaseQueueFirst);
+    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = current;
+    hook.baseState = baseFirst;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = current;
   }
-  return cache;
+  null === baseQueue && (queue.lanes = 0);
+  return [hook.memoizedState, queue.dispatch];
 }
-function mountHoistable(hoistableRoot, type, instance) {
-  hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
-  hoistableRoot.head.insertBefore(
-    instance,
-    "title" === type ? hoistableRoot.querySelector("head > title") : null
-  );
+function rerenderReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var dispatch = queue.dispatch,
+    lastRenderPhaseUpdate = queue.pending,
+    newState = hook.memoizedState;
+  if (null !== lastRenderPhaseUpdate) {
+    queue.pending = null;
+    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
+    do (newState = reducer(newState, update.action)), (update = update.next);
+    while (update !== lastRenderPhaseUpdate);
+    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = newState;
+    null === hook.baseQueue && (hook.baseState = newState);
+    queue.lastRenderedState = newState;
+  }
+  return [newState, dispatch];
 }
-var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
-function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
-  return value.replace(
-    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
-    function (ch) {
-      return "\\" + ch.charCodeAt(0).toString(16);
-    }
-  );
+function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+  var getVersion = source._getVersion;
+  getVersion = getVersion(source._source);
+  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
+  if (null !== JSCompiler_inline_result)
+    root = JSCompiler_inline_result === getVersion;
+  else if (
+    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
+  )
+    (source._workInProgressVersionPrimary = getVersion),
+      workInProgressSources.push(source);
+  if (root) return getSnapshot(source._source);
+  workInProgressSources.push(source);
+  throw Error(formatProdErrorMessage(350));
 }
-var eventsEnabled = null,
-  selectionInformation = null;
-function shouldSetTextContent(type, props) {
-  return (
-    "textarea" === type ||
-    "noscript" === type ||
-    "string" === typeof props.children ||
-    "number" === typeof props.children ||
-    ("object" === typeof props.dangerouslySetInnerHTML &&
-      null !== props.dangerouslySetInnerHTML &&
-      null != props.dangerouslySetInnerHTML.__html)
+function useMutableSource(hook, source, getSnapshot, subscribe) {
+  var root = workInProgressRoot;
+  if (null === root) throw Error(formatProdErrorMessage(349));
+  var getVersion = source._getVersion,
+    version = getVersion(source._source),
+    dispatcher = ReactCurrentDispatcher$1.current,
+    _dispatcher$useState = dispatcher.useState(function () {
+      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    }),
+    setSnapshot = _dispatcher$useState[1],
+    snapshot = _dispatcher$useState[0];
+  _dispatcher$useState = workInProgressHook;
+  var memoizedState = hook.memoizedState,
+    refs = memoizedState.refs,
+    prevGetSnapshot = refs.getSnapshot,
+    prevSource = memoizedState.source;
+  memoizedState = memoizedState.subscribe;
+  var fiber = currentlyRenderingFiber$1;
+  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
+  dispatcher.useEffect(
+    function () {
+      refs.getSnapshot = getSnapshot;
+      refs.setSnapshot = setSnapshot;
+      var maybeNewVersion = getVersion(source._source);
+      objectIs(version, maybeNewVersion) ||
+        ((maybeNewVersion = getSnapshot(source._source)),
+        objectIs(snapshot, maybeNewVersion) ||
+          (setSnapshot(maybeNewVersion),
+          (maybeNewVersion = requestUpdateLane(fiber)),
+          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
+        markRootEntangled(root, root.mutableReadLanes));
+    },
+    [getSnapshot, source, subscribe]
   );
+  dispatcher.useEffect(
+    function () {
+      return subscribe(source._source, function () {
+        var latestGetSnapshot = refs.getSnapshot,
+          latestSetSnapshot = refs.setSnapshot;
+        try {
+          latestSetSnapshot(latestGetSnapshot(source._source));
+          var lane = requestUpdateLane(fiber);
+          root.mutableReadLanes |= lane & root.pendingLanes;
+        } catch (error) {
+          latestSetSnapshot(function () {
+            throw error;
+          });
+        }
+      });
+    },
+    [source, subscribe]
+  );
+  (objectIs(prevGetSnapshot, getSnapshot) &&
+    objectIs(prevSource, source) &&
+    objectIs(memoizedState, subscribe)) ||
+    ((hook = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: snapshot
+    }),
+    (hook.dispatch = setSnapshot =
+      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
+    (_dispatcher$useState.queue = hook),
+    (_dispatcher$useState.baseQueue = null),
+    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
+    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
+      snapshot));
+  return snapshot;
 }
-var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
-  cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
-  localPromise = "function" === typeof Promise ? Promise : void 0,
-  localRequestAnimationFrame =
-    "function" === typeof requestAnimationFrame
-      ? requestAnimationFrame
-      : scheduleTimeout;
-function getInstanceFromScope(scopeInstance) {
-  scopeInstance = scopeInstance[internalInstanceKey] || null;
-  return scopeInstance;
-}
-var scheduleMicrotask =
-  "function" === typeof queueMicrotask
-    ? queueMicrotask
-    : "undefined" !== typeof localPromise
-    ? function (callback) {
-        return localPromise
-          .resolve(null)
-          .then(callback)
-          .catch(handleErrorInNextTick);
-      }
-    : scheduleTimeout;
-function handleErrorInNextTick(error) {
-  setTimeout(function () {
-    throw error;
-  });
-}
-function createEvent(type, bubbles) {
-  var event = document.createEvent("Event");
-  event.initEvent(type, bubbles, !1);
-  return event;
+function updateMutableSource(source, getSnapshot, subscribe) {
+  var hook = updateWorkInProgressHook();
+  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
-function dispatchBeforeDetachedBlur(target, internalInstanceHandle) {
-  var event = createEvent("beforeblur", !0);
-  event._detachedInterceptFiber = internalInstanceHandle;
-  target.dispatchEvent(event);
+function updateSyncExternalStore(subscribe, getSnapshot) {
+  var fiber = currentlyRenderingFiber$1,
+    hook = updateWorkInProgressHook(),
+    nextSnapshot = getSnapshot(),
+    snapshotChanged = !objectIs(
+      (currentHook || hook).memoizedState,
+      nextSnapshot
+    );
+  snapshotChanged &&
+    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
+  hook = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
+    subscribe
+  ]);
+  if (
+    hook.getSnapshot !== getSnapshot ||
+    snapshotChanged ||
+    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
+  ) {
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
+      void 0,
+      null
+    );
+    subscribe = workInProgressRoot;
+    if (null === subscribe) throw Error(formatProdErrorMessage(349));
+    includesBlockingLane(subscribe, renderLanes$1) ||
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+  }
+  return nextSnapshot;
 }
-function dispatchAfterDetachedBlur(target) {
-  var event = createEvent("afterblur", !1);
-  event.relatedTarget = target;
-  document.dispatchEvent(event);
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= 16384;
+  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
+  getSnapshot = currentlyRenderingFiber$1.updateQueue;
+  null === getSnapshot
+    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
+      (getSnapshot.stores = [fiber]))
+    : ((renderedSnapshot = getSnapshot.stores),
+      null === renderedSnapshot
+        ? (getSnapshot.stores = [fiber])
+        : renderedSnapshot.push(fiber));
 }
-function clearSuspenseBoundary(parentInstance, suspenseInstance) {
-  var node = suspenseInstance,
-    depth = 0;
-  do {
-    var nextNode = node.nextSibling;
-    parentInstance.removeChild(node);
-    if (nextNode && 8 === nextNode.nodeType)
-      if (((node = nextNode.data), "/$" === node)) {
-        if (0 === depth) {
-          parentInstance.removeChild(nextNode);
-          retryIfBlockedOn(suspenseInstance);
-          return;
-        }
-        depth--;
-      } else ("$" !== node && "$?" !== node && "$!" !== node) || depth++;
-    node = nextNode;
-  } while (node);
-  retryIfBlockedOn(suspenseInstance);
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot;
+  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
 }
-function clearContainerSparingly(container) {
-  var nextNode = container.firstChild;
-  nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
-  for (; nextNode; ) {
-    var node = nextNode;
-    nextNode = nextNode.nextSibling;
-    switch (node.nodeName) {
-      case "HTML":
-      case "HEAD":
-      case "BODY":
-        clearContainerSparingly(node);
-        detachDeletedInstance(node);
-        continue;
-      case "STYLE":
-        continue;
-      case "LINK":
-        if ("stylesheet" === node.rel.toLowerCase()) continue;
-    }
-    container.removeChild(node);
-  }
+function subscribeToStore(fiber, inst, subscribe) {
+  return subscribe(function () {
+    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+  });
 }
-function shouldSkipHydratableForInstance(instance, type, props) {
-  if (1 !== instance.nodeType) return !1;
-  if (
-    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
-    instance[internalHoistableMarker]
-  )
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  inst = inst.value;
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(inst, nextValue);
+  } catch (error) {
     return !0;
-  switch (type) {
-    case "meta":
-      if (!instance.hasAttribute("itemprop")) return !0;
-      break;
-    case "link":
-      type = instance.getAttribute("rel");
-      if (
-        ("stylesheet" === type && instance.hasAttribute("data-precedence")) ||
-        type !== props.rel ||
-        instance.getAttribute("href") !==
-          (null == props.href ? null : props.href) ||
-        instance.getAttribute("crossorigin") !==
-          (null == props.crossOrigin ? null : props.crossOrigin) ||
-        instance.getAttribute("title") !==
-          (null == props.title ? null : props.title)
-      )
-        return !0;
-      break;
-    case "style":
-      if (instance.hasAttribute("data-precedence")) return !0;
-      break;
-    case "script":
-      if (
-        ((type = instance.getAttribute("src")) &&
-          instance.hasAttribute("async") &&
-          !instance.hasAttribute("itemprop")) ||
-        type !== (null == props.src ? null : props.src) ||
-        instance.getAttribute("type") !==
-          (null == props.type ? null : props.type) ||
-        instance.getAttribute("crossorigin") !==
-          (null == props.crossOrigin ? null : props.crossOrigin)
-      )
-        return !0;
-  }
-  return !1;
-}
-function getNextHydratable(node) {
-  for (; null != node; node = node.nextSibling) {
-    var nodeType = node.nodeType;
-    if (1 === nodeType || 3 === nodeType) break;
-    if (8 === nodeType) {
-      nodeType = node.data;
-      if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType) break;
-      if ("/$" === nodeType) return null;
-    }
   }
-  return node;
 }
-function getParentSuspenseInstance(targetInstance) {
-  targetInstance = targetInstance.previousSibling;
-  for (var depth = 0; targetInstance; ) {
-    if (8 === targetInstance.nodeType) {
-      var data = targetInstance.data;
-      if ("$" === data || "$!" === data || "$?" === data) {
-        if (0 === depth) return targetInstance;
-        depth--;
-      } else "/$" === data && depth++;
-    }
-    targetInstance = targetInstance.previousSibling;
-  }
-  return null;
+function forceStoreRerender(fiber) {
+  var root = enqueueConcurrentRenderForLane(fiber, 2);
+  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
 }
-function requestPostPaintCallback(callback) {
-  localRequestAnimationFrame(function () {
-    localRequestAnimationFrame(function (time) {
-      return callback(time);
-    });
-  });
+function mountState(initialState) {
+  var hook = mountWorkInProgressHook();
+  "function" === typeof initialState && (initialState = initialState());
+  hook.memoizedState = hook.baseState = initialState;
+  initialState = {
+    pending: null,
+    lanes: 0,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = initialState;
+  initialState = initialState.dispatch = dispatchSetState.bind(
+    null,
+    currentlyRenderingFiber$1,
+    initialState
+  );
+  return [hook.memoizedState, initialState];
 }
-function isHostHoistableType(type, props, hostContext) {
-  if ("http://www.w3.org/2000/svg" === hostContext || null != props.itemProp)
-    return !1;
-  switch (type) {
-    case "meta":
-    case "title":
-      return !0;
-    case "style":
-      if (
-        "string" !== typeof props.precedence ||
-        "string" !== typeof props.href ||
-        "" === props.href
-      )
-        break;
-      return !0;
-    case "link":
-      if (
-        "string" !== typeof props.rel ||
-        "string" !== typeof props.href ||
-        "" === props.href ||
-        props.onLoad ||
-        props.onError
-      )
-        break;
-      switch (props.rel) {
-        case "stylesheet":
-          return (
-            (type = props.disabled),
-            "string" === typeof props.precedence && null == type
-          );
-        default:
-          return !0;
-      }
-    case "script":
-      if (
-        !0 === props.async &&
-        !props.onLoad &&
-        !props.onError &&
-        "string" === typeof props.src &&
-        props.src
-      )
-        return !0;
-  }
-  return !1;
-}
-function resolveSingletonInstance(type, props, rootContainerInstance) {
-  props = getOwnerDocumentFromRootContainer(rootContainerInstance);
-  switch (type) {
-    case "html":
-      type = props.documentElement;
-      if (!type) throw Error(formatProdErrorMessage(452));
-      return type;
-    case "head":
-      type = props.head;
-      if (!type) throw Error(formatProdErrorMessage(453));
-      return type;
-    case "body":
-      type = props.body;
-      if (!type) throw Error(formatProdErrorMessage(454));
-      return type;
-    default:
-      throw Error(formatProdErrorMessage(451));
-  }
+function pushEffect(tag, create, destroy, deps) {
+  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
+  create = currentlyRenderingFiber$1.updateQueue;
+  null === create
+    ? ((create = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = create),
+      (create.lastEffect = tag.next = tag))
+    : ((destroy = create.lastEffect),
+      null === destroy
+        ? (create.lastEffect = tag.next = tag)
+        : ((deps = destroy.next),
+          (destroy.next = tag),
+          (tag.next = deps),
+          (create.lastEffect = tag)));
+  return tag;
 }
-var emptyContextObject = {},
-  syncQueue = null,
-  includesLegacySyncCallbacks = !1,
-  isFlushingSyncQueue = !1;
-function scheduleSyncCallback(callback) {
-  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
+function updateRef() {
+  return updateWorkInProgressHook().memoizedState;
 }
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = !0;
-  scheduleSyncCallback(callback);
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = mountWorkInProgressHook();
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    1 | hookFlags,
+    create,
+    void 0,
+    void 0 === deps ? null : deps
+  );
 }
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && null !== syncQueue) {
-    isFlushingSyncQueue = !0;
-    var previousUpdatePriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
-      var callback = queue[i];
-      try {
-        do callback = callback(!0);
-        while (null !== callback);
-      } catch (error) {
-        null === errors ? (errors = [error]) : errors.push(error);
-      }
-    }
-    syncQueue = null;
-    includesLegacySyncCallbacks = !1;
-    currentUpdatePriority = previousUpdatePriority;
-    isFlushingSyncQueue = !1;
-    if (null !== errors) {
-      if (1 < errors.length) {
-        if ("function" === typeof AggregateError)
-          throw new AggregateError(errors);
-        for (
-          previousUpdatePriority = 1;
-          previousUpdatePriority < errors.length;
-          previousUpdatePriority++
-        )
-          scheduleCallback$2(
-            ImmediatePriority,
-            throwError.bind(null, errors[previousUpdatePriority])
-          );
-      }
-      throw errors[0];
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var destroy = void 0;
+  if (null !== currentHook) {
+    var prevEffect = currentHook.memoizedState;
+    destroy = prevEffect.destroy;
+    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
+      return;
     }
   }
-  return null;
-}
-function throwError(error) {
-  throw error;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
 }
-var forkStack = [],
-  forkStackIndex = 0,
-  treeForkProvider = null,
-  treeForkCount = 0,
-  idStack = [],
-  idStackIndex = 0,
-  treeContextProvider = null,
-  treeContextId = 1,
-  treeContextOverflow = "";
-function pushTreeFork(workInProgress, totalChildren) {
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
+function mountEffect(create, deps) {
+  mountEffectImpl(8390656, 8, create, deps);
 }
-function pushTreeId(workInProgress, totalChildren, index) {
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  workInProgress = treeContextOverflow;
-  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
-  baseIdWithLeadingBit &= ~(1 << baseLength);
-  index += 1;
-  var length = 32 - clz32(totalChildren) + baseLength;
-  if (30 < length) {
-    var numberOfOverflowBits = baseLength - (baseLength % 5);
-    length = (
-      baseIdWithLeadingBit &
-      ((1 << numberOfOverflowBits) - 1)
-    ).toString(32);
-    baseIdWithLeadingBit >>= numberOfOverflowBits;
-    baseLength -= numberOfOverflowBits;
-    treeContextId =
-      (1 << (32 - clz32(totalChildren) + baseLength)) |
-      (index << baseLength) |
-      baseIdWithLeadingBit;
-    treeContextOverflow = length + workInProgress;
-  } else
-    (treeContextId =
-      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
-      (treeContextOverflow = workInProgress);
+function updateEffect(create, deps) {
+  updateEffectImpl(2048, 8, create, deps);
 }
-function pushMaterializedTreeId(workInProgress) {
-  null !== workInProgress.return &&
-    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= 4;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+  if (null === componentUpdateQueue)
+    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
+      (componentUpdateQueue.events = [payload]);
+  else {
+    var events = componentUpdateQueue.events;
+    null === events
+      ? (componentUpdateQueue.events = [payload])
+      : events.push(payload);
+  }
 }
-function popTreeContext(workInProgress) {
-  for (; workInProgress === treeForkProvider; )
-    (treeForkProvider = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null),
-      (treeForkCount = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null);
-  for (; workInProgress === treeContextProvider; )
-    (treeContextProvider = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextOverflow = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextId = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null);
+function updateEvent(callback) {
+  var ref = updateWorkInProgressHook().memoizedState;
+  useEffectEventImpl({ ref: ref, nextImpl: callback });
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
 }
-var hydrationParentFiber = null,
-  nextHydratableInstance = null,
-  isHydrating = !1,
-  hydrationErrors = null,
-  rootOrSingletonContext = !1;
-function deleteHydratableInstance(returnFiber, instance) {
-  var fiber = createFiber(5, null, null, 0);
-  fiber.elementType = "DELETED";
-  fiber.stateNode = instance;
-  fiber.return = returnFiber;
-  instance = returnFiber.deletions;
-  null === instance
-    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
-    : instance.push(fiber);
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(4, 2, create, deps);
 }
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & -4097) | 2;
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(4, 4, create, deps);
 }
-function tryHydrateInstance(fiber, nextInstance) {
-  var type = fiber.type;
-  nextInstance =
-    1 !== nextInstance.nodeType ||
-    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
-      (rootOrSingletonContext = !1),
-      !0)
-    : !1;
-}
-function tryHydrateText(fiber, nextInstance) {
-  nextInstance =
-    "" === fiber.pendingProps
-      ? null
-      : 3 !== nextInstance.nodeType
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = null),
-      !0)
-    : !1;
+function imperativeHandleEffect(create, ref) {
+  if ("function" === typeof ref)
+    return (
+      (create = create()),
+      ref(create),
+      function () {
+        ref(null);
+      }
+    );
+  if (null !== ref && void 0 !== ref)
+    return (
+      (create = create()),
+      (ref.current = create),
+      function () {
+        ref.current = null;
+      }
+    );
 }
-function tryHydrateSuspense(fiber, nextInstance) {
-  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
-  if (null !== nextInstance) {
-    var JSCompiler_inline_result =
-      null !== treeContextProvider
-        ? { id: treeContextId, overflow: treeContextOverflow }
-        : null;
-    fiber.memoizedState = {
-      dehydrated: nextInstance,
-      treeContext: JSCompiler_inline_result,
-      retryLane: 1073741824
-    };
-    JSCompiler_inline_result = createFiber(18, null, null, 0);
-    JSCompiler_inline_result.stateNode = nextInstance;
-    JSCompiler_inline_result.return = fiber;
-    fiber.child = JSCompiler_inline_result;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = null;
-    return !0;
-  }
-  return !1;
+function updateImperativeHandle(ref, create, deps) {
+  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
 }
-function shouldClientRenderOnMismatch(fiber) {
-  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
+function mountDebugValue() {}
+function updateCallback(callback, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  hook.memoizedState = [callback, deps];
+  return callback;
 }
-function throwOnHydrationMismatch() {
-  throw Error(formatProdErrorMessage(418));
+function updateMemo(nextCreate, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+  nextCreate = nextCreate();
+  hook.memoizedState = [nextCreate, deps];
+  return nextCreate;
 }
-function advanceToFirstAttemptableInstance(fiber) {
-  for (
-    ;
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    );
-
-  )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
+function updateDeferredValueImpl(hook, prevValue, value) {
+  if (0 === (renderLanes$1 & 42))
+    return (
+      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
+      (hook.memoizedState = value)
     );
+  objectIs(value, prevValue) ||
+    ((value = claimNextTransitionLane()),
+    (currentlyRenderingFiber$1.lanes |= value),
+    (workInProgressRootSkippedLanes |= value),
+    (hook.baseState = !0));
+  return prevValue;
 }
-function advanceToFirstAttemptableTextInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function startTransition(setPending, callback, options) {
+  var previousPriority = currentUpdatePriority;
+  currentUpdatePriority =
+    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
+  setPending(!0);
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+  enableTransitionTracing &&
+    void 0 !== options &&
+    void 0 !== options.name &&
+    ((ReactCurrentBatchConfig$3.transition.name = options.name),
+    (ReactCurrentBatchConfig$3.transition.startTime = now()));
+  try {
+    setPending(!1), callback();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$3.transition = prevTransition);
+  }
 }
-function advanceToFirstAttemptableSuspenseInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function updateId() {
+  return updateWorkInProgressHook().memoizedState;
 }
-function prepareToHydrateHostInstance(fiber) {
-  var instance = fiber.stateNode,
-    type = fiber.type,
-    props = fiber.memoizedProps;
-  instance[internalInstanceKey] = fiber;
-  instance[internalPropsKey] = props;
-  switch (type) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", instance);
-      listenToNonDelegatedEvent("close", instance);
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "video":
-    case "audio":
-      for (var i = 0; i < mediaEventTypes.length; i++)
-        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", instance);
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", instance);
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", instance);
-      break;
-    case "input":
-      initWrapperState$2(instance, props);
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "select":
-      instance._wrapperState = { wasMultiple: !!props.multiple };
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "textarea":
-      initWrapperState(instance, props),
-        listenToNonDelegatedEvent("invalid", instance);
-  }
-  assertValidProps(type, props);
-  var updatePayload = null,
-    propKey;
-  for (propKey in props)
-    props.hasOwnProperty(propKey) &&
-      ((i = props[propKey]),
-      "children" === propKey
-        ? "string" === typeof i
-          ? instance.textContent !== i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", i]))
-          : "number" === typeof i &&
-            instance.textContent !== "" + i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", "" + i]))
-        : registrationNameDependencies.hasOwnProperty(propKey) &&
-          null != i &&
-          "onScroll" === propKey &&
-          listenToNonDelegatedEvent("scroll", instance));
-  switch (type) {
-    case "input":
-      track(instance);
-      postMountWrapper$3(instance, props, !0);
-      break;
-    case "textarea":
-      track(instance);
-      postMountWrapper(instance);
-      break;
-    case "select":
-    case "option":
-      break;
-    default:
-      "function" === typeof props.onClick && (instance.onclick = noop$1);
-  }
-  instance = updatePayload;
-  fiber.updateQueue = instance;
-  return null !== instance ? !0 : !1;
+function updateRefresh() {
+  return updateWorkInProgressHook().memoizedState;
 }
-function popToNextHostParent(fiber) {
-  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
-    switch (hydrationParentFiber.tag) {
+function refreshCache(fiber, seedKey, seedValue) {
+  for (var provider = fiber.return; null !== provider; ) {
+    switch (provider.tag) {
+      case 24:
       case 3:
-      case 27:
-        rootOrSingletonContext = !0;
-        return;
-      case 5:
-      case 13:
-        rootOrSingletonContext = !1;
+        var lane = requestUpdateLane(provider);
+        fiber = createUpdate(lane);
+        var root$51 = enqueueUpdate(provider, fiber, lane);
+        if (null !== root$51) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root$51, provider, lane, eventTime);
+          entangleTransitions(root$51, provider, lane);
+        }
+        provider = createCache();
+        null !== seedKey &&
+          void 0 !== seedKey &&
+          null !== root$51 &&
+          provider.data.set(seedKey, seedValue);
+        fiber.payload = { cache: provider };
         return;
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
     }
+    provider = provider.return;
+  }
 }
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) return !1;
-  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
-  var shouldClear = !1;
-  3 === fiber.tag ||
-    27 === fiber.tag ||
-    (5 === fiber.tag &&
-      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
-    (shouldClear = !0);
-  if (shouldClear && (shouldClear = nextHydratableInstance))
-    if (shouldClientRenderOnMismatch(fiber))
-      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
-    else
-      for (; shouldClear; )
-        deleteHydratableInstance(fiber, shouldClear),
-          (shouldClear = getNextHydratable(shouldClear.nextSibling));
-  popToNextHostParent(fiber);
-  if (13 === fiber.tag) {
-    fiber = fiber.memoizedState;
-    fiber = null !== fiber ? fiber.dehydrated : null;
-    if (!fiber) throw Error(formatProdErrorMessage(317));
-    a: {
-      fiber = fiber.nextSibling;
-      for (shouldClear = 0; fiber; ) {
-        if (8 === fiber.nodeType) {
-          var data = fiber.data;
-          if ("/$" === data) {
-            if (0 === shouldClear) {
-              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
-              break a;
-            }
-            shouldClear--;
-          } else
-            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
-        }
-        fiber = fiber.nextSibling;
-      }
-      nextHydratableInstance = null;
-    }
-  } else
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratable(fiber.stateNode.nextSibling)
-      : null;
-  return !0;
-}
-function warnIfUnhydratedTailNodes() {
-  for (var nextInstance = nextHydratableInstance; nextInstance; )
-    nextInstance = getNextHydratable(nextInstance.nextSibling);
-}
-function resetHydrationState() {
-  nextHydratableInstance = hydrationParentFiber = null;
-  isHydrating = !1;
-}
-function queueHydrationError(error) {
-  null === hydrationErrors
-    ? (hydrationErrors = [error])
-    : hydrationErrors.push(error);
-}
-var concurrentQueues = [],
-  concurrentQueuesIndex = 0,
-  concurrentlyUpdatedLanes = 0;
-function finishQueueingConcurrentUpdates() {
-  for (
-    var endIndex = concurrentQueuesIndex,
-      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
-    i < endIndex;
-
+function dispatchReducerAction(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber);
+  action = {
+    lane: lane,
+    action: action,
+    hasEagerState: !1,
+    eagerState: null,
+    next: null
+  };
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
+  else if (
+    (enqueueUpdate$1(fiber, queue, action, lane),
+    (action = getRootForUpdatedFiber(fiber)),
+    null !== action)
   ) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    if (null !== queue && null !== update) {
-      var pending = queue.pending;
-      null === pending
-        ? (update.next = update)
-        : ((update.next = pending.next), (pending.next = update));
-      queue.pending = update;
-    }
-    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
+    entangleTransitionUpdate(action, queue, lane);
   }
 }
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes |= lane;
-  fiber.lanes |= lane;
-  fiber = fiber.alternate;
-  null !== fiber && (fiber.lanes |= lane);
-}
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  sourceFiber.lanes |= lane;
-  var alternate = sourceFiber.alternate;
-  null !== alternate && (alternate.lanes |= lane);
-  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
-    (parent.childLanes |= lane),
-      (alternate = parent.alternate),
-      null !== alternate && (alternate.childLanes |= lane),
-      22 === parent.tag &&
-        ((sourceFiber = parent.stateNode),
-        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
-      (sourceFiber = parent),
-      (parent = parent.return);
-  isHidden &&
-    null !== update &&
-    3 === sourceFiber.tag &&
-    ((parent = sourceFiber.stateNode),
-    (isHidden = 31 - clz32(lane)),
-    (parent = parent.hiddenUpdates),
-    (sourceFiber = parent[isHidden]),
-    null === sourceFiber
-      ? (parent[isHidden] = [update])
-      : sourceFiber.push(update),
-    (update.lane = lane | 1073741824));
-}
-function getRootForUpdatedFiber(sourceFiber) {
-  if (50 < nestedUpdateCount)
-    throw (
-      ((nestedUpdateCount = 0),
-      (rootWithNestedUpdates = null),
-      Error(formatProdErrorMessage(185)))
-    );
-  for (var parent = sourceFiber.return; null !== parent; )
-    (sourceFiber = parent), (parent = sourceFiber.return);
-  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
-}
-var hasForceUpdate = !1;
-function initializeUpdateQueue(fiber) {
-  fiber.updateQueue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
-    callbacks: null
-  };
-}
-function cloneUpdateQueue(current, workInProgress) {
-  current = current.updateQueue;
-  workInProgress.updateQueue === current &&
-    (workInProgress.updateQueue = {
-      baseState: current.baseState,
-      firstBaseUpdate: current.firstBaseUpdate,
-      lastBaseUpdate: current.lastBaseUpdate,
-      shared: current.shared,
-      callbacks: null
-    });
+function dispatchSetState(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber),
+    update = {
+      lane: lane,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
+  else {
+    var alternate = fiber.alternate;
+    if (
+      0 === fiber.lanes &&
+      (null === alternate || 0 === alternate.lanes) &&
+      ((alternate = queue.lastRenderedReducer), null !== alternate)
+    )
+      try {
+        var currentState = queue.lastRenderedState,
+          eagerState = alternate(currentState, action);
+        update.hasEagerState = !0;
+        update.eagerState = eagerState;
+        if (objectIs(eagerState, currentState)) {
+          enqueueUpdate$1(fiber, queue, update, 0);
+          null === workInProgressRoot && finishQueueingConcurrentUpdates();
+          return;
+        }
+      } catch (error) {
+      } finally {
+      }
+    enqueueUpdate$1(fiber, queue, update, lane);
+    action = getRootForUpdatedFiber(fiber);
+    null !== action &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(action, fiber, lane, update),
+      entangleTransitionUpdate(action, queue, lane));
+  }
 }
-function createUpdate(lane) {
-  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
+function isRenderPhaseUpdate(fiber) {
+  var alternate = fiber.alternate;
+  return (
+    fiber === currentlyRenderingFiber$1 ||
+    (null !== alternate && alternate === currentlyRenderingFiber$1)
+  );
 }
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
-  if (null === updateQueue) return null;
-  updateQueue = updateQueue.shared;
-  if (
-    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
-    0 === (executionContext & 2)
-  )
-    return (
-      enqueueUpdate$1(fiber, updateQueue, update, lane),
-      getRootForUpdatedFiber(fiber)
-    );
-  var pending = updateQueue.pending;
+function enqueueRenderPhaseUpdate(queue, update) {
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
+    !0;
+  var pending = queue.pending;
   null === pending
     ? (update.next = update)
     : ((update.next = pending.next), (pending.next = update));
-  updateQueue.pending = update;
-  update = getRootForUpdatedFiber(fiber);
-  markUpdateLaneFromFiberToRoot(fiber, null, lane);
-  return update;
+  queue.pending = update;
 }
-function entangleTransitions(root, fiber, lane) {
-  fiber = fiber.updateQueue;
-  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
-    var queueLanes = fiber.lanes;
+function entangleTransitionUpdate(root, queue, lane) {
+  if (0 !== (lane & 8388480)) {
+    var queueLanes = queue.lanes;
     queueLanes &= root.pendingLanes;
     lane |= queueLanes;
-    fiber.lanes = lane;
+    queue.lanes = lane;
     markRootEntangled(root, lane);
   }
 }
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  var queue = workInProgress.updateQueue,
-    current = workInProgress.alternate;
-  if (
-    null !== current &&
-    ((current = current.updateQueue), queue === current)
-  ) {
-    var newFirst = null,
-      newLast = null;
-    queue = queue.firstBaseUpdate;
-    if (null !== queue) {
-      do {
-        var clone = {
-          lane: queue.lane,
-          tag: queue.tag,
-          payload: queue.payload,
-          callback: null,
-          next: null
-        };
-        null === newLast
-          ? (newFirst = newLast = clone)
-          : (newLast = newLast.next = clone);
-        queue = queue.next;
-      } while (null !== queue);
-      null === newLast
-        ? (newFirst = newLast = capturedUpdate)
-        : (newLast = newLast.next = capturedUpdate);
-    } else newFirst = newLast = capturedUpdate;
-    queue = {
-      baseState: current.baseState,
-      firstBaseUpdate: newFirst,
-      lastBaseUpdate: newLast,
-      shared: current.shared,
-      callbacks: current.callbacks
+var ContextOnlyDispatcher = {
+  readContext: readContext,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useMutableSource: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+ContextOnlyDispatcher.use = throwInvalidHookError;
+ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+var HooksDispatcherOnMount = {
+  readContext: readContext,
+  useCallback: function (callback, deps) {
+    mountWorkInProgressHook().memoizedState = [
+      callback,
+      void 0 === deps ? null : deps
+    ];
+    return callback;
+  },
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: function (ref, create, deps) {
+    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+    mountEffectImpl(
+      4194308,
+      4,
+      imperativeHandleEffect.bind(null, create, ref),
+      deps
+    );
+  },
+  useLayoutEffect: function (create, deps) {
+    return mountEffectImpl(4194308, 4, create, deps);
+  },
+  useInsertionEffect: function (create, deps) {
+    mountEffectImpl(4, 2, create, deps);
+  },
+  useMemo: function (nextCreate, deps) {
+    var hook = mountWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+    nextCreate = nextCreate();
+    hook.memoizedState = [nextCreate, deps];
+    return nextCreate;
+  },
+  useReducer: function (reducer, initialArg, init) {
+    var hook = mountWorkInProgressHook();
+    initialArg = void 0 !== init ? init(initialArg) : initialArg;
+    hook.memoizedState = hook.baseState = initialArg;
+    reducer = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: reducer,
+      lastRenderedState: initialArg
     };
-    workInProgress.updateQueue = queue;
-    return;
-  }
-  workInProgress = queue.lastBaseUpdate;
-  null === workInProgress
-    ? (queue.firstBaseUpdate = capturedUpdate)
-    : (workInProgress.next = capturedUpdate);
-  queue.lastBaseUpdate = capturedUpdate;
-}
-function processUpdateQueue(
-  workInProgress$jscomp$0,
-  props,
-  instance$jscomp$0,
-  renderLanes
-) {
-  var queue = workInProgress$jscomp$0.updateQueue;
-  hasForceUpdate = !1;
-  var firstBaseUpdate = queue.firstBaseUpdate,
-    lastBaseUpdate = queue.lastBaseUpdate,
-    pendingQueue = queue.shared.pending;
-  if (null !== pendingQueue) {
-    queue.shared.pending = null;
-    var lastPendingUpdate = pendingQueue,
-      firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null;
-    null === lastBaseUpdate
-      ? (firstBaseUpdate = firstPendingUpdate)
-      : (lastBaseUpdate.next = firstPendingUpdate);
-    lastBaseUpdate = lastPendingUpdate;
-    var current = workInProgress$jscomp$0.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      (pendingQueue = current.lastBaseUpdate),
-      pendingQueue !== lastBaseUpdate &&
-        (null === pendingQueue
-          ? (current.firstBaseUpdate = firstPendingUpdate)
-          : (pendingQueue.next = firstPendingUpdate),
-        (current.lastBaseUpdate = lastPendingUpdate)));
+    hook.queue = reducer;
+    reducer = reducer.dispatch = dispatchReducerAction.bind(
+      null,
+      currentlyRenderingFiber$1,
+      reducer
+    );
+    return [hook.memoizedState, reducer];
+  },
+  useRef: function (initialValue) {
+    var hook = mountWorkInProgressHook();
+    if (enableUseRefAccessWarning)
+      return (
+        (initialValue = { current: initialValue }),
+        (hook.memoizedState = initialValue)
+      );
+    initialValue = { current: initialValue };
+    return (hook.memoizedState = initialValue);
+  },
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    return (mountWorkInProgressHook().memoizedState = value);
+  },
+  useTransition: function () {
+    var _mountState = mountState(!1),
+      isPending = _mountState[0];
+    _mountState = startTransition.bind(null, _mountState[1]);
+    mountWorkInProgressHook().memoizedState = _mountState;
+    return [isPending, _mountState];
+  },
+  useMutableSource: function (source, getSnapshot, subscribe) {
+    var hook = mountWorkInProgressHook();
+    hook.memoizedState = {
+      refs: { getSnapshot: getSnapshot, setSnapshot: null },
+      source: source,
+      subscribe: subscribe
+    };
+    return useMutableSource(hook, source, getSnapshot, subscribe);
+  },
+  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+    var fiber = currentlyRenderingFiber$1,
+      hook = mountWorkInProgressHook();
+    if (isHydrating) {
+      if (void 0 === getServerSnapshot)
+        throw Error(formatProdErrorMessage(407));
+      getServerSnapshot = getServerSnapshot();
+    } else {
+      getServerSnapshot = getSnapshot();
+      var root$47 = workInProgressRoot;
+      if (null === root$47) throw Error(formatProdErrorMessage(349));
+      includesBlockingLane(root$47, renderLanes$1) ||
+        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
+    }
+    hook.memoizedState = getServerSnapshot;
+    root$47 = { value: getServerSnapshot, getSnapshot: getSnapshot };
+    hook.queue = root$47;
+    mountEffect(subscribeToStore.bind(null, fiber, root$47, subscribe), [
+      subscribe
+    ]);
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(
+        null,
+        fiber,
+        root$47,
+        getServerSnapshot,
+        getSnapshot
+      ),
+      void 0,
+      null
+    );
+    return getServerSnapshot;
+  },
+  useId: function () {
+    var hook = mountWorkInProgressHook(),
+      identifierPrefix = workInProgressRoot.identifierPrefix;
+    if (isHydrating) {
+      var JSCompiler_inline_result = treeContextOverflow;
+      var idWithLeadingBit = treeContextId;
+      JSCompiler_inline_result =
+        (
+          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
+        ).toString(32) + JSCompiler_inline_result;
+      identifierPrefix =
+        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
+      JSCompiler_inline_result = localIdCounter++;
+      0 < JSCompiler_inline_result &&
+        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
+      identifierPrefix += ":";
+    } else
+      (JSCompiler_inline_result = globalClientIdCounter++),
+        (identifierPrefix =
+          ":" +
+          identifierPrefix +
+          "r" +
+          JSCompiler_inline_result.toString(32) +
+          ":");
+    return (hook.memoizedState = identifierPrefix);
+  },
+  useCacheRefresh: function () {
+    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
+      null,
+      currentlyRenderingFiber$1
+    ));
   }
-  if (null !== firstBaseUpdate) {
-    var newState = queue.baseState;
-    lastBaseUpdate = 0;
-    current = firstPendingUpdate = lastPendingUpdate = null;
-    pendingQueue = firstBaseUpdate;
-    do {
-      var updateLane = pendingQueue.lane & -1073741825,
-        isHiddenUpdate = updateLane !== pendingQueue.lane;
-      if (
-        isHiddenUpdate
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes & updateLane) === updateLane
-      ) {
-        null !== current &&
-          (current = current.next =
-            {
-              lane: 0,
-              tag: pendingQueue.tag,
-              payload: pendingQueue.payload,
-              callback: null,
-              next: null
-            });
-        a: {
-          var workInProgress = workInProgress$jscomp$0,
-            update = pendingQueue;
-          updateLane = props;
-          var instance = instance$jscomp$0;
-          switch (update.tag) {
-            case 1:
-              workInProgress = update.payload;
-              if ("function" === typeof workInProgress) {
-                newState = workInProgress.call(instance, newState, updateLane);
-                break a;
-              }
-              newState = workInProgress;
-              break a;
-            case 3:
-              workInProgress.flags = (workInProgress.flags & -65537) | 128;
-            case 0:
-              workInProgress = update.payload;
-              updateLane =
-                "function" === typeof workInProgress
-                  ? workInProgress.call(instance, newState, updateLane)
-                  : workInProgress;
-              if (null === updateLane || void 0 === updateLane) break a;
-              newState = assign({}, newState, updateLane);
-              break a;
-            case 2:
-              hasForceUpdate = !0;
-          }
-        }
-        updateLane = pendingQueue.callback;
-        null !== updateLane &&
-          ((workInProgress$jscomp$0.flags |= 64),
-          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
-          (isHiddenUpdate = queue.callbacks),
-          null === isHiddenUpdate
-            ? (queue.callbacks = [updateLane])
-            : isHiddenUpdate.push(updateLane));
-      } else
-        (isHiddenUpdate = {
-          lane: updateLane,
-          tag: pendingQueue.tag,
-          payload: pendingQueue.payload,
-          callback: pendingQueue.callback,
-          next: null
-        }),
-          null === current
-            ? ((firstPendingUpdate = current = isHiddenUpdate),
-              (lastPendingUpdate = newState))
-            : (current = current.next = isHiddenUpdate),
-          (lastBaseUpdate |= updateLane);
-      pendingQueue = pendingQueue.next;
-      if (null === pendingQueue)
-        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
-          break;
-        else
-          (isHiddenUpdate = pendingQueue),
-            (pendingQueue = isHiddenUpdate.next),
-            (isHiddenUpdate.next = null),
-            (queue.lastBaseUpdate = isHiddenUpdate),
-            (queue.shared.pending = null);
-    } while (1);
-    null === current && (lastPendingUpdate = newState);
-    queue.baseState = lastPendingUpdate;
-    queue.firstBaseUpdate = firstPendingUpdate;
-    queue.lastBaseUpdate = current;
-    null === firstBaseUpdate && (queue.shared.lanes = 0);
-    workInProgressRootSkippedLanes |= lastBaseUpdate;
-    workInProgress$jscomp$0.lanes = lastBaseUpdate;
-    workInProgress$jscomp$0.memoizedState = newState;
+};
+HooksDispatcherOnMount.use = use;
+HooksDispatcherOnMount.useMemoCache = useMemoCache;
+HooksDispatcherOnMount.useEffectEvent = function (callback) {
+  var hook = mountWorkInProgressHook(),
+    ref = { impl: callback };
+  hook.memoizedState = ref;
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
+};
+var HooksDispatcherOnUpdate = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: function () {
+    return updateReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = updateReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
+HooksDispatcherOnUpdate.use = use;
+HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+var HooksDispatcherOnRerender = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: function () {
+    return rerenderReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return null === currentHook
+      ? (hook.memoizedState = value)
+      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = rerenderReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+HooksDispatcherOnRerender.use = use;
+HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    baseProps = assign({}, baseProps);
+    Component = Component.defaultProps;
+    for (var propName in Component)
+      void 0 === baseProps[propName] &&
+        (baseProps[propName] = Component[propName]);
+    return baseProps;
   }
+  return baseProps;
 }
-function callCallback(callback, context) {
-  if ("function" !== typeof callback)
-    throw Error(formatProdErrorMessage(191, callback));
-  callback.call(context);
+function applyDerivedStateFromProps(
+  workInProgress,
+  ctor,
+  getDerivedStateFromProps,
+  nextProps
+) {
+  ctor = workInProgress.memoizedState;
+  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+  getDerivedStateFromProps =
+    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
+      ? ctor
+      : assign({}, ctor, getDerivedStateFromProps);
+  workInProgress.memoizedState = getDerivedStateFromProps;
+  0 === workInProgress.lanes &&
+    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
 }
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
-  if (null !== callbacks)
-    for (
-      updateQueue.callbacks = null, updateQueue = 0;
-      updateQueue < callbacks.length;
-      updateQueue++
-    )
-      callCallback(callbacks[updateQueue], context);
+var classComponentUpdater = {
+  isMounted: function (component) {
+    return (component = component._reactInternals)
+      ? getNearestMountedFiber(component) === component
+      : !1;
+  },
+  enqueueSetState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+  },
+  enqueueReplaceState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 1;
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+  },
+  enqueueForceUpdate: function (inst, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 2;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    callback = enqueueUpdate(inst, update, lane);
+    null !== callback &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(callback, inst, lane, update),
+      entangleTransitions(callback, inst, lane));
+  }
+};
+function checkShouldComponentUpdate(
+  workInProgress,
+  ctor,
+  oldProps,
+  newProps,
+  oldState,
+  newState,
+  nextContext
+) {
+  workInProgress = workInProgress.stateNode;
+  return "function" === typeof workInProgress.shouldComponentUpdate
+    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
+    : ctor.prototype && ctor.prototype.isPureReactComponent
+    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
+    : !0;
 }
-var SuspenseException = Error(formatProdErrorMessage(460));
-function isThenableResolved(thenable) {
-  thenable = thenable.status;
-  return "fulfilled" === thenable || "rejected" === thenable;
+function constructClassInstance(workInProgress, ctor, props) {
+  var context = emptyContextObject,
+    contextType = ctor.contextType;
+  "object" === typeof contextType &&
+    null !== contextType &&
+    (context = readContext(contextType));
+  ctor = new ctor(props, context);
+  workInProgress.memoizedState =
+    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+  ctor.updater = classComponentUpdater;
+  workInProgress.stateNode = ctor;
+  ctor._reactInternals = workInProgress;
+  return ctor;
 }
-function noop() {}
-function trackUsedThenable(thenableState, thenable, index) {
-  index = thenableState[index];
-  void 0 === index
-    ? thenableState.push(thenable)
-    : index !== thenable && (thenable.then(noop, noop), (thenable = index));
-  switch (thenable.status) {
-    case "fulfilled":
-      return thenable.value;
-    case "rejected":
-      throw thenable.reason;
-    default:
-      "string" === typeof thenable.status
-        ? thenable.then(noop, noop)
-        : ((thenableState = thenable),
-          (thenableState.status = "pending"),
-          thenableState.then(
-            function (fulfilledValue) {
-              if ("pending" === thenable.status) {
-                var fulfilledThenable = thenable;
-                fulfilledThenable.status = "fulfilled";
-                fulfilledThenable.value = fulfilledValue;
-              }
-            },
-            function (error) {
-              if ("pending" === thenable.status) {
-                var rejectedThenable = thenable;
-                rejectedThenable.status = "rejected";
-                rejectedThenable.reason = error;
-              }
-            }
-          ));
-      switch (thenable.status) {
-        case "fulfilled":
-          return thenable.value;
-        case "rejected":
-          throw thenable.reason;
-      }
-      suspendedThenable = thenable;
-      throw SuspenseException;
-  }
+function callComponentWillReceiveProps(
+  workInProgress,
+  instance,
+  newProps,
+  nextContext
+) {
+  workInProgress = instance.state;
+  "function" === typeof instance.componentWillReceiveProps &&
+    instance.componentWillReceiveProps(newProps, nextContext);
+  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  instance.state !== workInProgress &&
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
 }
-var suspendedThenable = null,
-  thenableState$1 = null,
-  thenableIndexCounter$1 = 0;
-function unwrapThenable(thenable) {
-  var index = thenableIndexCounter$1;
-  thenableIndexCounter$1 += 1;
-  null === thenableState$1 && (thenableState$1 = []);
-  return trackUsedThenable(thenableState$1, thenable, index);
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  var instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  var contextType = ctor.contextType;
+  instance.context =
+    "object" === typeof contextType && null !== contextType
+      ? readContext(contextType)
+      : emptyContextObject;
+  instance.state = workInProgress.memoizedState;
+  contextType = ctor.getDerivedStateFromProps;
+  "function" === typeof contextType &&
+    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof ctor.getDerivedStateFromProps ||
+    "function" === typeof instance.getSnapshotBeforeUpdate ||
+    ("function" !== typeof instance.UNSAFE_componentWillMount &&
+      "function" !== typeof instance.componentWillMount) ||
+    ((ctor = instance.state),
+    "function" === typeof instance.componentWillMount &&
+      instance.componentWillMount(),
+    "function" === typeof instance.UNSAFE_componentWillMount &&
+      instance.UNSAFE_componentWillMount(),
+    ctor !== instance.state &&
+      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof instance.componentDidMount &&
+    (workInProgress.flags |= 4194308);
 }
-function coerceRef(returnFiber, current, element) {
-  returnFiber = element.ref;
-  if (
-    null !== returnFiber &&
-    "function" !== typeof returnFiber &&
-    "object" !== typeof returnFiber
-  ) {
-    if (element._owner) {
-      element = element._owner;
-      if (element) {
-        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
-        var inst = element.stateNode;
-      }
-      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
-      var resolvedInst = inst,
-        stringRef = "" + returnFiber;
-      if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
-      )
-        return current.ref;
-      current = function (value) {
-        var refs = resolvedInst.refs;
-        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
-      };
-      current._stringRef = stringRef;
-      return current;
-    }
-    if ("string" !== typeof returnFiber)
-      throw Error(formatProdErrorMessage(284));
-    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
+function createCapturedValueAtFiber(value, source) {
+  try {
+    var info = "",
+      node = source;
+    do (info += describeFiber(node)), (node = node.return);
+    while (node);
+    var JSCompiler_inline_result = info;
+  } catch (x) {
+    JSCompiler_inline_result =
+      "\nError generating stack: " + x.message + "\n" + x.stack;
   }
-  return returnFiber;
-}
-function throwOnInvalidObjectType(returnFiber, newChild) {
-  returnFiber = Object.prototype.toString.call(newChild);
-  throw Error(
-    formatProdErrorMessage(
-      31,
-      "[object Object]" === returnFiber
-        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
-        : returnFiber
-    )
-  );
+  return {
+    value: value,
+    source: source,
+    stack: JSCompiler_inline_result,
+    digest: null
+  };
 }
-function resolveLazy(lazyType) {
-  var init = lazyType._init;
-  return init(lazyType._payload);
+function createCapturedValue(value, digest, stack) {
+  return {
+    value: value,
+    source: null,
+    stack: null != stack ? stack : null,
+    digest: null != digest ? digest : null
+  };
 }
-function createChildReconciler(shouldTrackSideEffects) {
-  function deleteChild(returnFiber, childToDelete) {
-    if (shouldTrackSideEffects) {
-      var deletions = returnFiber.deletions;
-      null === deletions
-        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
-        : deletions.push(childToDelete);
-    }
-  }
-  function deleteRemainingChildren(returnFiber, currentFirstChild) {
-    if (!shouldTrackSideEffects) return null;
-    for (; null !== currentFirstChild; )
-      deleteChild(returnFiber, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return null;
-  }
-  function mapRemainingChildren(returnFiber, currentFirstChild) {
-    for (returnFiber = new Map(); null !== currentFirstChild; )
-      null !== currentFirstChild.key
-        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
-        : returnFiber.set(currentFirstChild.index, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return returnFiber;
-  }
-  function useFiber(fiber, pendingProps) {
-    fiber = createWorkInProgress(fiber, pendingProps);
-    fiber.index = 0;
-    fiber.sibling = null;
-    return fiber;
-  }
-  function placeChild(newFiber, lastPlacedIndex, newIndex) {
-    newFiber.index = newIndex;
-    if (!shouldTrackSideEffects)
-      return (newFiber.flags |= 1048576), lastPlacedIndex;
-    newIndex = newFiber.alternate;
-    if (null !== newIndex)
-      return (
-        (newIndex = newIndex.index),
-        newIndex < lastPlacedIndex
-          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
-          : newIndex
-      );
-    newFiber.flags |= 16777218;
-    return lastPlacedIndex;
-  }
-  function placeSingleChild(newFiber) {
-    shouldTrackSideEffects &&
-      null === newFiber.alternate &&
-      (newFiber.flags |= 16777218);
-    return newFiber;
+var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
+if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
+  throw Error(formatProdErrorMessage(320));
+function logCapturedError(boundary, errorInfo) {
+  try {
+    !1 !==
+      ReactFiberErrorDialogWWW.showErrorDialog({
+        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
+        error: errorInfo.value,
+        errorBoundary:
+          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
+      }) && console.error(errorInfo.value);
+  } catch (e) {
+    setTimeout(function () {
+      throw e;
+    });
   }
-  function updateTextNode(returnFiber, current, textContent, lanes) {
-    if (null === current || 6 !== current.tag)
-      return (
-        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, textContent);
-    current.return = returnFiber;
-    return current;
+}
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  lane.payload = { element: null };
+  var error = errorInfo.value;
+  lane.callback = function () {
+    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
+    logCapturedError(fiber, errorInfo);
+  };
+  return lane;
+}
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+  if ("function" === typeof getDerivedStateFromError) {
+    var error = errorInfo.value;
+    lane.payload = function () {
+      return getDerivedStateFromError(error);
+    };
+    lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+    };
   }
-  function updateElement(returnFiber, current, element, lanes) {
-    var elementType = element.type;
-    if (elementType === REACT_FRAGMENT_TYPE)
-      return updateFragment(
-        returnFiber,
-        current,
-        element.props.children,
-        lanes,
-        element.key
-      );
+  var inst = fiber.stateNode;
+  null !== inst &&
+    "function" === typeof inst.componentDidCatch &&
+    (lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+      "function" !== typeof getDerivedStateFromError &&
+        (null === legacyErrorBoundariesThatAlreadyFailed
+          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
+          : legacyErrorBoundariesThatAlreadyFailed.add(this));
+      var stack = errorInfo.stack;
+      this.componentDidCatch(errorInfo.value, {
+        componentStack: null !== stack ? stack : ""
+      });
+    });
+  return lane;
+}
+function markSuspenseBoundaryShouldCapture(
+  suspenseBoundary,
+  returnFiber,
+  sourceFiber,
+  root,
+  rootRenderLanes
+) {
+  if (0 === (suspenseBoundary.mode & 1))
+    return (
+      suspenseBoundary === returnFiber
+        ? (suspenseBoundary.flags |= 65536)
+        : ((suspenseBoundary.flags |= 128),
+          (sourceFiber.flags |= 131072),
+          (sourceFiber.flags &= -52805),
+          1 === sourceFiber.tag &&
+            (null === sourceFiber.alternate
+              ? (sourceFiber.tag = 17)
+              : ((returnFiber = createUpdate(2)),
+                (returnFiber.tag = 2),
+                enqueueUpdate(sourceFiber, returnFiber, 2))),
+          (sourceFiber.lanes |= 2)),
+      suspenseBoundary
+    );
+  suspenseBoundary.flags |= 65536;
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
+}
+function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
+  if (enableTransitionTracing && null !== pendingTransitions) {
+    var transitionStart = pendingTransitions.transitionStart,
+      onTransitionStart = callbacks.onTransitionStart;
+    null !== transitionStart &&
+      null != onTransitionStart &&
+      transitionStart.forEach(function (transition) {
+        return onTransitionStart(transition.name, transition.startTime);
+      });
+    transitionStart = pendingTransitions.markerProgress;
+    var onMarkerProgress = callbacks.onMarkerProgress;
+    null != onMarkerProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (markerInstance, markerName) {
+        if (null !== markerInstance.transitions) {
+          var pending =
+            null !== markerInstance.pendingBoundaries
+              ? Array.from(markerInstance.pendingBoundaries.values())
+              : [];
+          markerInstance.transitions.forEach(function (transition) {
+            onMarkerProgress(
+              transition.name,
+              markerName,
+              transition.startTime,
+              endTime,
+              pending
+            );
+          });
+        }
+      });
+    transitionStart = pendingTransitions.markerComplete;
+    var onMarkerComplete = callbacks.onMarkerComplete;
+    null !== transitionStart &&
+      null != onMarkerComplete &&
+      transitionStart.forEach(function (transitions, markerName) {
+        transitions.forEach(function (transition) {
+          onMarkerComplete(
+            transition.name,
+            markerName,
+            transition.startTime,
+            endTime
+          );
+        });
+      });
+    transitionStart = pendingTransitions.markerIncomplete;
+    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
+    null != onMarkerIncomplete &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (_ref, markerName) {
+        var aborts = _ref.aborts;
+        _ref.transitions.forEach(function (transition) {
+          var filteredAborts = [];
+          aborts.forEach(function (abort) {
+            switch (abort.reason) {
+              case "marker":
+                filteredAborts.push({
+                  type: "marker",
+                  name: abort.name,
+                  endTime: endTime
+                });
+                break;
+              case "suspense":
+                filteredAborts.push({
+                  type: "suspense",
+                  name: abort.name,
+                  endTime: endTime
+                });
+            }
+          });
+          0 < filteredAborts.length &&
+            onMarkerIncomplete(
+              transition.name,
+              markerName,
+              transition.startTime,
+              filteredAborts
+            );
+        });
+      });
+    transitionStart = pendingTransitions.transitionProgress;
+    var onTransitionProgress = callbacks.onTransitionProgress;
+    null != onTransitionProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (pending, transition) {
+        onTransitionProgress(
+          transition.name,
+          transition.startTime,
+          endTime,
+          Array.from(pending.values())
+        );
+      });
+    pendingTransitions = pendingTransitions.transitionComplete;
+    var onTransitionComplete = callbacks.onTransitionComplete;
+    null !== pendingTransitions &&
+      null != onTransitionComplete &&
+      pendingTransitions.forEach(function (transition) {
+        return onTransitionComplete(
+          transition.name,
+          transition.startTime,
+          endTime
+        );
+      });
+  }
+}
+var markerInstanceStack = createCursor(null);
+function pushRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    var transitions = workInProgressTransitions,
+      root$61 = workInProgress.stateNode;
+    null !== transitions &&
+      transitions.forEach(function (transition) {
+        if (!root$61.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: 0,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root$61.incompleteTransitions.set(transition, markerInstance);
+        }
+      });
+    var markerInstances = [];
+    root$61.incompleteTransitions.forEach(function (markerInstance) {
+      markerInstances.push(markerInstance);
+    });
+    push(markerInstanceStack, markerInstances);
+  }
+}
+function pushMarkerInstance(workInProgress, markerInstance) {
+  enableTransitionTracing &&
+    (null === markerInstanceStack.current
+      ? push(markerInstanceStack, [markerInstance])
+      : push(
+          markerInstanceStack,
+          markerInstanceStack.current.concat(markerInstance)
+        ));
+}
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
+  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
+  didReceiveUpdate = !1;
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  workInProgress.child =
+    null === current
+      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
+      : reconcileChildFibers(
+          workInProgress,
+          current.child,
+          nextChildren,
+          renderLanes
+        );
+}
+function updateForwardRef(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  Component = Component.render;
+  var ref = workInProgress.ref;
+  prepareToReadContext(workInProgress, renderLanes);
+  nextProps = renderWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    ref,
+    renderLanes
+  );
+  Component = checkDidRenderIdHook();
+  if (null !== current && !didReceiveUpdate)
+    return (
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+    );
+  isHydrating && Component && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, nextProps, renderLanes);
+  return workInProgress.child;
+}
+function updateMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null === current) {
+    var type = Component.type;
     if (
-      null !== current &&
-      (current.elementType === elementType ||
-        ("object" === typeof elementType &&
-          null !== elementType &&
-          elementType.$$typeof === REACT_LAZY_TYPE &&
-          resolveLazy(elementType) === current.type))
+      "function" === typeof type &&
+      !shouldConstruct(type) &&
+      void 0 === type.defaultProps &&
+      null === Component.compare &&
+      void 0 === Component.defaultProps
     )
       return (
-        (lanes = useFiber(current, element.props)),
-        (lanes.ref = coerceRef(returnFiber, current, element)),
-        (lanes.return = returnFiber),
-        lanes
+        (workInProgress.tag = 15),
+        (workInProgress.type = type),
+        updateSimpleMemoComponent(
+          current,
+          workInProgress,
+          type,
+          nextProps,
+          renderLanes
+        )
       );
-    lanes = createFiberFromTypeAndProps(
-      element.type,
-      element.key,
-      element.props,
+    current = createFiberFromTypeAndProps(
+      Component.type,
       null,
-      returnFiber.mode,
-      lanes
+      nextProps,
+      workInProgress,
+      workInProgress.mode,
+      renderLanes
     );
-    lanes.ref = coerceRef(returnFiber, current, element);
-    lanes.return = returnFiber;
-    return lanes;
-  }
-  function updatePortal(returnFiber, current, portal, lanes) {
-    if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
-    )
-      return (
-        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, portal.children || []);
-    current.return = returnFiber;
-    return current;
-  }
-  function updateFragment(returnFiber, current, fragment, lanes, key) {
-    if (null === current || 7 !== current.tag)
-      return (
-        (current = createFiberFromFragment(
-          fragment,
-          returnFiber.mode,
-          lanes,
-          key
-        )),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, fragment);
-    current.return = returnFiber;
-    return current;
+    current.ref = workInProgress.ref;
+    current.return = workInProgress;
+    return (workInProgress.child = current);
   }
-  function createChild(returnFiber, newChild, lanes) {
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return (
-        (newChild = createFiberFromText(
-          "" + newChild,
-          returnFiber.mode,
-          lanes
-        )),
-        (newChild.return = returnFiber),
-        newChild
-      );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (lanes = createFiberFromTypeAndProps(
-              newChild.type,
-              newChild.key,
-              newChild.props,
-              null,
-              returnFiber.mode,
-              lanes
-            )),
-            (lanes.ref = coerceRef(returnFiber, null, newChild)),
-            (lanes.return = returnFiber),
-            lanes
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (newChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (newChild.return = returnFiber),
-            newChild
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return createChild(returnFiber, init(newChild._payload), lanes);
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (newChild = createFiberFromFragment(
-            newChild,
-            returnFiber.mode,
-            lanes,
-            null
-          )),
-          (newChild.return = returnFiber),
-          newChild
-        );
-      if ("function" === typeof newChild.then)
-        return createChild(returnFiber, unwrapThenable(newChild), lanes);
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return createChild(
-          returnFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
+  type = current.child;
+  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+    var prevProps = type.memoizedProps;
+    Component = Component.compare;
+    Component = null !== Component ? Component : shallowEqual;
+    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
-  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
-    var key = null !== oldFiber ? oldFiber.key : null;
+  workInProgress.flags |= 1;
+  current = createWorkInProgress(type, nextProps);
+  current.ref = workInProgress.ref;
+  current.return = workInProgress;
+  return (workInProgress.child = current);
+}
+function updateSimpleMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null !== current) {
+    var prevProps = current.memoizedProps;
     if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
+      shallowEqual(prevProps, nextProps) &&
+      current.ref === workInProgress.ref
     )
-      return null !== key
-        ? null
-        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return newChild.key === key
-            ? updateElement(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_PORTAL_TYPE:
-          return newChild.key === key
-            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_LAZY_TYPE:
-          return (
-            (key = newChild._init),
-            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
-          );
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return null !== key
-          ? null
-          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
-      if ("function" === typeof newChild.then)
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          unwrapThenable(newChild),
-          lanes
-        );
       if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+        ((didReceiveUpdate = !1),
+        (workInProgress.pendingProps = nextProps = prevProps),
+        checkScheduledUpdateOrContext(current, renderLanes))
       )
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
+        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
+      else
+        return (
+          (workInProgress.lanes = current.lanes),
+          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
         );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
   }
-  function updateFromMap(
-    existingChildren,
-    returnFiber,
-    newIdx,
-    newChild,
-    lanes
+  return updateFunctionComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    renderLanes
+  );
+}
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    nextChildren = nextProps.children,
+    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
+    prevState = null !== current ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+  if (
+    "hidden" === nextProps.mode ||
+    "unstable-defer-without-hiding" === nextProps.mode ||
+    nextIsDetached
   ) {
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return (
-        (existingChildren = existingChildren.get(newIdx) || null),
-        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
+    if (0 !== (workInProgress.flags & 128)) {
+      nextChildren =
+        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+      if (null !== current) {
+        prevState = workInProgress.child = current.child;
+        for (nextProps = 0; null !== prevState; )
+          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
+            (prevState = prevState.sibling);
+        workInProgress.childLanes = nextProps & ~nextChildren;
+      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes
       );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updateElement(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updatePortal(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return updateFromMap(
-            existingChildren,
-            returnFiber,
-            newIdx,
-            init(newChild._payload),
-            lanes
-          );
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (existingChildren = existingChildren.get(newIdx) || null),
-          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
-        );
-      if ("function" === typeof newChild.then)
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
-  }
-  function reconcileChildrenArray(
-    returnFiber,
-    currentFirstChild,
-    newChildren,
-    lanes
-  ) {
-    for (
-      var resultingFirstChild = null,
-        previousNewFiber = null,
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null;
-      null !== oldFiber && newIdx < newChildren.length;
-      newIdx++
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(
-        returnFiber,
-        oldFiber,
-        newChildren[newIdx],
-        lanes
-      );
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
-      }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (resultingFirstChild = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
-    }
-    if (newIdx === newChildren.length)
-      return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        resultingFirstChild
-      );
-    if (null === oldFiber) {
-      for (; newIdx < newChildren.length; newIdx++)
-        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
-          null !== oldFiber &&
-            ((currentFirstChild = placeChild(
-              oldFiber,
-              currentFirstChild,
-              newIdx
-            )),
-            null === previousNewFiber
-              ? (resultingFirstChild = oldFiber)
-              : (previousNewFiber.sibling = oldFiber),
-            (previousNewFiber = oldFiber));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return resultingFirstChild;
-    }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      newIdx < newChildren.length;
-      newIdx++
-    )
-      (nextOldFiber = updateFromMap(
-        oldFiber,
-        returnFiber,
-        newIdx,
-        newChildren[newIdx],
-        lanes
-      )),
-        null !== nextOldFiber &&
-          (shouldTrackSideEffects &&
-            null !== nextOldFiber.alternate &&
-            oldFiber.delete(
-              null === nextOldFiber.key ? newIdx : nextOldFiber.key
-            ),
-          (currentFirstChild = placeChild(
-            nextOldFiber,
-            currentFirstChild,
-            newIdx
-          )),
-          null === previousNewFiber
-            ? (resultingFirstChild = nextOldFiber)
-            : (previousNewFiber.sibling = nextOldFiber),
-          (previousNewFiber = nextOldFiber));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return resultingFirstChild;
-  }
-  function reconcileChildrenIterator(
-    returnFiber,
-    currentFirstChild,
-    newChildrenIterable,
-    lanes
-  ) {
-    var iteratorFn = getIteratorFn(newChildrenIterable);
-    if ("function" !== typeof iteratorFn)
-      throw Error(formatProdErrorMessage(150));
-    newChildrenIterable = iteratorFn.call(newChildrenIterable);
-    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
-    for (
-      var previousNewFiber = (iteratorFn = null),
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null,
-        step = newChildrenIterable.next();
-      null !== oldFiber && !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
-      }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (iteratorFn = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
     }
-    if (step.done)
+    if (0 === (workInProgress.mode & 1))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current && pushTransition(workInProgress, null, null),
+        reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else if (0 !== (renderLanes & 1073741824))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current &&
+          pushTransition(
+            workInProgress,
+            null !== prevState ? prevState.cachePool : null,
+            null
+          ),
+        null !== prevState
+          ? pushHiddenContext(workInProgress, prevState)
+          : reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else
       return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        iteratorFn
+        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
+        deferHiddenOffscreenComponent(
+          current,
+          workInProgress,
+          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
+          renderLanes
+        )
       );
-    if (null === oldFiber) {
-      for (; !step.done; newIdx++, step = newChildrenIterable.next())
-        (step = createChild(returnFiber, step.value, lanes)),
-          null !== step &&
-            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-            null === previousNewFiber
-              ? (iteratorFn = step)
-              : (previousNewFiber.sibling = step),
-            (previousNewFiber = step));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return iteratorFn;
+  } else if (null !== prevState) {
+    nextProps = prevState.cachePool;
+    nextIsDetached = null;
+    if (enableTransitionTracing) {
+      var instance = workInProgress.stateNode;
+      null !== instance &&
+        null != instance._transitions &&
+        (nextIsDetached = Array.from(instance._transitions));
     }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    )
-      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
-        null !== step &&
-          (shouldTrackSideEffects &&
-            null !== step.alternate &&
-            oldFiber.delete(null === step.key ? newIdx : step.key),
-          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-          null === previousNewFiber
-            ? (iteratorFn = step)
-            : (previousNewFiber.sibling = step),
-          (previousNewFiber = step));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return iteratorFn;
-  }
-  function reconcileChildFibersImpl(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    "object" === typeof newChild &&
-      null !== newChild &&
-      newChild.type === REACT_FRAGMENT_TYPE &&
-      null === newChild.key &&
-      (newChild = newChild.props.children);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          a: {
-            for (
-              var key = newChild.key, child = currentFirstChild;
-              null !== child;
-
-            ) {
-              if (child.key === key) {
-                key = newChild.type;
-                if (key === REACT_FRAGMENT_TYPE) {
-                  if (7 === child.tag) {
-                    deleteRemainingChildren(returnFiber, child.sibling);
-                    currentFirstChild = useFiber(
-                      child,
-                      newChild.props.children
-                    );
-                    currentFirstChild.return = returnFiber;
-                    returnFiber = currentFirstChild;
-                    break a;
-                  }
-                } else if (
-                  child.elementType === key ||
-                  ("object" === typeof key &&
-                    null !== key &&
-                    key.$$typeof === REACT_LAZY_TYPE &&
-                    resolveLazy(key) === child.type)
-                ) {
-                  deleteRemainingChildren(returnFiber, child.sibling);
-                  currentFirstChild = useFiber(child, newChild.props);
-                  currentFirstChild.ref = coerceRef(
-                    returnFiber,
-                    child,
-                    newChild
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                }
-                deleteRemainingChildren(returnFiber, child);
-                break;
-              } else deleteChild(returnFiber, child);
-              child = child.sibling;
-            }
-            newChild.type === REACT_FRAGMENT_TYPE
-              ? ((currentFirstChild = createFiberFromFragment(
-                  newChild.props.children,
-                  returnFiber.mode,
-                  lanes,
-                  newChild.key
-                )),
-                (currentFirstChild.return = returnFiber),
-                (returnFiber = currentFirstChild))
-              : ((lanes = createFiberFromTypeAndProps(
-                  newChild.type,
-                  newChild.key,
-                  newChild.props,
-                  null,
-                  returnFiber.mode,
-                  lanes
-                )),
-                (lanes.ref = coerceRef(
-                  returnFiber,
-                  currentFirstChild,
-                  newChild
-                )),
-                (lanes.return = returnFiber),
-                (returnFiber = lanes));
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_PORTAL_TYPE:
-          a: {
-            for (child = newChild.key; null !== currentFirstChild; ) {
-              if (currentFirstChild.key === child)
-                if (
-                  4 === currentFirstChild.tag &&
-                  currentFirstChild.stateNode.containerInfo ===
-                    newChild.containerInfo &&
-                  currentFirstChild.stateNode.implementation ===
-                    newChild.implementation
-                ) {
-                  deleteRemainingChildren(
-                    returnFiber,
-                    currentFirstChild.sibling
-                  );
-                  currentFirstChild = useFiber(
-                    currentFirstChild,
-                    newChild.children || []
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                } else {
-                  deleteRemainingChildren(returnFiber, currentFirstChild);
-                  break;
-                }
-              else deleteChild(returnFiber, currentFirstChild);
-              currentFirstChild = currentFirstChild.sibling;
-            }
-            currentFirstChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            );
-            currentFirstChild.return = returnFiber;
-            returnFiber = currentFirstChild;
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_LAZY_TYPE:
-          return (
-            (child = newChild._init),
-            reconcileChildFibers(
-              returnFiber,
-              currentFirstChild,
-              child(newChild._payload),
-              lanes
-            )
-          );
-      }
-      if (isArrayImpl(newChild))
-        return reconcileChildrenArray(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if (getIteratorFn(newChild))
-        return reconcileChildrenIterator(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if ("function" === typeof newChild.then)
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-      ? ((newChild = "" + newChild),
-        null !== currentFirstChild && 6 === currentFirstChild.tag
-          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
-            (currentFirstChild = useFiber(currentFirstChild, newChild)),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild))
-          : (deleteRemainingChildren(returnFiber, currentFirstChild),
-            (currentFirstChild = createFiberFromText(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild)),
-        placeSingleChild(returnFiber))
-      : deleteRemainingChildren(returnFiber, currentFirstChild);
-  }
-  function reconcileChildFibers(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    thenableIndexCounter$1 = 0;
-    returnFiber = reconcileChildFibersImpl(
-      returnFiber,
-      currentFirstChild,
-      newChild,
-      lanes
-    );
-    thenableState$1 = null;
-    return returnFiber;
-  }
-  return reconcileChildFibers;
-}
-var reconcileChildFibers = createChildReconciler(!0),
-  mountChildFibers = createChildReconciler(!1),
-  currentTreeHiddenStackCursor = createCursor(null),
-  prevRenderLanesStackCursor = createCursor(0);
-function pushHiddenContext(fiber, context) {
-  fiber = renderLanes;
-  push(prevRenderLanesStackCursor, fiber);
-  push(currentTreeHiddenStackCursor, context);
-  renderLanes = fiber | context.baseLanes;
-}
-function reuseHiddenContextOnStack() {
-  push(prevRenderLanesStackCursor, renderLanes);
-  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+    pushTransition(workInProgress, nextProps, nextIsDetached);
+    pushHiddenContext(workInProgress, prevState);
+    reuseSuspenseHandlerOnStack();
+    workInProgress.memoizedState = null;
+  } else
+    null !== current && pushTransition(workInProgress, null, null),
+      reuseHiddenContextOnStack(),
+      reuseSuspenseHandlerOnStack();
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
-function popHiddenContext() {
-  renderLanes = prevRenderLanesStackCursor.current;
-  pop(currentTreeHiddenStackCursor);
-  pop(prevRenderLanesStackCursor);
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
+  var JSCompiler_inline_result = peekCacheFromPool();
+  JSCompiler_inline_result =
+    null === JSCompiler_inline_result
+      ? null
+      : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
+  workInProgress.memoizedState = {
+    baseLanes: nextBaseLanes,
+    cachePool: JSCompiler_inline_result
+  };
+  null !== current && pushTransition(workInProgress, null, null);
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+  enableLazyContextPropagation &&
+    null !== current &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
+  return null;
 }
-var suspenseHandlerStackCursor = createCursor(null),
-  shellBoundary = null;
-function pushPrimaryTreeSuspenseHandler(handler) {
-  var current = handler.alternate;
-  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
-  (null !== current && null === currentTreeHiddenStackCursor.current)
-    ? (push(suspenseHandlerStackCursor, handler),
-      null === shellBoundary &&
-        (null === current || null !== currentTreeHiddenStackCursor.current
-          ? (shellBoundary = handler)
-          : null !== current.memoizedState && (shellBoundary = handler)))
-    : null === shellBoundary
-    ? push(suspenseHandlerStackCursor, handler)
-    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+function markRef$1(current, workInProgress) {
+  var ref = workInProgress.ref;
+  if (
+    (null === current && null !== ref) ||
+    (null !== current && current.ref !== ref)
+  )
+    (workInProgress.flags |= 512), (workInProgress.flags |= 2097152);
 }
-function pushOffscreenSuspenseHandler(fiber) {
-  if (22 === fiber.tag) {
-    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
-      var current = fiber.alternate;
-      null !== current &&
-        null !== current.memoizedState &&
-        (shellBoundary = fiber);
-    }
-  } else reuseSuspenseHandlerOnStack();
-}
-function reuseSuspenseHandlerOnStack() {
-  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
-}
-function popSuspenseHandler(fiber) {
-  pop(suspenseHandlerStackCursor);
-  shellBoundary === fiber && (shellBoundary = null);
-}
-var suspenseStackCursor = createCursor(0);
-function findFirstSuspended(row) {
-  for (var node = row; null !== node; ) {
-    if (13 === node.tag) {
-      var state = node.memoizedState;
-      if (
-        null !== state &&
-        ((state = state.dehydrated),
-        null === state || "$?" === state.data || "$!" === state.data)
-      )
-        return node;
-    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
-      if (0 !== (node.flags & 128)) return node;
-    } else if (null !== node.child) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
-    if (node === row) break;
-    for (; null === node.sibling; ) {
-      if (null === node.return || node.return === row) return null;
-      node = node.return;
-    }
-    node.sibling.return = node.return;
-    node = node.sibling;
-  }
-  return null;
-}
-var workInProgressSources = [];
-function resetWorkInProgressVersions() {
-  for (var i = 0; i < workInProgressSources.length; i++)
-    workInProgressSources[i]._workInProgressVersionPrimary = null;
-  workInProgressSources.length = 0;
-}
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
-  renderLanes$1 = 0,
-  currentlyRenderingFiber$1 = null,
-  currentHook = null,
-  workInProgressHook = null,
-  didScheduleRenderPhaseUpdate = !1,
-  didScheduleRenderPhaseUpdateDuringThisPass = !1,
-  shouldDoubleInvokeUserFnsInHooksDEV = !1,
-  localIdCounter = 0,
-  thenableIndexCounter = 0,
-  thenableState = null,
-  globalClientIdCounter = 0;
-function throwInvalidHookError() {
-  throw Error(formatProdErrorMessage(321));
-}
-function areHookInputsEqual(nextDeps, prevDeps) {
-  if (null === prevDeps) return !1;
-  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
-    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
-  return !0;
+function updateFunctionComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  prepareToReadContext(workInProgress, renderLanes);
+  Component = renderWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    void 0,
+    renderLanes
+  );
+  nextProps = checkDidRenderIdHook();
+  if (null !== current && !didReceiveUpdate)
+    return (
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+    );
+  isHydrating && nextProps && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, Component, renderLanes);
+  return workInProgress.child;
 }
-function renderWithHooks(
+function replayFunctionComponent(
   current,
   workInProgress,
+  nextProps,
   Component,
-  props,
-  secondArg,
-  nextRenderLanes
+  renderLanes
 ) {
-  renderLanes$1 = nextRenderLanes;
-  currentlyRenderingFiber$1 = workInProgress;
-  workInProgress.memoizedState = null;
-  workInProgress.updateQueue = null;
-  workInProgress.lanes = 0;
-  ReactCurrentDispatcher$1.current =
-    null === current || null === current.memoizedState
-      ? HooksDispatcherOnMount
-      : HooksDispatcherOnUpdate;
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  nextRenderLanes = Component(props, secondArg);
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  didScheduleRenderPhaseUpdateDuringThisPass &&
-    (nextRenderLanes = renderWithHooksAgain(
-      workInProgress,
-      Component,
-      props,
-      secondArg
-    ));
+  prepareToReadContext(workInProgress, renderLanes);
+  nextProps = renderWithHooksAgain(
+    workInProgress,
+    Component,
+    nextProps,
+    void 0
+  );
   finishRenderingHooks(current);
-  return nextRenderLanes;
-}
-function finishRenderingHooks(current) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdate = !1;
-  thenableIndexCounter = 0;
-  thenableState = null;
-  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
-  enableLazyContextPropagation &&
-    null !== current &&
-    !didReceiveUpdate &&
-    ((current = current.dependencies),
-    null !== current &&
-      checkIfContextChanged(current) &&
-      (didReceiveUpdate = !0));
-}
-function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
-  var numberOfReRenders = 0;
-  do {
-    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
-    thenableIndexCounter = 0;
-    didScheduleRenderPhaseUpdateDuringThisPass = !1;
-    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
-    numberOfReRenders += 1;
-    workInProgressHook = currentHook = null;
-    workInProgress.updateQueue = null;
-    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
-    var children = Component(props, secondArg);
-  } while (didScheduleRenderPhaseUpdateDuringThisPass);
-  return children;
-}
-function checkDidRenderIdHook() {
-  var didRenderIdHook = 0 !== localIdCounter;
-  localIdCounter = 0;
-  return didRenderIdHook;
-}
-function bailoutHooks(current, workInProgress, lanes) {
-  workInProgress.updateQueue = current.updateQueue;
-  workInProgress.flags &= -2053;
-  current.lanes &= ~lanes;
-}
-function resetHooksOnUnwind() {
-  if (didScheduleRenderPhaseUpdate) {
-    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
-      var queue = hook.queue;
-      null !== queue && (queue.pending = null);
-      hook = hook.next;
-    }
-    didScheduleRenderPhaseUpdate = !1;
-  }
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdateDuringThisPass = !1;
-  thenableIndexCounter = localIdCounter = 0;
-  thenableState = null;
-}
-function mountWorkInProgressHook() {
-  var hook = {
-    memoizedState: null,
-    baseState: null,
-    baseQueue: null,
-    queue: null,
-    next: null
-  };
-  null === workInProgressHook
-    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
-    : (workInProgressHook = workInProgressHook.next = hook);
-  return workInProgressHook;
-}
-function updateWorkInProgressHook() {
-  if (null === currentHook) {
-    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
-    nextCurrentHook =
-      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
-  } else nextCurrentHook = currentHook.next;
-  var nextWorkInProgressHook =
-    null === workInProgressHook
-      ? currentlyRenderingFiber$1.memoizedState
-      : workInProgressHook.next;
-  if (null !== nextWorkInProgressHook)
-    (workInProgressHook = nextWorkInProgressHook),
-      (currentHook = nextCurrentHook);
-  else {
-    if (null === nextCurrentHook) {
-      if (null === currentlyRenderingFiber$1.alternate)
-        throw Error(formatProdErrorMessage(467));
-      throw Error(formatProdErrorMessage(310));
-    }
-    currentHook = nextCurrentHook;
-    nextCurrentHook = {
-      memoizedState: currentHook.memoizedState,
-      baseState: currentHook.baseState,
-      baseQueue: currentHook.baseQueue,
-      queue: currentHook.queue,
-      next: null
-    };
-    null === workInProgressHook
-      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
-          nextCurrentHook)
-      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
-  }
-  return workInProgressHook;
+  Component = checkDidRenderIdHook();
+  if (null !== current && !didReceiveUpdate)
+    return (
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+    );
+  isHydrating && Component && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, nextProps, renderLanes);
+  return workInProgress.child;
 }
-var createFunctionComponentUpdateQueue;
-createFunctionComponentUpdateQueue = function () {
-  return { lastEffect: null, events: null, stores: null, memoCache: null };
-};
-function use(usable) {
-  if (null !== usable && "object" === typeof usable) {
-    if ("function" === typeof usable.then) {
-      var index$88 = thenableIndexCounter;
-      thenableIndexCounter += 1;
-      null === thenableState && (thenableState = []);
-      usable = trackUsedThenable(thenableState, usable, index$88);
-      null === currentlyRenderingFiber$1.alternate &&
-        (null === workInProgressHook
-          ? null === currentlyRenderingFiber$1.memoizedState
-          : null === workInProgressHook.next) &&
-        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
-      return usable;
-    }
-    if (
-      usable.$$typeof === REACT_CONTEXT_TYPE ||
-      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
-    )
-      return readContext(usable);
-  }
-  throw Error(formatProdErrorMessage(438, String(usable)));
-}
-function useMemoCache(size) {
-  var memoCache = null,
-    updateQueue = currentlyRenderingFiber$1.updateQueue;
-  null !== updateQueue && (memoCache = updateQueue.memoCache);
-  if (null == memoCache) {
-    var current = currentlyRenderingFiber$1.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
+function updateClassComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  prepareToReadContext(workInProgress, renderLanes);
+  if (null === workInProgress.stateNode)
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+      constructClassInstance(workInProgress, Component, nextProps),
+      mountClassInstance(workInProgress, Component, nextProps, renderLanes),
+      (nextProps = !0);
+  else if (null === current) {
+    var instance = workInProgress.stateNode,
+      oldProps = workInProgress.memoizedProps;
+    instance.props = oldProps;
+    var oldContext = instance.context,
+      contextType = Component.contextType,
+      nextContext = emptyContextObject;
+    "object" === typeof contextType &&
+      null !== contextType &&
+      (nextContext = readContext(contextType));
+    var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+    (contextType =
+      "function" === typeof getDerivedStateFromProps ||
+      "function" === typeof instance.getSnapshotBeforeUpdate) ||
+      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
+        "function" !== typeof instance.componentWillReceiveProps) ||
+      ((oldProps !== nextProps || oldContext !== nextContext) &&
+        callComponentWillReceiveProps(
+          workInProgress,
+          instance,
+          nextProps,
+          nextContext
+        ));
+    hasForceUpdate = !1;
+    var oldState = workInProgress.memoizedState;
+    instance.state = oldState;
+    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+    oldContext = workInProgress.memoizedState;
+    oldProps !== nextProps || oldState !== oldContext || hasForceUpdate
+      ? ("function" === typeof getDerivedStateFromProps &&
+          (applyDerivedStateFromProps(
+            workInProgress,
+            Component,
+            getDerivedStateFromProps,
+            nextProps
+          ),
+          (oldContext = workInProgress.memoizedState)),
+        (oldProps =
+          hasForceUpdate ||
+          checkShouldComponentUpdate(
+            workInProgress,
+            Component,
+            oldProps,
+            nextProps,
+            oldState,
+            oldContext,
+            nextContext
+          ))
+          ? (contextType ||
+              ("function" !== typeof instance.UNSAFE_componentWillMount &&
+                "function" !== typeof instance.componentWillMount) ||
+              ("function" === typeof instance.componentWillMount &&
+                instance.componentWillMount(),
+              "function" === typeof instance.UNSAFE_componentWillMount &&
+                instance.UNSAFE_componentWillMount()),
+            "function" === typeof instance.componentDidMount &&
+              (workInProgress.flags |= 4194308))
+          : ("function" === typeof instance.componentDidMount &&
+              (workInProgress.flags |= 4194308),
+            (workInProgress.memoizedProps = nextProps),
+            (workInProgress.memoizedState = oldContext)),
+        (instance.props = nextProps),
+        (instance.state = oldContext),
+        (instance.context = nextContext),
+        (nextProps = oldProps))
+      : ("function" === typeof instance.componentDidMount &&
+          (workInProgress.flags |= 4194308),
+        (nextProps = !1));
+  } else {
+    instance = workInProgress.stateNode;
+    cloneUpdateQueue(current, workInProgress);
+    nextContext = workInProgress.memoizedProps;
+    contextType =
+      workInProgress.type === workInProgress.elementType
+        ? nextContext
+        : resolveDefaultProps(workInProgress.type, nextContext);
+    instance.props = contextType;
+    getDerivedStateFromProps = workInProgress.pendingProps;
+    var oldContext$jscomp$0 = instance.context;
+    oldContext = Component.contextType;
+    oldProps = emptyContextObject;
+    "object" === typeof oldContext &&
+      null !== oldContext &&
+      (oldProps = readContext(oldContext));
+    oldState = Component.getDerivedStateFromProps;
+    (oldContext =
+      "function" === typeof oldState ||
+      "function" === typeof instance.getSnapshotBeforeUpdate) ||
+      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
+        "function" !== typeof instance.componentWillReceiveProps) ||
+      ((nextContext !== getDerivedStateFromProps ||
+        oldContext$jscomp$0 !== oldProps) &&
+        callComponentWillReceiveProps(
+          workInProgress,
+          instance,
+          nextProps,
+          oldProps
+        ));
+    hasForceUpdate = !1;
+    oldContext$jscomp$0 = workInProgress.memoizedState;
+    instance.state = oldContext$jscomp$0;
+    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+    var newState = workInProgress.memoizedState;
+    nextContext !== getDerivedStateFromProps ||
+    oldContext$jscomp$0 !== newState ||
+    hasForceUpdate ||
+    (enableLazyContextPropagation &&
       null !== current &&
-        ((current = current.memoCache),
-        null != current &&
-          (memoCache = {
-            data: current.data.map(function (array) {
-              return array.slice();
-            }),
-            index: 0
-          })));
+      null !== current.dependencies &&
+      checkIfContextChanged(current.dependencies))
+      ? ("function" === typeof oldState &&
+          (applyDerivedStateFromProps(
+            workInProgress,
+            Component,
+            oldState,
+            nextProps
+          ),
+          (newState = workInProgress.memoizedState)),
+        (contextType =
+          hasForceUpdate ||
+          checkShouldComponentUpdate(
+            workInProgress,
+            Component,
+            contextType,
+            nextProps,
+            oldContext$jscomp$0,
+            newState,
+            oldProps
+          ) ||
+          (enableLazyContextPropagation &&
+            null !== current &&
+            null !== current.dependencies &&
+            checkIfContextChanged(current.dependencies)))
+          ? (oldContext ||
+              ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
+                "function" !== typeof instance.componentWillUpdate) ||
+              ("function" === typeof instance.componentWillUpdate &&
+                instance.componentWillUpdate(nextProps, newState, oldProps),
+              "function" === typeof instance.UNSAFE_componentWillUpdate &&
+                instance.UNSAFE_componentWillUpdate(
+                  nextProps,
+                  newState,
+                  oldProps
+                )),
+            "function" === typeof instance.componentDidUpdate &&
+              (workInProgress.flags |= 4),
+            "function" === typeof instance.getSnapshotBeforeUpdate &&
+              (workInProgress.flags |= 1024))
+          : ("function" !== typeof instance.componentDidUpdate ||
+              (nextContext === current.memoizedProps &&
+                oldContext$jscomp$0 === current.memoizedState) ||
+              (workInProgress.flags |= 4),
+            "function" !== typeof instance.getSnapshotBeforeUpdate ||
+              (nextContext === current.memoizedProps &&
+                oldContext$jscomp$0 === current.memoizedState) ||
+              (workInProgress.flags |= 1024),
+            (workInProgress.memoizedProps = nextProps),
+            (workInProgress.memoizedState = newState)),
+        (instance.props = nextProps),
+        (instance.state = newState),
+        (instance.context = oldProps),
+        (nextProps = contextType))
+      : ("function" !== typeof instance.componentDidUpdate ||
+          (nextContext === current.memoizedProps &&
+            oldContext$jscomp$0 === current.memoizedState) ||
+          (workInProgress.flags |= 4),
+        "function" !== typeof instance.getSnapshotBeforeUpdate ||
+          (nextContext === current.memoizedProps &&
+            oldContext$jscomp$0 === current.memoizedState) ||
+          (workInProgress.flags |= 1024),
+        (nextProps = !1));
   }
-  null == memoCache && (memoCache = { data: [], index: 0 });
-  null === updateQueue &&
-    ((updateQueue = createFunctionComponentUpdateQueue()),
-    (currentlyRenderingFiber$1.updateQueue = updateQueue));
-  updateQueue.memoCache = memoCache;
-  updateQueue = memoCache.data[memoCache.index];
-  if (void 0 === updateQueue)
-    for (
-      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
-      current < size;
-      current++
-    )
-      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
-  memoCache.index++;
-  return updateQueue;
-}
-function basicStateReducer(state, action) {
-  return "function" === typeof action ? action(state) : action;
+  return finishClassComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    !1,
+    renderLanes
+  );
 }
-function updateReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var current = currentHook,
-    baseQueue = current.baseQueue,
-    pendingQueue = queue.pending;
-  if (null !== pendingQueue) {
-    if (null !== baseQueue) {
-      var baseFirst = baseQueue.next;
-      baseQueue.next = pendingQueue.next;
-      pendingQueue.next = baseFirst;
-    }
-    current.baseQueue = baseQueue = pendingQueue;
-    queue.pending = null;
-  }
-  if (null !== baseQueue) {
-    pendingQueue = baseQueue.next;
-    current = current.baseState;
-    var newBaseQueueFirst = (baseFirst = null),
-      newBaseQueueLast = null,
-      update = pendingQueue;
-    do {
-      var updateLane = update.lane & -1073741825;
+function finishClassComponent(
+  current,
+  workInProgress,
+  Component,
+  shouldUpdate,
+  hasContext,
+  renderLanes
+) {
+  markRef$1(current, workInProgress);
+  hasContext = 0 !== (workInProgress.flags & 128);
+  if (!shouldUpdate && !hasContext)
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  shouldUpdate = workInProgress.stateNode;
+  ReactCurrentOwner$1.current = workInProgress;
+  Component =
+    hasContext && "function" !== typeof Component.getDerivedStateFromError
+      ? null
+      : shouldUpdate.render();
+  workInProgress.flags |= 1;
+  null !== current && hasContext
+    ? ((workInProgress.child = reconcileChildFibers(
+        workInProgress,
+        current.child,
+        null,
+        renderLanes
+      )),
+      (workInProgress.child = reconcileChildFibers(
+        workInProgress,
+        null,
+        Component,
+        renderLanes
+      )))
+    : reconcileChildren(current, workInProgress, Component, renderLanes);
+  workInProgress.memoizedState = shouldUpdate.state;
+  return workInProgress.child;
+}
+function mountHostRootWithoutHydrating(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes,
+  recoverableError
+) {
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= 256;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+var SUSPENDED_MARKER = { dehydrated: null, treeContext: null, retryLane: 0 };
+function mountSuspenseOffscreenState(renderLanes) {
+  return { baseLanes: renderLanes, cachePool: getSuspendedCache() };
+}
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    showFallback = !1,
+    didSuspend = 0 !== (workInProgress.flags & 128),
+    JSCompiler_temp;
+  (JSCompiler_temp = didSuspend) ||
+    (JSCompiler_temp =
+      null !== current && null === current.memoizedState
+        ? !1
+        : 0 !== (suspenseStackCursor.current & 2));
+  JSCompiler_temp && ((showFallback = !0), (workInProgress.flags &= -129));
+  if (null === current) {
+    if (isHydrating) {
+      showFallback
+        ? pushPrimaryTreeSuspenseHandler(workInProgress)
+        : reuseSuspenseHandlerOnStack();
+      isHydrating &&
+        (((current = nextHydratableInstance),
+        rootOrSingletonContext && advanceToFirstAttemptableSuspenseInstance(),
+        (didSuspend = nextHydratableInstance),
+        didSuspend)
+          ? tryHydrateSuspense(workInProgress, didSuspend) ||
+            (shouldClientRenderOnMismatch(workInProgress) &&
+              throwOnHydrationMismatch(),
+            (nextHydratableInstance = getNextHydratable(
+              didSuspend.nextSibling
+            )),
+            (JSCompiler_temp = hydrationParentFiber),
+            rootOrSingletonContext &&
+              advanceToFirstAttemptableSuspenseInstance(),
+            nextHydratableInstance &&
+            tryHydrateSuspense(workInProgress, nextHydratableInstance)
+              ? deleteHydratableInstance(JSCompiler_temp, didSuspend)
+              : (insertNonHydratedInstance(
+                  hydrationParentFiber,
+                  workInProgress
+                ),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = current)))
+          : (shouldClientRenderOnMismatch(workInProgress) &&
+              throwOnHydrationMismatch(),
+            insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+            (isHydrating = !1),
+            (hydrationParentFiber = workInProgress),
+            (nextHydratableInstance = current)));
+      current = workInProgress.memoizedState;
       if (
-        updateLane !== update.lane
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes$1 & updateLane) === updateLane
+        null !== current &&
+        ((current = current.dehydrated), null !== current)
       )
-        null !== newBaseQueueLast &&
-          (newBaseQueueLast = newBaseQueueLast.next =
-            {
-              lane: 0,
-              action: update.action,
-              hasEagerState: update.hasEagerState,
-              eagerState: update.eagerState,
-              next: null
-            }),
-          (updateLane = update.action),
-          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
-          (current = update.hasEagerState
-            ? update.eagerState
-            : reducer(current, updateLane));
-      else {
-        var clone = {
-          lane: updateLane,
-          action: update.action,
-          hasEagerState: update.hasEagerState,
-          eagerState: update.eagerState,
-          next: null
-        };
-        null === newBaseQueueLast
-          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
-            (baseFirst = current))
-          : (newBaseQueueLast = newBaseQueueLast.next = clone);
-        currentlyRenderingFiber$1.lanes |= updateLane;
-        workInProgressRootSkippedLanes |= updateLane;
-      }
-      update = update.next;
-    } while (null !== update && update !== pendingQueue);
-    null === newBaseQueueLast
-      ? (baseFirst = current)
-      : (newBaseQueueLast.next = newBaseQueueFirst);
-    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = current;
-    hook.baseState = baseFirst;
-    hook.baseQueue = newBaseQueueLast;
-    queue.lastRenderedState = current;
+        return (
+          0 === (workInProgress.mode & 1)
+            ? (workInProgress.lanes = 2)
+            : "$!" === current.data
+            ? (workInProgress.lanes = 16)
+            : (workInProgress.lanes = 1073741824),
+          null
+        );
+      popSuspenseHandler(workInProgress);
+    }
+    current = nextProps.children;
+    didSuspend = nextProps.fallback;
+    if (showFallback)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (current = mountSuspenseFallbackChildren(
+          workInProgress,
+          current,
+          didSuspend,
+          renderLanes
+        )),
+        (nextProps = workInProgress.child),
+        (nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes)),
+        (workInProgress.memoizedState = SUSPENDED_MARKER),
+        enableTransitionTracing &&
+          ((workInProgress = enableTransitionTracing
+            ? transitionStack.current
+            : null),
+          null !== workInProgress &&
+            ((renderLanes = enableTransitionTracing
+              ? markerInstanceStack.current
+              : null),
+            (showFallback = nextProps.updateQueue),
+            null === showFallback
+              ? (nextProps.updateQueue = {
+                  transitions: workInProgress,
+                  markerInstances: renderLanes,
+                  wakeables: null
+                })
+              : ((showFallback.transitions = workInProgress),
+                (showFallback.markerInstances = renderLanes)))),
+        current
+      );
+    if ("number" === typeof nextProps.unstable_expectedLoadTime)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (current = mountSuspenseFallbackChildren(
+          workInProgress,
+          current,
+          didSuspend,
+          renderLanes
+        )),
+        (workInProgress.child.memoizedState =
+          mountSuspenseOffscreenState(renderLanes)),
+        (workInProgress.memoizedState = SUSPENDED_MARKER),
+        (workInProgress.lanes = 8388608),
+        current
+      );
+    pushPrimaryTreeSuspenseHandler(workInProgress);
+    return mountSuspensePrimaryChildren(workInProgress, current);
   }
-  null === baseQueue && (queue.lanes = 0);
-  return [hook.memoizedState, queue.dispatch];
-}
-function rerenderReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var dispatch = queue.dispatch,
-    lastRenderPhaseUpdate = queue.pending,
-    newState = hook.memoizedState;
-  if (null !== lastRenderPhaseUpdate) {
-    queue.pending = null;
-    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
-    do (newState = reducer(newState, update.action)), (update = update.next);
-    while (update !== lastRenderPhaseUpdate);
-    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = newState;
-    null === hook.baseQueue && (hook.baseState = newState);
-    queue.lastRenderedState = newState;
+  JSCompiler_temp = current.memoizedState;
+  if (null !== JSCompiler_temp) {
+    var dehydrated$68 = JSCompiler_temp.dehydrated;
+    if (null !== dehydrated$68)
+      return updateDehydratedSuspenseComponent(
+        current,
+        workInProgress,
+        didSuspend,
+        nextProps,
+        dehydrated$68,
+        JSCompiler_temp,
+        renderLanes
+      );
   }
-  return [newState, dispatch];
-}
-function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
-  var getVersion = source._getVersion;
-  getVersion = getVersion(source._source);
-  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
-  if (null !== JSCompiler_inline_result)
-    root = JSCompiler_inline_result === getVersion;
-  else if (
-    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
-  )
-    (source._workInProgressVersionPrimary = getVersion),
-      workInProgressSources.push(source);
-  if (root) return getSnapshot(source._source);
-  workInProgressSources.push(source);
-  throw Error(formatProdErrorMessage(350));
+  if (showFallback) {
+    reuseSuspenseHandlerOnStack();
+    showFallback = nextProps.fallback;
+    didSuspend = workInProgress.mode;
+    JSCompiler_temp = current.child;
+    dehydrated$68 = JSCompiler_temp.sibling;
+    var primaryChildProps = { mode: "hidden", children: nextProps.children };
+    0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
+      ? ((nextProps = workInProgress.child),
+        (nextProps.childLanes = 0),
+        (nextProps.pendingProps = primaryChildProps),
+        (workInProgress.deletions = null))
+      : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
+        (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
+    null !== dehydrated$68
+      ? (showFallback = createWorkInProgress(dehydrated$68, showFallback))
+      : ((showFallback = createFiberFromFragment(
+          showFallback,
+          didSuspend,
+          renderLanes,
+          null
+        )),
+        (showFallback.flags |= 2));
+    showFallback.return = workInProgress;
+    nextProps.return = workInProgress;
+    nextProps.sibling = showFallback;
+    workInProgress.child = nextProps;
+    nextProps = showFallback;
+    showFallback = workInProgress.child;
+    didSuspend = current.child.memoizedState;
+    null === didSuspend
+      ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
+      : ((JSCompiler_temp = didSuspend.cachePool),
+        null !== JSCompiler_temp
+          ? ((dehydrated$68 = CacheContext._currentValue),
+            (JSCompiler_temp =
+              JSCompiler_temp.parent !== dehydrated$68
+                ? { parent: dehydrated$68, pool: dehydrated$68 }
+                : JSCompiler_temp))
+          : (JSCompiler_temp = getSuspendedCache()),
+        (didSuspend = {
+          baseLanes: didSuspend.baseLanes | renderLanes,
+          cachePool: JSCompiler_temp
+        }));
+    showFallback.memoizedState = didSuspend;
+    enableTransitionTracing &&
+      ((didSuspend = enableTransitionTracing ? transitionStack.current : null),
+      null !== didSuspend &&
+        ((JSCompiler_temp = enableTransitionTracing
+          ? markerInstanceStack.current
+          : null),
+        (dehydrated$68 = showFallback.updateQueue),
+        (primaryChildProps = current.updateQueue),
+        null === dehydrated$68
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables: null
+            })
+          : dehydrated$68 === primaryChildProps
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables:
+                null !== primaryChildProps ? primaryChildProps.wakeables : null
+            })
+          : ((dehydrated$68.transitions = didSuspend),
+            (dehydrated$68.markerInstances = JSCompiler_temp))));
+    showFallback.childLanes = current.childLanes & ~renderLanes;
+    workInProgress.memoizedState = SUSPENDED_MARKER;
+    return nextProps;
+  }
+  pushPrimaryTreeSuspenseHandler(workInProgress);
+  showFallback = current.child;
+  current = showFallback.sibling;
+  nextProps = createWorkInProgress(showFallback, {
+    mode: "visible",
+    children: nextProps.children
+  });
+  0 === (workInProgress.mode & 1) && (nextProps.lanes = renderLanes);
+  nextProps.return = workInProgress;
+  nextProps.sibling = null;
+  null !== current &&
+    ((renderLanes = workInProgress.deletions),
+    null === renderLanes
+      ? ((workInProgress.deletions = [current]), (workInProgress.flags |= 16))
+      : renderLanes.push(current));
+  workInProgress.child = nextProps;
+  workInProgress.memoizedState = null;
+  return nextProps;
 }
-function useMutableSource(hook, source, getSnapshot, subscribe) {
-  var root = workInProgressRoot;
-  if (null === root) throw Error(formatProdErrorMessage(349));
-  var getVersion = source._getVersion,
-    version = getVersion(source._source),
-    dispatcher = ReactCurrentDispatcher$1.current,
-    _dispatcher$useState = dispatcher.useState(function () {
-      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    }),
-    setSnapshot = _dispatcher$useState[1],
-    snapshot = _dispatcher$useState[0];
-  _dispatcher$useState = workInProgressHook;
-  var memoizedState = hook.memoizedState,
-    refs = memoizedState.refs,
-    prevGetSnapshot = refs.getSnapshot,
-    prevSource = memoizedState.source;
-  memoizedState = memoizedState.subscribe;
-  var fiber = currentlyRenderingFiber$1;
-  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
-  dispatcher.useEffect(
-    function () {
-      refs.getSnapshot = getSnapshot;
-      refs.setSnapshot = setSnapshot;
-      var maybeNewVersion = getVersion(source._source);
-      objectIs(version, maybeNewVersion) ||
-        ((maybeNewVersion = getSnapshot(source._source)),
-        objectIs(snapshot, maybeNewVersion) ||
-          (setSnapshot(maybeNewVersion),
-          (maybeNewVersion = requestUpdateLane(fiber)),
-          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
-        markRootEntangled(root, root.mutableReadLanes));
-    },
-    [getSnapshot, source, subscribe]
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
+  primaryChildren = createFiberFromOffscreen(
+    { mode: "visible", children: primaryChildren },
+    workInProgress.mode,
+    0,
+    null
   );
-  dispatcher.useEffect(
-    function () {
-      return subscribe(source._source, function () {
-        var latestGetSnapshot = refs.getSnapshot,
-          latestSetSnapshot = refs.setSnapshot;
-        try {
-          latestSetSnapshot(latestGetSnapshot(source._source));
-          var lane = requestUpdateLane(fiber);
-          root.mutableReadLanes |= lane & root.pendingLanes;
-        } catch (error) {
-          latestSetSnapshot(function () {
-            throw error;
-          });
-        }
-      });
-    },
-    [source, subscribe]
+  primaryChildren.return = workInProgress;
+  return (workInProgress.child = primaryChildren);
+}
+function mountSuspenseFallbackChildren(
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode,
+    progressedPrimaryFragment = workInProgress.child;
+  primaryChildren = { mode: "hidden", children: primaryChildren };
+  0 === (mode & 1) && null !== progressedPrimaryFragment
+    ? ((progressedPrimaryFragment.childLanes = 0),
+      (progressedPrimaryFragment.pendingProps = primaryChildren))
+    : (progressedPrimaryFragment = createFiberFromOffscreen(
+        primaryChildren,
+        mode,
+        0,
+        null
+      ));
+  fallbackChildren = createFiberFromFragment(
+    fallbackChildren,
+    mode,
+    renderLanes,
+    null
   );
-  (objectIs(prevGetSnapshot, getSnapshot) &&
-    objectIs(prevSource, source) &&
-    objectIs(memoizedState, subscribe)) ||
-    ((hook = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: basicStateReducer,
-      lastRenderedState: snapshot
-    }),
-    (hook.dispatch = setSnapshot =
-      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
-    (_dispatcher$useState.queue = hook),
-    (_dispatcher$useState.baseQueue = null),
-    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
-    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
-      snapshot));
-  return snapshot;
+  progressedPrimaryFragment.return = workInProgress;
+  fallbackChildren.return = workInProgress;
+  progressedPrimaryFragment.sibling = fallbackChildren;
+  workInProgress.child = progressedPrimaryFragment;
+  return fallbackChildren;
 }
-function updateMutableSource(source, getSnapshot, subscribe) {
-  var hook = updateWorkInProgressHook();
-  return useMutableSource(hook, source, getSnapshot, subscribe);
+function retrySuspenseComponentWithoutHydrating(
+  current,
+  workInProgress,
+  renderLanes,
+  recoverableError
+) {
+  null !== recoverableError && queueHydrationError(recoverableError);
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  current = mountSuspensePrimaryChildren(
+    workInProgress,
+    workInProgress.pendingProps.children
+  );
+  current.flags |= 2;
+  workInProgress.memoizedState = null;
+  return current;
 }
-function updateSyncExternalStore(subscribe, getSnapshot) {
-  var fiber = currentlyRenderingFiber$1,
-    hook = updateWorkInProgressHook(),
-    nextSnapshot = getSnapshot(),
-    snapshotChanged = !objectIs(
-      (currentHook || hook).memoizedState,
-      nextSnapshot
+function updateDehydratedSuspenseComponent(
+  current,
+  workInProgress,
+  didSuspend,
+  nextProps,
+  suspenseInstance,
+  suspenseState,
+  renderLanes
+) {
+  if (didSuspend) {
+    if (workInProgress.flags & 256)
+      return (
+        pushPrimaryTreeSuspenseHandler(workInProgress),
+        (workInProgress.flags &= -257),
+        (suspenseState = createCapturedValue(
+          Error(formatProdErrorMessage(422))
+        )),
+        retrySuspenseComponentWithoutHydrating(
+          current,
+          workInProgress,
+          renderLanes,
+          suspenseState
+        )
+      );
+    if (null !== workInProgress.memoizedState)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (workInProgress.child = current.child),
+        (workInProgress.flags |= 128),
+        null
+      );
+    reuseSuspenseHandlerOnStack();
+    suspenseState = nextProps.fallback;
+    suspenseInstance = workInProgress.mode;
+    nextProps = createFiberFromOffscreen(
+      { mode: "visible", children: nextProps.children },
+      suspenseInstance,
+      0,
+      null
     );
-  snapshotChanged &&
-    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
-  hook = hook.queue;
-  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
-    subscribe
-  ]);
-  if (
-    hook.getSnapshot !== getSnapshot ||
-    snapshotChanged ||
-    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
-  ) {
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
-      void 0,
+    suspenseState = createFiberFromFragment(
+      suspenseState,
+      suspenseInstance,
+      renderLanes,
       null
     );
-    subscribe = workInProgressRoot;
-    if (null === subscribe) throw Error(formatProdErrorMessage(349));
-    includesBlockingLane(subscribe, renderLanes$1) ||
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    suspenseState.flags |= 2;
+    nextProps.return = workInProgress;
+    suspenseState.return = workInProgress;
+    nextProps.sibling = suspenseState;
+    workInProgress.child = nextProps;
+    0 !== (workInProgress.mode & 1) &&
+      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+    workInProgress.child.memoizedState =
+      mountSuspenseOffscreenState(renderLanes);
+    workInProgress.memoizedState = SUSPENDED_MARKER;
+    return suspenseState;
   }
-  return nextSnapshot;
-}
-function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
-  fiber.flags |= 16384;
-  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
-  getSnapshot = currentlyRenderingFiber$1.updateQueue;
-  null === getSnapshot
-    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
-      (getSnapshot.stores = [fiber]))
-    : ((renderedSnapshot = getSnapshot.stores),
-      null === renderedSnapshot
-        ? (getSnapshot.stores = [fiber])
-        : renderedSnapshot.push(fiber));
-}
-function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
-  inst.value = nextSnapshot;
-  inst.getSnapshot = getSnapshot;
-  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
-}
-function subscribeToStore(fiber, inst, subscribe) {
-  return subscribe(function () {
-    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
-  });
-}
-function checkIfSnapshotChanged(inst) {
-  var latestGetSnapshot = inst.getSnapshot;
-  inst = inst.value;
-  try {
-    var nextValue = latestGetSnapshot();
-    return !objectIs(inst, nextValue);
-  } catch (error) {
-    return !0;
+  pushPrimaryTreeSuspenseHandler(workInProgress);
+  if (0 === (workInProgress.mode & 1))
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      null
+    );
+  if ("$!" === suspenseInstance.data) {
+    suspenseState =
+      suspenseInstance.nextSibling && suspenseInstance.nextSibling.dataset;
+    if (suspenseState) var digest = suspenseState.dgst;
+    suspenseState = digest;
+    nextProps = Error(formatProdErrorMessage(419));
+    nextProps.digest = suspenseState;
+    suspenseState = createCapturedValue(nextProps, suspenseState, void 0);
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      suspenseState
+    );
   }
-}
-function forceStoreRerender(fiber) {
-  var root = enqueueConcurrentRenderForLane(fiber, 2);
-  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
-}
-function mountState(initialState) {
-  var hook = mountWorkInProgressHook();
-  "function" === typeof initialState && (initialState = initialState());
-  hook.memoizedState = hook.baseState = initialState;
-  initialState = {
-    pending: null,
-    lanes: 0,
-    dispatch: null,
-    lastRenderedReducer: basicStateReducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = initialState;
-  initialState = initialState.dispatch = dispatchSetState.bind(
-    null,
-    currentlyRenderingFiber$1,
-    initialState
-  );
-  return [hook.memoizedState, initialState];
-}
-function pushEffect(tag, create, destroy, deps) {
-  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
-  create = currentlyRenderingFiber$1.updateQueue;
-  null === create
-    ? ((create = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = create),
-      (create.lastEffect = tag.next = tag))
-    : ((destroy = create.lastEffect),
-      null === destroy
-        ? (create.lastEffect = tag.next = tag)
-        : ((deps = destroy.next),
-          (destroy.next = tag),
-          (tag.next = deps),
-          (create.lastEffect = tag)));
-  return tag;
-}
-function updateRef() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = mountWorkInProgressHook();
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    1 | hookFlags,
-    create,
-    void 0,
-    void 0 === deps ? null : deps
-  );
-}
-function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var destroy = void 0;
-  if (null !== currentHook) {
-    var prevEffect = currentHook.memoizedState;
-    destroy = prevEffect.destroy;
-    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
-      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
-      return;
+  enableLazyContextPropagation &&
+    !didReceiveUpdate &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !1);
+  digest = 0 !== (renderLanes & current.childLanes);
+  if (didReceiveUpdate || digest) {
+    nextProps = workInProgressRoot;
+    if (null !== nextProps) {
+      suspenseInstance = renderLanes & -renderLanes;
+      if (enableUnifiedSyncLane && 0 !== (suspenseInstance & 42))
+        suspenseInstance = 1;
+      else
+        switch (suspenseInstance) {
+          case 2:
+            suspenseInstance = 1;
+            break;
+          case 8:
+            suspenseInstance = 4;
+            break;
+          case 32:
+            suspenseInstance = 16;
+            break;
+          case 128:
+          case 256:
+          case 512:
+          case 1024:
+          case 2048:
+          case 4096:
+          case 8192:
+          case 16384:
+          case 32768:
+          case 65536:
+          case 131072:
+          case 262144:
+          case 524288:
+          case 1048576:
+          case 2097152:
+          case 4194304:
+          case 8388608:
+          case 16777216:
+          case 33554432:
+          case 67108864:
+            suspenseInstance = 64;
+            break;
+          case 536870912:
+            suspenseInstance = 268435456;
+            break;
+          default:
+            suspenseInstance = 0;
+        }
+      suspenseInstance =
+        0 !== (suspenseInstance & (nextProps.suspendedLanes | renderLanes))
+          ? 0
+          : suspenseInstance;
+      if (
+        0 !== suspenseInstance &&
+        suspenseInstance !== suspenseState.retryLane
+      )
+        throw (
+          ((suspenseState.retryLane = suspenseInstance),
+          enqueueConcurrentRenderForLane(current, suspenseInstance),
+          scheduleUpdateOnFiber(nextProps, current, suspenseInstance, -1),
+          SelectiveHydrationException)
+        );
     }
+    renderDidSuspendDelayIfPossible();
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      null
+    );
   }
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
-}
-function mountEffect(create, deps) {
-  mountEffectImpl(8390656, 8, create, deps);
+  if ("$?" === suspenseInstance.data)
+    return (
+      (workInProgress.flags |= 128),
+      (workInProgress.child = current.child),
+      (workInProgress = retryDehydratedSuspenseBoundary.bind(null, current)),
+      (suspenseInstance._reactRetry = workInProgress),
+      null
+    );
+  current = suspenseState.treeContext;
+  nextHydratableInstance = getNextHydratable(suspenseInstance.nextSibling);
+  hydrationParentFiber = workInProgress;
+  isHydrating = !0;
+  hydrationErrors = null;
+  rootOrSingletonContext = !1;
+  null !== current &&
+    ((idStack[idStackIndex++] = treeContextId),
+    (idStack[idStackIndex++] = treeContextOverflow),
+    (idStack[idStackIndex++] = treeContextProvider),
+    (treeContextId = current.id),
+    (treeContextOverflow = current.overflow),
+    (treeContextProvider = workInProgress));
+  workInProgress = mountSuspensePrimaryChildren(
+    workInProgress,
+    nextProps.children
+  );
+  workInProgress.flags |= 4096;
+  return workInProgress;
 }
-function updateEffect(create, deps) {
-  updateEffectImpl(2048, 8, create, deps);
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes |= renderLanes;
+  var alternate = fiber.alternate;
+  null !== alternate && (alternate.lanes |= renderLanes);
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
 }
-function useEffectEventImpl(payload) {
-  currentlyRenderingFiber$1.flags |= 4;
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
-  if (null === componentUpdateQueue)
-    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
-      (componentUpdateQueue.events = [payload]);
+function initSuspenseListRenderState(
+  workInProgress,
+  isBackwards,
+  tail,
+  lastContentRow,
+  tailMode
+) {
+  var renderState = workInProgress.memoizedState;
+  null === renderState
+    ? (workInProgress.memoizedState = {
+        isBackwards: isBackwards,
+        rendering: null,
+        renderingStartTime: 0,
+        last: lastContentRow,
+        tail: tail,
+        tailMode: tailMode
+      })
+    : ((renderState.isBackwards = isBackwards),
+      (renderState.rendering = null),
+      (renderState.renderingStartTime = 0),
+      (renderState.last = lastContentRow),
+      (renderState.tail = tail),
+      (renderState.tailMode = tailMode));
+}
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    revealOrder = nextProps.revealOrder,
+    tailMode = nextProps.tail;
+  reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
+  nextProps = suspenseStackCursor.current;
+  if (0 !== (nextProps & 2))
+    (nextProps = (nextProps & 1) | 2), (workInProgress.flags |= 128);
   else {
-    var events = componentUpdateQueue.events;
-    null === events
-      ? (componentUpdateQueue.events = [payload])
-      : events.push(payload);
+    if (null !== current && 0 !== (current.flags & 128))
+      a: for (current = workInProgress.child; null !== current; ) {
+        if (13 === current.tag)
+          null !== current.memoizedState &&
+            scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
+        else if (19 === current.tag)
+          scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
+        else if (null !== current.child) {
+          current.child.return = current;
+          current = current.child;
+          continue;
+        }
+        if (current === workInProgress) break a;
+        for (; null === current.sibling; ) {
+          if (null === current.return || current.return === workInProgress)
+            break a;
+          current = current.return;
+        }
+        current.sibling.return = current.return;
+        current = current.sibling;
+      }
+    nextProps &= 1;
   }
+  push(suspenseStackCursor, nextProps);
+  if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;
+  else
+    switch (revealOrder) {
+      case "forwards":
+        renderLanes = workInProgress.child;
+        for (revealOrder = null; null !== renderLanes; )
+          (current = renderLanes.alternate),
+            null !== current &&
+              null === findFirstSuspended(current) &&
+              (revealOrder = renderLanes),
+            (renderLanes = renderLanes.sibling);
+        renderLanes = revealOrder;
+        null === renderLanes
+          ? ((revealOrder = workInProgress.child),
+            (workInProgress.child = null))
+          : ((revealOrder = renderLanes.sibling), (renderLanes.sibling = null));
+        initSuspenseListRenderState(
+          workInProgress,
+          !1,
+          revealOrder,
+          renderLanes,
+          tailMode
+        );
+        break;
+      case "backwards":
+        renderLanes = null;
+        revealOrder = workInProgress.child;
+        for (workInProgress.child = null; null !== revealOrder; ) {
+          current = revealOrder.alternate;
+          if (null !== current && null === findFirstSuspended(current)) {
+            workInProgress.child = revealOrder;
+            break;
+          }
+          current = revealOrder.sibling;
+          revealOrder.sibling = renderLanes;
+          renderLanes = revealOrder;
+          revealOrder = current;
+        }
+        initSuspenseListRenderState(
+          workInProgress,
+          !0,
+          renderLanes,
+          null,
+          tailMode
+        );
+        break;
+      case "together":
+        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+        break;
+      default:
+        workInProgress.memoizedState = null;
+    }
+  return workInProgress.child;
 }
-function updateEvent(callback) {
-  var ref = updateWorkInProgressHook().memoizedState;
-  useEffectEventImpl({ ref: ref, nextImpl: callback });
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  0 === (workInProgress.mode & 1) &&
+    null !== current &&
+    ((current.alternate = null),
+    (workInProgress.alternate = null),
+    (workInProgress.flags |= 2));
 }
-function updateInsertionEffect(create, deps) {
-  return updateEffectImpl(4, 2, create, deps);
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  null !== current && (workInProgress.dependencies = current.dependencies);
+  workInProgressRootSkippedLanes |= workInProgress.lanes;
+  if (0 === (renderLanes & workInProgress.childLanes))
+    if (enableLazyContextPropagation && null !== current) {
+      if (
+        (propagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+          !1
+        ),
+        0 === (renderLanes & workInProgress.childLanes))
+      )
+        return null;
+    } else return null;
+  if (null !== current && workInProgress.child !== current.child)
+    throw Error(formatProdErrorMessage(153));
+  if (null !== workInProgress.child) {
+    current = workInProgress.child;
+    renderLanes = createWorkInProgress(current, current.pendingProps);
+    workInProgress.child = renderLanes;
+    for (renderLanes.return = workInProgress; null !== current.sibling; )
+      (current = current.sibling),
+        (renderLanes = renderLanes.sibling =
+          createWorkInProgress(current, current.pendingProps)),
+        (renderLanes.return = workInProgress);
+    renderLanes.sibling = null;
+  }
+  return workInProgress.child;
 }
-function updateLayoutEffect(create, deps) {
-  return updateEffectImpl(4, 4, create, deps);
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  return 0 !== (current.lanes & renderLanes) ||
+    (enableLazyContextPropagation &&
+      ((current = current.dependencies),
+      null !== current && checkIfContextChanged(current)))
+    ? !0
+    : !1;
 }
-function imperativeHandleEffect(create, ref) {
-  if ("function" === typeof ref)
-    return (
-      (create = create()),
-      ref(create),
-      function () {
-        ref(null);
+function attemptEarlyBailoutIfNoScheduledUpdate(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  switch (workInProgress.tag) {
+    case 3:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      enableTransitionTracing &&
+        push(transitionStack, workInProgressTransitions);
+      enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      resetHydrationState();
+      break;
+    case 27:
+    case 5:
+      pushHostContext(workInProgress);
+      break;
+    case 4:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+    case 10:
+      pushProvider(
+        workInProgress,
+        workInProgress.type._context,
+        workInProgress.memoizedProps.value
+      );
+      break;
+    case 13:
+      var state = workInProgress.memoizedState;
+      if (null !== state) {
+        if (null !== state.dehydrated)
+          return (
+            pushPrimaryTreeSuspenseHandler(workInProgress),
+            (workInProgress.flags |= 128),
+            null
+          );
+        if (0 !== (renderLanes & workInProgress.child.childLanes))
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+        current = bailoutOnAlreadyFinishedWork(
+          current,
+          workInProgress,
+          renderLanes
+        );
+        return null !== current ? current.sibling : null;
       }
-    );
-  if (null !== ref && void 0 !== ref)
-    return (
-      (create = create()),
-      (ref.current = create),
-      function () {
-        ref.current = null;
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      break;
+    case 19:
+      var didSuspendBefore = 0 !== (current.flags & 128);
+      state = 0 !== (renderLanes & workInProgress.childLanes);
+      enableLazyContextPropagation &&
+        !state &&
+        (propagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+          !1
+        ),
+        (state = 0 !== (renderLanes & workInProgress.childLanes)));
+      if (didSuspendBefore) {
+        if (state)
+          return updateSuspenseListComponent(
+            current,
+            workInProgress,
+            renderLanes
+          );
+        workInProgress.flags |= 128;
       }
-    );
-}
-function updateImperativeHandle(ref, create, deps) {
-  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+      didSuspendBefore = workInProgress.memoizedState;
+      null !== didSuspendBefore &&
+        ((didSuspendBefore.rendering = null),
+        (didSuspendBefore.tail = null),
+        (didSuspendBefore.lastEffect = null));
+      push(suspenseStackCursor, suspenseStackCursor.current);
+      if (state) break;
+      else return null;
+    case 22:
+    case 23:
+      return (
+        (workInProgress.lanes = 0),
+        updateOffscreenComponent(current, workInProgress, renderLanes)
+      );
+    case 24:
+      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        ((state = workInProgress.stateNode),
+        null !== state && pushMarkerInstance(workInProgress, state));
+  }
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
 }
-function mountDebugValue() {}
-function updateCallback(callback, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  hook.memoizedState = [callback, deps];
-  return callback;
+var valueCursor = createCursor(null),
+  currentlyRenderingFiber = null,
+  lastContextDependency = null,
+  lastFullyObservedContext = null;
+function resetContextDependencies() {
+  lastFullyObservedContext =
+    lastContextDependency =
+    currentlyRenderingFiber =
+      null;
 }
-function updateMemo(nextCreate, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-  nextCreate = nextCreate();
-  hook.memoizedState = [nextCreate, deps];
-  return nextCreate;
+function pushProvider(providerFiber, context, nextValue) {
+  push(valueCursor, context._currentValue);
+  context._currentValue = nextValue;
 }
-function updateDeferredValueImpl(hook, prevValue, value) {
-  if (0 === (renderLanes$1 & 42))
-    return (
-      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
-      (hook.memoizedState = value)
-    );
-  objectIs(value, prevValue) ||
-    ((value = claimNextTransitionLane()),
-    (currentlyRenderingFiber$1.lanes |= value),
-    (workInProgressRootSkippedLanes |= value),
-    (hook.baseState = !0));
-  return prevValue;
+function popProvider(context) {
+  var currentValue = valueCursor.current;
+  context._currentValue =
+    currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED
+      ? context._defaultValue
+      : currentValue;
+  pop(valueCursor);
 }
-function startTransition(setPending, callback, options) {
-  var previousPriority = currentUpdatePriority;
-  currentUpdatePriority =
-    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
-  setPending(!0);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
-  enableTransitionTracing &&
-    void 0 !== options &&
-    void 0 !== options.name &&
-    ((ReactCurrentBatchConfig$2.transition.name = options.name),
-    (ReactCurrentBatchConfig$2.transition.startTime = now()));
-  try {
-    setPending(!1), callback();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$2.transition = prevTransition);
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  for (; null !== parent; ) {
+    var alternate = parent.alternate;
+    (parent.childLanes & renderLanes) !== renderLanes
+      ? ((parent.childLanes |= renderLanes),
+        null !== alternate && (alternate.childLanes |= renderLanes))
+      : null !== alternate &&
+        (alternate.childLanes & renderLanes) !== renderLanes &&
+        (alternate.childLanes |= renderLanes);
+    if (parent === propagationRoot) break;
+    parent = parent.return;
   }
 }
-function updateId() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function updateRefresh() {
-  return updateWorkInProgressHook().memoizedState;
+function propagateContextChange(workInProgress, context, renderLanes) {
+  if (enableLazyContextPropagation)
+    propagateContextChanges(workInProgress, [context], renderLanes, !0);
+  else if (!enableLazyContextPropagation) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber; ) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        for (var dependency = list.firstContext; null !== dependency; ) {
+          if (dependency.context === context) {
+            if (1 === fiber.tag) {
+              dependency = createUpdate(renderLanes & -renderLanes);
+              dependency.tag = 2;
+              var updateQueue = fiber.updateQueue;
+              if (null !== updateQueue) {
+                updateQueue = updateQueue.shared;
+                var pending = updateQueue.pending;
+                null === pending
+                  ? (dependency.next = dependency)
+                  : ((dependency.next = pending.next),
+                    (pending.next = dependency));
+                updateQueue.pending = dependency;
+              }
+            }
+            fiber.lanes |= renderLanes;
+            dependency = fiber.alternate;
+            null !== dependency && (dependency.lanes |= renderLanes);
+            scheduleContextWorkOnParentPath(
+              fiber.return,
+              renderLanes,
+              workInProgress
+            );
+            list.lanes |= renderLanes;
+            break;
+          }
+          dependency = dependency.next;
+        }
+      } else if (10 === fiber.tag)
+        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+      else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = fiber.sibling;
+      } else 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 refreshCache(fiber, seedKey, seedValue) {
-  for (var provider = fiber.return; null !== provider; ) {
-    switch (provider.tag) {
-      case 24:
-      case 3:
-        var lane = requestUpdateLane(provider);
-        fiber = createUpdate(lane);
-        var root$94 = enqueueUpdate(provider, fiber, lane);
-        if (null !== root$94) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root$94, provider, lane, eventTime);
-          entangleTransitions(root$94, provider, lane);
+function propagateContextChanges(
+  workInProgress,
+  contexts,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (enableLazyContextPropagation) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber; ) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        list = list.firstContext;
+        a: for (; null !== list; ) {
+          var dependency = list;
+          list = fiber;
+          for (var i = 0; i < contexts.length; i++)
+            if (dependency.context === contexts[i]) {
+              list.lanes |= renderLanes;
+              dependency = list.alternate;
+              null !== dependency && (dependency.lanes |= renderLanes);
+              scheduleContextWorkOnParentPath(
+                list.return,
+                renderLanes,
+                workInProgress
+              );
+              forcePropagateEntireTree || (nextFiber = null);
+              break a;
+            }
+          list = dependency.next;
         }
-        provider = createCache();
-        null !== seedKey &&
-          void 0 !== seedKey &&
-          null !== root$94 &&
-          provider.data.set(seedKey, seedValue);
-        fiber.payload = { cache: provider };
-        return;
+      } else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = null;
+      } else 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;
     }
-    provider = provider.return;
   }
 }
-function dispatchReducerAction(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber);
-  action = {
-    lane: lane,
-    action: action,
-    hasEagerState: !1,
-    eagerState: null,
-    next: null
-  };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
-  else if (
-    (enqueueUpdate$1(fiber, queue, action, lane),
-    (action = getRootForUpdatedFiber(fiber)),
-    null !== action)
-  ) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
-    entangleTransitionUpdate(action, queue, lane);
+function propagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (enableLazyContextPropagation) {
+    current = null;
+    for (
+      var parent = workInProgress, isInsidePropagationBailout = !1;
+      null !== parent;
+
+    ) {
+      if (!isInsidePropagationBailout)
+        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
+        else if (0 !== (parent.flags & 262144)) break;
+      if (10 === parent.tag) {
+        var currentParent = parent.alternate;
+        if (null === currentParent) throw Error(formatProdErrorMessage(387));
+        currentParent = currentParent.memoizedProps;
+        if (null !== currentParent) {
+          var context = parent.type._context;
+          objectIs(parent.pendingProps.value, currentParent.value) ||
+            (null !== current ? current.push(context) : (current = [context]));
+        }
+      }
+      parent = parent.return;
+    }
+    null !== current &&
+      propagateContextChanges(
+        workInProgress,
+        current,
+        renderLanes,
+        forcePropagateEntireTree
+      );
+    workInProgress.flags |= 262144;
   }
 }
-function dispatchSetState(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber),
-    update = {
-      lane: lane,
-      action: action,
-      hasEagerState: !1,
-      eagerState: null,
-      next: null
-    };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
-  else {
-    var alternate = fiber.alternate;
+function checkIfContextChanged(currentDependencies) {
+  if (!enableLazyContextPropagation) return !1;
+  for (
+    currentDependencies = currentDependencies.firstContext;
+    null !== currentDependencies;
+
+  ) {
     if (
-      0 === fiber.lanes &&
-      (null === alternate || 0 === alternate.lanes) &&
-      ((alternate = queue.lastRenderedReducer), null !== alternate)
+      !objectIs(
+        currentDependencies.context._currentValue,
+        currentDependencies.memoizedValue
+      )
     )
-      try {
-        var currentState = queue.lastRenderedState,
-          eagerState = alternate(currentState, action);
-        update.hasEagerState = !0;
-        update.eagerState = eagerState;
-        if (objectIs(eagerState, currentState)) {
-          enqueueUpdate$1(fiber, queue, update, 0);
-          null === workInProgressRoot && finishQueueingConcurrentUpdates();
-          return;
-        }
-      } catch (error) {
-      } finally {
-      }
-    enqueueUpdate$1(fiber, queue, update, lane);
-    action = getRootForUpdatedFiber(fiber);
-    null !== action &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(action, fiber, lane, update),
-      entangleTransitionUpdate(action, queue, lane));
+      return !0;
+    currentDependencies = currentDependencies.next;
   }
+  return !1;
 }
-function isRenderPhaseUpdate(fiber) {
-  var alternate = fiber.alternate;
-  return (
-    fiber === currentlyRenderingFiber$1 ||
-    (null !== alternate && alternate === currentlyRenderingFiber$1)
-  );
+function prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastFullyObservedContext = lastContextDependency = null;
+  workInProgress = workInProgress.dependencies;
+  null !== workInProgress &&
+    (enableLazyContextPropagation
+      ? (workInProgress.firstContext = null)
+      : null !== workInProgress.firstContext &&
+        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
+        (workInProgress.firstContext = null)));
 }
-function enqueueRenderPhaseUpdate(queue, update) {
-  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
-    !0;
-  var pending = queue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  queue.pending = update;
+function readContext(context) {
+  return readContextForConsumer(currentlyRenderingFiber, context);
 }
-function entangleTransitionUpdate(root, queue, lane) {
-  if (0 !== (lane & 8388480)) {
-    var queueLanes = queue.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    queue.lanes = lane;
-    markRootEntangled(root, lane);
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  null === currentlyRenderingFiber &&
+    prepareToReadContext(consumer, renderLanes);
+  return readContextForConsumer(consumer, context);
+}
+function readContextForConsumer(consumer, context) {
+  var value = context._currentValue;
+  if (lastFullyObservedContext !== context)
+    if (
+      ((context = { context: context, memoizedValue: value, next: null }),
+      null === lastContextDependency)
+    ) {
+      if (null === consumer) throw Error(formatProdErrorMessage(308));
+      lastContextDependency = context;
+      consumer.dependencies = { lanes: 0, firstContext: context };
+      enableLazyContextPropagation && (consumer.flags |= 524288);
+    } else lastContextDependency = lastContextDependency.next = context;
+  return value;
+}
+var AbortControllerLocal =
+    "undefined" !== typeof AbortController
+      ? AbortController
+      : function () {
+          var listeners = [],
+            signal = (this.signal = {
+              aborted: !1,
+              addEventListener: function (type, listener) {
+                listeners.push(listener);
+              }
+            });
+          this.abort = function () {
+            signal.aborted = !0;
+            listeners.forEach(function (listener) {
+              return listener();
+            });
+          };
+        },
+  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+  NormalPriority = Scheduler.unstable_NormalPriority,
+  CacheContext = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    Consumer: null,
+    Provider: null,
+    _currentValue: null,
+    _currentValue2: null,
+    _threadCount: 0,
+    _defaultValue: null,
+    _globalName: null
+  };
+function createCache() {
+  return {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+}
+function releaseCache(cache) {
+  cache.refCount--;
+  0 === cache.refCount &&
+    scheduleCallback$1(NormalPriority, function () {
+      cache.controller.abort();
+    });
+}
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
+  resumedCache = createCursor(null),
+  transitionStack = createCursor(null);
+function peekCacheFromPool() {
+  var cacheResumedFromPreviousRender = resumedCache.current;
+  return null !== cacheResumedFromPreviousRender
+    ? cacheResumedFromPreviousRender
+    : workInProgressRoot.pooledCache;
+}
+function pushTransition(
+  offscreenWorkInProgress,
+  prevCachePool,
+  newTransitions
+) {
+  null === prevCachePool
+    ? push(resumedCache, resumedCache.current)
+    : push(resumedCache, prevCachePool.pool);
+  enableTransitionTracing &&
+    (null === transitionStack.current
+      ? push(transitionStack, newTransitions)
+      : null === newTransitions
+      ? push(transitionStack, transitionStack.current)
+      : push(transitionStack, transitionStack.current.concat(newTransitions)));
+}
+function popTransition(workInProgress, current) {
+  null !== current &&
+    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
+}
+function getSuspendedCache() {
+  var cacheFromPool = peekCacheFromPool();
+  return null === cacheFromPool
+    ? null
+    : { parent: CacheContext._currentValue, pool: cacheFromPool };
+}
+var emptyObject = {};
+function collectScopedNodesFromChildren(
+  startingChild,
+  fn$jscomp$0,
+  scopedNodes$jscomp$0
+) {
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      fn = fn$jscomp$0,
+      scopedNodes = scopedNodes$jscomp$0;
+    if (5 === node.tag) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        instance = node.stateNode;
+      null !== instance &&
+        !0 === fn(type, memoizedProps || emptyObject, instance) &&
+        scopedNodes.push(instance);
+    }
+    type = node.child;
+    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
+    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
+    startingChild = startingChild.sibling;
   }
 }
-var ContextOnlyDispatcher = {
-  readContext: readContext,
-  useCallback: throwInvalidHookError,
-  useContext: throwInvalidHookError,
-  useEffect: throwInvalidHookError,
-  useImperativeHandle: throwInvalidHookError,
-  useInsertionEffect: throwInvalidHookError,
-  useLayoutEffect: throwInvalidHookError,
-  useMemo: throwInvalidHookError,
-  useReducer: throwInvalidHookError,
-  useRef: throwInvalidHookError,
-  useState: throwInvalidHookError,
-  useDebugValue: throwInvalidHookError,
-  useDeferredValue: throwInvalidHookError,
-  useTransition: throwInvalidHookError,
-  useMutableSource: throwInvalidHookError,
-  useSyncExternalStore: throwInvalidHookError,
-  useId: throwInvalidHookError
-};
-ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
-ContextOnlyDispatcher.use = throwInvalidHookError;
-ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
-ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
-var HooksDispatcherOnMount = {
-  readContext: readContext,
-  useCallback: function (callback, deps) {
-    mountWorkInProgressHook().memoizedState = [
-      callback,
-      void 0 === deps ? null : deps
-    ];
-    return callback;
-  },
-  useContext: readContext,
-  useEffect: mountEffect,
-  useImperativeHandle: function (ref, create, deps) {
-    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-    mountEffectImpl(
-      4194308,
-      4,
-      imperativeHandleEffect.bind(null, create, ref),
-      deps
-    );
-  },
-  useLayoutEffect: function (create, deps) {
-    return mountEffectImpl(4194308, 4, create, deps);
-  },
-  useInsertionEffect: function (create, deps) {
-    mountEffectImpl(4, 2, create, deps);
-  },
-  useMemo: function (nextCreate, deps) {
-    var hook = mountWorkInProgressHook();
-    deps = void 0 === deps ? null : deps;
-    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-    nextCreate = nextCreate();
-    hook.memoizedState = [nextCreate, deps];
-    return nextCreate;
-  },
-  useReducer: function (reducer, initialArg, init) {
-    var hook = mountWorkInProgressHook();
-    initialArg = void 0 !== init ? init(initialArg) : initialArg;
-    hook.memoizedState = hook.baseState = initialArg;
-    reducer = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: reducer,
-      lastRenderedState: initialArg
-    };
-    hook.queue = reducer;
-    reducer = reducer.dispatch = dispatchReducerAction.bind(
-      null,
-      currentlyRenderingFiber$1,
-      reducer
-    );
-    return [hook.memoizedState, reducer];
-  },
-  useRef: function (initialValue) {
-    var hook = mountWorkInProgressHook();
-    if (enableUseRefAccessWarning)
-      return (
-        (initialValue = { current: initialValue }),
-        (hook.memoizedState = initialValue)
-      );
-    initialValue = { current: initialValue };
-    return (hook.memoizedState = initialValue);
-  },
-  useState: mountState,
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    return (mountWorkInProgressHook().memoizedState = value);
-  },
-  useTransition: function () {
-    var _mountState = mountState(!1),
-      isPending = _mountState[0];
-    _mountState = startTransition.bind(null, _mountState[1]);
-    mountWorkInProgressHook().memoizedState = _mountState;
-    return [isPending, _mountState];
-  },
-  useMutableSource: function (source, getSnapshot, subscribe) {
-    var hook = mountWorkInProgressHook();
-    hook.memoizedState = {
-      refs: { getSnapshot: getSnapshot, setSnapshot: null },
-      source: source,
-      subscribe: subscribe
-    };
-    return useMutableSource(hook, source, getSnapshot, subscribe);
-  },
-  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-    var fiber = currentlyRenderingFiber$1,
-      hook = mountWorkInProgressHook();
-    if (isHydrating) {
-      if (void 0 === getServerSnapshot)
-        throw Error(formatProdErrorMessage(407));
-      getServerSnapshot = getServerSnapshot();
-    } else {
-      getServerSnapshot = getSnapshot();
-      var root$90 = workInProgressRoot;
-      if (null === root$90) throw Error(formatProdErrorMessage(349));
-      includesBlockingLane(root$90, renderLanes$1) ||
-        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
-    }
-    hook.memoizedState = getServerSnapshot;
-    root$90 = { value: getServerSnapshot, getSnapshot: getSnapshot };
-    hook.queue = root$90;
-    mountEffect(subscribeToStore.bind(null, fiber, root$90, subscribe), [
-      subscribe
-    ]);
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(
-        null,
-        fiber,
-        root$90,
-        getServerSnapshot,
-        getSnapshot
-      ),
-      void 0,
-      null
-    );
-    return getServerSnapshot;
-  },
-  useId: function () {
-    var hook = mountWorkInProgressHook(),
-      identifierPrefix = workInProgressRoot.identifierPrefix;
-    if (isHydrating) {
-      var JSCompiler_inline_result = treeContextOverflow;
-      var idWithLeadingBit = treeContextId;
+function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
+  for (; null !== startingChild; ) {
+    a: {
+      var JSCompiler_inline_result = startingChild;
+      var fn = fn$jscomp$0;
+      if (5 === JSCompiler_inline_result.tag) {
+        var type = JSCompiler_inline_result.type,
+          memoizedProps = JSCompiler_inline_result.memoizedProps,
+          instance = JSCompiler_inline_result.stateNode;
+        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
+          JSCompiler_inline_result = instance;
+          break a;
+        }
+      }
+      type = JSCompiler_inline_result.child;
+      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
+        (type = JSCompiler_inline_result.child.sibling.child);
       JSCompiler_inline_result =
-        (
-          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
-        ).toString(32) + JSCompiler_inline_result;
-      identifierPrefix =
-        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
-      JSCompiler_inline_result = localIdCounter++;
-      0 < JSCompiler_inline_result &&
-        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
-      identifierPrefix += ":";
-    } else
-      (JSCompiler_inline_result = globalClientIdCounter++),
-        (identifierPrefix =
-          ":" +
-          identifierPrefix +
-          "r" +
-          JSCompiler_inline_result.toString(32) +
-          ":");
-    return (hook.memoizedState = identifierPrefix);
-  },
-  useCacheRefresh: function () {
-    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
-      null,
-      currentlyRenderingFiber$1
-    ));
+        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
+    }
+    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
+    startingChild = startingChild.sibling;
   }
-};
-HooksDispatcherOnMount.use = use;
-HooksDispatcherOnMount.useMemoCache = useMemoCache;
-HooksDispatcherOnMount.useEffectEvent = function (callback) {
-  var hook = mountWorkInProgressHook(),
-    ref = { impl: callback };
-  hook.memoizedState = ref;
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
-};
-var HooksDispatcherOnUpdate = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: updateReducer,
-  useRef: updateRef,
-  useState: function () {
-    return updateReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = updateReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
-HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
-HooksDispatcherOnUpdate.use = use;
-HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
-var HooksDispatcherOnRerender = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: rerenderReducer,
-  useRef: updateRef,
-  useState: function () {
-    return rerenderReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return null === currentHook
-      ? (hook.memoizedState = value)
-      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = rerenderReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
-HooksDispatcherOnRerender.use = use;
-HooksDispatcherOnRerender.useMemoCache = useMemoCache;
-HooksDispatcherOnRerender.useEffectEvent = updateEvent;
-function resolveDefaultProps(Component, baseProps) {
-  if (Component && Component.defaultProps) {
-    baseProps = assign({}, baseProps);
-    Component = Component.defaultProps;
-    for (var propName in Component)
-      void 0 === baseProps[propName] &&
-        (baseProps[propName] = Component[propName]);
-    return baseProps;
-  }
-  return baseProps;
+  return null;
 }
-function applyDerivedStateFromProps(
-  workInProgress,
-  ctor,
-  getDerivedStateFromProps,
-  nextProps
+function collectNearestChildContextValues(
+  startingChild,
+  context$jscomp$0,
+  childContextValues$jscomp$0
 ) {
-  ctor = workInProgress.memoizedState;
-  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
-  getDerivedStateFromProps =
-    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
-      ? ctor
-      : assign({}, ctor, getDerivedStateFromProps);
-  workInProgress.memoizedState = getDerivedStateFromProps;
-  0 === workInProgress.lanes &&
-    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
-}
-var classComponentUpdater = {
-  isMounted: function (component) {
-    return (component = component._reactInternals)
-      ? getNearestMountedFiber(component) === component
-      : !1;
-  },
-  enqueueSetState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-  },
-  enqueueReplaceState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 1;
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-  },
-  enqueueForceUpdate: function (inst, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 2;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    callback = enqueueUpdate(inst, update, lane);
-    null !== callback &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(callback, inst, lane, update),
-      entangleTransitions(callback, inst, lane));
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      context = context$jscomp$0,
+      childContextValues = childContextValues$jscomp$0;
+    if (10 === node.tag && node.type._context === context)
+      childContextValues.push(node.memoizedProps.value);
+    else {
+      var child = node.child;
+      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
+      null !== child &&
+        collectNearestChildContextValues(child, context, childContextValues);
+    }
+    startingChild = startingChild.sibling;
   }
-};
-function checkShouldComponentUpdate(
-  workInProgress,
-  ctor,
-  oldProps,
-  newProps,
-  oldState,
-  newState,
-  nextContext
-) {
-  workInProgress = workInProgress.stateNode;
-  return "function" === typeof workInProgress.shouldComponentUpdate
-    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
-    : ctor.prototype && ctor.prototype.isPureReactComponent
-    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
-    : !0;
-}
-function constructClassInstance(workInProgress, ctor, props) {
-  var context = emptyContextObject,
-    contextType = ctor.contextType;
-  "object" === typeof contextType &&
-    null !== contextType &&
-    (context = readContext(contextType));
-  ctor = new ctor(props, context);
-  workInProgress.memoizedState =
-    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
-  ctor.updater = classComponentUpdater;
-  workInProgress.stateNode = ctor;
-  ctor._reactInternals = workInProgress;
-  return ctor;
 }
-function callComponentWillReceiveProps(
-  workInProgress,
-  instance,
-  newProps,
-  nextContext
-) {
-  workInProgress = instance.state;
-  "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, nextContext);
-  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
-  instance.state !== workInProgress &&
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  var scopedNodes = [];
+  null !== currentFiber &&
+    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
+  return 0 === scopedNodes.length ? null : scopedNodes;
 }
-function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  var instance = workInProgress.stateNode;
-  instance.props = newProps;
-  instance.state = workInProgress.memoizedState;
-  instance.refs = {};
-  initializeUpdateQueue(workInProgress);
-  var contextType = ctor.contextType;
-  instance.context =
-    "object" === typeof contextType && null !== contextType
-      ? readContext(contextType)
-      : emptyContextObject;
-  instance.state = workInProgress.memoizedState;
-  contextType = ctor.getDerivedStateFromProps;
-  "function" === typeof contextType &&
-    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof ctor.getDerivedStateFromProps ||
-    "function" === typeof instance.getSnapshotBeforeUpdate ||
-    ("function" !== typeof instance.UNSAFE_componentWillMount &&
-      "function" !== typeof instance.componentWillMount) ||
-    ((ctor = instance.state),
-    "function" === typeof instance.componentWillMount &&
-      instance.componentWillMount(),
-    "function" === typeof instance.UNSAFE_componentWillMount &&
-      instance.UNSAFE_componentWillMount(),
-    ctor !== instance.state &&
-      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
-    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof instance.componentDidMount &&
-    (workInProgress.flags |= 4194308);
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  return null !== currentFiber
+    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
+    : null;
 }
-function createCapturedValueAtFiber(value, source) {
-  try {
-    var info = "",
-      node = source;
-    do (info += describeFiber(node)), (node = node.return);
-    while (node);
-    var JSCompiler_inline_result = info;
-  } catch (x) {
-    JSCompiler_inline_result =
-      "\nError generating stack: " + x.message + "\n" + x.stack;
+function containsNode$1(node) {
+  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
+    if (21 === node.tag && node.stateNode === this) return !0;
+    node = node.return;
   }
-  return {
-    value: value,
-    source: source,
-    stack: JSCompiler_inline_result,
-    digest: null
-  };
+  return !1;
 }
-function createCapturedValue(value, digest, stack) {
-  return {
-    value: value,
-    source: null,
-    stack: null != stack ? stack : null,
-    digest: null != digest ? digest : null
-  };
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return [];
+  currentFiber = currentFiber.child;
+  var childContextValues = [];
+  null !== currentFiber &&
+    collectNearestChildContextValues(currentFiber, context, childContextValues);
+  return childContextValues;
 }
-var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
-if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
-  throw Error(formatProdErrorMessage(320));
-function logCapturedError(boundary, errorInfo) {
-  try {
-    !1 !==
-      ReactFiberErrorDialogWWW.showErrorDialog({
-        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
-        error: errorInfo.value,
-        errorBoundary:
-          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
-      }) && console.error(errorInfo.value);
-  } catch (e$99) {
-    setTimeout(function () {
-      throw e$99;
-    });
-  }
+function markUpdate(workInProgress) {
+  workInProgress.flags |= 4;
 }
-function createRootErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  lane.payload = { element: null };
-  var error = errorInfo.value;
-  lane.callback = function () {
-    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
-    logCapturedError(fiber, errorInfo);
-  };
-  return lane;
+function markRef(workInProgress) {
+  workInProgress.flags |= 2097664;
 }
-function createClassErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
-  if ("function" === typeof getDerivedStateFromError) {
-    var error = errorInfo.value;
-    lane.payload = function () {
-      return getDerivedStateFromError(error);
-    };
-    lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-    };
-  }
-  var inst = fiber.stateNode;
-  null !== inst &&
-    "function" === typeof inst.componentDidCatch &&
-    (lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-      "function" !== typeof getDerivedStateFromError &&
-        (null === legacyErrorBoundariesThatAlreadyFailed
-          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
-          : legacyErrorBoundariesThatAlreadyFailed.add(this));
-      var stack = errorInfo.stack;
-      this.componentDidCatch(errorInfo.value, {
-        componentStack: null !== stack ? stack : ""
-      });
-    });
-  return lane;
-}
-function markSuspenseBoundaryShouldCapture(
-  suspenseBoundary,
-  returnFiber,
-  sourceFiber,
-  root,
-  rootRenderLanes
-) {
-  if (0 === (suspenseBoundary.mode & 1))
-    return (
-      suspenseBoundary === returnFiber
-        ? (suspenseBoundary.flags |= 65536)
-        : ((suspenseBoundary.flags |= 128),
-          (sourceFiber.flags |= 131072),
-          (sourceFiber.flags &= -52805),
-          1 === sourceFiber.tag &&
-            (null === sourceFiber.alternate
-              ? (sourceFiber.tag = 17)
-              : ((returnFiber = createUpdate(2)),
-                (returnFiber.tag = 2),
-                enqueueUpdate(sourceFiber, returnFiber, 2))),
-          (sourceFiber.lanes |= 2)),
-      suspenseBoundary
-    );
-  suspenseBoundary.flags |= 65536;
-  suspenseBoundary.lanes = rootRenderLanes;
-  return suspenseBoundary;
-}
-function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
-  if (enableTransitionTracing && null !== pendingTransitions) {
-    var transitionStart = pendingTransitions.transitionStart,
-      onTransitionStart = callbacks.onTransitionStart;
-    null !== transitionStart &&
-      null != onTransitionStart &&
-      transitionStart.forEach(function (transition) {
-        return onTransitionStart(transition.name, transition.startTime);
-      });
-    transitionStart = pendingTransitions.markerProgress;
-    var onMarkerProgress = callbacks.onMarkerProgress;
-    null != onMarkerProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (markerInstance, markerName) {
-        if (null !== markerInstance.transitions) {
-          var pending =
-            null !== markerInstance.pendingBoundaries
-              ? Array.from(markerInstance.pendingBoundaries.values())
-              : [];
-          markerInstance.transitions.forEach(function (transition) {
-            onMarkerProgress(
-              transition.name,
-              markerName,
-              transition.startTime,
-              endTime,
-              pending
-            );
-          });
-        }
-      });
-    transitionStart = pendingTransitions.markerComplete;
-    var onMarkerComplete = callbacks.onMarkerComplete;
-    null !== transitionStart &&
-      null != onMarkerComplete &&
-      transitionStart.forEach(function (transitions, markerName) {
-        transitions.forEach(function (transition) {
-          onMarkerComplete(
-            transition.name,
-            markerName,
-            transition.startTime,
-            endTime
-          );
-        });
-      });
-    transitionStart = pendingTransitions.markerIncomplete;
-    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
-    null != onMarkerIncomplete &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (_ref, markerName) {
-        var aborts = _ref.aborts;
-        _ref.transitions.forEach(function (transition) {
-          var filteredAborts = [];
-          aborts.forEach(function (abort) {
-            switch (abort.reason) {
-              case "marker":
-                filteredAborts.push({
-                  type: "marker",
-                  name: abort.name,
-                  endTime: endTime
-                });
-                break;
-              case "suspense":
-                filteredAborts.push({
-                  type: "suspense",
-                  name: abort.name,
-                  endTime: endTime
-                });
-            }
-          });
-          0 < filteredAborts.length &&
-            onMarkerIncomplete(
-              transition.name,
-              markerName,
-              transition.startTime,
-              filteredAborts
-            );
-        });
-      });
-    transitionStart = pendingTransitions.transitionProgress;
-    var onTransitionProgress = callbacks.onTransitionProgress;
-    null != onTransitionProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (pending, transition) {
-        onTransitionProgress(
-          transition.name,
-          transition.startTime,
-          endTime,
-          Array.from(pending.values())
-        );
-      });
-    pendingTransitions = pendingTransitions.transitionComplete;
-    var onTransitionComplete = callbacks.onTransitionComplete;
-    null !== pendingTransitions &&
-      null != onTransitionComplete &&
-      pendingTransitions.forEach(function (transition) {
-        return onTransitionComplete(
-          transition.name,
-          transition.startTime,
-          endTime
-        );
-      });
+function updateHostComponent(current, workInProgress, type, newProps) {
+  var oldProps = current.memoizedProps;
+  if (oldProps !== newProps) {
+    current = workInProgress.stateNode;
+    var updatePayload = null;
+    switch (type) {
+      case "input":
+        oldProps = getHostProps$2(current, oldProps);
+        newProps = getHostProps$2(current, newProps);
+        updatePayload = [];
+        break;
+      case "select":
+        oldProps = assign({}, oldProps, { value: void 0 });
+        newProps = assign({}, newProps, { value: void 0 });
+        updatePayload = [];
+        break;
+      case "textarea":
+        oldProps = getHostProps(current, oldProps);
+        newProps = getHostProps(current, newProps);
+        updatePayload = [];
+        break;
+      default:
+        "function" !== typeof oldProps.onClick &&
+          "function" === typeof newProps.onClick &&
+          (current.onclick = noop);
+    }
+    assertValidProps(type, newProps);
+    var styleName;
+    type = null;
+    for (JSCompiler_inline_result in oldProps)
+      if (
+        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
+        null != oldProps[JSCompiler_inline_result]
+      )
+        if ("style" === JSCompiler_inline_result) {
+          var lastStyle = oldProps[JSCompiler_inline_result];
+          for (styleName in lastStyle)
+            lastStyle.hasOwnProperty(styleName) &&
+              (type || (type = {}), (type[styleName] = ""));
+        } else
+          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
+            "children" !== JSCompiler_inline_result &&
+            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+            "suppressHydrationWarning" !== JSCompiler_inline_result &&
+            "autoFocus" !== JSCompiler_inline_result &&
+            (registrationNameDependencies.hasOwnProperty(
+              JSCompiler_inline_result
+            )
+              ? updatePayload || (updatePayload = [])
+              : (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  null
+                ));
+    for (JSCompiler_inline_result in newProps) {
+      var nextProp = newProps[JSCompiler_inline_result];
+      lastStyle =
+        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
+      if (
+        newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        nextProp !== lastStyle &&
+        (null != nextProp || null != lastStyle)
+      )
+        if ("style" === JSCompiler_inline_result)
+          if (lastStyle) {
+            for (styleName in lastStyle)
+              !lastStyle.hasOwnProperty(styleName) ||
+                (nextProp && nextProp.hasOwnProperty(styleName)) ||
+                (type || (type = {}), (type[styleName] = ""));
+            for (styleName in nextProp)
+              nextProp.hasOwnProperty(styleName) &&
+                lastStyle[styleName] !== nextProp[styleName] &&
+                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+          } else
+            type ||
+              (updatePayload || (updatePayload = []),
+              updatePayload.push(JSCompiler_inline_result, type)),
+              (type = nextProp);
+        else
+          "dangerouslySetInnerHTML" === JSCompiler_inline_result
+            ? ((nextProp = nextProp ? nextProp.__html : void 0),
+              (lastStyle = lastStyle ? lastStyle.__html : void 0),
+              null != nextProp &&
+                lastStyle !== nextProp &&
+                (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  nextProp
+                ))
+            : "children" === JSCompiler_inline_result
+            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
+              (updatePayload = updatePayload || []).push(
+                JSCompiler_inline_result,
+                "" + nextProp
+              )
+            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+              "suppressHydrationWarning" !== JSCompiler_inline_result &&
+              (registrationNameDependencies.hasOwnProperty(
+                JSCompiler_inline_result
+              )
+                ? (null != nextProp &&
+                    "onScroll" === JSCompiler_inline_result &&
+                    listenToNonDelegatedEvent("scroll", current),
+                  updatePayload ||
+                    lastStyle === nextProp ||
+                    (updatePayload = []))
+                : (updatePayload = updatePayload || []).push(
+                    JSCompiler_inline_result,
+                    nextProp
+                  ));
+    }
+    type && (updatePayload = updatePayload || []).push("style", type);
+    var JSCompiler_inline_result = updatePayload;
+    (workInProgress.updateQueue = JSCompiler_inline_result) &&
+      markUpdate(workInProgress);
   }
 }
-var markerInstanceStack = createCursor(null);
-function pushRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    var transitions = workInProgressTransitions,
-      root$105 = workInProgress.stateNode;
-    null !== transitions &&
-      transitions.forEach(function (transition) {
-        if (!root$105.incompleteTransitions.has(transition)) {
-          var markerInstance = {
-            tag: 0,
-            transitions: new Set([transition]),
-            pendingBoundaries: null,
-            aborts: null,
-            name: null
-          };
-          root$105.incompleteTransitions.set(transition, markerInstance);
-        }
-      });
-    var markerInstances = [];
-    root$105.incompleteTransitions.forEach(function (markerInstance) {
-      markerInstances.push(markerInstance);
-    });
-    push(markerInstanceStack, markerInstances);
-  }
-}
-function pushMarkerInstance(workInProgress, markerInstance) {
-  enableTransitionTracing &&
-    (null === markerInstanceStack.current
-      ? push(markerInstanceStack, [markerInstance])
-      : push(
-          markerInstanceStack,
-          markerInstanceStack.current.concat(markerInstance)
-        ));
-}
-var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
-  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
-  didReceiveUpdate = !1;
-function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
-  workInProgress.child =
-    null === current
-      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
-      : reconcileChildFibers(
-          workInProgress,
-          current.child,
-          nextChildren,
-          renderLanes
-        );
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (!isHydrating)
+    switch (renderState.tailMode) {
+      case "hidden":
+        hasRenderedATailFallback = renderState.tail;
+        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
+          null !== hasRenderedATailFallback.alternate &&
+            (lastTailNode = hasRenderedATailFallback),
+            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
+        null === lastTailNode
+          ? (renderState.tail = null)
+          : (lastTailNode.sibling = null);
+        break;
+      case "collapsed":
+        lastTailNode = renderState.tail;
+        for (var lastTailNode$99 = null; null !== lastTailNode; )
+          null !== lastTailNode.alternate && (lastTailNode$99 = lastTailNode),
+            (lastTailNode = lastTailNode.sibling);
+        null === lastTailNode$99
+          ? hasRenderedATailFallback || null === renderState.tail
+            ? (renderState.tail = null)
+            : (renderState.tail.sibling = null)
+          : (lastTailNode$99.sibling = null);
+    }
 }
-function updateForwardRef(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  Component = Component.render;
-  var ref = workInProgress.ref;
-  prepareToReadContext(workInProgress, renderLanes);
-  nextProps = renderWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    ref,
-    renderLanes
-  );
-  Component = checkDidRenderIdHook();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && Component && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, nextProps, renderLanes);
-  return workInProgress.child;
+function bubbleProperties(completedWork) {
+  var didBailout =
+      null !== completedWork.alternate &&
+      completedWork.alternate.child === completedWork.child,
+    newChildLanes = 0,
+    subtreeFlags = 0;
+  if (didBailout)
+    for (var child$100 = completedWork.child; null !== child$100; )
+      (newChildLanes |= child$100.lanes | child$100.childLanes),
+        (subtreeFlags |= child$100.subtreeFlags & 14680064),
+        (subtreeFlags |= child$100.flags & 14680064),
+        (child$100.return = completedWork),
+        (child$100 = child$100.sibling);
+  else
+    for (child$100 = completedWork.child; null !== child$100; )
+      (newChildLanes |= child$100.lanes | child$100.childLanes),
+        (subtreeFlags |= child$100.subtreeFlags),
+        (subtreeFlags |= child$100.flags),
+        (child$100.return = completedWork),
+        (child$100 = child$100.sibling);
+  completedWork.subtreeFlags |= subtreeFlags;
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
 }
-function updateMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (null === current) {
-    var type = Component.type;
-    if (
-      "function" === typeof type &&
-      !shouldConstruct(type) &&
-      void 0 === type.defaultProps &&
-      null === Component.compare &&
-      void 0 === Component.defaultProps
-    )
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps;
+  popTreeContext(workInProgress);
+  switch (workInProgress.tag) {
+    case 2:
+    case 16:
+    case 15:
+    case 0:
+    case 11:
+    case 7:
+    case 8:
+    case 12:
+    case 9:
+    case 14:
+      return bubbleProperties(workInProgress), null;
+    case 1:
+      return bubbleProperties(workInProgress), null;
+    case 3:
+      renderLanes = workInProgress.stateNode;
+      enableTransitionTracing &&
+        null !== workInProgressTransitions &&
+        (workInProgress.flags |= 2048);
+      newProps = null;
+      null !== current && (newProps = current.memoizedState.cache);
+      workInProgress.memoizedState.cache !== newProps &&
+        (workInProgress.flags |= 2048);
+      popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
+      popHostContainer();
+      resetWorkInProgressVersions();
+      renderLanes.pendingContext &&
+        ((renderLanes.context = renderLanes.pendingContext),
+        (renderLanes.pendingContext = null));
+      if (null === current || null === current.child)
+        popHydrationState(workInProgress)
+          ? markUpdate(workInProgress)
+          : null === current ||
+            (current.memoizedState.isDehydrated &&
+              0 === (workInProgress.flags & 256)) ||
+            ((workInProgress.flags |= 1024),
+            null !== hydrationErrors &&
+              (queueRecoverableErrors(hydrationErrors),
+              (hydrationErrors = null)));
+      bubbleProperties(workInProgress);
+      enableTransitionTracing &&
+        0 !== (workInProgress.subtreeFlags & 8192) &&
+        (workInProgress.flags |= 2048);
+      return null;
+    case 26:
       return (
-        (workInProgress.tag = 15),
-        (workInProgress.type = type),
-        updateSimpleMemoComponent(
-          current,
-          workInProgress,
-          type,
-          nextProps,
-          renderLanes
-        )
+        (current ? current.ref : null) !== workInProgress.ref &&
+          markRef(workInProgress),
+        null === current ||
+        current.memoizedState !== workInProgress.memoizedState
+          ? markUpdate(workInProgress)
+          : null === workInProgress.memoizedState &&
+            updateHostComponent(
+              current,
+              workInProgress,
+              workInProgress.type,
+              workInProgress.pendingProps
+            ),
+        bubbleProperties(workInProgress),
+        null
       );
-    current = createFiberFromTypeAndProps(
-      Component.type,
-      null,
-      nextProps,
-      workInProgress,
-      workInProgress.mode,
-      renderLanes
-    );
-    current.ref = workInProgress.ref;
-    current.return = workInProgress;
-    return (workInProgress.child = current);
-  }
-  type = current.child;
-  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
-    var prevProps = type.memoizedProps;
-    Component = Component.compare;
-    Component = null !== Component ? Component : shallowEqual;
-    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  }
-  workInProgress.flags |= 1;
-  current = createWorkInProgress(type, nextProps);
-  current.ref = workInProgress.ref;
-  current.return = workInProgress;
-  return (workInProgress.child = current);
-}
-function updateSimpleMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (null !== current) {
-    var prevProps = current.memoizedProps;
-    if (
-      shallowEqual(prevProps, nextProps) &&
-      current.ref === workInProgress.ref
-    )
-      if (
-        ((didReceiveUpdate = !1),
-        (workInProgress.pendingProps = nextProps = prevProps),
-        checkScheduledUpdateOrContext(current, renderLanes))
-      )
-        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
-      else
-        return (
-          (workInProgress.lanes = current.lanes),
-          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-        );
-  }
-  return updateFunctionComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    renderLanes
-  );
-}
-function updateOffscreenComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    nextChildren = nextProps.children,
-    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
-    prevState = null !== current ? current.memoizedState : null;
-  markRef$1(current, workInProgress);
-  if (
-    "hidden" === nextProps.mode ||
-    "unstable-defer-without-hiding" === nextProps.mode ||
-    nextIsDetached
-  ) {
-    if (0 !== (workInProgress.flags & 128)) {
-      nextChildren =
-        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
-      if (null !== current) {
-        prevState = workInProgress.child = current.child;
-        for (nextProps = 0; null !== prevState; )
-          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
-            (prevState = prevState.sibling);
-        workInProgress.childLanes = nextProps & ~nextChildren;
-      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes
-      );
-    }
-    if (0 === (workInProgress.mode & 1))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current && pushTransition(workInProgress, null, null),
-        reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else if (0 !== (renderLanes & 1073741824))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current &&
-          pushTransition(
-            workInProgress,
-            null !== prevState ? prevState.cachePool : null,
-            null
-          ),
-        null !== prevState
-          ? pushHiddenContext(workInProgress, prevState)
-          : reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else
-      return (
-        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
-        deferHiddenOffscreenComponent(
-          current,
-          workInProgress,
-          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
-          renderLanes
-        )
-      );
-  } else if (null !== prevState) {
-    nextProps = prevState.cachePool;
-    nextIsDetached = null;
-    if (enableTransitionTracing) {
-      var instance = workInProgress.stateNode;
-      null !== instance &&
-        null != instance._transitions &&
-        (nextIsDetached = Array.from(instance._transitions));
-    }
-    pushTransition(workInProgress, nextProps, nextIsDetached);
-    pushHiddenContext(workInProgress, prevState);
-    reuseSuspenseHandlerOnStack();
-    workInProgress.memoizedState = null;
-  } else
-    null !== current && pushTransition(workInProgress, null, null),
-      reuseHiddenContextOnStack(),
-      reuseSuspenseHandlerOnStack();
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
-function deferHiddenOffscreenComponent(
-  current,
-  workInProgress,
-  nextBaseLanes,
-  renderLanes
-) {
-  var JSCompiler_inline_result = peekCacheFromPool();
-  JSCompiler_inline_result =
-    null === JSCompiler_inline_result
-      ? null
-      : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
-  workInProgress.memoizedState = {
-    baseLanes: nextBaseLanes,
-    cachePool: JSCompiler_inline_result
-  };
-  null !== current && pushTransition(workInProgress, null, null);
-  reuseHiddenContextOnStack();
-  pushOffscreenSuspenseHandler(workInProgress);
-  enableLazyContextPropagation &&
-    null !== current &&
-    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
-  return null;
-}
-function markRef$1(current, workInProgress) {
-  var ref = workInProgress.ref;
-  if (
-    (null === current && null !== ref) ||
-    (null !== current && current.ref !== ref)
-  )
-    (workInProgress.flags |= 512), (workInProgress.flags |= 2097152);
-}
-function updateFunctionComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  prepareToReadContext(workInProgress, renderLanes);
-  Component = renderWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    void 0,
-    renderLanes
-  );
-  nextProps = checkDidRenderIdHook();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && nextProps && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, Component, renderLanes);
-  return workInProgress.child;
-}
-function replayFunctionComponent(
-  current,
-  workInProgress,
-  nextProps,
-  Component,
-  renderLanes
-) {
-  prepareToReadContext(workInProgress, renderLanes);
-  nextProps = renderWithHooksAgain(
-    workInProgress,
-    Component,
-    nextProps,
-    void 0
-  );
-  finishRenderingHooks(current);
-  Component = checkDidRenderIdHook();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && Component && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, nextProps, renderLanes);
-  return workInProgress.child;
-}
-function updateClassComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  prepareToReadContext(workInProgress, renderLanes);
-  if (null === workInProgress.stateNode)
-    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-      constructClassInstance(workInProgress, Component, nextProps),
-      mountClassInstance(workInProgress, Component, nextProps, renderLanes),
-      (nextProps = !0);
-  else if (null === current) {
-    var instance = workInProgress.stateNode,
-      oldProps = workInProgress.memoizedProps;
-    instance.props = oldProps;
-    var oldContext = instance.context,
-      contextType = Component.contextType,
-      nextContext = emptyContextObject;
-    "object" === typeof contextType &&
-      null !== contextType &&
-      (nextContext = readContext(contextType));
-    var getDerivedStateFromProps = Component.getDerivedStateFromProps;
-    (contextType =
-      "function" === typeof getDerivedStateFromProps ||
-      "function" === typeof instance.getSnapshotBeforeUpdate) ||
-      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
-        "function" !== typeof instance.componentWillReceiveProps) ||
-      ((oldProps !== nextProps || oldContext !== nextContext) &&
-        callComponentWillReceiveProps(
-          workInProgress,
-          instance,
-          nextProps,
-          nextContext
-        ));
-    hasForceUpdate = !1;
-    var oldState = workInProgress.memoizedState;
-    instance.state = oldState;
-    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
-    oldContext = workInProgress.memoizedState;
-    oldProps !== nextProps || oldState !== oldContext || hasForceUpdate
-      ? ("function" === typeof getDerivedStateFromProps &&
-          (applyDerivedStateFromProps(
-            workInProgress,
-            Component,
-            getDerivedStateFromProps,
-            nextProps
-          ),
-          (oldContext = workInProgress.memoizedState)),
-        (oldProps =
-          hasForceUpdate ||
-          checkShouldComponentUpdate(
-            workInProgress,
-            Component,
-            oldProps,
-            nextProps,
-            oldState,
-            oldContext,
-            nextContext
-          ))
-          ? (contextType ||
-              ("function" !== typeof instance.UNSAFE_componentWillMount &&
-                "function" !== typeof instance.componentWillMount) ||
-              ("function" === typeof instance.componentWillMount &&
-                instance.componentWillMount(),
-              "function" === typeof instance.UNSAFE_componentWillMount &&
-                instance.UNSAFE_componentWillMount()),
-            "function" === typeof instance.componentDidMount &&
-              (workInProgress.flags |= 4194308))
-          : ("function" === typeof instance.componentDidMount &&
-              (workInProgress.flags |= 4194308),
-            (workInProgress.memoizedProps = nextProps),
-            (workInProgress.memoizedState = oldContext)),
-        (instance.props = nextProps),
-        (instance.state = oldContext),
-        (instance.context = nextContext),
-        (nextProps = oldProps))
-      : ("function" === typeof instance.componentDidMount &&
-          (workInProgress.flags |= 4194308),
-        (nextProps = !1));
-  } else {
-    instance = workInProgress.stateNode;
-    cloneUpdateQueue(current, workInProgress);
-    nextContext = workInProgress.memoizedProps;
-    contextType =
-      workInProgress.type === workInProgress.elementType
-        ? nextContext
-        : resolveDefaultProps(workInProgress.type, nextContext);
-    instance.props = contextType;
-    getDerivedStateFromProps = workInProgress.pendingProps;
-    var oldContext$jscomp$0 = instance.context;
-    oldContext = Component.contextType;
-    oldProps = emptyContextObject;
-    "object" === typeof oldContext &&
-      null !== oldContext &&
-      (oldProps = readContext(oldContext));
-    oldState = Component.getDerivedStateFromProps;
-    (oldContext =
-      "function" === typeof oldState ||
-      "function" === typeof instance.getSnapshotBeforeUpdate) ||
-      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
-        "function" !== typeof instance.componentWillReceiveProps) ||
-      ((nextContext !== getDerivedStateFromProps ||
-        oldContext$jscomp$0 !== oldProps) &&
-        callComponentWillReceiveProps(
-          workInProgress,
-          instance,
-          nextProps,
-          oldProps
-        ));
-    hasForceUpdate = !1;
-    oldContext$jscomp$0 = workInProgress.memoizedState;
-    instance.state = oldContext$jscomp$0;
-    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
-    var newState = workInProgress.memoizedState;
-    nextContext !== getDerivedStateFromProps ||
-    oldContext$jscomp$0 !== newState ||
-    hasForceUpdate ||
-    (enableLazyContextPropagation &&
-      null !== current &&
-      null !== current.dependencies &&
-      checkIfContextChanged(current.dependencies))
-      ? ("function" === typeof oldState &&
-          (applyDerivedStateFromProps(
-            workInProgress,
-            Component,
-            oldState,
-            nextProps
-          ),
-          (newState = workInProgress.memoizedState)),
-        (contextType =
-          hasForceUpdate ||
-          checkShouldComponentUpdate(
-            workInProgress,
-            Component,
-            contextType,
-            nextProps,
-            oldContext$jscomp$0,
-            newState,
-            oldProps
-          ) ||
-          (enableLazyContextPropagation &&
-            null !== current &&
-            null !== current.dependencies &&
-            checkIfContextChanged(current.dependencies)))
-          ? (oldContext ||
-              ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
-                "function" !== typeof instance.componentWillUpdate) ||
-              ("function" === typeof instance.componentWillUpdate &&
-                instance.componentWillUpdate(nextProps, newState, oldProps),
-              "function" === typeof instance.UNSAFE_componentWillUpdate &&
-                instance.UNSAFE_componentWillUpdate(
-                  nextProps,
-                  newState,
-                  oldProps
-                )),
-            "function" === typeof instance.componentDidUpdate &&
-              (workInProgress.flags |= 4),
-            "function" === typeof instance.getSnapshotBeforeUpdate &&
-              (workInProgress.flags |= 1024))
-          : ("function" !== typeof instance.componentDidUpdate ||
-              (nextContext === current.memoizedProps &&
-                oldContext$jscomp$0 === current.memoizedState) ||
-              (workInProgress.flags |= 4),
-            "function" !== typeof instance.getSnapshotBeforeUpdate ||
-              (nextContext === current.memoizedProps &&
-                oldContext$jscomp$0 === current.memoizedState) ||
-              (workInProgress.flags |= 1024),
-            (workInProgress.memoizedProps = nextProps),
-            (workInProgress.memoizedState = newState)),
-        (instance.props = nextProps),
-        (instance.state = newState),
-        (instance.context = oldProps),
-        (nextProps = contextType))
-      : ("function" !== typeof instance.componentDidUpdate ||
-          (nextContext === current.memoizedProps &&
-            oldContext$jscomp$0 === current.memoizedState) ||
-          (workInProgress.flags |= 4),
-        "function" !== typeof instance.getSnapshotBeforeUpdate ||
-          (nextContext === current.memoizedProps &&
-            oldContext$jscomp$0 === current.memoizedState) ||
-          (workInProgress.flags |= 1024),
-        (nextProps = !1));
-  }
-  return finishClassComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    !1,
-    renderLanes
-  );
-}
-function finishClassComponent(
-  current,
-  workInProgress,
-  Component,
-  shouldUpdate,
-  hasContext,
-  renderLanes
-) {
-  markRef$1(current, workInProgress);
-  hasContext = 0 !== (workInProgress.flags & 128);
-  if (!shouldUpdate && !hasContext)
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  shouldUpdate = workInProgress.stateNode;
-  ReactCurrentOwner$1.current = workInProgress;
-  Component =
-    hasContext && "function" !== typeof Component.getDerivedStateFromError
-      ? null
-      : shouldUpdate.render();
-  workInProgress.flags |= 1;
-  null !== current && hasContext
-    ? ((workInProgress.child = reconcileChildFibers(
-        workInProgress,
-        current.child,
-        null,
-        renderLanes
-      )),
-      (workInProgress.child = reconcileChildFibers(
-        workInProgress,
-        null,
-        Component,
-        renderLanes
-      )))
-    : reconcileChildren(current, workInProgress, Component, renderLanes);
-  workInProgress.memoizedState = shouldUpdate.state;
-  return workInProgress.child;
-}
-function mountHostRootWithoutHydrating(
-  current,
-  workInProgress,
-  nextChildren,
-  renderLanes,
-  recoverableError
-) {
-  resetHydrationState();
-  queueHydrationError(recoverableError);
-  workInProgress.flags |= 256;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
-var SUSPENDED_MARKER = { dehydrated: null, treeContext: null, retryLane: 0 };
-function mountSuspenseOffscreenState(renderLanes) {
-  return { baseLanes: renderLanes, cachePool: getSuspendedCache() };
-}
-function updateSuspenseComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    showFallback = !1,
-    didSuspend = 0 !== (workInProgress.flags & 128),
-    JSCompiler_temp;
-  (JSCompiler_temp = didSuspend) ||
-    (JSCompiler_temp =
-      null !== current && null === current.memoizedState
-        ? !1
-        : 0 !== (suspenseStackCursor.current & 2));
-  JSCompiler_temp && ((showFallback = !0), (workInProgress.flags &= -129));
-  if (null === current) {
-    if (isHydrating) {
-      showFallback
-        ? pushPrimaryTreeSuspenseHandler(workInProgress)
-        : reuseSuspenseHandlerOnStack();
-      isHydrating &&
-        (((current = nextHydratableInstance),
-        rootOrSingletonContext && advanceToFirstAttemptableSuspenseInstance(),
-        (didSuspend = nextHydratableInstance),
-        didSuspend)
-          ? tryHydrateSuspense(workInProgress, didSuspend) ||
-            (shouldClientRenderOnMismatch(workInProgress) &&
-              throwOnHydrationMismatch(),
-            (nextHydratableInstance = getNextHydratable(
-              didSuspend.nextSibling
-            )),
-            (JSCompiler_temp = hydrationParentFiber),
-            rootOrSingletonContext &&
-              advanceToFirstAttemptableSuspenseInstance(),
-            nextHydratableInstance &&
-            tryHydrateSuspense(workInProgress, nextHydratableInstance)
-              ? deleteHydratableInstance(JSCompiler_temp, didSuspend)
-              : (insertNonHydratedInstance(
-                  hydrationParentFiber,
-                  workInProgress
-                ),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = current)))
-          : (shouldClientRenderOnMismatch(workInProgress) &&
-              throwOnHydrationMismatch(),
-            insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-            (isHydrating = !1),
-            (hydrationParentFiber = workInProgress),
-            (nextHydratableInstance = current)));
-      current = workInProgress.memoizedState;
-      if (
-        null !== current &&
-        ((current = current.dehydrated), null !== current)
-      )
-        return (
-          0 === (workInProgress.mode & 1)
-            ? (workInProgress.lanes = 2)
-            : "$!" === current.data
-            ? (workInProgress.lanes = 16)
-            : (workInProgress.lanes = 1073741824),
-          null
-        );
-      popSuspenseHandler(workInProgress);
-    }
-    current = nextProps.children;
-    didSuspend = nextProps.fallback;
-    if (showFallback)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (current = mountSuspenseFallbackChildren(
-          workInProgress,
-          current,
-          didSuspend,
-          renderLanes
-        )),
-        (nextProps = workInProgress.child),
-        (nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes)),
-        (workInProgress.memoizedState = SUSPENDED_MARKER),
-        enableTransitionTracing &&
-          ((workInProgress = enableTransitionTracing
-            ? transitionStack.current
-            : null),
-          null !== workInProgress &&
-            ((renderLanes = enableTransitionTracing
-              ? markerInstanceStack.current
-              : null),
-            (showFallback = nextProps.updateQueue),
-            null === showFallback
-              ? (nextProps.updateQueue = {
-                  transitions: workInProgress,
-                  markerInstances: renderLanes,
-                  wakeables: null
-                })
-              : ((showFallback.transitions = workInProgress),
-                (showFallback.markerInstances = renderLanes)))),
-        current
-      );
-    if ("number" === typeof nextProps.unstable_expectedLoadTime)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (current = mountSuspenseFallbackChildren(
-          workInProgress,
-          current,
-          didSuspend,
-          renderLanes
-        )),
-        (workInProgress.child.memoizedState =
-          mountSuspenseOffscreenState(renderLanes)),
-        (workInProgress.memoizedState = SUSPENDED_MARKER),
-        (workInProgress.lanes = 8388608),
-        current
-      );
-    pushPrimaryTreeSuspenseHandler(workInProgress);
-    return mountSuspensePrimaryChildren(workInProgress, current);
-  }
-  JSCompiler_temp = current.memoizedState;
-  if (null !== JSCompiler_temp) {
-    var dehydrated$112 = JSCompiler_temp.dehydrated;
-    if (null !== dehydrated$112)
-      return updateDehydratedSuspenseComponent(
-        current,
-        workInProgress,
-        didSuspend,
-        nextProps,
-        dehydrated$112,
-        JSCompiler_temp,
-        renderLanes
-      );
-  }
-  if (showFallback) {
-    reuseSuspenseHandlerOnStack();
-    showFallback = nextProps.fallback;
-    didSuspend = workInProgress.mode;
-    JSCompiler_temp = current.child;
-    dehydrated$112 = JSCompiler_temp.sibling;
-    var primaryChildProps = { mode: "hidden", children: nextProps.children };
-    0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
-      ? ((nextProps = workInProgress.child),
-        (nextProps.childLanes = 0),
-        (nextProps.pendingProps = primaryChildProps),
-        (workInProgress.deletions = null))
-      : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
-        (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
-    null !== dehydrated$112
-      ? (showFallback = createWorkInProgress(dehydrated$112, showFallback))
-      : ((showFallback = createFiberFromFragment(
-          showFallback,
-          didSuspend,
-          renderLanes,
-          null
-        )),
-        (showFallback.flags |= 2));
-    showFallback.return = workInProgress;
-    nextProps.return = workInProgress;
-    nextProps.sibling = showFallback;
-    workInProgress.child = nextProps;
-    nextProps = showFallback;
-    showFallback = workInProgress.child;
-    didSuspend = current.child.memoizedState;
-    null === didSuspend
-      ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
-      : ((JSCompiler_temp = didSuspend.cachePool),
-        null !== JSCompiler_temp
-          ? ((dehydrated$112 = CacheContext._currentValue),
-            (JSCompiler_temp =
-              JSCompiler_temp.parent !== dehydrated$112
-                ? { parent: dehydrated$112, pool: dehydrated$112 }
-                : JSCompiler_temp))
-          : (JSCompiler_temp = getSuspendedCache()),
-        (didSuspend = {
-          baseLanes: didSuspend.baseLanes | renderLanes,
-          cachePool: JSCompiler_temp
-        }));
-    showFallback.memoizedState = didSuspend;
-    enableTransitionTracing &&
-      ((didSuspend = enableTransitionTracing ? transitionStack.current : null),
-      null !== didSuspend &&
-        ((JSCompiler_temp = enableTransitionTracing
-          ? markerInstanceStack.current
-          : null),
-        (dehydrated$112 = showFallback.updateQueue),
-        (primaryChildProps = current.updateQueue),
-        null === dehydrated$112
-          ? (showFallback.updateQueue = {
-              transitions: didSuspend,
-              markerInstances: JSCompiler_temp,
-              wakeables: null
-            })
-          : dehydrated$112 === primaryChildProps
-          ? (showFallback.updateQueue = {
-              transitions: didSuspend,
-              markerInstances: JSCompiler_temp,
-              wakeables:
-                null !== primaryChildProps ? primaryChildProps.wakeables : null
-            })
-          : ((dehydrated$112.transitions = didSuspend),
-            (dehydrated$112.markerInstances = JSCompiler_temp))));
-    showFallback.childLanes = current.childLanes & ~renderLanes;
-    workInProgress.memoizedState = SUSPENDED_MARKER;
-    return nextProps;
-  }
-  pushPrimaryTreeSuspenseHandler(workInProgress);
-  showFallback = current.child;
-  current = showFallback.sibling;
-  nextProps = createWorkInProgress(showFallback, {
-    mode: "visible",
-    children: nextProps.children
-  });
-  0 === (workInProgress.mode & 1) && (nextProps.lanes = renderLanes);
-  nextProps.return = workInProgress;
-  nextProps.sibling = null;
-  null !== current &&
-    ((renderLanes = workInProgress.deletions),
-    null === renderLanes
-      ? ((workInProgress.deletions = [current]), (workInProgress.flags |= 16))
-      : renderLanes.push(current));
-  workInProgress.child = nextProps;
-  workInProgress.memoizedState = null;
-  return nextProps;
-}
-function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
-  primaryChildren = createFiberFromOffscreen(
-    { mode: "visible", children: primaryChildren },
-    workInProgress.mode,
-    0,
-    null
-  );
-  primaryChildren.return = workInProgress;
-  return (workInProgress.child = primaryChildren);
-}
-function mountSuspenseFallbackChildren(
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode,
-    progressedPrimaryFragment = workInProgress.child;
-  primaryChildren = { mode: "hidden", children: primaryChildren };
-  0 === (mode & 1) && null !== progressedPrimaryFragment
-    ? ((progressedPrimaryFragment.childLanes = 0),
-      (progressedPrimaryFragment.pendingProps = primaryChildren))
-    : (progressedPrimaryFragment = createFiberFromOffscreen(
-        primaryChildren,
-        mode,
-        0,
-        null
-      ));
-  fallbackChildren = createFiberFromFragment(
-    fallbackChildren,
-    mode,
-    renderLanes,
-    null
-  );
-  progressedPrimaryFragment.return = workInProgress;
-  fallbackChildren.return = workInProgress;
-  progressedPrimaryFragment.sibling = fallbackChildren;
-  workInProgress.child = progressedPrimaryFragment;
-  return fallbackChildren;
-}
-function retrySuspenseComponentWithoutHydrating(
-  current,
-  workInProgress,
-  renderLanes,
-  recoverableError
-) {
-  null !== recoverableError && queueHydrationError(recoverableError);
-  reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-  current = mountSuspensePrimaryChildren(
-    workInProgress,
-    workInProgress.pendingProps.children
-  );
-  current.flags |= 2;
-  workInProgress.memoizedState = null;
-  return current;
-}
-function updateDehydratedSuspenseComponent(
-  current,
-  workInProgress,
-  didSuspend,
-  nextProps,
-  suspenseInstance,
-  suspenseState,
-  renderLanes
-) {
-  if (didSuspend) {
-    if (workInProgress.flags & 256)
-      return (
-        pushPrimaryTreeSuspenseHandler(workInProgress),
-        (workInProgress.flags &= -257),
-        (suspenseState = createCapturedValue(
-          Error(formatProdErrorMessage(422))
-        )),
-        retrySuspenseComponentWithoutHydrating(
-          current,
-          workInProgress,
-          renderLanes,
-          suspenseState
-        )
-      );
-    if (null !== workInProgress.memoizedState)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (workInProgress.child = current.child),
-        (workInProgress.flags |= 128),
-        null
-      );
-    reuseSuspenseHandlerOnStack();
-    suspenseState = nextProps.fallback;
-    suspenseInstance = workInProgress.mode;
-    nextProps = createFiberFromOffscreen(
-      { mode: "visible", children: nextProps.children },
-      suspenseInstance,
-      0,
-      null
-    );
-    suspenseState = createFiberFromFragment(
-      suspenseState,
-      suspenseInstance,
-      renderLanes,
-      null
-    );
-    suspenseState.flags |= 2;
-    nextProps.return = workInProgress;
-    suspenseState.return = workInProgress;
-    nextProps.sibling = suspenseState;
-    workInProgress.child = nextProps;
-    0 !== (workInProgress.mode & 1) &&
-      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-    workInProgress.child.memoizedState =
-      mountSuspenseOffscreenState(renderLanes);
-    workInProgress.memoizedState = SUSPENDED_MARKER;
-    return suspenseState;
-  }
-  pushPrimaryTreeSuspenseHandler(workInProgress);
-  if (0 === (workInProgress.mode & 1))
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      null
-    );
-  if ("$!" === suspenseInstance.data) {
-    suspenseState =
-      suspenseInstance.nextSibling && suspenseInstance.nextSibling.dataset;
-    if (suspenseState) var digest = suspenseState.dgst;
-    suspenseState = digest;
-    nextProps = Error(formatProdErrorMessage(419));
-    nextProps.digest = suspenseState;
-    suspenseState = createCapturedValue(nextProps, suspenseState, void 0);
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      suspenseState
-    );
-  }
-  enableLazyContextPropagation &&
-    !didReceiveUpdate &&
-    propagateParentContextChanges(current, workInProgress, renderLanes, !1);
-  digest = 0 !== (renderLanes & current.childLanes);
-  if (didReceiveUpdate || digest) {
-    nextProps = workInProgressRoot;
-    if (null !== nextProps) {
-      suspenseInstance = renderLanes & -renderLanes;
-      if (enableUnifiedSyncLane && 0 !== (suspenseInstance & 42))
-        suspenseInstance = 1;
-      else
-        switch (suspenseInstance) {
-          case 2:
-            suspenseInstance = 1;
-            break;
-          case 8:
-            suspenseInstance = 4;
-            break;
-          case 32:
-            suspenseInstance = 16;
-            break;
-          case 128:
-          case 256:
-          case 512:
-          case 1024:
-          case 2048:
-          case 4096:
-          case 8192:
-          case 16384:
-          case 32768:
-          case 65536:
-          case 131072:
-          case 262144:
-          case 524288:
-          case 1048576:
-          case 2097152:
-          case 4194304:
-          case 8388608:
-          case 16777216:
-          case 33554432:
-          case 67108864:
-            suspenseInstance = 64;
-            break;
-          case 536870912:
-            suspenseInstance = 268435456;
-            break;
-          default:
-            suspenseInstance = 0;
-        }
-      suspenseInstance =
-        0 !== (suspenseInstance & (nextProps.suspendedLanes | renderLanes))
-          ? 0
-          : suspenseInstance;
-      if (
-        0 !== suspenseInstance &&
-        suspenseInstance !== suspenseState.retryLane
-      )
-        throw (
-          ((suspenseState.retryLane = suspenseInstance),
-          enqueueConcurrentRenderForLane(current, suspenseInstance),
-          scheduleUpdateOnFiber(nextProps, current, suspenseInstance, -1),
-          SelectiveHydrationException)
-        );
-    }
-    renderDidSuspendDelayIfPossible();
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      null
-    );
-  }
-  if ("$?" === suspenseInstance.data)
-    return (
-      (workInProgress.flags |= 128),
-      (workInProgress.child = current.child),
-      (workInProgress = retryDehydratedSuspenseBoundary.bind(null, current)),
-      (suspenseInstance._reactRetry = workInProgress),
-      null
-    );
-  current = suspenseState.treeContext;
-  nextHydratableInstance = getNextHydratable(suspenseInstance.nextSibling);
-  hydrationParentFiber = workInProgress;
-  isHydrating = !0;
-  hydrationErrors = null;
-  rootOrSingletonContext = !1;
-  null !== current &&
-    ((idStack[idStackIndex++] = treeContextId),
-    (idStack[idStackIndex++] = treeContextOverflow),
-    (idStack[idStackIndex++] = treeContextProvider),
-    (treeContextId = current.id),
-    (treeContextOverflow = current.overflow),
-    (treeContextProvider = workInProgress));
-  workInProgress = mountSuspensePrimaryChildren(
-    workInProgress,
-    nextProps.children
-  );
-  workInProgress.flags |= 4096;
-  return workInProgress;
-}
-function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
-  fiber.lanes |= renderLanes;
-  var alternate = fiber.alternate;
-  null !== alternate && (alternate.lanes |= renderLanes);
-  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
-}
-function initSuspenseListRenderState(
-  workInProgress,
-  isBackwards,
-  tail,
-  lastContentRow,
-  tailMode
-) {
-  var renderState = workInProgress.memoizedState;
-  null === renderState
-    ? (workInProgress.memoizedState = {
-        isBackwards: isBackwards,
-        rendering: null,
-        renderingStartTime: 0,
-        last: lastContentRow,
-        tail: tail,
-        tailMode: tailMode
-      })
-    : ((renderState.isBackwards = isBackwards),
-      (renderState.rendering = null),
-      (renderState.renderingStartTime = 0),
-      (renderState.last = lastContentRow),
-      (renderState.tail = tail),
-      (renderState.tailMode = tailMode));
-}
-function updateSuspenseListComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    revealOrder = nextProps.revealOrder,
-    tailMode = nextProps.tail;
-  reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
-  nextProps = suspenseStackCursor.current;
-  if (0 !== (nextProps & 2))
-    (nextProps = (nextProps & 1) | 2), (workInProgress.flags |= 128);
-  else {
-    if (null !== current && 0 !== (current.flags & 128))
-      a: for (current = workInProgress.child; null !== current; ) {
-        if (13 === current.tag)
-          null !== current.memoizedState &&
-            scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
-        else if (19 === current.tag)
-          scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
-        else if (null !== current.child) {
-          current.child.return = current;
-          current = current.child;
-          continue;
-        }
-        if (current === workInProgress) break a;
-        for (; null === current.sibling; ) {
-          if (null === current.return || current.return === workInProgress)
-            break a;
-          current = current.return;
-        }
-        current.sibling.return = current.return;
-        current = current.sibling;
-      }
-    nextProps &= 1;
-  }
-  push(suspenseStackCursor, nextProps);
-  if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;
-  else
-    switch (revealOrder) {
-      case "forwards":
-        renderLanes = workInProgress.child;
-        for (revealOrder = null; null !== renderLanes; )
-          (current = renderLanes.alternate),
-            null !== current &&
-              null === findFirstSuspended(current) &&
-              (revealOrder = renderLanes),
-            (renderLanes = renderLanes.sibling);
-        renderLanes = revealOrder;
-        null === renderLanes
-          ? ((revealOrder = workInProgress.child),
-            (workInProgress.child = null))
-          : ((revealOrder = renderLanes.sibling), (renderLanes.sibling = null));
-        initSuspenseListRenderState(
-          workInProgress,
-          !1,
-          revealOrder,
-          renderLanes,
-          tailMode
-        );
-        break;
-      case "backwards":
-        renderLanes = null;
-        revealOrder = workInProgress.child;
-        for (workInProgress.child = null; null !== revealOrder; ) {
-          current = revealOrder.alternate;
-          if (null !== current && null === findFirstSuspended(current)) {
-            workInProgress.child = revealOrder;
-            break;
-          }
-          current = revealOrder.sibling;
-          revealOrder.sibling = renderLanes;
-          renderLanes = revealOrder;
-          revealOrder = current;
-        }
-        initSuspenseListRenderState(
-          workInProgress,
-          !0,
-          renderLanes,
-          null,
-          tailMode
-        );
-        break;
-      case "together":
-        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
-        break;
-      default:
-        workInProgress.memoizedState = null;
-    }
-  return workInProgress.child;
-}
-function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
-  0 === (workInProgress.mode & 1) &&
-    null !== current &&
-    ((current.alternate = null),
-    (workInProgress.alternate = null),
-    (workInProgress.flags |= 2));
-}
-function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
-  null !== current && (workInProgress.dependencies = current.dependencies);
-  workInProgressRootSkippedLanes |= workInProgress.lanes;
-  if (0 === (renderLanes & workInProgress.childLanes))
-    if (enableLazyContextPropagation && null !== current) {
-      if (
-        (propagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes,
-          !1
-        ),
-        0 === (renderLanes & workInProgress.childLanes))
-      )
-        return null;
-    } else return null;
-  if (null !== current && workInProgress.child !== current.child)
-    throw Error(formatProdErrorMessage(153));
-  if (null !== workInProgress.child) {
-    current = workInProgress.child;
-    renderLanes = createWorkInProgress(current, current.pendingProps);
-    workInProgress.child = renderLanes;
-    for (renderLanes.return = workInProgress; null !== current.sibling; )
-      (current = current.sibling),
-        (renderLanes = renderLanes.sibling =
-          createWorkInProgress(current, current.pendingProps)),
-        (renderLanes.return = workInProgress);
-    renderLanes.sibling = null;
-  }
-  return workInProgress.child;
-}
-function checkScheduledUpdateOrContext(current, renderLanes) {
-  return 0 !== (current.lanes & renderLanes) ||
-    (enableLazyContextPropagation &&
-      ((current = current.dependencies),
-      null !== current && checkIfContextChanged(current)))
-    ? !0
-    : !1;
-}
-function attemptEarlyBailoutIfNoScheduledUpdate(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  switch (workInProgress.tag) {
-    case 3:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      enableTransitionTracing &&
-        push(transitionStack, workInProgressTransitions);
-      enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
-      resetHydrationState();
-      break;
     case 27:
-    case 5:
-      pushHostContext(workInProgress);
-      break;
-    case 4:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      break;
-    case 10:
-      pushProvider(
-        workInProgress,
-        workInProgress.type._context,
-        workInProgress.memoizedProps.value
-      );
-      break;
-    case 13:
-      var state = workInProgress.memoizedState;
-      if (null !== state) {
-        if (null !== state.dehydrated)
-          return (
-            pushPrimaryTreeSuspenseHandler(workInProgress),
-            (workInProgress.flags |= 128),
-            null
-          );
-        if (0 !== (renderLanes & workInProgress.child.childLanes))
-          return updateSuspenseComponent(current, workInProgress, renderLanes);
-        pushPrimaryTreeSuspenseHandler(workInProgress);
-        current = bailoutOnAlreadyFinishedWork(
-          current,
-          workInProgress,
-          renderLanes
-        );
-        return null !== current ? current.sibling : null;
-      }
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      break;
-    case 19:
-      var didSuspendBefore = 0 !== (current.flags & 128);
-      state = 0 !== (renderLanes & workInProgress.childLanes);
-      enableLazyContextPropagation &&
-        !state &&
-        (propagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes,
-          !1
-        ),
-        (state = 0 !== (renderLanes & workInProgress.childLanes)));
-      if (didSuspendBefore) {
-        if (state)
-          return updateSuspenseListComponent(
-            current,
-            workInProgress,
-            renderLanes
-          );
-        workInProgress.flags |= 128;
+      popHostContext(workInProgress);
+      renderLanes = rootInstanceStackCursor.current;
+      var type = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, type, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor.current;
+        popHydrationState(workInProgress)
+          ? prepareToHydrateHostInstance(workInProgress, current)
+          : ((workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              renderLanes
+            )),
+            markUpdate(workInProgress));
+        null !== workInProgress.ref && markRef(workInProgress);
       }
-      didSuspendBefore = workInProgress.memoizedState;
-      null !== didSuspendBefore &&
-        ((didSuspendBefore.rendering = null),
-        (didSuspendBefore.tail = null),
-        (didSuspendBefore.lastEffect = null));
-      push(suspenseStackCursor, suspenseStackCursor.current);
-      if (state) break;
-      else return null;
-    case 22:
-    case 23:
-      return (
-        (workInProgress.lanes = 0),
-        updateOffscreenComponent(current, workInProgress, renderLanes)
-      );
-    case 24:
-      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
-      break;
-    case 25:
-      enableTransitionTracing &&
-        ((state = workInProgress.stateNode),
-        null !== state && pushMarkerInstance(workInProgress, state));
-  }
-  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-}
-var valueCursor = createCursor(null),
-  currentlyRenderingFiber = null,
-  lastContextDependency = null,
-  lastFullyObservedContext = null;
-function resetContextDependencies() {
-  lastFullyObservedContext =
-    lastContextDependency =
-    currentlyRenderingFiber =
-      null;
-}
-function pushProvider(providerFiber, context, nextValue) {
-  push(valueCursor, context._currentValue);
-  context._currentValue = nextValue;
-}
-function popProvider(context) {
-  var currentValue = valueCursor.current;
-  context._currentValue =
-    currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED
-      ? context._defaultValue
-      : currentValue;
-  pop(valueCursor);
-}
-function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
-  for (; null !== parent; ) {
-    var alternate = parent.alternate;
-    (parent.childLanes & renderLanes) !== renderLanes
-      ? ((parent.childLanes |= renderLanes),
-        null !== alternate && (alternate.childLanes |= renderLanes))
-      : null !== alternate &&
-        (alternate.childLanes & renderLanes) !== renderLanes &&
-        (alternate.childLanes |= renderLanes);
-    if (parent === propagationRoot) break;
-    parent = parent.return;
-  }
-}
-function propagateContextChange(workInProgress, context, renderLanes) {
-  if (enableLazyContextPropagation)
-    propagateContextChanges(workInProgress, [context], renderLanes, !0);
-  else if (!enableLazyContextPropagation) {
-    var fiber = workInProgress.child;
-    null !== fiber && (fiber.return = workInProgress);
-    for (; null !== fiber; ) {
-      var list = fiber.dependencies;
-      if (null !== list) {
-        var nextFiber = fiber.child;
-        for (var dependency = list.firstContext; null !== dependency; ) {
-          if (dependency.context === context) {
-            if (1 === fiber.tag) {
-              dependency = createUpdate(renderLanes & -renderLanes);
-              dependency.tag = 2;
-              var updateQueue = fiber.updateQueue;
-              if (null !== updateQueue) {
-                updateQueue = updateQueue.shared;
-                var pending = updateQueue.pending;
-                null === pending
-                  ? (dependency.next = dependency)
-                  : ((dependency.next = pending.next),
-                    (pending.next = dependency));
-                updateQueue.pending = dependency;
-              }
-            }
-            fiber.lanes |= renderLanes;
-            dependency = fiber.alternate;
-            null !== dependency && (dependency.lanes |= renderLanes);
-            scheduleContextWorkOnParentPath(
-              fiber.return,
-              renderLanes,
-              workInProgress
-            );
-            list.lanes |= renderLanes;
-            break;
-          }
-          dependency = dependency.next;
+      bubbleProperties(workInProgress);
+      return null;
+    case 5:
+      popHostContext(workInProgress);
+      renderLanes = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, renderLanes, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
         }
-      } else if (10 === fiber.tag)
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-      else if (18 === fiber.tag) {
-        nextFiber = fiber.return;
-        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
-        nextFiber.lanes |= renderLanes;
-        list = nextFiber.alternate;
-        null !== list && (list.lanes |= renderLanes);
-        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
-        nextFiber = fiber.sibling;
-      } else 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;
+        current = contextStackCursor.current;
+        if (popHydrationState(workInProgress))
+          prepareToHydrateHostInstance(workInProgress, current) &&
+            markUpdate(workInProgress);
+        else {
+          type = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          );
+          switch (current) {
+            case "http://www.w3.org/2000/svg":
+            case "http://www.w3.org/1998/Math/MathML":
+              current = type.createElementNS(current, renderLanes);
+              break;
+            default:
+              switch (renderLanes) {
+                case "svg":
+                  current = type.createElementNS(
+                    "http://www.w3.org/2000/svg",
+                    renderLanes
+                  );
+                  break;
+                case "math":
+                  current = type.createElementNS(
+                    "http://www.w3.org/1998/Math/MathML",
+                    renderLanes
+                  );
+                  break;
+                case "script":
+                  current = type.createElement("div");
+                  current.innerHTML = "<script>\x3c/script>";
+                  current = current.removeChild(current.firstChild);
+                  break;
+                case "select":
+                  current =
+                    "string" === typeof newProps.is
+                      ? type.createElement("select", { is: newProps.is })
+                      : type.createElement("select");
+                  newProps.multiple
+                    ? (current.multiple = !0)
+                    : newProps.size && (current.size = newProps.size);
+                  break;
+                default:
+                  current = createHTMLElement(renderLanes, newProps, type);
+              }
           }
-          nextFiber = nextFiber.return;
-        }
-      fiber = nextFiber;
-    }
-  }
-}
-function propagateContextChanges(
-  workInProgress,
-  contexts,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (enableLazyContextPropagation) {
-    var fiber = workInProgress.child;
-    null !== fiber && (fiber.return = workInProgress);
-    for (; null !== fiber; ) {
-      var list = fiber.dependencies;
-      if (null !== list) {
-        var nextFiber = fiber.child;
-        list = list.firstContext;
-        a: for (; null !== list; ) {
-          var dependency = list;
-          list = fiber;
-          for (var i = 0; i < contexts.length; i++)
-            if (dependency.context === contexts[i]) {
-              list.lanes |= renderLanes;
-              dependency = list.alternate;
-              null !== dependency && (dependency.lanes |= renderLanes);
-              scheduleContextWorkOnParentPath(
-                list.return,
-                renderLanes,
-                workInProgress
-              );
-              forcePropagateEntireTree || (nextFiber = null);
-              break a;
-            }
-          list = dependency.next;
-        }
-      } else if (18 === fiber.tag) {
-        nextFiber = fiber.return;
-        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
-        nextFiber.lanes |= renderLanes;
-        list = nextFiber.alternate;
-        null !== list && (list.lanes |= renderLanes);
-        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
-        nextFiber = null;
-      } else nextFiber = fiber.child;
-      if (null !== nextFiber) nextFiber.return = fiber;
-      else
-        for (nextFiber = fiber; null !== nextFiber; ) {
-          if (nextFiber === workInProgress) {
-            nextFiber = null;
-            break;
+          current[internalInstanceKey] = workInProgress;
+          current[internalPropsKey] = newProps;
+          a: for (type = workInProgress.child; null !== type; ) {
+            if (5 === type.tag || 6 === type.tag)
+              current.appendChild(type.stateNode);
+            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
+              type.child.return = type;
+              type = type.child;
+              continue;
+            }
+            if (type === workInProgress) break a;
+            for (; null === type.sibling; ) {
+              if (null === type.return || type.return === workInProgress)
+                break a;
+              type = type.return;
+            }
+            type.sibling.return = type.return;
+            type = type.sibling;
           }
-          fiber = nextFiber.sibling;
-          if (null !== fiber) {
-            fiber.return = nextFiber.return;
-            nextFiber = fiber;
-            break;
+          workInProgress.stateNode = current;
+          a: switch (
+            (setInitialProperties(current, renderLanes, newProps), renderLanes)
+          ) {
+            case "button":
+            case "input":
+            case "select":
+            case "textarea":
+              current = !!newProps.autoFocus;
+              break a;
+            case "img":
+              current = !0;
+              break a;
+            default:
+              current = !1;
           }
-          nextFiber = nextFiber.return;
-        }
-      fiber = nextFiber;
-    }
-  }
-}
-function propagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (enableLazyContextPropagation) {
-    current = null;
-    for (
-      var parent = workInProgress, isInsidePropagationBailout = !1;
-      null !== parent;
-
-    ) {
-      if (!isInsidePropagationBailout)
-        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
-        else if (0 !== (parent.flags & 262144)) break;
-      if (10 === parent.tag) {
-        var currentParent = parent.alternate;
-        if (null === currentParent) throw Error(formatProdErrorMessage(387));
-        currentParent = currentParent.memoizedProps;
-        if (null !== currentParent) {
-          var context = parent.type._context;
-          objectIs(parent.pendingProps.value, currentParent.value) ||
-            (null !== current ? current.push(context) : (current = [context]));
+          current && markUpdate(workInProgress);
         }
+        null !== workInProgress.ref && markRef(workInProgress);
       }
-      parent = parent.return;
-    }
-    null !== current &&
-      propagateContextChanges(
-        workInProgress,
-        current,
-        renderLanes,
-        forcePropagateEntireTree
-      );
-    workInProgress.flags |= 262144;
-  }
-}
-function checkIfContextChanged(currentDependencies) {
-  if (!enableLazyContextPropagation) return !1;
-  for (
-    currentDependencies = currentDependencies.firstContext;
-    null !== currentDependencies;
-
-  ) {
-    if (
-      !objectIs(
-        currentDependencies.context._currentValue,
-        currentDependencies.memoizedValue
-      )
-    )
-      return !0;
-    currentDependencies = currentDependencies.next;
-  }
-  return !1;
-}
-function prepareToReadContext(workInProgress, renderLanes) {
-  currentlyRenderingFiber = workInProgress;
-  lastFullyObservedContext = lastContextDependency = null;
-  workInProgress = workInProgress.dependencies;
-  null !== workInProgress &&
-    (enableLazyContextPropagation
-      ? (workInProgress.firstContext = null)
-      : null !== workInProgress.firstContext &&
-        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
-        (workInProgress.firstContext = null)));
-}
-function readContext(context) {
-  return readContextForConsumer(currentlyRenderingFiber, context);
-}
-function readContextDuringReconcilation(consumer, context, renderLanes) {
-  null === currentlyRenderingFiber &&
-    prepareToReadContext(consumer, renderLanes);
-  return readContextForConsumer(consumer, context);
-}
-function readContextForConsumer(consumer, context) {
-  var value = context._currentValue;
-  if (lastFullyObservedContext !== context)
-    if (
-      ((context = { context: context, memoizedValue: value, next: null }),
-      null === lastContextDependency)
-    ) {
-      if (null === consumer) throw Error(formatProdErrorMessage(308));
-      lastContextDependency = context;
-      consumer.dependencies = { lanes: 0, firstContext: context };
-      enableLazyContextPropagation && (consumer.flags |= 524288);
-    } else lastContextDependency = lastContextDependency.next = context;
-  return value;
-}
-var AbortControllerLocal =
-    "undefined" !== typeof AbortController
-      ? AbortController
-      : function () {
-          var listeners = [],
-            signal = (this.signal = {
-              aborted: !1,
-              addEventListener: function (type, listener) {
-                listeners.push(listener);
-              }
-            });
-          this.abort = function () {
-            signal.aborted = !0;
-            listeners.forEach(function (listener) {
-              return listener();
-            });
-          };
-        },
-  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
-  NormalPriority = Scheduler.unstable_NormalPriority,
-  CacheContext = {
-    $$typeof: REACT_CONTEXT_TYPE,
-    Consumer: null,
-    Provider: null,
-    _currentValue: null,
-    _currentValue2: null,
-    _threadCount: 0,
-    _defaultValue: null,
-    _globalName: null
-  };
-function createCache() {
-  return {
-    controller: new AbortControllerLocal(),
-    data: new Map(),
-    refCount: 0
-  };
-}
-function releaseCache(cache) {
-  cache.refCount--;
-  0 === cache.refCount &&
-    scheduleCallback$1(NormalPriority, function () {
-      cache.controller.abort();
-    });
-}
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
-  resumedCache = createCursor(null),
-  transitionStack = createCursor(null);
-function peekCacheFromPool() {
-  var cacheResumedFromPreviousRender = resumedCache.current;
-  return null !== cacheResumedFromPreviousRender
-    ? cacheResumedFromPreviousRender
-    : workInProgressRoot.pooledCache;
-}
-function pushTransition(
-  offscreenWorkInProgress,
-  prevCachePool,
-  newTransitions
-) {
-  null === prevCachePool
-    ? push(resumedCache, resumedCache.current)
-    : push(resumedCache, prevCachePool.pool);
-  enableTransitionTracing &&
-    (null === transitionStack.current
-      ? push(transitionStack, newTransitions)
-      : null === newTransitions
-      ? push(transitionStack, transitionStack.current)
-      : push(transitionStack, transitionStack.current.concat(newTransitions)));
-}
-function popTransition(workInProgress, current) {
-  null !== current &&
-    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
-}
-function getSuspendedCache() {
-  var cacheFromPool = peekCacheFromPool();
-  return null === cacheFromPool
-    ? null
-    : { parent: CacheContext._currentValue, pool: cacheFromPool };
-}
-var emptyObject = {};
-function collectScopedNodesFromChildren(
-  startingChild,
-  fn$jscomp$0,
-  scopedNodes$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      fn = fn$jscomp$0,
-      scopedNodes = scopedNodes$jscomp$0;
-    if (5 === node.tag) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        instance = node.stateNode;
-      null !== instance &&
-        !0 === fn(type, memoizedProps || emptyObject, instance) &&
-        scopedNodes.push(instance);
-    }
-    type = node.child;
-    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
-    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
-    startingChild = startingChild.sibling;
-  }
-}
-function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
-  for (; null !== startingChild; ) {
-    a: {
-      var JSCompiler_inline_result = startingChild;
-      var fn = fn$jscomp$0;
-      if (5 === JSCompiler_inline_result.tag) {
-        var type = JSCompiler_inline_result.type,
-          memoizedProps = JSCompiler_inline_result.memoizedProps,
-          instance = JSCompiler_inline_result.stateNode;
-        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
-          JSCompiler_inline_result = instance;
-          break a;
-        }
+      bubbleProperties(workInProgress);
+      return null;
+    case 6:
+      if (current && null != workInProgress.stateNode)
+        current.memoizedProps !== newProps && markUpdate(workInProgress);
+      else {
+        if ("string" !== typeof newProps && null === workInProgress.stateNode)
+          throw Error(formatProdErrorMessage(166));
+        current = rootInstanceStackCursor.current;
+        if (popHydrationState(workInProgress)) {
+          newProps = workInProgress.stateNode;
+          current = workInProgress.memoizedProps;
+          newProps[internalInstanceKey] = workInProgress;
+          if ((renderLanes = newProps.nodeValue !== current))
+            if (((type = hydrationParentFiber), null !== type))
+              switch (type.tag) {
+                case 3:
+                  newProps = newProps.nodeValue;
+                  normalizeMarkupForTextOrAttribute(current);
+                  normalizeMarkupForTextOrAttribute(newProps);
+                  break;
+                case 27:
+                case 5:
+                  !0 !== type.memoizedProps.suppressHydrationWarning &&
+                    ((newProps = newProps.nodeValue),
+                    normalizeMarkupForTextOrAttribute(current),
+                    normalizeMarkupForTextOrAttribute(newProps));
+              }
+          renderLanes && markUpdate(workInProgress);
+        } else
+          (current =
+            getOwnerDocumentFromRootContainer(current).createTextNode(
+              newProps
+            )),
+            (current[internalInstanceKey] = workInProgress),
+            (workInProgress.stateNode = current);
       }
-      type = JSCompiler_inline_result.child;
-      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
-        (type = JSCompiler_inline_result.child.sibling.child);
-      JSCompiler_inline_result =
-        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
-    }
-    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
-    startingChild = startingChild.sibling;
-  }
-  return null;
-}
-function collectNearestChildContextValues(
-  startingChild,
-  context$jscomp$0,
-  childContextValues$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      context = context$jscomp$0,
-      childContextValues = childContextValues$jscomp$0;
-    if (10 === node.tag && node.type._context === context)
-      childContextValues.push(node.memoizedProps.value);
-    else {
-      var child = node.child;
-      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
-      null !== child &&
-        collectNearestChildContextValues(child, context, childContextValues);
-    }
-    startingChild = startingChild.sibling;
-  }
-}
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  var scopedNodes = [];
-  null !== currentFiber &&
-    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
-  return 0 === scopedNodes.length ? null : scopedNodes;
-}
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  return null !== currentFiber
-    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
-    : null;
-}
-function containsNode(node) {
-  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
-    if (21 === node.tag && node.stateNode === this) return !0;
-    node = node.return;
-  }
-  return !1;
-}
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return [];
-  currentFiber = currentFiber.child;
-  var childContextValues = [];
-  null !== currentFiber &&
-    collectNearestChildContextValues(currentFiber, context, childContextValues);
-  return childContextValues;
-}
-function markUpdate(workInProgress) {
-  workInProgress.flags |= 4;
-}
-function markRef(workInProgress) {
-  workInProgress.flags |= 2097664;
-}
-function updateHostComponent(current, workInProgress, type, newProps) {
-  var oldProps = current.memoizedProps;
-  if (oldProps !== newProps) {
-    current = workInProgress.stateNode;
-    var updatePayload = null;
-    switch (type) {
-      case "input":
-        oldProps = getHostProps$2(current, oldProps);
-        newProps = getHostProps$2(current, newProps);
-        updatePayload = [];
-        break;
-      case "select":
-        oldProps = assign({}, oldProps, { value: void 0 });
-        newProps = assign({}, newProps, { value: void 0 });
-        updatePayload = [];
-        break;
-      case "textarea":
-        oldProps = getHostProps(current, oldProps);
-        newProps = getHostProps(current, newProps);
-        updatePayload = [];
-        break;
-      default:
-        "function" !== typeof oldProps.onClick &&
-          "function" === typeof newProps.onClick &&
-          (current.onclick = noop$1);
-    }
-    assertValidProps(type, newProps);
-    var styleName;
-    type = null;
-    for (JSCompiler_inline_result in oldProps)
+      bubbleProperties(workInProgress);
+      return null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      newProps = workInProgress.memoizedState;
       if (
-        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
-        null != oldProps[JSCompiler_inline_result]
-      )
-        if ("style" === JSCompiler_inline_result) {
-          var lastStyle = oldProps[JSCompiler_inline_result];
-          for (styleName in lastStyle)
-            lastStyle.hasOwnProperty(styleName) &&
-              (type || (type = {}), (type[styleName] = ""));
+        null === current ||
+        (null !== current.memoizedState &&
+          null !== current.memoizedState.dehydrated)
+      ) {
+        if (
+          isHydrating &&
+          null !== nextHydratableInstance &&
+          0 !== (workInProgress.mode & 1) &&
+          0 === (workInProgress.flags & 128)
+        )
+          warnIfUnhydratedTailNodes(),
+            resetHydrationState(),
+            (workInProgress.flags |= 98560),
+            (type = !1);
+        else if (
+          ((type = popHydrationState(workInProgress)),
+          null !== newProps && null !== newProps.dehydrated)
+        ) {
+          if (null === current) {
+            if (!type) throw Error(formatProdErrorMessage(318));
+            type = workInProgress.memoizedState;
+            type = null !== type ? type.dehydrated : null;
+            if (!type) throw Error(formatProdErrorMessage(317));
+            type[internalInstanceKey] = workInProgress;
+          } else
+            resetHydrationState(),
+              0 === (workInProgress.flags & 128) &&
+                (workInProgress.memoizedState = null),
+              (workInProgress.flags |= 4);
+          bubbleProperties(workInProgress);
+          type = !1;
         } else
-          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
-            "children" !== JSCompiler_inline_result &&
-            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-            "suppressHydrationWarning" !== JSCompiler_inline_result &&
-            "autoFocus" !== JSCompiler_inline_result &&
-            (registrationNameDependencies.hasOwnProperty(
-              JSCompiler_inline_result
+          null !== hydrationErrors &&
+            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
+            (type = !0);
+        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
+      }
+      if (0 !== (workInProgress.flags & 128))
+        return (workInProgress.lanes = renderLanes), workInProgress;
+      renderLanes = null !== newProps;
+      current = null !== current && null !== current.memoizedState;
+      if (renderLanes) {
+        newProps = workInProgress.child;
+        type = null;
+        null !== newProps.alternate &&
+          null !== newProps.alternate.memoizedState &&
+          null !== newProps.alternate.memoizedState.cachePool &&
+          (type = newProps.alternate.memoizedState.cachePool.pool);
+        var cache$110 = null;
+        null !== newProps.memoizedState &&
+          null !== newProps.memoizedState.cachePool &&
+          (cache$110 = newProps.memoizedState.cachePool.pool);
+        cache$110 !== type && (newProps.flags |= 2048);
+      }
+      renderLanes !== current &&
+        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
+        renderLanes && (workInProgress.child.flags |= 8192));
+      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
+      null !== workInProgress.updateQueue &&
+        null != workInProgress.memoizedProps.suspenseCallback &&
+        (workInProgress.flags |= 4);
+      bubbleProperties(workInProgress);
+      return null;
+    case 4:
+      return (
+        popHostContainer(),
+        null === current &&
+          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 10:
+      return (
+        popProvider(workInProgress.type._context),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 17:
+      return bubbleProperties(workInProgress), null;
+    case 19:
+      pop(suspenseStackCursor);
+      type = workInProgress.memoizedState;
+      if (null === type) return bubbleProperties(workInProgress), null;
+      newProps = 0 !== (workInProgress.flags & 128);
+      cache$110 = type.rendering;
+      if (null === cache$110)
+        if (newProps) cutOffTailIfNeeded(type, !1);
+        else {
+          if (
+            0 !== workInProgressRootExitStatus ||
+            (null !== current && 0 !== (current.flags & 128))
+          )
+            for (current = workInProgress.child; null !== current; ) {
+              cache$110 = findFirstSuspended(current);
+              if (null !== cache$110) {
+                workInProgress.flags |= 128;
+                cutOffTailIfNeeded(type, !1);
+                current = cache$110.updateQueue;
+                null !== current &&
+                  ((workInProgress.updateQueue = current),
+                  (workInProgress.flags |= 4));
+                workInProgress.subtreeFlags = 0;
+                current = renderLanes;
+                for (renderLanes = workInProgress.child; null !== renderLanes; )
+                  resetWorkInProgress(renderLanes, current),
+                    (renderLanes = renderLanes.sibling);
+                push(
+                  suspenseStackCursor,
+                  (suspenseStackCursor.current & 1) | 2
+                );
+                return workInProgress.child;
+              }
+              current = current.sibling;
+            }
+          null !== type.tail &&
+            now() > workInProgressRootRenderTargetTime &&
+            ((workInProgress.flags |= 128),
+            (newProps = !0),
+            cutOffTailIfNeeded(type, !1),
+            (workInProgress.lanes = 8388608));
+        }
+      else {
+        if (!newProps)
+          if (((current = findFirstSuspended(cache$110)), null !== current)) {
+            if (
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              (current = current.updateQueue),
+              null !== current &&
+                ((workInProgress.updateQueue = current),
+                (workInProgress.flags |= 4)),
+              cutOffTailIfNeeded(type, !0),
+              null === type.tail &&
+                "hidden" === type.tailMode &&
+                !cache$110.alternate &&
+                !isHydrating)
             )
-              ? updatePayload || (updatePayload = [])
-              : (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  null
-                ));
-    for (JSCompiler_inline_result in newProps) {
-      var nextProp = newProps[JSCompiler_inline_result];
-      lastStyle =
-        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
-      if (
-        newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        nextProp !== lastStyle &&
-        (null != nextProp || null != lastStyle)
-      )
-        if ("style" === JSCompiler_inline_result)
-          if (lastStyle) {
-            for (styleName in lastStyle)
-              !lastStyle.hasOwnProperty(styleName) ||
-                (nextProp && nextProp.hasOwnProperty(styleName)) ||
-                (type || (type = {}), (type[styleName] = ""));
-            for (styleName in nextProp)
-              nextProp.hasOwnProperty(styleName) &&
-                lastStyle[styleName] !== nextProp[styleName] &&
-                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+              return bubbleProperties(workInProgress), null;
           } else
-            type ||
-              (updatePayload || (updatePayload = []),
-              updatePayload.push(JSCompiler_inline_result, type)),
-              (type = nextProp);
-        else
-          "dangerouslySetInnerHTML" === JSCompiler_inline_result
-            ? ((nextProp = nextProp ? nextProp.__html : void 0),
-              (lastStyle = lastStyle ? lastStyle.__html : void 0),
-              null != nextProp &&
-                lastStyle !== nextProp &&
-                (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  nextProp
-                ))
-            : "children" === JSCompiler_inline_result
-            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
-              (updatePayload = updatePayload || []).push(
-                JSCompiler_inline_result,
-                "" + nextProp
-              )
-            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-              "suppressHydrationWarning" !== JSCompiler_inline_result &&
-              (registrationNameDependencies.hasOwnProperty(
-                JSCompiler_inline_result
-              )
-                ? (null != nextProp &&
-                    "onScroll" === JSCompiler_inline_result &&
-                    listenToNonDelegatedEvent("scroll", current),
-                  updatePayload ||
-                    lastStyle === nextProp ||
-                    (updatePayload = []))
-                : (updatePayload = updatePayload || []).push(
-                    JSCompiler_inline_result,
-                    nextProp
-                  ));
-    }
-    type && (updatePayload = updatePayload || []).push("style", type);
-    var JSCompiler_inline_result = updatePayload;
-    (workInProgress.updateQueue = JSCompiler_inline_result) &&
-      markUpdate(workInProgress);
+            2 * now() - type.renderingStartTime >
+              workInProgressRootRenderTargetTime &&
+              1073741824 !== renderLanes &&
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              cutOffTailIfNeeded(type, !1),
+              (workInProgress.lanes = 8388608));
+        type.isBackwards
+          ? ((cache$110.sibling = workInProgress.child),
+            (workInProgress.child = cache$110))
+          : ((current = type.last),
+            null !== current
+              ? (current.sibling = cache$110)
+              : (workInProgress.child = cache$110),
+            (type.last = cache$110));
+      }
+      if (null !== type.tail)
+        return (
+          (workInProgress = type.tail),
+          (type.rendering = workInProgress),
+          (type.tail = workInProgress.sibling),
+          (type.renderingStartTime = now()),
+          (workInProgress.sibling = null),
+          (current = suspenseStackCursor.current),
+          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
+          workInProgress
+        );
+      bubbleProperties(workInProgress);
+      return null;
+    case 21:
+      return (
+        null === current
+          ? ((current = {
+              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+              containsNode: containsNode$1,
+              getChildContextValues: getChildContextValues
+            }),
+            (workInProgress.stateNode = current),
+            (current[internalInstanceKey] = workInProgress),
+            null !== workInProgress.ref &&
+              (markRef(workInProgress), markUpdate(workInProgress)))
+          : (null !== workInProgress.ref && markUpdate(workInProgress),
+            current.ref !== workInProgress.ref && markRef(workInProgress)),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        (newProps = null !== workInProgress.memoizedState),
+        23 !== workInProgress.tag &&
+          (null !== current
+            ? (null !== current.memoizedState) !== newProps &&
+              (workInProgress.flags |= 8192)
+            : newProps && (workInProgress.flags |= 8192)),
+        newProps && 0 !== (workInProgress.mode & 1)
+          ? 0 !== (renderLanes & 1073741824) &&
+            0 === (workInProgress.flags & 128) &&
+            (bubbleProperties(workInProgress),
+            23 !== workInProgress.tag &&
+              workInProgress.subtreeFlags & 6 &&
+              (workInProgress.flags |= 8192))
+          : bubbleProperties(workInProgress),
+        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
+        (renderLanes = null),
+        null !== current &&
+          null !== current.memoizedState &&
+          null !== current.memoizedState.cachePool &&
+          (renderLanes = current.memoizedState.cachePool.pool),
+        (newProps = null),
+        null !== workInProgress.memoizedState &&
+          null !== workInProgress.memoizedState.cachePool &&
+          (newProps = workInProgress.memoizedState.cachePool.pool),
+        newProps !== renderLanes && (workInProgress.flags |= 2048),
+        popTransition(workInProgress, current),
+        null
+      );
+    case 24:
+      return (
+        (renderLanes = null),
+        null !== current && (renderLanes = current.memoizedState.cache),
+        workInProgress.memoizedState.cache !== renderLanes &&
+          (workInProgress.flags |= 2048),
+        popProvider(CacheContext),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 25:
+      return (
+        enableTransitionTracing &&
+          (null !== workInProgress.stateNode &&
+            enableTransitionTracing &&
+            pop(markerInstanceStack),
+          bubbleProperties(workInProgress)),
+        null
+      );
   }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (!isHydrating)
-    switch (renderState.tailMode) {
-      case "hidden":
-        hasRenderedATailFallback = renderState.tail;
-        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
-          null !== hasRenderedATailFallback.alternate &&
-            (lastTailNode = hasRenderedATailFallback),
-            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
-        null === lastTailNode
-          ? (renderState.tail = null)
-          : (lastTailNode.sibling = null);
-        break;
-      case "collapsed":
-        lastTailNode = renderState.tail;
-        for (var lastTailNode$143 = null; null !== lastTailNode; )
-          null !== lastTailNode.alternate && (lastTailNode$143 = lastTailNode),
-            (lastTailNode = lastTailNode.sibling);
-        null === lastTailNode$143
-          ? hasRenderedATailFallback || null === renderState.tail
-            ? (renderState.tail = null)
-            : (renderState.tail.sibling = null)
-          : (lastTailNode$143.sibling = null);
-    }
-}
-function bubbleProperties(completedWork) {
-  var didBailout =
-      null !== completedWork.alternate &&
-      completedWork.alternate.child === completedWork.child,
-    newChildLanes = 0,
-    subtreeFlags = 0;
-  if (didBailout)
-    for (var child$144 = completedWork.child; null !== child$144; )
-      (newChildLanes |= child$144.lanes | child$144.childLanes),
-        (subtreeFlags |= child$144.subtreeFlags & 14680064),
-        (subtreeFlags |= child$144.flags & 14680064),
-        (child$144.return = completedWork),
-        (child$144 = child$144.sibling);
-  else
-    for (child$144 = completedWork.child; null !== child$144; )
-      (newChildLanes |= child$144.lanes | child$144.childLanes),
-        (subtreeFlags |= child$144.subtreeFlags),
-        (subtreeFlags |= child$144.flags),
-        (child$144.return = completedWork),
-        (child$144 = child$144.sibling);
-  completedWork.subtreeFlags |= subtreeFlags;
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
+function unwindWork(current, workInProgress) {
+  popTreeContext(workInProgress);
+  switch (workInProgress.tag) {
+    case 1:
+      return (
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 3:
+      return (
+        popProvider(CacheContext),
+        enableTransitionTracing &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        enableTransitionTracing && pop(transitionStack),
+        popHostContainer(),
+        resetWorkInProgressVersions(),
+        (current = workInProgress.flags),
+        0 !== (current & 65536) && 0 === (current & 128)
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 26:
+    case 27:
+    case 5:
+      return popHostContext(workInProgress), null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      current = workInProgress.memoizedState;
+      if (null !== current && null !== current.dehydrated) {
+        if (null === workInProgress.alternate)
+          throw Error(formatProdErrorMessage(340));
+        resetHydrationState();
+      }
+      current = workInProgress.flags;
+      return current & 65536
+        ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+        : null;
+    case 19:
+      return pop(suspenseStackCursor), null;
+    case 4:
+      return popHostContainer(), null;
+    case 10:
+      return popProvider(workInProgress.type._context), null;
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        popTransition(workInProgress, current),
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 24:
+      return popProvider(CacheContext), null;
+    case 25:
+      return (
+        enableTransitionTracing &&
+          null !== workInProgress.stateNode &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        null
+      );
+    default:
+      return null;
+  }
 }
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps;
-  popTreeContext(workInProgress);
-  switch (workInProgress.tag) {
-    case 2:
-    case 16:
-    case 15:
-    case 0:
-    case 11:
-    case 7:
-    case 8:
-    case 12:
-    case 9:
-    case 14:
-      return bubbleProperties(workInProgress), null;
-    case 1:
-      return bubbleProperties(workInProgress), null;
+function unwindInterruptedWork(current, interruptedWork) {
+  popTreeContext(interruptedWork);
+  switch (interruptedWork.tag) {
     case 3:
-      renderLanes = workInProgress.stateNode;
-      enableTransitionTracing &&
-        null !== workInProgressTransitions &&
-        (workInProgress.flags |= 2048);
-      newProps = null;
-      null !== current && (newProps = current.memoizedState.cache);
-      workInProgress.memoizedState.cache !== newProps &&
-        (workInProgress.flags |= 2048);
       popProvider(CacheContext);
       enableTransitionTracing &&
         enableTransitionTracing &&
@@ -9821,5257 +7074,8070 @@ function completeWork(current, workInProgress, renderLanes) {
       enableTransitionTracing && pop(transitionStack);
       popHostContainer();
       resetWorkInProgressVersions();
-      renderLanes.pendingContext &&
-        ((renderLanes.context = renderLanes.pendingContext),
-        (renderLanes.pendingContext = null));
-      if (null === current || null === current.child)
-        popHydrationState(workInProgress)
-          ? markUpdate(workInProgress)
-          : null === current ||
-            (current.memoizedState.isDehydrated &&
-              0 === (workInProgress.flags & 256)) ||
-            ((workInProgress.flags |= 1024),
-            null !== hydrationErrors &&
-              (queueRecoverableErrors(hydrationErrors),
-              (hydrationErrors = null)));
-      bubbleProperties(workInProgress);
-      enableTransitionTracing &&
-        0 !== (workInProgress.subtreeFlags & 8192) &&
-        (workInProgress.flags |= 2048);
-      return null;
+      break;
     case 26:
-      return (
-        (current ? current.ref : null) !== workInProgress.ref &&
-          markRef(workInProgress),
-        null === current ||
-        current.memoizedState !== workInProgress.memoizedState
-          ? markUpdate(workInProgress)
-          : null === workInProgress.memoizedState &&
-            updateHostComponent(
-              current,
-              workInProgress,
-              workInProgress.type,
-              workInProgress.pendingProps
-            ),
-        bubbleProperties(workInProgress),
-        null
-      );
     case 27:
-      popHostContext(workInProgress);
-      renderLanes = rootInstanceStackCursor.current;
-      var type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, type, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor.current;
-        popHydrationState(workInProgress)
-          ? prepareToHydrateHostInstance(workInProgress, current)
-          : ((workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              renderLanes
-            )),
-            markUpdate(workInProgress));
-        null !== workInProgress.ref && markRef(workInProgress);
+    case 5:
+      popHostContext(interruptedWork);
+      break;
+    case 4:
+      popHostContainer();
+      break;
+    case 13:
+      popSuspenseHandler(interruptedWork);
+      break;
+    case 19:
+      pop(suspenseStackCursor);
+      break;
+    case 10:
+      popProvider(interruptedWork.type._context);
+      break;
+    case 22:
+    case 23:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+    case 24:
+      popProvider(CacheContext);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        null !== interruptedWork.stateNode &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+  }
+}
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
+if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
+  throw Error(formatProdErrorMessage(255));
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
+}
+var hasError = !1,
+  caughtError = null,
+  hasRethrowError = !1,
+  rethrowError = null,
+  reporter = {
+    onError: function (error) {
+      hasError = !0;
+      caughtError = error;
+    }
+  };
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = !1;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
+) {
+  invokeGuardedCallback.apply(this, arguments);
+  if (hasError) {
+    if (hasError) {
+      var error = caughtError;
+      hasError = !1;
+      caughtError = null;
+    } else throw Error(formatProdErrorMessage(198));
+    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
+  }
+}
+var offscreenSubtreeIsHidden = !1,
+  offscreenSubtreeWasHidden = !1,
+  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+  nextEffect = null;
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    var ref = current.ref;
+    if (null !== ref) {
+      var instance = current.stateNode;
+      switch (current.tag) {
+        case 26:
+        case 27:
+        case 5:
+          var instanceToUse = instance;
+          break;
+        default:
+          instanceToUse = instance;
+      }
+      21 === current.tag && (instanceToUse = instance);
+      "function" === typeof ref
+        ? (current.refCleanup = ref(instanceToUse))
+        : (ref.current = instanceToUse);
+    }
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+function safelyDetachRef(current, nearestMountedAncestor) {
+  var ref = current.ref,
+    refCleanup = current.refCleanup;
+  if (null !== ref)
+    if ("function" === typeof refCleanup)
+      try {
+        refCleanup();
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        (current.refCleanup = null),
+          (current = current.alternate),
+          null != current && (current.refCleanup = null);
+      }
+    else if ("function" === typeof ref)
+      try {
+        ref(null);
+      } catch (error$125) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$125);
+      }
+    else ref.current = null;
+}
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+var focusedInstanceHandle = null,
+  shouldFireAfterActiveInstanceBlur = !1;
+function commitBeforeMutationEffects(root, firstChild) {
+  eventsEnabled = _enabled;
+  root = getActiveElementDeep();
+  if (hasSelectionCapabilities(root)) {
+    if ("selectionStart" in root)
+      var JSCompiler_temp = {
+        start: root.selectionStart,
+        end: root.selectionEnd
+      };
+    else
+      a: {
+        JSCompiler_temp =
+          ((JSCompiler_temp = root.ownerDocument) &&
+            JSCompiler_temp.defaultView) ||
+          window;
+        var selection =
+          JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
+        if (selection && 0 !== selection.rangeCount) {
+          JSCompiler_temp = selection.anchorNode;
+          var anchorOffset = selection.anchorOffset,
+            focusNode = selection.focusNode;
+          selection = selection.focusOffset;
+          try {
+            JSCompiler_temp.nodeType, focusNode.nodeType;
+          } catch (e$187) {
+            JSCompiler_temp = null;
+            break a;
+          }
+          var length = 0,
+            start = -1,
+            end = -1,
+            indexWithinAnchor = 0,
+            indexWithinFocus = 0,
+            node = root,
+            parentNode = null;
+          b: for (;;) {
+            for (var next; ; ) {
+              node !== JSCompiler_temp ||
+                (0 !== anchorOffset && 3 !== node.nodeType) ||
+                (start = length + anchorOffset);
+              node !== focusNode ||
+                (0 !== selection && 3 !== node.nodeType) ||
+                (end = length + selection);
+              3 === node.nodeType && (length += node.nodeValue.length);
+              if (null === (next = node.firstChild)) break;
+              parentNode = node;
+              node = next;
+            }
+            for (;;) {
+              if (node === root) break b;
+              parentNode === JSCompiler_temp &&
+                ++indexWithinAnchor === anchorOffset &&
+                (start = length);
+              parentNode === focusNode &&
+                ++indexWithinFocus === selection &&
+                (end = length);
+              if (null !== (next = node.nextSibling)) break;
+              node = parentNode;
+              parentNode = node.parentNode;
+            }
+            node = next;
+          }
+          JSCompiler_temp =
+            -1 === start || -1 === end ? null : { start: start, end: end };
+        } else JSCompiler_temp = null;
       }
-      bubbleProperties(workInProgress);
-      return null;
-    case 5:
-      popHostContext(workInProgress);
-      renderLanes = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, renderLanes, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor.current;
-        if (popHydrationState(workInProgress))
-          prepareToHydrateHostInstance(workInProgress, current) &&
-            markUpdate(workInProgress);
-        else {
-          type = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
-          );
-          switch (current) {
-            case "http://www.w3.org/2000/svg":
-            case "http://www.w3.org/1998/Math/MathML":
-              current = type.createElementNS(current, renderLanes);
+    JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
+  } else JSCompiler_temp = null;
+  selectionInformation = { focusedElem: root, selectionRange: JSCompiler_temp };
+  root = null;
+  JSCompiler_temp = selectionInformation.focusedElem;
+  null !== JSCompiler_temp &&
+    (root = getClosestInstanceFromNode(JSCompiler_temp));
+  _enabled = !1;
+  focusedInstanceHandle = root;
+  for (nextEffect = firstChild; null !== nextEffect; ) {
+    firstChild = nextEffect;
+    root = firstChild.deletions;
+    if (null !== root)
+      for (
+        JSCompiler_temp = 0;
+        JSCompiler_temp < root.length;
+        JSCompiler_temp++
+      )
+        (anchorOffset = root[JSCompiler_temp]),
+          doesFiberContain(anchorOffset, focusedInstanceHandle) &&
+            ((shouldFireAfterActiveInstanceBlur = !0),
+            beforeActiveInstanceBlur(anchorOffset));
+    root = firstChild.child;
+    if (0 !== (firstChild.subtreeFlags & 9236) && null !== root)
+      (root.return = firstChild), (nextEffect = root);
+    else
+      for (; null !== nextEffect; ) {
+        firstChild = nextEffect;
+        try {
+          var current = firstChild.alternate,
+            flags = firstChild.flags,
+            JSCompiler_temp$jscomp$0;
+          if (
+            (JSCompiler_temp$jscomp$0 =
+              !shouldFireAfterActiveInstanceBlur &&
+              null !== focusedInstanceHandle)
+          ) {
+            var JSCompiler_temp$jscomp$1;
+            if ((JSCompiler_temp$jscomp$1 = 13 === firstChild.tag))
+              a: {
+                if (null !== current) {
+                  var oldState = current.memoizedState;
+                  if (null === oldState || null !== oldState.dehydrated) {
+                    var newState = firstChild.memoizedState;
+                    JSCompiler_temp$jscomp$1 =
+                      null !== newState && null === newState.dehydrated;
+                    break a;
+                  }
+                }
+                JSCompiler_temp$jscomp$1 = !1;
+              }
+            JSCompiler_temp$jscomp$0 =
+              JSCompiler_temp$jscomp$1 &&
+              doesFiberContain(firstChild, focusedInstanceHandle);
+          }
+          JSCompiler_temp$jscomp$0 &&
+            ((shouldFireAfterActiveInstanceBlur = !0),
+            beforeActiveInstanceBlur(firstChild));
+          switch (firstChild.tag) {
+            case 0:
+              if (0 !== (flags & 4)) {
+                var updateQueue = firstChild.updateQueue,
+                  eventPayloads =
+                    null !== updateQueue ? updateQueue.events : null;
+                if (null !== eventPayloads)
+                  for (root = 0; root < eventPayloads.length; root++) {
+                    var _eventPayloads$ii = eventPayloads[root];
+                    _eventPayloads$ii.ref.impl = _eventPayloads$ii.nextImpl;
+                  }
+              }
               break;
-            default:
-              switch (renderLanes) {
-                case "svg":
-                  current = type.createElementNS(
-                    "http://www.w3.org/2000/svg",
-                    renderLanes
-                  );
-                  break;
-                case "math":
-                  current = type.createElementNS(
-                    "http://www.w3.org/1998/Math/MathML",
-                    renderLanes
+            case 11:
+            case 15:
+              break;
+            case 1:
+              if (0 !== (flags & 1024) && null !== current) {
+                var prevProps = current.memoizedProps,
+                  prevState = current.memoizedState,
+                  instance = firstChild.stateNode,
+                  snapshot = instance.getSnapshotBeforeUpdate(
+                    firstChild.elementType === firstChild.type
+                      ? prevProps
+                      : resolveDefaultProps(firstChild.type, prevProps),
+                    prevState
                   );
-                  break;
-                case "script":
-                  current = type.createElement("div");
-                  current.innerHTML = "<script>\x3c/script>";
-                  current = current.removeChild(current.firstChild);
-                  break;
-                case "select":
-                  current =
-                    "string" === typeof newProps.is
-                      ? type.createElement("select", { is: newProps.is })
-                      : type.createElement("select");
-                  newProps.multiple
-                    ? (current.multiple = !0)
-                    : newProps.size && (current.size = newProps.size);
-                  break;
-                default:
-                  current = createHTMLElement(renderLanes, newProps, type);
+                instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+              }
+              break;
+            case 3:
+              if (0 !== (flags & 1024)) {
+                var container = firstChild.stateNode.containerInfo,
+                  nodeType = container.nodeType;
+                if (9 === nodeType) clearContainerSparingly(container);
+                else if (1 === nodeType)
+                  switch (container.nodeName) {
+                    case "HEAD":
+                    case "HTML":
+                    case "BODY":
+                      clearContainerSparingly(container);
+                      break;
+                    default:
+                      container.textContent = "";
+                  }
               }
+              break;
+            case 5:
+            case 26:
+            case 27:
+            case 6:
+            case 4:
+            case 17:
+              break;
+            default:
+              if (0 !== (flags & 1024))
+                throw Error(formatProdErrorMessage(163));
+          }
+        } catch (error) {
+          captureCommitPhaseError(firstChild, firstChild.return, error);
+        }
+        root = firstChild.sibling;
+        if (null !== root) {
+          root.return = firstChild.return;
+          nextEffect = root;
+          break;
+        }
+        nextEffect = firstChild.return;
+      }
+  }
+  current = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = !1;
+  focusedInstanceHandle = null;
+  return current;
+}
+function commitHookEffectListUnmount(
+  flags,
+  finishedWork,
+  nearestMountedAncestor
+) {
+  var updateQueue = finishedWork.updateQueue;
+  updateQueue = null !== updateQueue ? updateQueue.lastEffect : null;
+  if (null !== updateQueue) {
+    var effect = (updateQueue = updateQueue.next);
+    do {
+      if ((effect.tag & flags) === flags) {
+        var destroy = effect.destroy;
+        effect.destroy = void 0;
+        void 0 !== destroy &&
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+      }
+      effect = effect.next;
+    } while (effect !== updateQueue);
+  }
+}
+function commitHookEffectListMount(flags, finishedWork) {
+  finishedWork = finishedWork.updateQueue;
+  finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
+  if (null !== finishedWork) {
+    var effect = (finishedWork = finishedWork.next);
+    do {
+      if ((effect.tag & flags) === flags) {
+        var create = effect.create;
+        effect.destroy = create();
+      }
+      effect = effect.next;
+    } while (effect !== finishedWork);
+  }
+}
+function commitHookLayoutEffects(finishedWork, hookFlags) {
+  try {
+    commitHookEffectListMount(hookFlags, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+function commitClassCallbacks(finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  if (null !== updateQueue) {
+    var instance = finishedWork.stateNode;
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+function commitHostComponentMount(finishedWork) {
+  var type = finishedWork.type,
+    props = finishedWork.memoizedProps,
+    instance = finishedWork.stateNode;
+  try {
+    a: switch (type) {
+      case "button":
+      case "input":
+      case "select":
+      case "textarea":
+        props.autoFocus && instance.focus();
+        break a;
+      case "img":
+        props.src && (instance.src = props.src);
+    }
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+  var flags = finishedWork.flags;
+  switch (finishedWork.tag) {
+    case 0:
+    case 11:
+    case 15:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 && commitHookLayoutEffects(finishedWork, 5);
+      break;
+    case 1:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      if (flags & 4)
+        if (((finishedRoot = finishedWork.stateNode), null === current))
+          try {
+            finishedRoot.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
           }
-          current[internalInstanceKey] = workInProgress;
-          current[internalPropsKey] = newProps;
-          a: for (type = workInProgress.child; null !== type; ) {
-            if (5 === type.tag || 6 === type.tag)
-              current.appendChild(type.stateNode);
-            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
-              type.child.return = type;
-              type = type.child;
-              continue;
-            }
-            if (type === workInProgress) break a;
-            for (; null === type.sibling; ) {
-              if (null === type.return || type.return === workInProgress)
-                break a;
-              type = type.return;
-            }
-            type.sibling.return = type.return;
-            type = type.sibling;
+        else {
+          var prevProps =
+            finishedWork.elementType === finishedWork.type
+              ? current.memoizedProps
+              : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+          current = current.memoizedState;
+          try {
+            finishedRoot.componentDidUpdate(
+              prevProps,
+              current,
+              finishedRoot.__reactInternalSnapshotBeforeUpdate
+            );
+          } catch (error$127) {
+            captureCommitPhaseError(
+              finishedWork,
+              finishedWork.return,
+              error$127
+            );
           }
-          workInProgress.stateNode = current;
-          a: switch (
-            (setInitialProperties(current, renderLanes, newProps), renderLanes)
-          ) {
-            case "button":
-            case "input":
-            case "select":
-            case "textarea":
-              current = !!newProps.autoFocus;
-              break a;
-            case "img":
-              current = !0;
-              break a;
-            default:
-              current = !1;
+        }
+      flags & 64 && commitClassCallbacks(finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    case 3:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      if (flags & 64 && ((flags = finishedWork.updateQueue), null !== flags)) {
+        finishedRoot = null;
+        if (null !== finishedWork.child)
+          switch (finishedWork.child.tag) {
+            case 27:
+            case 5:
+              finishedRoot = finishedWork.child.stateNode;
+              break;
+            case 1:
+              finishedRoot = finishedWork.child.stateNode;
           }
-          current && markUpdate(workInProgress);
+        try {
+          commitCallbacks(flags, finishedRoot);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
         }
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        current.memoizedProps !== newProps && markUpdate(workInProgress);
-      else {
-        if ("string" !== typeof newProps && null === workInProgress.stateNode)
-          throw Error(formatProdErrorMessage(166));
-        current = rootInstanceStackCursor.current;
-        if (popHydrationState(workInProgress)) {
-          newProps = workInProgress.stateNode;
-          current = workInProgress.memoizedProps;
-          newProps[internalInstanceKey] = workInProgress;
-          if ((renderLanes = newProps.nodeValue !== current))
-            if (((type = hydrationParentFiber), null !== type))
-              switch (type.tag) {
-                case 3:
-                  newProps = newProps.nodeValue;
-                  normalizeMarkupForTextOrAttribute(current);
-                  normalizeMarkupForTextOrAttribute(newProps);
-                  break;
-                case 27:
-                case 5:
-                  !0 !== type.memoizedProps.suppressHydrationWarning &&
-                    ((newProps = newProps.nodeValue),
-                    normalizeMarkupForTextOrAttribute(current),
-                    normalizeMarkupForTextOrAttribute(newProps));
-              }
-          renderLanes && markUpdate(workInProgress);
-        } else
-          (current =
-            getOwnerDocumentFromRootContainer(current).createTextNode(
-              newProps
-            )),
-            (current[internalInstanceKey] = workInProgress),
-            (workInProgress.stateNode = current);
       }
-      bubbleProperties(workInProgress);
-      return null;
+      break;
+    case 26:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    case 27:
+    case 5:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      null === current && flags & 4 && commitHostComponentMount(finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    case 12:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      break;
     case 13:
-      popSuspenseHandler(workInProgress);
-      newProps = workInProgress.memoizedState;
-      if (
-        null === current ||
-        (null !== current.memoizedState &&
-          null !== current.memoizedState.dehydrated)
-      ) {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+      break;
+    case 22:
+      if (0 !== (finishedWork.mode & 1)) {
         if (
-          isHydrating &&
-          null !== nextHydratableInstance &&
-          0 !== (workInProgress.mode & 1) &&
-          0 === (workInProgress.flags & 128)
-        )
-          warnIfUnhydratedTailNodes(),
-            resetHydrationState(),
-            (workInProgress.flags |= 98560),
-            (type = !1);
-        else if (
-          ((type = popHydrationState(workInProgress)),
-          null !== newProps && null !== newProps.dehydrated)
+          ((prevProps =
+            null !== finishedWork.memoizedState || offscreenSubtreeIsHidden),
+          !prevProps)
+        ) {
+          current =
+            (null !== current && null !== current.memoizedState) ||
+            offscreenSubtreeWasHidden;
+          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
+            prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevProps;
+          (offscreenSubtreeWasHidden = current) &&
+          !prevOffscreenSubtreeWasHidden
+            ? recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                0 !== (finishedWork.subtreeFlags & 8772)
+              )
+            : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        }
+      } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 512 &&
+        ("manual" === finishedWork.memoizedProps.mode
+          ? safelyAttachRef(finishedWork, finishedWork.return)
+          : safelyDetachRef(finishedWork, finishedWork.return));
+      break;
+    default:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+  }
+}
+function abortRootTransitions(
+  root,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance
+) {
+  if (enableTransitionTracing) {
+    var rootTransitions = root.incompleteTransitions;
+    deletedTransitions.forEach(function (transition) {
+      rootTransitions.has(transition) &&
+        ((transition = rootTransitions.get(transition)),
+        null === transition.aborts && (transition.aborts = []),
+        transition.aborts.push(abort),
+        null !== deletedOffscreenInstance &&
+          null !== transition.pendingBoundaries &&
+          transition.pendingBoundaries.has(deletedOffscreenInstance) &&
+          transition.pendingBoundaries.delete(deletedOffscreenInstance));
+    });
+  }
+}
+function abortTracingMarkerTransitions(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    var markerInstance = abortedFiber.stateNode,
+      markerTransitions = markerInstance.transitions,
+      pendingBoundaries = markerInstance.pendingBoundaries;
+    null !== markerTransitions &&
+      deletedTransitions.forEach(function (transition) {
+        if (
+          null !== abortedFiber &&
+          markerTransitions.has(transition) &&
+          (null === markerInstance.aborts ||
+            !markerInstance.aborts.includes(abort)) &&
+          null !== markerInstance.transitions
         ) {
-          if (null === current) {
-            if (!type) throw Error(formatProdErrorMessage(318));
-            type = workInProgress.memoizedState;
-            type = null !== type ? type.dehydrated : null;
-            if (!type) throw Error(formatProdErrorMessage(317));
-            type[internalInstanceKey] = workInProgress;
-          } else
-            resetHydrationState(),
-              0 === (workInProgress.flags & 128) &&
-                (workInProgress.memoizedState = null),
-              (workInProgress.flags |= 4);
-          bubbleProperties(workInProgress);
-          type = !1;
-        } else
-          null !== hydrationErrors &&
-            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
-            (type = !0);
-        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
-      }
-      if (0 !== (workInProgress.flags & 128))
-        return (workInProgress.lanes = renderLanes), workInProgress;
-      renderLanes = null !== newProps;
-      current = null !== current && null !== current.memoizedState;
-      if (renderLanes) {
-        newProps = workInProgress.child;
-        type = null;
-        null !== newProps.alternate &&
-          null !== newProps.alternate.memoizedState &&
-          null !== newProps.alternate.memoizedState.cachePool &&
-          (type = newProps.alternate.memoizedState.cachePool.pool);
-        var cache$154 = null;
-        null !== newProps.memoizedState &&
-          null !== newProps.memoizedState.cachePool &&
-          (cache$154 = newProps.memoizedState.cachePool.pool);
-        cache$154 !== type && (newProps.flags |= 2048);
+          if (null === markerInstance.aborts) {
+            markerInstance.aborts = [abort];
+            transition = abortedFiber.memoizedProps.name;
+            var transitions = markerInstance.transitions,
+              aborts = markerInstance.aborts;
+            enableTransitionTracing &&
+              (null === currentPendingTransitionCallbacks &&
+                (currentPendingTransitionCallbacks = {
+                  transitionStart: null,
+                  transitionProgress: null,
+                  transitionComplete: null,
+                  markerProgress: null,
+                  markerIncomplete: new Map(),
+                  markerComplete: null
+                }),
+              null === currentPendingTransitionCallbacks.markerIncomplete &&
+                (currentPendingTransitionCallbacks.markerIncomplete =
+                  new Map()),
+              currentPendingTransitionCallbacks.markerIncomplete.set(
+                transition,
+                { transitions: transitions, aborts: aborts }
+              ));
+          } else markerInstance.aborts.push(abort);
+          null !== deletedOffscreenInstance &&
+            !isInDeletedTree &&
+            null !== pendingBoundaries &&
+            pendingBoundaries.has(deletedOffscreenInstance) &&
+            (pendingBoundaries.delete(deletedOffscreenInstance),
+            addMarkerProgressCallbackToPendingTransition(
+              abortedFiber.memoizedProps.name,
+              deletedTransitions,
+              pendingBoundaries
+            ));
+        }
+      });
+  }
+}
+function abortParentMarkerTransitionsForDeletedFiber(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing)
+    for (; null !== abortedFiber; ) {
+      switch (abortedFiber.tag) {
+        case 25:
+          abortTracingMarkerTransitions(
+            abortedFiber,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance,
+            isInDeletedTree
+          );
+          break;
+        case 3:
+          abortRootTransitions(
+            abortedFiber.stateNode,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance
+          );
       }
-      renderLanes !== current &&
-        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
-        renderLanes && (workInProgress.child.flags |= 8192));
-      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
-      null !== workInProgress.updateQueue &&
-        null != workInProgress.memoizedProps.suspenseCallback &&
-        (workInProgress.flags |= 4);
-      bubbleProperties(workInProgress);
-      return null;
-    case 4:
-      return (
-        popHostContainer(),
-        null === current &&
-          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
-        bubbleProperties(workInProgress),
-        null
+      abortedFiber = abortedFiber.return;
+    }
+}
+function commitTransitionProgress(offscreenFiber) {
+  if (enableTransitionTracing) {
+    var offscreenInstance = offscreenFiber.stateNode,
+      prevState = null,
+      previousFiber = offscreenFiber.alternate;
+    null !== previousFiber &&
+      null !== previousFiber.memoizedState &&
+      (prevState = previousFiber.memoizedState);
+    prevState = null !== prevState;
+    previousFiber = null !== offscreenFiber.memoizedState;
+    var pendingMarkers = offscreenInstance._pendingMarkers,
+      name = null;
+    offscreenFiber = offscreenFiber.return;
+    null !== offscreenFiber &&
+      13 === offscreenFiber.tag &&
+      offscreenFiber.memoizedProps.unstable_name &&
+      (name = offscreenFiber.memoizedProps.unstable_name);
+    !prevState && previousFiber
+      ? null !== pendingMarkers &&
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries,
+            transitions = markerInstance.transitions,
+            markerName = markerInstance.name;
+          null === pendingBoundaries ||
+            pendingBoundaries.has(offscreenInstance) ||
+            (pendingBoundaries.set(offscreenInstance, { name: name }),
+            null !== transitions &&
+              (1 === markerInstance.tag && null !== markerName
+                ? addMarkerProgressCallbackToPendingTransition(
+                    markerName,
+                    transitions,
+                    pendingBoundaries
+                  )
+                : 0 === markerInstance.tag &&
+                  transitions.forEach(function (transition) {
+                    addTransitionProgressCallbackToPendingTransition(
+                      transition,
+                      pendingBoundaries
+                    );
+                  })));
+        })
+      : prevState &&
+        !previousFiber &&
+        null !== pendingMarkers &&
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries,
+            transitions = markerInstance.transitions,
+            markerName = markerInstance.name;
+          null !== pendingBoundaries &&
+            pendingBoundaries.has(offscreenInstance) &&
+            (pendingBoundaries.delete(offscreenInstance),
+            null !== transitions &&
+              (1 === markerInstance.tag && null !== markerName
+                ? (addMarkerProgressCallbackToPendingTransition(
+                    markerName,
+                    transitions,
+                    pendingBoundaries
+                  ),
+                  0 === pendingBoundaries.size &&
+                    (null === markerInstance.aborts &&
+                      addMarkerCompleteCallbackToPendingTransition(
+                        markerName,
+                        transitions
+                      ),
+                    (markerInstance.transitions = null),
+                    (markerInstance.pendingBoundaries = null),
+                    (markerInstance.aborts = null)))
+                : 0 === markerInstance.tag &&
+                  transitions.forEach(function (transition) {
+                    addTransitionProgressCallbackToPendingTransition(
+                      transition,
+                      pendingBoundaries
+                    );
+                  })));
+        });
+  }
+}
+function detachFiberAfterEffects(fiber) {
+  var alternate = fiber.alternate;
+  null !== alternate &&
+    ((fiber.alternate = null), detachFiberAfterEffects(alternate));
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null;
+  5 === fiber.tag &&
+    ((alternate = fiber.stateNode),
+    null !== alternate && detachDeletedInstance(alternate));
+  fiber.stateNode = null;
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null;
+  fiber.updateQueue = null;
+}
+function isHostParent(fiber) {
+  return (
+    5 === fiber.tag ||
+    3 === fiber.tag ||
+    26 === fiber.tag ||
+    27 === fiber.tag ||
+    4 === fiber.tag
+  );
+}
+function getHostSibling(fiber) {
+  a: for (;;) {
+    for (; null === fiber.sibling; ) {
+      if (null === fiber.return || isHostParent(fiber.return)) return null;
+      fiber = fiber.return;
+    }
+    fiber.sibling.return = fiber.return;
+    for (
+      fiber = fiber.sibling;
+      5 !== fiber.tag &&
+      6 !== fiber.tag &&
+      27 !== fiber.tag &&
+      18 !== fiber.tag;
+
+    ) {
+      if (fiber.flags & 2) continue a;
+      if (null === fiber.child || 4 === fiber.tag) continue a;
+      else (fiber.child.return = fiber), (fiber = fiber.child);
+    }
+    if (!(fiber.flags & 2)) return fiber.stateNode;
+  }
+}
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  var tag = node.tag;
+  if (5 === tag || 6 === tag)
+    (node = node.stateNode),
+      before
+        ? 8 === parent.nodeType
+          ? parent.parentNode.insertBefore(node, before)
+          : parent.insertBefore(node, before)
+        : (8 === parent.nodeType
+            ? ((before = parent.parentNode), before.insertBefore(node, parent))
+            : ((before = parent), before.appendChild(node)),
+          (parent = parent._reactRootContainer),
+          (null !== parent && void 0 !== parent) ||
+            null !== before.onclick ||
+            (before.onclick = noop));
+  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
+    for (
+      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
+        node = node.sibling;
+      null !== node;
+
+    )
+      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
+        (node = node.sibling);
+}
+function insertOrAppendPlacementNode(node, before, parent) {
+  var tag = node.tag;
+  if (5 === tag || 6 === tag)
+    (node = node.stateNode),
+      before ? parent.insertBefore(node, before) : parent.appendChild(node);
+  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
+    for (
+      insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
+      null !== node;
+
+    )
+      insertOrAppendPlacementNode(node, before, parent), (node = node.sibling);
+}
+var hostParent = null,
+  hostParentIsContainer = !1;
+function recursivelyTraverseDeletionEffects(
+  finishedRoot,
+  nearestMountedAncestor,
+  parent
+) {
+  for (parent = parent.child; null !== parent; )
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent),
+      (parent = parent.sibling);
+}
+function commitDeletionEffectsOnFiber(
+  finishedRoot,
+  nearestMountedAncestor,
+  deletedFiber
+) {
+  if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+    } catch (err) {}
+  switch (deletedFiber.tag) {
+    case 26:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
       );
-    case 10:
-      return (
-        popProvider(workInProgress.type._context),
-        bubbleProperties(workInProgress),
-        null
+      deletedFiber.memoizedState
+        ? deletedFiber.memoizedState.count--
+        : deletedFiber.stateNode &&
+          ((deletedFiber = deletedFiber.stateNode),
+          deletedFiber.parentNode.removeChild(deletedFiber));
+      break;
+    case 27:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      var prevHostParent = hostParent,
+        prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = deletedFiber.stateNode;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
       );
-    case 17:
-      return bubbleProperties(workInProgress), null;
-    case 19:
-      pop(suspenseStackCursor);
-      type = workInProgress.memoizedState;
-      if (null === type) return bubbleProperties(workInProgress), null;
-      newProps = 0 !== (workInProgress.flags & 128);
-      cache$154 = type.rendering;
-      if (null === cache$154)
-        if (newProps) cutOffTailIfNeeded(type, !1);
-        else {
-          if (
-            0 !== workInProgressRootExitStatus ||
-            (null !== current && 0 !== (current.flags & 128))
-          )
-            for (current = workInProgress.child; null !== current; ) {
-              cache$154 = findFirstSuspended(current);
-              if (null !== cache$154) {
-                workInProgress.flags |= 128;
-                cutOffTailIfNeeded(type, !1);
-                current = cache$154.updateQueue;
-                null !== current &&
-                  ((workInProgress.updateQueue = current),
-                  (workInProgress.flags |= 4));
-                workInProgress.subtreeFlags = 0;
-                current = renderLanes;
-                for (renderLanes = workInProgress.child; null !== renderLanes; )
-                  resetWorkInProgress(renderLanes, current),
-                    (renderLanes = renderLanes.sibling);
-                push(
-                  suspenseStackCursor,
-                  (suspenseStackCursor.current & 1) | 2
-                );
-                return workInProgress.child;
-              }
-              current = current.sibling;
-            }
-          null !== type.tail &&
-            now() > workInProgressRootRenderTargetTime &&
-            ((workInProgress.flags |= 128),
-            (newProps = !0),
-            cutOffTailIfNeeded(type, !1),
-            (workInProgress.lanes = 8388608));
-        }
-      else {
-        if (!newProps)
-          if (((current = findFirstSuspended(cache$154)), null !== current)) {
-            if (
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              (current = current.updateQueue),
-              null !== current &&
-                ((workInProgress.updateQueue = current),
-                (workInProgress.flags |= 4)),
-              cutOffTailIfNeeded(type, !0),
-              null === type.tail &&
-                "hidden" === type.tailMode &&
-                !cache$154.alternate &&
-                !isHydrating)
-            )
-              return bubbleProperties(workInProgress), null;
-          } else
-            2 * now() - type.renderingStartTime >
-              workInProgressRootRenderTargetTime &&
-              1073741824 !== renderLanes &&
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              cutOffTailIfNeeded(type, !1),
-              (workInProgress.lanes = 8388608));
-        type.isBackwards
-          ? ((cache$154.sibling = workInProgress.child),
-            (workInProgress.child = cache$154))
-          : ((current = type.last),
-            null !== current
-              ? (current.sibling = cache$154)
-              : (workInProgress.child = cache$154),
-            (type.last = cache$154));
-      }
-      if (null !== type.tail)
-        return (
-          (workInProgress = type.tail),
-          (type.rendering = workInProgress),
-          (type.tail = workInProgress.sibling),
-          (type.renderingStartTime = now()),
-          (workInProgress.sibling = null),
-          (current = suspenseStackCursor.current),
-          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
-          workInProgress
-        );
-      bubbleProperties(workInProgress);
-      return null;
-    case 21:
-      return (
-        null === current
-          ? ((current = {
-              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-              containsNode: containsNode,
-              getChildContextValues: getChildContextValues
-            }),
-            (workInProgress.stateNode = current),
-            (current[internalInstanceKey] = workInProgress),
-            null !== workInProgress.ref &&
-              (markRef(workInProgress), markUpdate(workInProgress)))
-          : (null !== workInProgress.ref && markUpdate(workInProgress),
-            current.ref !== workInProgress.ref && markRef(workInProgress)),
-        bubbleProperties(workInProgress),
-        null
+      deletedFiber = deletedFiber.stateNode;
+      for (finishedRoot = deletedFiber.attributes; finishedRoot.length; )
+        deletedFiber.removeAttributeNode(finishedRoot[0]);
+      detachDeletedInstance(deletedFiber);
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      break;
+    case 5:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+    case 6:
+      prevHostParent = hostParent;
+      prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = null;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      null !== hostParent &&
+        (hostParentIsContainer
+          ? ((finishedRoot = hostParent),
+            (deletedFiber = deletedFiber.stateNode),
+            8 === finishedRoot.nodeType
+              ? finishedRoot.parentNode.removeChild(deletedFiber)
+              : finishedRoot.removeChild(deletedFiber))
+          : hostParent.removeChild(deletedFiber.stateNode));
+      break;
+    case 18:
+      finishedRoot = finishedRoot.hydrationCallbacks;
+      null !== finishedRoot &&
+        (finishedRoot = finishedRoot.onDeleted) &&
+        finishedRoot(deletedFiber.stateNode);
+      null !== hostParent &&
+        (hostParentIsContainer
+          ? ((finishedRoot = hostParent),
+            (deletedFiber = deletedFiber.stateNode),
+            8 === finishedRoot.nodeType
+              ? clearSuspenseBoundary(finishedRoot.parentNode, deletedFiber)
+              : 1 === finishedRoot.nodeType &&
+                clearSuspenseBoundary(finishedRoot, deletedFiber),
+            retryIfBlockedOn(finishedRoot))
+          : clearSuspenseBoundary(hostParent, deletedFiber.stateNode));
+      break;
+    case 4:
+      prevHostParent = hostParent;
+      prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = deletedFiber.stateNode.containerInfo;
+      hostParentIsContainer = !0;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      break;
+    case 0:
+    case 11:
+    case 14:
+    case 15:
+      if (
+        !offscreenSubtreeWasHidden &&
+        ((prevHostParent = deletedFiber.updateQueue),
+        null !== prevHostParent &&
+          ((prevHostParent = prevHostParent.lastEffect),
+          null !== prevHostParent))
+      ) {
+        prevHostParentIsContainer = prevHostParent = prevHostParent.next;
+        do {
+          var _effect = prevHostParentIsContainer,
+            destroy = _effect.destroy;
+          _effect = _effect.tag;
+          void 0 !== destroy &&
+            (0 !== (_effect & 2)
+              ? safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy)
+              : 0 !== (_effect & 4) &&
+                safelyCallDestroy(
+                  deletedFiber,
+                  nearestMountedAncestor,
+                  destroy
+                ));
+          prevHostParentIsContainer = prevHostParentIsContainer.next;
+        } while (prevHostParentIsContainer !== prevHostParent);
+      }
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
       );
-    case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        (newProps = null !== workInProgress.memoizedState),
-        23 !== workInProgress.tag &&
-          (null !== current
-            ? (null !== current.memoizedState) !== newProps &&
-              (workInProgress.flags |= 8192)
-            : newProps && (workInProgress.flags |= 8192)),
-        newProps && 0 !== (workInProgress.mode & 1)
-          ? 0 !== (renderLanes & 1073741824) &&
-            0 === (workInProgress.flags & 128) &&
-            (bubbleProperties(workInProgress),
-            23 !== workInProgress.tag &&
-              workInProgress.subtreeFlags & 6 &&
-              (workInProgress.flags |= 8192))
-          : bubbleProperties(workInProgress),
-        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
-        (renderLanes = null),
-        null !== current &&
-          null !== current.memoizedState &&
-          null !== current.memoizedState.cachePool &&
-          (renderLanes = current.memoizedState.cachePool.pool),
-        (newProps = null),
-        null !== workInProgress.memoizedState &&
-          null !== workInProgress.memoizedState.cachePool &&
-          (newProps = workInProgress.memoizedState.cachePool.pool),
-        newProps !== renderLanes && (workInProgress.flags |= 2048),
-        popTransition(workInProgress, current),
-        null
+      break;
+    case 1:
+      if (
+        !offscreenSubtreeWasHidden &&
+        (safelyDetachRef(deletedFiber, nearestMountedAncestor),
+        (prevHostParent = deletedFiber.stateNode),
+        "function" === typeof prevHostParent.componentWillUnmount)
+      )
+        try {
+          (prevHostParent.props = deletedFiber.memoizedProps),
+            (prevHostParent.state = deletedFiber.memoizedState),
+            prevHostParent.componentWillUnmount();
+        } catch (error) {
+          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
+        }
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
       );
-    case 24:
-      return (
-        (renderLanes = null),
-        null !== current && (renderLanes = current.memoizedState.cache),
-        workInProgress.memoizedState.cache !== renderLanes &&
-          (workInProgress.flags |= 2048),
-        popProvider(CacheContext),
-        bubbleProperties(workInProgress),
-        null
+      break;
+    case 21:
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
       );
-    case 25:
-      return (
-        enableTransitionTracing &&
-          (null !== workInProgress.stateNode &&
-            enableTransitionTracing &&
-            pop(markerInstanceStack),
-          bubbleProperties(workInProgress)),
-        null
+      break;
+    case 22:
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      deletedFiber.mode & 1
+        ? ((offscreenSubtreeWasHidden =
+            (prevHostParent = offscreenSubtreeWasHidden) ||
+            null !== deletedFiber.memoizedState),
+          recursivelyTraverseDeletionEffects(
+            finishedRoot,
+            nearestMountedAncestor,
+            deletedFiber
+          ),
+          (offscreenSubtreeWasHidden = prevHostParent))
+        : recursivelyTraverseDeletionEffects(
+            finishedRoot,
+            nearestMountedAncestor,
+            deletedFiber
+          );
+      break;
+    default:
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
       );
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
-function unwindWork(current, workInProgress) {
-  popTreeContext(workInProgress);
-  switch (workInProgress.tag) {
-    case 1:
-      return (
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 3:
-      return (
-        popProvider(CacheContext),
-        enableTransitionTracing &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        enableTransitionTracing && pop(transitionStack),
-        popHostContainer(),
-        resetWorkInProgressVersions(),
-        (current = workInProgress.flags),
-        0 !== (current & 65536) && 0 === (current & 128)
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 26:
-    case 27:
-    case 5:
-      return popHostContext(workInProgress), null;
-    case 13:
-      popSuspenseHandler(workInProgress);
-      current = workInProgress.memoizedState;
-      if (null !== current && null !== current.dehydrated) {
-        if (null === workInProgress.alternate)
-          throw Error(formatProdErrorMessage(340));
-        resetHydrationState();
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+  if (null === finishedWork.memoizedState) {
+    var current = finishedWork.alternate;
+    if (
+      null !== current &&
+      ((current = current.memoizedState),
+      null !== current && ((current = current.dehydrated), null !== current))
+    )
+      try {
+        retryIfBlockedOn(current);
+        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+        if (null !== hydrationCallbacks) {
+          var onHydrated = hydrationCallbacks.onHydrated;
+          onHydrated && onHydrated(current);
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
       }
-      current = workInProgress.flags;
-      return current & 65536
-        ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-        : null;
+  }
+}
+function getRetryCache(finishedWork) {
+  switch (finishedWork.tag) {
+    case 13:
     case 19:
-      return pop(suspenseStackCursor), null;
-    case 4:
-      return popHostContainer(), null;
-    case 10:
-      return popProvider(workInProgress.type._context), null;
+      var retryCache = finishedWork.stateNode;
+      null === retryCache &&
+        (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+      return retryCache;
     case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        popTransition(workInProgress, current),
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 24:
-      return popProvider(CacheContext), null;
-    case 25:
       return (
-        enableTransitionTracing &&
-          null !== workInProgress.stateNode &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        null
+        (finishedWork = finishedWork.stateNode),
+        (retryCache = finishedWork._retryCache),
+        null === retryCache &&
+          (retryCache = finishedWork._retryCache = new PossiblyWeakSet()),
+        retryCache
       );
     default:
-      return null;
+      throw Error(formatProdErrorMessage(435, finishedWork.tag));
+  }
+}
+function detachOffscreenInstance(instance) {
+  var fiber = instance._current;
+  if (null === fiber) throw Error(formatProdErrorMessage(456));
+  if (0 === (instance._pendingVisibility & 2)) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root &&
+      ((instance._pendingVisibility |= 2),
+      scheduleUpdateOnFiber(root, fiber, 2, -1));
+  }
+}
+function attachOffscreenInstance(instance) {
+  var fiber = instance._current;
+  if (null === fiber) throw Error(formatProdErrorMessage(456));
+  if (0 !== (instance._pendingVisibility & 2)) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root &&
+      ((instance._pendingVisibility &= -3),
+      scheduleUpdateOnFiber(root, fiber, 2, -1));
   }
 }
-function unwindInterruptedWork(current, interruptedWork) {
-  popTreeContext(interruptedWork);
-  switch (interruptedWork.tag) {
-    case 3:
-      popProvider(CacheContext);
-      enableTransitionTracing &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
-      enableTransitionTracing && pop(transitionStack);
-      popHostContainer();
-      resetWorkInProgressVersions();
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  var retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(function (wakeable) {
+    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+    retryCache.has(wakeable) ||
+      (retryCache.add(wakeable), wakeable.then(retry, retry));
+  });
+}
+function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (null !== deletions)
+    for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i];
+      try {
+        var root = root$jscomp$0,
+          returnFiber = parentFiber,
+          parent = returnFiber;
+        a: for (; null !== parent; ) {
+          switch (parent.tag) {
+            case 27:
+            case 5:
+              hostParent = parent.stateNode;
+              hostParentIsContainer = !1;
+              break a;
+            case 3:
+              hostParent = parent.stateNode.containerInfo;
+              hostParentIsContainer = !0;
+              break a;
+            case 4:
+              hostParent = parent.stateNode.containerInfo;
+              hostParentIsContainer = !0;
+              break a;
+          }
+          parent = parent.return;
+        }
+        if (null === hostParent) throw Error(formatProdErrorMessage(160));
+        commitDeletionEffectsOnFiber(root, returnFiber, childToDelete);
+        hostParent = null;
+        hostParentIsContainer = !1;
+        var alternate = childToDelete.alternate;
+        null !== alternate && (alternate.return = null);
+        childToDelete.return = null;
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
+    }
+  if (parentFiber.subtreeFlags & 12854)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitMutationEffectsOnFiber(parentFiber, root$jscomp$0),
+        (parentFiber = parentFiber.sibling);
+}
+var currentHoistableRoot = null;
+function commitMutationEffectsOnFiber(finishedWork, root) {
+  var current = finishedWork.alternate,
+    flags = finishedWork.flags;
+  switch (finishedWork.tag) {
+    case 0:
+    case 11:
+    case 14:
+    case 15:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4) {
+        try {
+          commitHookEffectListUnmount(3, finishedWork, finishedWork.return),
+            commitHookEffectListMount(3, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+        try {
+          commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
+        } catch (error$140) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$140);
+        }
+      }
+      break;
+    case 1:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      flags & 64 &&
+        offscreenSubtreeIsHidden &&
+        ((finishedWork = finishedWork.updateQueue),
+        null !== finishedWork &&
+          ((current = finishedWork.callbacks),
+          null !== current &&
+            ((flags = finishedWork.shared.hiddenCallbacks),
+            (finishedWork.shared.hiddenCallbacks =
+              null === flags ? current : flags.concat(current)))));
       break;
     case 26:
+      var hoistableRoot = currentHoistableRoot;
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      if (flags & 4)
+        if (
+          ((root = null !== current ? current.memoizedState : null),
+          (flags = finishedWork.memoizedState),
+          null === current)
+        )
+          if (null === flags)
+            if (null === finishedWork.stateNode) {
+              a: {
+                current = finishedWork.type;
+                flags = finishedWork.memoizedProps;
+                root = hoistableRoot.ownerDocument || hoistableRoot;
+                b: switch (current) {
+                  case "title":
+                    hoistableRoot = root.getElementsByTagName("title")[0];
+                    if (
+                      !hoistableRoot ||
+                      hoistableRoot[internalHoistableMarker] ||
+                      hoistableRoot[internalInstanceKey] ||
+                      "http://www.w3.org/2000/svg" ===
+                        hoistableRoot.namespaceURI ||
+                      hoistableRoot.hasAttribute("itemprop")
+                    )
+                      (hoistableRoot = root.createElement(current)),
+                        root.head.insertBefore(
+                          hoistableRoot,
+                          root.querySelector("head > title")
+                        );
+                    setInitialProperties(hoistableRoot, current, flags);
+                    hoistableRoot[internalInstanceKey] = finishedWork;
+                    markNodeAsHoistable(hoistableRoot);
+                    current = hoistableRoot;
+                    break a;
+                  case "link":
+                    var maybeNodes = getHydratableHoistableCache(
+                      "link",
+                      "href",
+                      root
+                    ).get(current + (flags.href || ""));
+                    if (maybeNodes)
+                      for (var i = 0; i < maybeNodes.length; i++)
+                        if (
+                          ((hoistableRoot = maybeNodes[i]),
+                          hoistableRoot.getAttribute("href") ===
+                            (null == flags.href ? null : flags.href) &&
+                            hoistableRoot.getAttribute("rel") ===
+                              (null == flags.rel ? null : flags.rel) &&
+                            hoistableRoot.getAttribute("title") ===
+                              (null == flags.title ? null : flags.title) &&
+                            hoistableRoot.getAttribute("crossorigin") ===
+                              (null == flags.crossOrigin
+                                ? null
+                                : flags.crossOrigin))
+                        ) {
+                          maybeNodes.splice(i, 1);
+                          break b;
+                        }
+                    hoistableRoot = root.createElement(current);
+                    setInitialProperties(hoistableRoot, current, flags);
+                    root.head.appendChild(hoistableRoot);
+                    break;
+                  case "meta":
+                    if (
+                      (maybeNodes = getHydratableHoistableCache(
+                        "meta",
+                        "content",
+                        root
+                      ).get(current + (flags.content || "")))
+                    )
+                      for (i = 0; i < maybeNodes.length; i++)
+                        if (
+                          ((hoistableRoot = maybeNodes[i]),
+                          hoistableRoot.getAttribute("content") ===
+                            (null == flags.content
+                              ? null
+                              : "" + flags.content) &&
+                            hoistableRoot.getAttribute("name") ===
+                              (null == flags.name ? null : flags.name) &&
+                            hoistableRoot.getAttribute("property") ===
+                              (null == flags.property
+                                ? null
+                                : flags.property) &&
+                            hoistableRoot.getAttribute("http-equiv") ===
+                              (null == flags.httpEquiv
+                                ? null
+                                : flags.httpEquiv) &&
+                            hoistableRoot.getAttribute("charset") ===
+                              (null == flags.charSet ? null : flags.charSet))
+                        ) {
+                          maybeNodes.splice(i, 1);
+                          break b;
+                        }
+                    hoistableRoot = root.createElement(current);
+                    setInitialProperties(hoistableRoot, current, flags);
+                    root.head.appendChild(hoistableRoot);
+                    break;
+                  default:
+                    throw Error(formatProdErrorMessage(468, current));
+                }
+                hoistableRoot[internalInstanceKey] = finishedWork;
+                markNodeAsHoistable(hoistableRoot);
+                current = hoistableRoot;
+              }
+              finishedWork.stateNode = current;
+            } else
+              mountHoistable(
+                hoistableRoot,
+                finishedWork.type,
+                finishedWork.stateNode
+              );
+          else
+            finishedWork.stateNode = acquireResource(
+              hoistableRoot,
+              flags,
+              finishedWork.memoizedProps
+            );
+        else if (root !== flags)
+          null === root
+            ? null !== current.stateNode &&
+              ((current = current.stateNode),
+              current.parentNode.removeChild(current))
+            : root.count--,
+            null === flags
+              ? mountHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.stateNode
+                )
+              : acquireResource(
+                  hoistableRoot,
+                  flags,
+                  finishedWork.memoizedProps
+                );
+        else if (
+          null === flags &&
+          null !== finishedWork.stateNode &&
+          ((flags = finishedWork.updateQueue),
+          (finishedWork.updateQueue = null),
+          null !== flags)
+        )
+          try {
+            var domElement = finishedWork.stateNode,
+              newProps = finishedWork.memoizedProps;
+            updateProperties(
+              domElement,
+              flags,
+              finishedWork.type,
+              current.memoizedProps,
+              newProps
+            );
+            domElement[internalPropsKey] = newProps;
+          } catch (error$141) {
+            captureCommitPhaseError(
+              finishedWork,
+              finishedWork.return,
+              error$141
+            );
+          }
+      break;
     case 27:
+      if (flags & 4 && null === finishedWork.alternate) {
+        hoistableRoot = finishedWork.stateNode;
+        maybeNodes = finishedWork.memoizedProps;
+        for (i = hoistableRoot.firstChild; i; ) {
+          var nextNode = i.nextSibling,
+            nodeName = i.nodeName;
+          i[internalHoistableMarker] ||
+            "HEAD" === nodeName ||
+            "BODY" === nodeName ||
+            "STYLE" === nodeName ||
+            ("LINK" === nodeName && "stylesheet" === i.rel.toLowerCase()) ||
+            hoistableRoot.removeChild(i);
+          i = nextNode;
+        }
+        i = finishedWork.type;
+        for (nextNode = hoistableRoot.attributes; nextNode.length; )
+          hoistableRoot.removeAttributeNode(nextNode[0]);
+        setInitialProperties(hoistableRoot, i, maybeNodes);
+        hoistableRoot[internalInstanceKey] = finishedWork;
+        hoistableRoot[internalPropsKey] = maybeNodes;
+      }
     case 5:
-      popHostContext(interruptedWork);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      if (finishedWork.flags & 32) {
+        root = finishedWork.stateNode;
+        try {
+          setTextContent(root, "");
+        } catch (error$142) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$142);
+        }
+      }
+      if (
+        flags & 4 &&
+        ((flags = finishedWork.stateNode),
+        null != flags &&
+          ((root = finishedWork.memoizedProps),
+          (current = null !== current ? current.memoizedProps : root),
+          (hoistableRoot = finishedWork.type),
+          (maybeNodes = finishedWork.updateQueue),
+          (finishedWork.updateQueue = null),
+          null !== maybeNodes))
+      )
+        try {
+          updateProperties(flags, maybeNodes, hoistableRoot, current, root),
+            (flags[internalPropsKey] = root);
+        } catch (error$145) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$145);
+        }
       break;
-    case 4:
-      popHostContainer();
+    case 6:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4) {
+        if (null === finishedWork.stateNode)
+          throw Error(formatProdErrorMessage(162));
+        current = finishedWork.stateNode;
+        flags = finishedWork.memoizedProps;
+        try {
+          current.nodeValue = flags;
+        } catch (error$146) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$146);
+        }
+      }
       break;
-    case 13:
-      popSuspenseHandler(interruptedWork);
+    case 3:
+      tagCaches = null;
+      hoistableRoot = currentHoistableRoot;
+      currentHoistableRoot = getHoistableRoot(root.containerInfo);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      currentHoistableRoot = hoistableRoot;
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
+        try {
+          retryIfBlockedOn(root.containerInfo);
+        } catch (error$147) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$147);
+        }
       break;
-    case 19:
-      pop(suspenseStackCursor);
+    case 4:
+      current = currentHoistableRoot;
+      currentHoistableRoot = getHoistableRoot(
+        finishedWork.stateNode.containerInfo
+      );
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      currentHoistableRoot = current;
       break;
-    case 10:
-      popProvider(interruptedWork.type._context);
+    case 13:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      current = finishedWork.child;
+      current.flags & 8192 &&
+        null !== current.memoizedState &&
+        (null === current.alternate ||
+          null === current.alternate.memoizedState) &&
+        (globalMostRecentFallbackTime = now());
+      if (flags & 4) {
+        try {
+          if (null !== finishedWork.memoizedState) {
+            var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
+            if ("function" === typeof suspenseCallback) {
+              var wakeables = finishedWork.updateQueue;
+              null !== wakeables && suspenseCallback(new Set(wakeables));
+            }
+          }
+        } catch (error$149) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$149);
+        }
+        current = finishedWork.updateQueue;
+        null !== current &&
+          ((finishedWork.updateQueue = null),
+          attachSuspenseRetryListeners(finishedWork, current));
+      }
       break;
     case 22:
-    case 23:
-      popSuspenseHandler(interruptedWork);
-      popHiddenContext();
-      popTransition(interruptedWork, current);
-      break;
-    case 24:
-      popProvider(CacheContext);
-      break;
-    case 25:
-      enableTransitionTracing &&
-        null !== interruptedWork.stateNode &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
-  }
-}
-var offscreenSubtreeIsHidden = !1,
-  offscreenSubtreeWasHidden = !1,
-  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
-  nextEffect = null;
-function safelyAttachRef(current, nearestMountedAncestor) {
-  try {
-    var ref = current.ref;
-    if (null !== ref) {
-      var instance = current.stateNode;
-      switch (current.tag) {
-        case 26:
-        case 27:
-        case 5:
-          var instanceToUse = instance;
-          break;
-        default:
-          instanceToUse = instance;
-      }
-      21 === current.tag && (instanceToUse = instance);
-      "function" === typeof ref
-        ? (current.refCleanup = ref(instanceToUse))
-        : (ref.current = instanceToUse);
-    }
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
-  }
-}
-function safelyDetachRef(current, nearestMountedAncestor) {
-  var ref = current.ref,
-    refCleanup = current.refCleanup;
-  if (null !== ref)
-    if ("function" === typeof refCleanup)
-      try {
-        refCleanup();
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      } finally {
-        (current.refCleanup = null),
-          (current = current.alternate),
-          null != current && (current.refCleanup = null);
-      }
-    else if ("function" === typeof ref)
-      try {
-        ref(null);
-      } catch (error$169) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error$169);
-      }
-    else ref.current = null;
-}
-function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
-  try {
-    destroy();
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      domElement = null !== finishedWork.memoizedState;
+      newProps = null !== current && null !== current.memoizedState;
+      finishedWork.mode & 1
+        ? ((suspenseCallback = offscreenSubtreeIsHidden),
+          (wakeables = offscreenSubtreeWasHidden),
+          (offscreenSubtreeIsHidden = suspenseCallback || domElement),
+          (offscreenSubtreeWasHidden = wakeables || newProps),
+          recursivelyTraverseMutationEffects(root, finishedWork),
+          (offscreenSubtreeWasHidden = wakeables),
+          (offscreenSubtreeIsHidden = suspenseCallback))
+        : recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      root = finishedWork.stateNode;
+      root._current = finishedWork;
+      root._visibility &= -3;
+      root._visibility |= root._pendingVisibility & 2;
+      if (
+        flags & 8192 &&
+        ((root._visibility = domElement
+          ? root._visibility & -2
+          : root._visibility | 1),
+        domElement &&
+          ((root = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden),
+          null === current ||
+            newProps ||
+            root ||
+            (0 !== (finishedWork.mode & 1) &&
+              recursivelyTraverseDisappearLayoutEffects(finishedWork))),
+        null === finishedWork.memoizedProps ||
+          "manual" !== finishedWork.memoizedProps.mode)
+      )
+        a: for (current = null, root = finishedWork; ; ) {
+          if (5 === root.tag || 26 === root.tag || 27 === root.tag) {
+            if (null === current) {
+              current = root;
+              try {
+                (hoistableRoot = root.stateNode),
+                  domElement
+                    ? ((maybeNodes = hoistableRoot.style),
+                      "function" === typeof maybeNodes.setProperty
+                        ? maybeNodes.setProperty("display", "none", "important")
+                        : (maybeNodes.display = "none"))
+                    : ((i = root.stateNode),
+                      (nextNode = root.memoizedProps.style),
+                      (nodeName =
+                        void 0 !== nextNode &&
+                        null !== nextNode &&
+                        nextNode.hasOwnProperty("display")
+                          ? nextNode.display
+                          : null),
+                      (i.style.display = dangerousStyleValue(
+                        "display",
+                        nodeName
+                      )));
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          } else if (6 === root.tag) {
+            if (null === current)
+              try {
+                root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
+              } catch (error$130) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error$130
+                );
+              }
+          } else if (
+            ((22 !== root.tag && 23 !== root.tag) ||
+              null === root.memoizedState ||
+              root === finishedWork) &&
+            null !== root.child
+          ) {
+            root.child.return = root;
+            root = root.child;
+            continue;
+          }
+          if (root === finishedWork) break a;
+          for (; null === root.sibling; ) {
+            if (null === root.return || root.return === finishedWork) break a;
+            current === root && (current = null);
+            root = root.return;
+          }
+          current === root && (current = null);
+          root.sibling.return = root.return;
+          root = root.sibling;
+        }
+      flags & 4 &&
+        ((current = finishedWork.updateQueue),
+        null !== current &&
+          ((flags = current.wakeables),
+          null !== flags &&
+            ((current.wakeables = null),
+            attachSuspenseRetryListeners(finishedWork, flags))));
+      break;
+    case 19:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 4 &&
+        ((current = finishedWork.updateQueue),
+        null !== current &&
+          ((finishedWork.updateQueue = null),
+          attachSuspenseRetryListeners(finishedWork, current)));
+      break;
+    case 21:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        (null !== current && safelyDetachRef(finishedWork, finishedWork.return),
+        safelyAttachRef(finishedWork, finishedWork.return));
+      flags & 4 && (finishedWork.stateNode[internalInstanceKey] = finishedWork);
+      break;
+    default:
+      recursivelyTraverseMutationEffects(root, finishedWork),
+        commitReconciliationEffects(finishedWork);
   }
 }
-var focusedInstanceHandle = null,
-  shouldFireAfterActiveInstanceBlur = !1;
-function commitBeforeMutationEffects(root, firstChild) {
-  eventsEnabled = _enabled;
-  root = getActiveElementDeep();
-  if (hasSelectionCapabilities(root)) {
-    if ("selectionStart" in root)
-      var JSCompiler_temp = {
-        start: root.selectionStart,
-        end: root.selectionEnd
-      };
-    else
-      a: {
-        JSCompiler_temp =
-          ((JSCompiler_temp = root.ownerDocument) &&
-            JSCompiler_temp.defaultView) ||
-          window;
-        var selection =
-          JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
-        if (selection && 0 !== selection.rangeCount) {
-          JSCompiler_temp = selection.anchorNode;
-          var anchorOffset = selection.anchorOffset,
-            focusNode = selection.focusNode;
-          selection = selection.focusOffset;
-          try {
-            JSCompiler_temp.nodeType, focusNode.nodeType;
-          } catch (e$25) {
-            JSCompiler_temp = null;
-            break a;
-          }
-          var length = 0,
-            start = -1,
-            end = -1,
-            indexWithinAnchor = 0,
-            indexWithinFocus = 0,
-            node = root,
-            parentNode = null;
-          b: for (;;) {
-            for (var next; ; ) {
-              node !== JSCompiler_temp ||
-                (0 !== anchorOffset && 3 !== node.nodeType) ||
-                (start = length + anchorOffset);
-              node !== focusNode ||
-                (0 !== selection && 3 !== node.nodeType) ||
-                (end = length + selection);
-              3 === node.nodeType && (length += node.nodeValue.length);
-              if (null === (next = node.firstChild)) break;
-              parentNode = node;
-              node = next;
-            }
-            for (;;) {
-              if (node === root) break b;
-              parentNode === JSCompiler_temp &&
-                ++indexWithinAnchor === anchorOffset &&
-                (start = length);
-              parentNode === focusNode &&
-                ++indexWithinFocus === selection &&
-                (end = length);
-              if (null !== (next = node.nextSibling)) break;
-              node = parentNode;
-              parentNode = node.parentNode;
+function commitReconciliationEffects(finishedWork) {
+  var flags = finishedWork.flags;
+  if (flags & 2) {
+    try {
+      if (27 !== finishedWork.tag) {
+        b: {
+          for (var parent = finishedWork.return; null !== parent; ) {
+            if (isHostParent(parent)) {
+              var JSCompiler_inline_result = parent;
+              break b;
             }
-            node = next;
+            parent = parent.return;
           }
-          JSCompiler_temp =
-            -1 === start || -1 === end ? null : { start: start, end: end };
-        } else JSCompiler_temp = null;
+          throw Error(formatProdErrorMessage(160));
+        }
+        switch (JSCompiler_inline_result.tag) {
+          case 27:
+            var parent$jscomp$0 = JSCompiler_inline_result.stateNode,
+              before = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
+            break;
+          case 5:
+            var parent$131 = JSCompiler_inline_result.stateNode;
+            JSCompiler_inline_result.flags & 32 &&
+              (setTextContent(parent$131, ""),
+              (JSCompiler_inline_result.flags &= -33));
+            var before$132 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before$132, parent$131);
+            break;
+          case 3:
+          case 4:
+            var parent$133 = JSCompiler_inline_result.stateNode.containerInfo,
+              before$134 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNodeIntoContainer(
+              finishedWork,
+              before$134,
+              parent$133
+            );
+            break;
+          default:
+            throw Error(formatProdErrorMessage(161));
+        }
       }
-    JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
-  } else JSCompiler_temp = null;
-  selectionInformation = { focusedElem: root, selectionRange: JSCompiler_temp };
-  root = null;
-  JSCompiler_temp = selectionInformation.focusedElem;
-  null !== JSCompiler_temp &&
-    (root = getClosestInstanceFromNode(JSCompiler_temp));
-  _enabled = !1;
-  focusedInstanceHandle = root;
-  for (nextEffect = firstChild; null !== nextEffect; ) {
-    firstChild = nextEffect;
-    root = firstChild.deletions;
-    if (null !== root)
-      for (
-        JSCompiler_temp = 0;
-        JSCompiler_temp < root.length;
-        JSCompiler_temp++
-      )
-        (anchorOffset = root[JSCompiler_temp]),
-          doesFiberContain(anchorOffset, focusedInstanceHandle) &&
-            ((_enabled = shouldFireAfterActiveInstanceBlur = !0),
-            dispatchBeforeDetachedBlur(
-              selectionInformation.focusedElem,
-              anchorOffset
-            ),
-            (_enabled = !1));
-    root = firstChild.child;
-    if (0 !== (firstChild.subtreeFlags & 9236) && null !== root)
-      (root.return = firstChild), (nextEffect = root);
-    else
-      for (; null !== nextEffect; ) {
-        firstChild = nextEffect;
-        try {
-          var current = firstChild.alternate,
-            flags = firstChild.flags,
-            JSCompiler_temp$jscomp$0;
-          if (
-            (JSCompiler_temp$jscomp$0 =
-              !shouldFireAfterActiveInstanceBlur &&
-              null !== focusedInstanceHandle)
-          ) {
-            var JSCompiler_temp$jscomp$1;
-            if ((JSCompiler_temp$jscomp$1 = 13 === firstChild.tag))
-              a: {
-                if (null !== current) {
-                  var oldState = current.memoizedState;
-                  if (null === oldState || null !== oldState.dehydrated) {
-                    var newState = firstChild.memoizedState;
-                    JSCompiler_temp$jscomp$1 =
-                      null !== newState && null === newState.dehydrated;
-                    break a;
-                  }
-                }
-                JSCompiler_temp$jscomp$1 = !1;
-              }
-            JSCompiler_temp$jscomp$0 =
-              JSCompiler_temp$jscomp$1 &&
-              doesFiberContain(firstChild, focusedInstanceHandle);
-          }
-          JSCompiler_temp$jscomp$0 &&
-            ((shouldFireAfterActiveInstanceBlur = !0),
-            (root = firstChild),
-            (_enabled = !0),
-            dispatchBeforeDetachedBlur(selectionInformation.focusedElem, root),
-            (_enabled = !1));
-          switch (firstChild.tag) {
-            case 0:
-              if (0 !== (flags & 4)) {
-                var updateQueue = firstChild.updateQueue,
-                  eventPayloads =
-                    null !== updateQueue ? updateQueue.events : null;
-                if (null !== eventPayloads)
-                  for (root = 0; root < eventPayloads.length; root++) {
-                    var _eventPayloads$ii = eventPayloads[root];
-                    _eventPayloads$ii.ref.impl = _eventPayloads$ii.nextImpl;
-                  }
-              }
-              break;
-            case 11:
-            case 15:
-              break;
-            case 1:
-              if (0 !== (flags & 1024) && null !== current) {
-                var prevProps = current.memoizedProps,
-                  prevState = current.memoizedState,
-                  instance = firstChild.stateNode,
-                  snapshot = instance.getSnapshotBeforeUpdate(
-                    firstChild.elementType === firstChild.type
-                      ? prevProps
-                      : resolveDefaultProps(firstChild.type, prevProps),
-                    prevState
-                  );
-                instance.__reactInternalSnapshotBeforeUpdate = snapshot;
-              }
-              break;
-            case 3:
-              if (0 !== (flags & 1024)) {
-                var container = firstChild.stateNode.containerInfo,
-                  nodeType = container.nodeType;
-                if (9 === nodeType) clearContainerSparingly(container);
-                else if (1 === nodeType)
-                  switch (container.nodeName) {
-                    case "HEAD":
-                    case "HTML":
-                    case "BODY":
-                      clearContainerSparingly(container);
-                      break;
-                    default:
-                      container.textContent = "";
-                  }
-              }
-              break;
-            case 5:
-            case 26:
-            case 27:
-            case 6:
-            case 4:
-            case 17:
-              break;
-            default:
-              if (0 !== (flags & 1024))
-                throw Error(formatProdErrorMessage(163));
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+    finishedWork.flags &= -3;
+  }
+  flags & 4096 && (finishedWork.flags &= -4097);
+}
+function recursivelyTraverseLayoutEffects(root, parentFiber) {
+  if (parentFiber.subtreeFlags & 8772)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber),
+        (parentFiber = parentFiber.sibling);
+}
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var finishedWork = parentFiber;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 14:
+      case 15:
+        commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 1:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        var instance = finishedWork.stateNode;
+        if ("function" === typeof instance.componentWillUnmount) {
+          var current = finishedWork,
+            nearestMountedAncestor = finishedWork.return;
+          try {
+            var current$jscomp$0 = current;
+            instance.props = current$jscomp$0.memoizedProps;
+            instance.state = current$jscomp$0.memoizedState;
+            instance.componentWillUnmount();
+          } catch (error) {
+            captureCommitPhaseError(current, nearestMountedAncestor, error);
           }
-        } catch (error) {
-          captureCommitPhaseError(firstChild, firstChild.return, error);
         }
-        root = firstChild.sibling;
-        if (null !== root) {
-          root.return = firstChild.return;
-          nextEffect = root;
-          break;
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 26:
+      case 27:
+      case 5:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 22:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        null === finishedWork.memoizedState &&
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      default:
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+    }
+    parentFiber = parentFiber.sibling;
+  }
+}
+function recursivelyTraverseReappearLayoutEffects(
+  finishedRoot$jscomp$0,
+  parentFiber,
+  includeWorkInProgressEffects
+) {
+  includeWorkInProgressEffects =
+    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var current = parentFiber.alternate,
+      finishedRoot = finishedRoot$jscomp$0,
+      finishedWork = parentFiber,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        commitHookLayoutEffects(finishedWork, 4);
+        break;
+      case 1:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        finishedRoot = finishedWork.stateNode;
+        if ("function" === typeof finishedRoot.componentDidMount)
+          try {
+            finishedRoot.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        current = finishedWork.updateQueue;
+        if (null !== current) {
+          var hiddenCallbacks = current.shared.hiddenCallbacks;
+          if (null !== hiddenCallbacks)
+            for (
+              current.shared.hiddenCallbacks = null, current = 0;
+              current < hiddenCallbacks.length;
+              current++
+            )
+              callCallback(hiddenCallbacks[current], finishedRoot);
+        }
+        includeWorkInProgressEffects &&
+          flags & 64 &&
+          commitClassCallbacks(finishedWork);
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 26:
+      case 27:
+      case 5:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          null === current &&
+          flags & 4 &&
+          commitHostComponentMount(finishedWork);
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 12:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        break;
+      case 13:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 4 &&
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        break;
+      case 22:
+        null === finishedWork.memoizedState &&
+          recursivelyTraverseReappearLayoutEffects(
+            finishedRoot,
+            finishedWork,
+            includeWorkInProgressEffects
+          );
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      default:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+    }
+    parentFiber = parentFiber.sibling;
+  }
+}
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  try {
+    commitHookEffectListMount(hookFlags, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  var previousCache = null;
+  null !== current &&
+    null !== current.memoizedState &&
+    null !== current.memoizedState.cachePool &&
+    (previousCache = current.memoizedState.cachePool.pool);
+  current = null;
+  null !== finishedWork.memoizedState &&
+    null !== finishedWork.memoizedState.cachePool &&
+    (current = finishedWork.memoizedState.cachePool.pool);
+  current !== previousCache &&
+    (null != current && current.refCount++,
+    null != previousCache && releaseCache(previousCache));
+  if (enableTransitionTracing) {
+    current = finishedWork.updateQueue;
+    previousCache = null !== finishedWork.memoizedState;
+    if (null !== current) {
+      if (previousCache) {
+        var transitions = current.transitions;
+        null !== transitions &&
+          transitions.forEach(function (transition) {
+            null === instance._transitions &&
+              (instance._transitions = new Set());
+            instance._transitions.add(transition);
+          });
+        current = current.markerInstances;
+        null !== current &&
+          current.forEach(function (markerInstance) {
+            var markerTransitions = markerInstance.transitions;
+            null !== markerTransitions &&
+              markerTransitions.forEach(function (transition) {
+                null === instance._transitions
+                  ? (instance._transitions = new Set())
+                  : instance._transitions.has(transition) &&
+                    (null === markerInstance.pendingBoundaries &&
+                      (markerInstance.pendingBoundaries = new Map()),
+                    null === instance._pendingMarkers &&
+                      (instance._pendingMarkers = new Set()),
+                    instance._pendingMarkers.add(markerInstance));
+              });
+          });
+      }
+      finishedWork.updateQueue = null;
+    }
+    commitTransitionProgress(finishedWork);
+    previousCache ||
+      ((instance._transitions = null), (instance._pendingMarkers = null));
+  }
+}
+function commitCachePassiveMountEffect(current, finishedWork) {
+  current = null;
+  null !== finishedWork.alternate &&
+    (current = finishedWork.alternate.memoizedState.cache);
+  finishedWork = finishedWork.memoizedState.cache;
+  finishedWork !== current &&
+    (finishedWork.refCount++, null != current && releaseCache(current));
+}
+function commitTracingMarkerPassiveMountEffect(finishedWork) {
+  var instance = finishedWork.stateNode;
+  null !== instance.transitions &&
+    null === instance.pendingBoundaries &&
+    (addMarkerCompleteCallbackToPendingTransition(
+      finishedWork.memoizedProps.name,
+      instance.transitions
+    ),
+    (instance.transitions = null),
+    (instance.pendingBoundaries = null),
+    (instance.aborts = null),
+    (instance.name = null));
+}
+function recursivelyTraversePassiveMountEffects(
+  root,
+  parentFiber,
+  committedLanes,
+  committedTransitions
+) {
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitPassiveMountOnFiber(
+        root,
+        parentFiber,
+        committedLanes,
+        committedTransitions
+      ),
+        (parentFiber = parentFiber.sibling);
+}
+function commitPassiveMountOnFiber(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions
+) {
+  var flags = finishedWork.flags;
+  switch (finishedWork.tag) {
+    case 0:
+    case 11:
+    case 15:
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+      flags & 2048 && commitHookPassiveMountEffects(finishedWork, 9);
+      break;
+    case 3:
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+      if (flags & 2048) {
+        flags = null;
+        null !== finishedWork.alternate &&
+          (flags = finishedWork.alternate.memoizedState.cache);
+        var nextCache = finishedWork.memoizedState.cache;
+        nextCache !== flags &&
+          (nextCache.refCount++, null != flags && releaseCache(flags));
+        if (enableTransitionTracing) {
+          var incompleteTransitions =
+            finishedWork.stateNode.incompleteTransitions;
+          null !== committedTransitions &&
+            (committedTransitions.forEach(function (transition) {
+              enableTransitionTracing &&
+                (null === currentPendingTransitionCallbacks &&
+                  (currentPendingTransitionCallbacks = {
+                    transitionStart: [],
+                    transitionProgress: null,
+                    transitionComplete: null,
+                    markerProgress: null,
+                    markerIncomplete: null,
+                    markerComplete: null
+                  }),
+                null === currentPendingTransitionCallbacks.transitionStart &&
+                  (currentPendingTransitionCallbacks.transitionStart = []),
+                currentPendingTransitionCallbacks.transitionStart.push(
+                  transition
+                ));
+            }),
+            clearTransitionsForLanes(finishedRoot, committedLanes));
+          incompleteTransitions.forEach(function (markerInstance, transition) {
+            var pendingBoundaries = markerInstance.pendingBoundaries;
+            if (null === pendingBoundaries || 0 === pendingBoundaries.size)
+              null === markerInstance.aborts &&
+                enableTransitionTracing &&
+                (null === currentPendingTransitionCallbacks &&
+                  (currentPendingTransitionCallbacks = {
+                    transitionStart: null,
+                    transitionProgress: null,
+                    transitionComplete: [],
+                    markerProgress: null,
+                    markerIncomplete: null,
+                    markerComplete: null
+                  }),
+                null === currentPendingTransitionCallbacks.transitionComplete &&
+                  (currentPendingTransitionCallbacks.transitionComplete = []),
+                currentPendingTransitionCallbacks.transitionComplete.push(
+                  transition
+                )),
+                incompleteTransitions.delete(transition);
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
         }
-        nextEffect = firstChild.return;
       }
+      break;
+    case 23:
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+      flags & 2048 &&
+        commitOffscreenPassiveMountEffects(
+          finishedWork.alternate,
+          finishedWork,
+          finishedWork.stateNode
+        );
+      break;
+    case 22:
+      nextCache = finishedWork.stateNode;
+      null !== finishedWork.memoizedState
+        ? nextCache._visibility & 4
+          ? recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            )
+          : finishedWork.mode & 1
+          ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
+          : ((nextCache._visibility |= 4),
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            ))
+        : nextCache._visibility & 4
+        ? recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          )
+        : ((nextCache._visibility |= 4),
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            0 !== (finishedWork.subtreeFlags & 10256)
+          ));
+      flags & 2048 &&
+        commitOffscreenPassiveMountEffects(
+          finishedWork.alternate,
+          finishedWork,
+          nextCache
+        );
+      break;
+    case 24:
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+      flags & 2048 &&
+        commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+      break;
+    case 25:
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
+        break;
+      }
+    default:
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
   }
-  current = shouldFireAfterActiveInstanceBlur;
-  shouldFireAfterActiveInstanceBlur = !1;
-  focusedInstanceHandle = null;
-  return current;
 }
-function commitHookEffectListUnmount(
-  flags,
-  finishedWork,
-  nearestMountedAncestor
+function recursivelyTraverseReconnectPassiveEffects(
+  finishedRoot$jscomp$0,
+  parentFiber,
+  committedLanes$jscomp$0,
+  committedTransitions$jscomp$0,
+  includeWorkInProgressEffects
 ) {
-  var updateQueue = finishedWork.updateQueue;
-  updateQueue = null !== updateQueue ? updateQueue.lastEffect : null;
-  if (null !== updateQueue) {
-    var effect = (updateQueue = updateQueue.next);
-    do {
-      if ((effect.tag & flags) === flags) {
-        var destroy = effect.destroy;
-        effect.destroy = void 0;
-        void 0 !== destroy &&
-          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
-      }
-      effect = effect.next;
-    } while (effect !== updateQueue);
+  includeWorkInProgressEffects =
+    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var finishedRoot = finishedRoot$jscomp$0,
+      finishedWork = parentFiber,
+      committedLanes = committedLanes$jscomp$0,
+      committedTransitions = committedTransitions$jscomp$0,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        commitHookPassiveMountEffects(finishedWork, 8);
+        break;
+      case 23:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitOffscreenPassiveMountEffects(
+            finishedWork.alternate,
+            finishedWork,
+            finishedWork.stateNode
+          );
+        break;
+      case 22:
+        var instance$159 = finishedWork.stateNode;
+        null !== finishedWork.memoizedState
+          ? instance$159._visibility & 4
+            ? recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              )
+            : finishedWork.mode & 1
+            ? recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              )
+            : ((instance$159._visibility |= 4),
+              recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              ))
+          : ((instance$159._visibility |= 4),
+            recursivelyTraverseReconnectPassiveEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions,
+              includeWorkInProgressEffects
+            ));
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitOffscreenPassiveMountEffects(
+            finishedWork.alternate,
+            finishedWork,
+            instance$159
+          );
+        break;
+      case 24:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+        break;
+      case 25:
+        if (enableTransitionTracing) {
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+          includeWorkInProgressEffects &&
+            flags & 2048 &&
+            commitTracingMarkerPassiveMountEffect(finishedWork);
+          break;
+        }
+      default:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+    }
+    parentFiber = parentFiber.sibling;
   }
 }
-function commitHookEffectListMount(flags, finishedWork) {
-  finishedWork = finishedWork.updateQueue;
-  finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
-  if (null !== finishedWork) {
-    var effect = (finishedWork = finishedWork.next);
-    do {
-      if ((effect.tag & flags) === flags) {
-        var create = effect.create;
-        effect.destroy = create();
+function recursivelyTraverseAtomicPassiveEffects(
+  finishedRoot$jscomp$0,
+  parentFiber
+) {
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 22:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 &&
+            commitOffscreenPassiveMountEffects(
+              finishedWork.alternate,
+              finishedWork,
+              finishedWork.stateNode
+            );
+          break;
+        case 24:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 &&
+            commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
       }
-      effect = effect.next;
-    } while (effect !== finishedWork);
-  }
-}
-function commitHookLayoutEffects(finishedWork, hookFlags) {
-  try {
-    commitHookEffectListMount(hookFlags, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
-  }
-}
-function commitClassCallbacks(finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  if (null !== updateQueue) {
-    var instance = finishedWork.stateNode;
-    try {
-      commitCallbacks(updateQueue, instance);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      parentFiber = parentFiber.sibling;
     }
+}
+function detachAlternateSiblings(parentFiber) {
+  var previousFiber = parentFiber.alternate;
+  if (
+    null !== previousFiber &&
+    ((parentFiber = previousFiber.child), null !== parentFiber)
+  ) {
+    previousFiber.child = null;
+    do
+      (previousFiber = parentFiber.sibling),
+        (parentFiber.sibling = null),
+        (parentFiber = previousFiber);
+    while (null !== parentFiber);
   }
 }
-function commitHostComponentMount(finishedWork) {
-  var type = finishedWork.type,
-    props = finishedWork.memoizedProps,
-    instance = finishedWork.stateNode;
-  try {
-    a: switch (type) {
-      case "button":
-      case "input":
-      case "select":
-      case "textarea":
-        props.autoFocus && instance.focus();
-        break a;
-      case "img":
-        props.src && (instance.src = props.src);
-    }
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (0 !== (parentFiber.flags & 16)) {
+    if (null !== deletions)
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
+    detachAlternateSiblings(parentFiber);
   }
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitPassiveUnmountOnFiber(parentFiber),
+        (parentFiber = parentFiber.sibling);
 }
-function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
-  var flags = finishedWork.flags;
+function commitPassiveUnmountOnFiber(finishedWork) {
   switch (finishedWork.tag) {
     case 0:
     case 11:
     case 15:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 4 && commitHookLayoutEffects(finishedWork, 5);
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
+      finishedWork.flags & 2048 &&
+        commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
       break;
-    case 1:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      if (flags & 4)
-        if (((finishedRoot = finishedWork.stateNode), null === current))
-          try {
-            finishedRoot.componentDidMount();
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        else {
-          var prevProps =
-            finishedWork.elementType === finishedWork.type
-              ? current.memoizedProps
-              : resolveDefaultProps(finishedWork.type, current.memoizedProps);
-          current = current.memoizedState;
-          try {
-            finishedRoot.componentDidUpdate(
-              prevProps,
-              current,
-              finishedRoot.__reactInternalSnapshotBeforeUpdate
-            );
-          } catch (error$171) {
-            captureCommitPhaseError(
-              finishedWork,
-              finishedWork.return,
-              error$171
-            );
-          }
-        }
-      flags & 64 && commitClassCallbacks(finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+    case 22:
+      var instance = finishedWork.stateNode;
+      null !== finishedWork.memoizedState &&
+      instance._visibility & 4 &&
+      (null === finishedWork.return || 13 !== finishedWork.return.tag)
+        ? ((instance._visibility &= -5),
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork))
+        : recursivelyTraversePassiveUnmountEffects(finishedWork);
       break;
-    case 3:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      if (flags & 64 && ((flags = finishedWork.updateQueue), null !== flags)) {
-        finishedRoot = null;
-        if (null !== finishedWork.child)
-          switch (finishedWork.child.tag) {
-            case 27:
-            case 5:
-              finishedRoot = finishedWork.child.stateNode;
-              break;
-            case 1:
-              finishedRoot = finishedWork.child.stateNode;
+    default:
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
+  }
+}
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (0 !== (parentFiber.flags & 16)) {
+    if (null !== deletions)
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
+    detachAlternateSiblings(parentFiber);
+  }
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    deletions = parentFiber;
+    switch (deletions.tag) {
+      case 0:
+      case 11:
+      case 15:
+        commitHookEffectListUnmount(8, deletions, deletions.return);
+        recursivelyTraverseDisconnectPassiveEffects(deletions);
+        break;
+      case 22:
+        i = deletions.stateNode;
+        i._visibility & 4 &&
+          ((i._visibility &= -5),
+          recursivelyTraverseDisconnectPassiveEffects(deletions));
+        break;
+      default:
+        recursivelyTraverseDisconnectPassiveEffects(deletions);
+    }
+    parentFiber = parentFiber.sibling;
+  }
+}
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+  deletedSubtreeRoot,
+  nearestMountedAncestor$jscomp$0
+) {
+  for (; null !== nextEffect; ) {
+    var fiber = nextEffect,
+      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
+    switch (fiber.tag) {
+      case 0:
+      case 11:
+      case 15:
+        commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
+        break;
+      case 23:
+      case 22:
+        null !== fiber.memoizedState &&
+          null !== fiber.memoizedState.cachePool &&
+          ((nearestMountedAncestor = fiber.memoizedState.cachePool.pool),
+          null != nearestMountedAncestor && nearestMountedAncestor.refCount++);
+        break;
+      case 13:
+        if (enableTransitionTracing) {
+          var offscreenFiber = fiber.child,
+            instance = offscreenFiber.stateNode,
+            transitions = instance._transitions;
+          if (null !== transitions) {
+            var abortReason = {
+              reason: "suspense",
+              name: fiber.memoizedProps.unstable_name || null
+            };
+            if (
+              null === fiber.memoizedState ||
+              null === fiber.memoizedState.dehydrated
+            )
+              abortParentMarkerTransitionsForDeletedFiber(
+                offscreenFiber,
+                abortReason,
+                transitions,
+                instance,
+                !0
+              ),
+                null !== nearestMountedAncestor &&
+                  abortParentMarkerTransitionsForDeletedFiber(
+                    nearestMountedAncestor,
+                    abortReason,
+                    transitions,
+                    instance,
+                    !1
+                  );
           }
-        try {
-          commitCallbacks(flags, finishedRoot);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
         }
-      }
-      break;
-    case 26:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    case 27:
-    case 5:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      null === current && flags & 4 && commitHostComponentMount(finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    case 12:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      break;
-    case 13:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
-      break;
-    case 22:
-      if (0 !== (finishedWork.mode & 1)) {
-        if (
-          ((prevProps =
-            null !== finishedWork.memoizedState || offscreenSubtreeIsHidden),
-          !prevProps)
-        ) {
-          current =
-            (null !== current && null !== current.memoizedState) ||
-            offscreenSubtreeWasHidden;
-          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
-            prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-          offscreenSubtreeIsHidden = prevProps;
-          (offscreenSubtreeWasHidden = current) &&
-          !prevOffscreenSubtreeWasHidden
-            ? recursivelyTraverseReappearLayoutEffects(
-                finishedRoot,
-                finishedWork,
-                0 !== (finishedWork.subtreeFlags & 8772)
-              )
-            : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        break;
+      case 24:
+        releaseCache(fiber.memoizedState.cache);
+        break;
+      case 25:
+        enableTransitionTracing &&
+          ((offscreenFiber = fiber.stateNode.transitions),
+          null !== offscreenFiber &&
+            ((instance = { reason: "marker", name: fiber.memoizedProps.name }),
+            abortParentMarkerTransitionsForDeletedFiber(
+              fiber,
+              instance,
+              offscreenFiber,
+              null,
+              !0
+            ),
+            null !== nearestMountedAncestor &&
+              abortParentMarkerTransitionsForDeletedFiber(
+                nearestMountedAncestor,
+                instance,
+                offscreenFiber,
+                null,
+                !1
+              )));
+    }
+    nearestMountedAncestor = fiber.child;
+    if (null !== nearestMountedAncestor)
+      (nearestMountedAncestor.return = fiber),
+        (nextEffect = nearestMountedAncestor);
+    else
+      a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
+        nearestMountedAncestor = nextEffect;
+        offscreenFiber = nearestMountedAncestor.sibling;
+        instance = nearestMountedAncestor.return;
+        detachFiberAfterEffects(nearestMountedAncestor);
+        if (nearestMountedAncestor === fiber) {
+          nextEffect = null;
+          break a;
         }
-      } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 512 &&
-        ("manual" === finishedWork.memoizedProps.mode
-          ? safelyAttachRef(finishedWork, finishedWork.return)
-          : safelyDetachRef(finishedWork, finishedWork.return));
-      break;
-    default:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        if (null !== offscreenFiber) {
+          offscreenFiber.return = instance;
+          nextEffect = offscreenFiber;
+          break a;
+        }
+        nextEffect = instance;
+      }
   }
 }
-function abortRootTransitions(
-  root,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance
+var DefaultCacheDispatcher = {
+    getCacheSignal: function () {
+      return readContext(CacheContext).controller.signal;
+    },
+    getCacheForType: function (resourceType) {
+      var cache = readContext(CacheContext),
+        cacheForType = cache.data.get(resourceType);
+      void 0 === cacheForType &&
+        ((cacheForType = resourceType()),
+        cache.data.set(resourceType, cacheForType));
+      return cacheForType;
+    }
+  },
+  postPaintCallbackScheduled = !1,
+  callbacks = [];
+function schedulePostPaintCallback(callback) {
+  callbacks.push(callback);
+  postPaintCallbackScheduled ||
+    ((postPaintCallbackScheduled = !0),
+    requestPostPaintCallback(function (endTime) {
+      for (var i = 0; i < callbacks.length; i++) callbacks[i](endTime);
+      postPaintCallbackScheduled = !1;
+      callbacks = [];
+    }));
+}
+var ceil = Math.ceil,
+  PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+  ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+  executionContext = 0,
+  workInProgressRoot = null,
+  workInProgress = null,
+  workInProgressRootRenderLanes = 0,
+  workInProgressSuspendedReason = 0,
+  workInProgressThrownValue = null,
+  workInProgressRootDidAttachPingListener = !1,
+  renderLanes = 0,
+  workInProgressRootExitStatus = 0,
+  workInProgressRootFatalError = null,
+  workInProgressRootSkippedLanes = 0,
+  workInProgressRootInterleavedUpdatedLanes = 0,
+  workInProgressRootPingedLanes = 0,
+  workInProgressRootConcurrentErrors = null,
+  workInProgressRootRecoverableErrors = null,
+  globalMostRecentFallbackTime = 0,
+  workInProgressRootRenderTargetTime = Infinity,
+  workInProgressTransitions = null,
+  currentPendingTransitionCallbacks = null,
+  currentEndTime = null;
+function addMarkerProgressCallbackToPendingTransition(
+  markerName,
+  transitions,
+  pendingBoundaries
 ) {
-  if (enableTransitionTracing) {
-    var rootTransitions = root.incompleteTransitions;
-    deletedTransitions.forEach(function (transition) {
-      rootTransitions.has(transition) &&
-        ((transition = rootTransitions.get(transition)),
-        null === transition.aborts && (transition.aborts = []),
-        transition.aborts.push(abort),
-        null !== deletedOffscreenInstance &&
-          null !== transition.pendingBoundaries &&
-          transition.pendingBoundaries.has(deletedOffscreenInstance) &&
-          transition.pendingBoundaries.delete(deletedOffscreenInstance));
-    });
-  }
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: new Map(),
+        markerIncomplete: null,
+        markerComplete: null
+      }),
+    null === currentPendingTransitionCallbacks.markerProgress &&
+      (currentPendingTransitionCallbacks.markerProgress = new Map()),
+    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
+      pendingBoundaries: pendingBoundaries,
+      transitions: transitions
+    }));
+}
+function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: new Map()
+      }),
+    null === currentPendingTransitionCallbacks.markerComplete &&
+      (currentPendingTransitionCallbacks.markerComplete = new Map()),
+    currentPendingTransitionCallbacks.markerComplete.set(
+      markerName,
+      transitions
+    ));
+}
+function addTransitionProgressCallbackToPendingTransition(
+  transition,
+  boundaries
+) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: new Map(),
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      }),
+    null === currentPendingTransitionCallbacks.transitionProgress &&
+      (currentPendingTransitionCallbacks.transitionProgress = new Map()),
+    currentPendingTransitionCallbacks.transitionProgress.set(
+      transition,
+      boundaries
+    ));
+}
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now() + 500;
+}
+var hasUncaughtError = !1,
+  firstUncaughtError = null,
+  legacyErrorBoundariesThatAlreadyFailed = null,
+  rootDoesHavePassiveEffects = !1,
+  rootWithPendingPassiveEffects = null,
+  pendingPassiveEffectsLanes = 0,
+  pendingPassiveEffectsRemainingLanes = 0,
+  pendingPassiveTransitions = null,
+  nestedUpdateCount = 0,
+  rootWithNestedUpdates = null,
+  currentEventTime = -1,
+  currentEventTransitionLane = 0;
+function requestEventTime() {
+  return 0 !== (executionContext & 6)
+    ? now()
+    : -1 !== currentEventTime
+    ? currentEventTime
+    : (currentEventTime = now());
 }
-function abortTracingMarkerTransitions(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var markerInstance = abortedFiber.stateNode,
-      markerTransitions = markerInstance.transitions,
-      pendingBoundaries = markerInstance.pendingBoundaries;
-    null !== markerTransitions &&
-      deletedTransitions.forEach(function (transition) {
-        if (
-          null !== abortedFiber &&
-          markerTransitions.has(transition) &&
-          (null === markerInstance.aborts ||
-            !markerInstance.aborts.includes(abort)) &&
-          null !== markerInstance.transitions
-        ) {
-          if (null === markerInstance.aborts) {
-            markerInstance.aborts = [abort];
-            transition = abortedFiber.memoizedProps.name;
-            var transitions = markerInstance.transitions,
-              aborts = markerInstance.aborts;
-            enableTransitionTracing &&
-              (null === currentPendingTransitionCallbacks &&
-                (currentPendingTransitionCallbacks = {
-                  transitionStart: null,
-                  transitionProgress: null,
-                  transitionComplete: null,
-                  markerProgress: null,
-                  markerIncomplete: new Map(),
-                  markerComplete: null
-                }),
-              null === currentPendingTransitionCallbacks.markerIncomplete &&
-                (currentPendingTransitionCallbacks.markerIncomplete =
-                  new Map()),
-              currentPendingTransitionCallbacks.markerIncomplete.set(
-                transition,
-                { transitions: transitions, aborts: aborts }
-              ));
-          } else markerInstance.aborts.push(abort);
-          null !== deletedOffscreenInstance &&
-            !isInDeletedTree &&
-            null !== pendingBoundaries &&
-            pendingBoundaries.has(deletedOffscreenInstance) &&
-            (pendingBoundaries.delete(deletedOffscreenInstance),
-            addMarkerProgressCallbackToPendingTransition(
-              abortedFiber.memoizedProps.name,
-              deletedTransitions,
-              pendingBoundaries
-            ));
-        }
-      });
+function requestUpdateLane(fiber) {
+  if (0 === (fiber.mode & 1)) return 2;
+  if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    0 !== (executionContext & 2) &&
+    0 !== workInProgressRootRenderLanes
+  )
+    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
+  if (null !== ReactCurrentBatchConfig$2.transition)
+    return (
+      0 === currentEventTransitionLane &&
+        (currentEventTransitionLane = claimNextTransitionLane()),
+      currentEventTransitionLane
+    );
+  fiber = currentUpdatePriority;
+  if (0 !== fiber) return fiber;
+  fiber = window.event;
+  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
+  return fiber;
+}
+function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+  2 === workInProgressSuspendedReason &&
+    root === workInProgressRoot &&
+    (prepareFreshStack(root, 0),
+    markRootSuspended(root, workInProgressRootRenderLanes));
+  markRootUpdated(root, lane, eventTime);
+  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig$1.transition;
+      if (
+        null !== transition &&
+        null != transition.name &&
+        (-1 === transition.startTime && (transition.startTime = now()),
+        enableTransitionTracing)
+      ) {
+        var transitionLanesMap = root.transitionLanes,
+          index$15 = 31 - clz32(lane),
+          transitions = transitionLanesMap[index$15];
+        null === transitions && (transitions = new Set());
+        transitions.add(transition);
+        transitionLanesMap[index$15] = transitions;
+      }
+    }
+    if (root === workInProgressRoot) {
+      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
+        workInProgressRootInterleavedUpdatedLanes |= lane;
+      4 === workInProgressRootExitStatus &&
+        markRootSuspended(root, workInProgressRootRenderLanes);
+    }
+    ensureRootIsScheduled(root, eventTime);
+    2 === lane &&
+      0 === executionContext &&
+      0 === (fiber.mode & 1) &&
+      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
   }
 }
-function abortParentMarkerTransitionsForDeletedFiber(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing)
-    for (; null !== abortedFiber; ) {
-      switch (abortedFiber.tag) {
-        case 25:
-          abortTracingMarkerTransitions(
-            abortedFiber,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance,
-            isInDeletedTree
-          );
+function ensureRootIsScheduled(root, currentTime) {
+  var existingCallbackNode = root.callbackNode;
+  markStarvedLanesAsExpired(root, currentTime);
+  var nextLanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+  );
+  if (0 === nextLanes)
+    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
+      (root.callbackNode = null),
+      (root.callbackPriority = 0);
+  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
+    (root.callbackPriority = 0), (root.callbackNode = null);
+  else if (
+    ((currentTime = nextLanes & -nextLanes),
+    root.callbackPriority !== currentTime)
+  ) {
+    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
+    if (0 !== (currentTime & 3))
+      0 === root.tag
+        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
+        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
+        scheduleMicrotask(function () {
+          0 === (executionContext & 6) && flushSyncCallbacks();
+        }),
+        (existingCallbackNode = null);
+    else {
+      switch (lanesToEventPriority(nextLanes)) {
+        case 2:
+          existingCallbackNode = ImmediatePriority;
           break;
-        case 3:
-          abortRootTransitions(
-            abortedFiber.stateNode,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance
-          );
+        case 8:
+          existingCallbackNode = UserBlockingPriority;
+          break;
+        case 32:
+          existingCallbackNode = NormalPriority$1;
+          break;
+        case 536870912:
+          existingCallbackNode = IdlePriority;
+          break;
+        default:
+          existingCallbackNode = NormalPriority$1;
       }
-      abortedFiber = abortedFiber.return;
+      existingCallbackNode = scheduleCallback(
+        existingCallbackNode,
+        performConcurrentWorkOnRoot.bind(null, root)
+      );
     }
-}
-function commitTransitionProgress(offscreenFiber) {
-  if (enableTransitionTracing) {
-    var offscreenInstance = offscreenFiber.stateNode,
-      prevState = null,
-      previousFiber = offscreenFiber.alternate;
-    null !== previousFiber &&
-      null !== previousFiber.memoizedState &&
-      (prevState = previousFiber.memoizedState);
-    prevState = null !== prevState;
-    previousFiber = null !== offscreenFiber.memoizedState;
-    var pendingMarkers = offscreenInstance._pendingMarkers,
-      name = null;
-    offscreenFiber = offscreenFiber.return;
-    null !== offscreenFiber &&
-      13 === offscreenFiber.tag &&
-      offscreenFiber.memoizedProps.unstable_name &&
-      (name = offscreenFiber.memoizedProps.unstable_name);
-    !prevState && previousFiber
-      ? null !== pendingMarkers &&
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries,
-            transitions = markerInstance.transitions,
-            markerName = markerInstance.name;
-          null === pendingBoundaries ||
-            pendingBoundaries.has(offscreenInstance) ||
-            (pendingBoundaries.set(offscreenInstance, { name: name }),
-            null !== transitions &&
-              (1 === markerInstance.tag && null !== markerName
-                ? addMarkerProgressCallbackToPendingTransition(
-                    markerName,
-                    transitions,
-                    pendingBoundaries
-                  )
-                : 0 === markerInstance.tag &&
-                  transitions.forEach(function (transition) {
-                    addTransitionProgressCallbackToPendingTransition(
-                      transition,
-                      pendingBoundaries
-                    );
-                  })));
-        })
-      : prevState &&
-        !previousFiber &&
-        null !== pendingMarkers &&
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries,
-            transitions = markerInstance.transitions,
-            markerName = markerInstance.name;
-          null !== pendingBoundaries &&
-            pendingBoundaries.has(offscreenInstance) &&
-            (pendingBoundaries.delete(offscreenInstance),
-            null !== transitions &&
-              (1 === markerInstance.tag && null !== markerName
-                ? (addMarkerProgressCallbackToPendingTransition(
-                    markerName,
-                    transitions,
-                    pendingBoundaries
-                  ),
-                  0 === pendingBoundaries.size &&
-                    (null === markerInstance.aborts &&
-                      addMarkerCompleteCallbackToPendingTransition(
-                        markerName,
-                        transitions
-                      ),
-                    (markerInstance.transitions = null),
-                    (markerInstance.pendingBoundaries = null),
-                    (markerInstance.aborts = null)))
-                : 0 === markerInstance.tag &&
-                  transitions.forEach(function (transition) {
-                    addTransitionProgressCallbackToPendingTransition(
-                      transition,
-                      pendingBoundaries
-                    );
-                  })));
-        });
+    root.callbackPriority = currentTime;
+    root.callbackNode = existingCallbackNode;
   }
 }
-function detachFiberAfterEffects(fiber) {
-  var alternate = fiber.alternate;
-  null !== alternate &&
-    ((fiber.alternate = null), detachFiberAfterEffects(alternate));
-  fiber.child = null;
-  fiber.deletions = null;
-  fiber.sibling = null;
-  5 === fiber.tag &&
-    ((alternate = fiber.stateNode),
-    null !== alternate && detachDeletedInstance(alternate));
-  fiber.stateNode = null;
-  fiber.return = null;
-  fiber.dependencies = null;
-  fiber.memoizedProps = null;
-  fiber.memoizedState = null;
-  fiber.pendingProps = null;
-  fiber.stateNode = null;
-  fiber.updateQueue = null;
-}
-function isHostParent(fiber) {
-  return (
-    5 === fiber.tag ||
-    3 === fiber.tag ||
-    26 === fiber.tag ||
-    27 === fiber.tag ||
-    4 === fiber.tag
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  currentEventTime = -1;
+  currentEventTransitionLane = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var originalCallbackNode = root.callbackNode;
+  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
+    return null;
+  var lanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
   );
-}
-function getHostSibling(fiber) {
-  a: for (;;) {
-    for (; null === fiber.sibling; ) {
-      if (null === fiber.return || isHostParent(fiber.return)) return null;
-      fiber = fiber.return;
+  if (0 === lanes) return null;
+  didTimeout =
+    includesBlockingLane(root, lanes) ||
+    0 !== (lanes & root.expiredLanes) ||
+    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
+      ? renderRootSync(root, lanes)
+      : renderRootConcurrent(root, lanes);
+  if (0 !== didTimeout) {
+    if (2 === didTimeout) {
+      var originallyAttemptedLanes = lanes,
+        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+          root,
+          originallyAttemptedLanes
+        );
+      0 !== errorRetryLanes &&
+        ((lanes = errorRetryLanes),
+        (didTimeout = recoverFromConcurrentError(
+          root,
+          originallyAttemptedLanes,
+          errorRetryLanes
+        )));
     }
-    fiber.sibling.return = fiber.return;
-    for (
-      fiber = fiber.sibling;
-      5 !== fiber.tag &&
-      6 !== fiber.tag &&
-      27 !== fiber.tag &&
-      18 !== fiber.tag;
-
-    ) {
-      if (fiber.flags & 2) continue a;
-      if (null === fiber.child || 4 === fiber.tag) continue a;
-      else (fiber.child.return = fiber), (fiber = fiber.child);
+    if (1 === didTimeout)
+      throw (
+        ((originalCallbackNode = workInProgressRootFatalError),
+        prepareFreshStack(root, 0),
+        markRootSuspended(root, lanes),
+        ensureRootIsScheduled(root, now()),
+        originalCallbackNode)
+      );
+    if (6 === didTimeout) markRootSuspended(root, lanes);
+    else {
+      errorRetryLanes = !includesBlockingLane(root, lanes);
+      originallyAttemptedLanes = root.current.alternate;
+      if (
+        errorRetryLanes &&
+        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
+      ) {
+        didTimeout = renderRootSync(root, lanes);
+        if (2 === didTimeout) {
+          errorRetryLanes = lanes;
+          var errorRetryLanes$168 = getLanesToRetrySynchronouslyOnError(
+            root,
+            errorRetryLanes
+          );
+          0 !== errorRetryLanes$168 &&
+            ((lanes = errorRetryLanes$168),
+            (didTimeout = recoverFromConcurrentError(
+              root,
+              errorRetryLanes,
+              errorRetryLanes$168
+            )));
+        }
+        if (1 === didTimeout)
+          throw (
+            ((originalCallbackNode = workInProgressRootFatalError),
+            prepareFreshStack(root, 0),
+            markRootSuspended(root, lanes),
+            ensureRootIsScheduled(root, now()),
+            originalCallbackNode)
+          );
+      }
+      root.finishedWork = originallyAttemptedLanes;
+      root.finishedLanes = lanes;
+      switch (didTimeout) {
+        case 0:
+        case 1:
+          throw Error(formatProdErrorMessage(345));
+        case 2:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 3:
+          markRootSuspended(root, lanes);
+          if (
+            (lanes & 125829120) === lanes &&
+            ((lanes = globalMostRecentFallbackTime + 500 - now()), 10 < lanes)
+          ) {
+            if (0 !== getNextLanes(root, 0)) break;
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
+            );
+            break;
+          }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 4:
+          markRootSuspended(root, lanes);
+          if ((lanes & 8388480) === lanes) break;
+          didTimeout = root.eventTimes;
+          for (originallyAttemptedLanes = -1; 0 < lanes; )
+            (errorRetryLanes$168 = 31 - clz32(lanes)),
+              (errorRetryLanes = 1 << errorRetryLanes$168),
+              (errorRetryLanes$168 = didTimeout[errorRetryLanes$168]),
+              errorRetryLanes$168 > originallyAttemptedLanes &&
+                (originallyAttemptedLanes = errorRetryLanes$168),
+              (lanes &= ~errorRetryLanes);
+          lanes = originallyAttemptedLanes;
+          lanes = now() - lanes;
+          lanes =
+            (120 > lanes
+              ? 120
+              : 480 > lanes
+              ? 480
+              : 1080 > lanes
+              ? 1080
+              : 1920 > lanes
+              ? 1920
+              : 3e3 > lanes
+              ? 3e3
+              : 4320 > lanes
+              ? 4320
+              : 1960 * ceil(lanes / 1960)) - lanes;
+          if (10 < lanes) {
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
+            );
+            break;
+          }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 5:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        default:
+          throw Error(formatProdErrorMessage(329));
+      }
     }
-    if (!(fiber.flags & 2)) return fiber.stateNode;
   }
-}
-function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
-  var tag = node.tag;
-  if (5 === tag || 6 === tag)
-    (node = node.stateNode),
-      before
-        ? 8 === parent.nodeType
-          ? parent.parentNode.insertBefore(node, before)
-          : parent.insertBefore(node, before)
-        : (8 === parent.nodeType
-            ? ((before = parent.parentNode), before.insertBefore(node, parent))
-            : ((before = parent), before.appendChild(node)),
-          (parent = parent._reactRootContainer),
-          (null !== parent && void 0 !== parent) ||
-            null !== before.onclick ||
-            (before.onclick = noop$1));
-  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
-    for (
-      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
-        node = node.sibling;
-      null !== node;
-
-    )
-      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
-        (node = node.sibling);
-}
-function insertOrAppendPlacementNode(node, before, parent) {
-  var tag = node.tag;
-  if (5 === tag || 6 === tag)
-    (node = node.stateNode),
-      before ? parent.insertBefore(node, before) : parent.appendChild(node);
-  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
-    for (
-      insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
-      null !== node;
-
-    )
-      insertOrAppendPlacementNode(node, before, parent), (node = node.sibling);
-}
-var hostParent = null,
-  hostParentIsContainer = !1;
-function recursivelyTraverseDeletionEffects(
-  finishedRoot,
-  nearestMountedAncestor,
-  parent
-) {
-  for (parent = parent.child; null !== parent; )
-    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent),
-      (parent = parent.sibling);
-}
-function commitDeletionEffectsOnFiber(
-  finishedRoot,
-  nearestMountedAncestor,
-  deletedFiber
+  ensureRootIsScheduled(root, now());
+  return root.callbackNode === originalCallbackNode
+    ? performConcurrentWorkOnRoot.bind(null, root)
+    : null;
+}
+function recoverFromConcurrentError(
+  root,
+  originallyAttemptedLanes,
+  errorRetryLanes
 ) {
-  if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
-    try {
-      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
-    } catch (err) {}
-  switch (deletedFiber.tag) {
-    case 26:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      deletedFiber.memoizedState
-        ? deletedFiber.memoizedState.count--
-        : deletedFiber.stateNode &&
-          ((deletedFiber = deletedFiber.stateNode),
-          deletedFiber.parentNode.removeChild(deletedFiber));
-      break;
-    case 27:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      var prevHostParent = hostParent,
-        prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = deletedFiber.stateNode;
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      deletedFiber = deletedFiber.stateNode;
-      for (finishedRoot = deletedFiber.attributes; finishedRoot.length; )
-        deletedFiber.removeAttributeNode(finishedRoot[0]);
-      detachDeletedInstance(deletedFiber);
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
-      break;
-    case 5:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-    case 6:
-      prevHostParent = hostParent;
-      prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = null;
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
-      null !== hostParent &&
-        (hostParentIsContainer
-          ? ((finishedRoot = hostParent),
-            (deletedFiber = deletedFiber.stateNode),
-            8 === finishedRoot.nodeType
-              ? finishedRoot.parentNode.removeChild(deletedFiber)
-              : finishedRoot.removeChild(deletedFiber))
-          : hostParent.removeChild(deletedFiber.stateNode));
-      break;
-    case 18:
-      finishedRoot = finishedRoot.hydrationCallbacks;
-      null !== finishedRoot &&
-        (finishedRoot = finishedRoot.onDeleted) &&
-        finishedRoot(deletedFiber.stateNode);
-      null !== hostParent &&
-        (hostParentIsContainer
-          ? ((finishedRoot = hostParent),
-            (deletedFiber = deletedFiber.stateNode),
-            8 === finishedRoot.nodeType
-              ? clearSuspenseBoundary(finishedRoot.parentNode, deletedFiber)
-              : 1 === finishedRoot.nodeType &&
-                clearSuspenseBoundary(finishedRoot, deletedFiber),
-            retryIfBlockedOn(finishedRoot))
-          : clearSuspenseBoundary(hostParent, deletedFiber.stateNode));
-      break;
-    case 4:
-      prevHostParent = hostParent;
-      prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = deletedFiber.stateNode.containerInfo;
-      hostParentIsContainer = !0;
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
+    wasRootDehydrated = root.current.memoizedState.isDehydrated;
+  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
+  errorRetryLanes = renderRootSync(root, errorRetryLanes);
+  if (2 !== errorRetryLanes) {
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
+      return (
+        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
+        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
+        4
       );
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
-      break;
-    case 0:
-    case 11:
-    case 14:
-    case 15:
-      if (
-        !offscreenSubtreeWasHidden &&
-        ((prevHostParent = deletedFiber.updateQueue),
-        null !== prevHostParent &&
-          ((prevHostParent = prevHostParent.lastEffect),
-          null !== prevHostParent))
-      ) {
-        prevHostParentIsContainer = prevHostParent = prevHostParent.next;
-        do {
-          var _effect = prevHostParentIsContainer,
-            destroy = _effect.destroy;
-          _effect = _effect.tag;
-          void 0 !== destroy &&
-            (0 !== (_effect & 2)
-              ? safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy)
-              : 0 !== (_effect & 4) &&
-                safelyCallDestroy(
-                  deletedFiber,
-                  nearestMountedAncestor,
-                  destroy
-                ));
-          prevHostParentIsContainer = prevHostParentIsContainer.next;
-        } while (prevHostParentIsContainer !== prevHostParent);
-      }
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+    root = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
+    null !== root && queueRecoverableErrors(root);
+  }
+  return errorRetryLanes;
+}
+function queueRecoverableErrors(errors) {
+  null === workInProgressRootRecoverableErrors
+    ? (workInProgressRootRecoverableErrors = errors)
+    : workInProgressRootRecoverableErrors.push.apply(
+        workInProgressRootRecoverableErrors,
+        errors
       );
-      break;
-    case 1:
+}
+function isRenderConsistentWithExternalStores(finishedWork) {
+  for (var node = finishedWork; ; ) {
+    if (node.flags & 16384) {
+      var updateQueue = node.updateQueue;
       if (
-        !offscreenSubtreeWasHidden &&
-        (safelyDetachRef(deletedFiber, nearestMountedAncestor),
-        (prevHostParent = deletedFiber.stateNode),
-        "function" === typeof prevHostParent.componentWillUnmount)
+        null !== updateQueue &&
+        ((updateQueue = updateQueue.stores), null !== updateQueue)
       )
-        try {
-          (prevHostParent.props = deletedFiber.memoizedProps),
-            (prevHostParent.state = deletedFiber.memoizedState),
-            prevHostParent.componentWillUnmount();
-        } catch (error) {
-          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
+        for (var i = 0; i < updateQueue.length; i++) {
+          var check = updateQueue[i],
+            getSnapshot = check.getSnapshot;
+          check = check.value;
+          try {
+            if (!objectIs(getSnapshot(), check)) return !1;
+          } catch (error) {
+            return !1;
+          }
         }
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      break;
-    case 21:
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      break;
-    case 22:
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      deletedFiber.mode & 1
-        ? ((offscreenSubtreeWasHidden =
-            (prevHostParent = offscreenSubtreeWasHidden) ||
-            null !== deletedFiber.memoizedState),
-          recursivelyTraverseDeletionEffects(
-            finishedRoot,
-            nearestMountedAncestor,
-            deletedFiber
-          ),
-          (offscreenSubtreeWasHidden = prevHostParent))
-        : recursivelyTraverseDeletionEffects(
-            finishedRoot,
-            nearestMountedAncestor,
-            deletedFiber
-          );
-      break;
-    default:
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+    }
+    updateQueue = node.child;
+    if (node.subtreeFlags & 16384 && null !== updateQueue)
+      (updateQueue.return = node), (node = updateQueue);
+    else {
+      if (node === finishedWork) break;
+      for (; null === node.sibling; ) {
+        if (null === node.return || node.return === finishedWork) return !0;
+        node = node.return;
+      }
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+  return !0;
+}
+function markRootSuspended(root, suspendedLanes) {
+  suspendedLanes &= ~workInProgressRootPingedLanes;
+  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes;
+  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
+    var index$12 = 31 - clz32(suspendedLanes),
+      lane = 1 << index$12;
+    root[index$12] = -1;
+    suspendedLanes &= ~lane;
+  }
+}
+function performSyncWorkOnRoot(root) {
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  flushPassiveEffects();
+  var lanes = getNextLanes(root, 0);
+  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now()), null;
+  var exitStatus = renderRootSync(root, lanes);
+  if (0 !== root.tag && 2 === exitStatus) {
+    var originallyAttemptedLanes = lanes,
+      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+        root,
+        originallyAttemptedLanes
       );
+    0 !== errorRetryLanes &&
+      ((lanes = errorRetryLanes),
+      (exitStatus = recoverFromConcurrentError(
+        root,
+        originallyAttemptedLanes,
+        errorRetryLanes
+      )));
   }
+  if (1 === exitStatus)
+    throw (
+      ((exitStatus = workInProgressRootFatalError),
+      prepareFreshStack(root, 0),
+      markRootSuspended(root, lanes),
+      ensureRootIsScheduled(root, now()),
+      exitStatus)
+    );
+  if (6 === exitStatus)
+    return (
+      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now()), null
+    );
+  root.finishedWork = root.current.alternate;
+  root.finishedLanes = lanes;
+  commitRoot(
+    root,
+    workInProgressRootRecoverableErrors,
+    workInProgressTransitions
+  );
+  ensureRootIsScheduled(root, now());
+  return null;
 }
-function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
-  if (null === finishedWork.memoizedState) {
-    var current = finishedWork.alternate;
+function batchedUpdates$1(fn, a) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  try {
+    return fn(a);
+  } finally {
+    (executionContext = prevExecutionContext),
+      0 === executionContext &&
+        (resetRenderTimer(),
+        includesLegacySyncCallbacks && flushSyncCallbacks());
+  }
+}
+function flushSync$1(fn) {
+  null !== rootWithPendingPassiveEffects &&
+    0 === rootWithPendingPassiveEffects.tag &&
+    0 === (executionContext & 6) &&
+    flushPassiveEffects();
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
+    previousPriority = currentUpdatePriority;
+  try {
     if (
-      null !== current &&
-      ((current = current.memoizedState),
-      null !== current && ((current = current.dehydrated), null !== current))
+      ((ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      fn)
     )
-      try {
-        retryIfBlockedOn(current);
-        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
-        if (null !== hydrationCallbacks) {
-          var onHydrated = hydrationCallbacks.onHydrated;
-          onHydrated && onHydrated(current);
-        }
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
+      return fn();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (executionContext = prevExecutionContext),
+      0 === (executionContext & 6) && flushSyncCallbacks();
   }
 }
-function getRetryCache(finishedWork) {
-  switch (finishedWork.tag) {
-    case 13:
-    case 19:
-      var retryCache = finishedWork.stateNode;
-      null === retryCache &&
-        (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
-      return retryCache;
-    case 22:
-      return (
-        (finishedWork = finishedWork.stateNode),
-        (retryCache = finishedWork._retryCache),
-        null === retryCache &&
-          (retryCache = finishedWork._retryCache = new PossiblyWeakSet()),
-        retryCache
-      );
-    default:
-      throw Error(formatProdErrorMessage(435, finishedWork.tag));
+function resetWorkInProgressStack() {
+  if (null !== workInProgress) {
+    if (0 === workInProgressSuspendedReason)
+      var interruptedWork = workInProgress.return;
+    else
+      resetContextDependencies(),
+        resetHooksOnUnwind(),
+        (thenableState$1 = null),
+        (thenableIndexCounter$1 = 0),
+        (interruptedWork = workInProgress);
+    for (; null !== interruptedWork; )
+      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
+        (interruptedWork = interruptedWork.return);
+    workInProgress = null;
   }
 }
-function detachOffscreenInstance(instance) {
-  var fiber = instance._current;
-  if (null === fiber) throw Error(formatProdErrorMessage(456));
-  if (0 === (instance._pendingVisibility & 2)) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    null !== root &&
-      ((instance._pendingVisibility |= 2),
-      scheduleUpdateOnFiber(root, fiber, 2, -1));
-  }
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  var timeoutHandle = root.timeoutHandle;
+  -1 !== timeoutHandle &&
+    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  workInProgress = root = createWorkInProgress(root.current, null);
+  workInProgressRootRenderLanes = renderLanes = lanes;
+  workInProgressSuspendedReason = 0;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = !1;
+  workInProgressRootExitStatus = 0;
+  workInProgressRootFatalError = null;
+  workInProgressRootPingedLanes =
+    workInProgressRootInterleavedUpdatedLanes =
+    workInProgressRootSkippedLanes =
+      0;
+  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
+    null;
+  finishQueueingConcurrentUpdates();
+  return root;
 }
-function attachOffscreenInstance(instance) {
-  var fiber = instance._current;
-  if (null === fiber) throw Error(formatProdErrorMessage(456));
-  if (0 !== (instance._pendingVisibility & 2)) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    null !== root &&
-      ((instance._pendingVisibility &= -3),
-      scheduleUpdateOnFiber(root, fiber, 2, -1));
-  }
+function handleThrow(root, thrownValue) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  ReactCurrentOwner.current = null;
+  if (thrownValue === SuspenseException) {
+    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
+    root = suspendedThenable;
+    suspendedThenable = null;
+    thrownValue = root;
+    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
+      ? 2
+      : 3;
+  } else
+    workInProgressSuspendedReason =
+      thrownValue === SelectiveHydrationException
+        ? 6
+        : null !== thrownValue &&
+          "object" === typeof thrownValue &&
+          "function" === typeof thrownValue.then
+        ? 4
+        : 1;
+  workInProgressThrownValue = thrownValue;
+  null === workInProgress &&
+    ((workInProgressRootExitStatus = 1),
+    (workInProgressRootFatalError = thrownValue));
 }
-function attachSuspenseRetryListeners(finishedWork, wakeables) {
-  var retryCache = getRetryCache(finishedWork);
-  wakeables.forEach(function (wakeable) {
-    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
-    retryCache.has(wakeable) ||
-      (retryCache.add(wakeable), wakeable.then(retry, retry));
-  });
+function shouldAttemptToSuspendUntilDataResolves() {
+  if (
+    0 !== (workInProgressRootSkippedLanes & 268435455) ||
+    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
+  )
+    return !1;
+  if (
+    (workInProgressRootRenderLanes & 8388480) ===
+    workInProgressRootRenderLanes
+  )
+    return null === shellBoundary;
+  var handler = suspenseHandlerStackCursor.current;
+  return null !== handler &&
+    (workInProgressRootRenderLanes & 125829120) ===
+      workInProgressRootRenderLanes
+    ? handler === shellBoundary
+    : !1;
 }
-function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (null !== deletions)
-    for (var i = 0; i < deletions.length; i++) {
-      var childToDelete = deletions[i];
-      try {
-        var root = root$jscomp$0,
-          returnFiber = parentFiber,
-          parent = returnFiber;
-        a: for (; null !== parent; ) {
-          switch (parent.tag) {
-            case 27:
-            case 5:
-              hostParent = parent.stateNode;
-              hostParentIsContainer = !1;
-              break a;
-            case 3:
-              hostParent = parent.stateNode.containerInfo;
-              hostParentIsContainer = !0;
-              break a;
-            case 4:
-              hostParent = parent.stateNode.containerInfo;
-              hostParentIsContainer = !0;
-              break a;
-          }
-          parent = parent.return;
+function pushDispatcher(container) {
+  container = getHoistableRoot(container);
+  lastCurrentDocument = container.ownerDocument || container;
+  previousDispatcher = Dispatcher$1.current;
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  container = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+  return null === container ? ContextOnlyDispatcher : container;
+}
+function pushCacheDispatcher() {
+  var prevCacheDispatcher = ReactCurrentCache.current;
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  return prevCacheDispatcher;
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = 4;
+  null === workInProgressRoot ||
+    (0 === (workInProgressRootSkippedLanes & 268435455) &&
+      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+}
+function renderRootSync(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      prepareFreshStack(root, lanes);
+  a: do
+    try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            (workInProgressSuspendedReason = 0),
+              (workInProgressThrownValue = null),
+              unwindSuspendedUnitOfWork(lanes, thrownValue);
         }
-        if (null === hostParent) throw Error(formatProdErrorMessage(160));
-        commitDeletionEffectsOnFiber(root, returnFiber, childToDelete);
-        hostParent = null;
-        hostParentIsContainer = !1;
-        var alternate = childToDelete.alternate;
-        null !== alternate && (alternate.return = null);
-        childToDelete.return = null;
-      } catch (error) {
-        captureCommitPhaseError(childToDelete, parentFiber, error);
       }
+      workLoopSync();
+      break;
+    } catch (thrownValue$171) {
+      handleThrow(root, thrownValue$171);
     }
-  if (parentFiber.subtreeFlags & 12854)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitMutationEffectsOnFiber(parentFiber, root$jscomp$0),
-        (parentFiber = parentFiber.sibling);
+  while (1);
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
 }
-var currentHoistableRoot = null;
-function commitMutationEffectsOnFiber(finishedWork, root) {
-  var current = finishedWork.alternate,
-    flags = finishedWork.flags;
-  switch (finishedWork.tag) {
-    case 0:
-    case 11:
-    case 14:
-    case 15:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4) {
-        try {
-          commitHookEffectListUnmount(3, finishedWork, finishedWork.return),
-            commitHookEffectListMount(3, finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
-        try {
-          commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-        } catch (error$184) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$184);
-        }
-      }
-      break;
-    case 1:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      flags & 64 &&
-        offscreenSubtreeIsHidden &&
-        ((finishedWork = finishedWork.updateQueue),
-        null !== finishedWork &&
-          ((current = finishedWork.callbacks),
-          null !== current &&
-            ((flags = finishedWork.shared.hiddenCallbacks),
-            (finishedWork.shared.hiddenCallbacks =
-              null === flags ? current : flags.concat(current)))));
-      break;
-    case 26:
-      var hoistableRoot = currentHoistableRoot;
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      if (flags & 4)
-        if (
-          ((root = null !== current ? current.memoizedState : null),
-          (flags = finishedWork.memoizedState),
-          null === current)
-        )
-          if (null === flags)
-            if (null === finishedWork.stateNode) {
-              a: {
-                current = finishedWork.type;
-                flags = finishedWork.memoizedProps;
-                root = hoistableRoot.ownerDocument || hoistableRoot;
-                b: switch (current) {
-                  case "title":
-                    hoistableRoot = root.getElementsByTagName("title")[0];
-                    if (
-                      !hoistableRoot ||
-                      hoistableRoot[internalHoistableMarker] ||
-                      hoistableRoot[internalInstanceKey] ||
-                      "http://www.w3.org/2000/svg" ===
-                        hoistableRoot.namespaceURI ||
-                      hoistableRoot.hasAttribute("itemprop")
-                    )
-                      (hoistableRoot = root.createElement(current)),
-                        root.head.insertBefore(
-                          hoistableRoot,
-                          root.querySelector("head > title")
-                        );
-                    setInitialProperties(hoistableRoot, current, flags);
-                    hoistableRoot[internalInstanceKey] = finishedWork;
-                    markNodeAsHoistable(hoistableRoot);
-                    current = hoistableRoot;
-                    break a;
-                  case "link":
-                    var maybeNodes = getHydratableHoistableCache(
-                      "link",
-                      "href",
-                      root
-                    ).get(current + (flags.href || ""));
-                    if (maybeNodes)
-                      for (var i = 0; i < maybeNodes.length; i++)
-                        if (
-                          ((hoistableRoot = maybeNodes[i]),
-                          hoistableRoot.getAttribute("href") ===
-                            (null == flags.href ? null : flags.href) &&
-                            hoistableRoot.getAttribute("rel") ===
-                              (null == flags.rel ? null : flags.rel) &&
-                            hoistableRoot.getAttribute("title") ===
-                              (null == flags.title ? null : flags.title) &&
-                            hoistableRoot.getAttribute("crossorigin") ===
-                              (null == flags.crossOrigin
-                                ? null
-                                : flags.crossOrigin))
-                        ) {
-                          maybeNodes.splice(i, 1);
-                          break b;
-                        }
-                    hoistableRoot = root.createElement(current);
-                    setInitialProperties(hoistableRoot, current, flags);
-                    root.head.appendChild(hoistableRoot);
-                    break;
-                  case "meta":
-                    if (
-                      (maybeNodes = getHydratableHoistableCache(
-                        "meta",
-                        "content",
-                        root
-                      ).get(current + (flags.content || "")))
-                    )
-                      for (i = 0; i < maybeNodes.length; i++)
-                        if (
-                          ((hoistableRoot = maybeNodes[i]),
-                          hoistableRoot.getAttribute("content") ===
-                            (null == flags.content
-                              ? null
-                              : "" + flags.content) &&
-                            hoistableRoot.getAttribute("name") ===
-                              (null == flags.name ? null : flags.name) &&
-                            hoistableRoot.getAttribute("property") ===
-                              (null == flags.property
-                                ? null
-                                : flags.property) &&
-                            hoistableRoot.getAttribute("http-equiv") ===
-                              (null == flags.httpEquiv
-                                ? null
-                                : flags.httpEquiv) &&
-                            hoistableRoot.getAttribute("charset") ===
-                              (null == flags.charSet ? null : flags.charSet))
-                        ) {
-                          maybeNodes.splice(i, 1);
-                          break b;
-                        }
-                    hoistableRoot = root.createElement(current);
-                    setInitialProperties(hoistableRoot, current, flags);
-                    root.head.appendChild(hoistableRoot);
-                    break;
-                  default:
-                    throw Error(formatProdErrorMessage(468, current));
-                }
-                hoistableRoot[internalInstanceKey] = finishedWork;
-                markNodeAsHoistable(hoistableRoot);
-                current = hoistableRoot;
-              }
-              finishedWork.stateNode = current;
-            } else
-              mountHoistable(
-                hoistableRoot,
-                finishedWork.type,
-                finishedWork.stateNode
-              );
-          else
-            finishedWork.stateNode = acquireResource(
-              hoistableRoot,
-              flags,
-              finishedWork.memoizedProps
-            );
-        else if (root !== flags)
-          null === root
-            ? null !== current.stateNode &&
-              ((current = current.stateNode),
-              current.parentNode.removeChild(current))
-            : root.count--,
-            null === flags
-              ? mountHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.stateNode
-                )
-              : acquireResource(
-                  hoistableRoot,
-                  flags,
-                  finishedWork.memoizedProps
-                );
-        else if (
-          null === flags &&
-          null !== finishedWork.stateNode &&
-          ((flags = finishedWork.updateQueue),
-          (finishedWork.updateQueue = null),
-          null !== flags)
-        )
-          try {
-            var domElement = finishedWork.stateNode,
-              newProps = finishedWork.memoizedProps;
-            updateProperties(
-              domElement,
-              flags,
-              finishedWork.type,
-              current.memoizedProps,
-              newProps
-            );
-            domElement[internalPropsKey] = newProps;
-          } catch (error$185) {
-            captureCommitPhaseError(
-              finishedWork,
-              finishedWork.return,
-              error$185
-            );
-          }
-      break;
-    case 27:
-      if (flags & 4 && null === finishedWork.alternate) {
-        hoistableRoot = finishedWork.stateNode;
-        maybeNodes = finishedWork.memoizedProps;
-        for (i = hoistableRoot.firstChild; i; ) {
-          var nextNode = i.nextSibling,
-            nodeName = i.nodeName;
-          i[internalHoistableMarker] ||
-            "HEAD" === nodeName ||
-            "BODY" === nodeName ||
-            "STYLE" === nodeName ||
-            ("LINK" === nodeName && "stylesheet" === i.rel.toLowerCase()) ||
-            hoistableRoot.removeChild(i);
-          i = nextNode;
+function workLoopSync() {
+  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+}
+function renderRootConcurrent(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      resetRenderTimer(),
+      prepareFreshStack(root, lanes);
+  a: do
+    try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 1:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, thrownValue);
+            break;
+          case 2:
+            if (isThenableResolved(thrownValue)) {
+              workInProgressSuspendedReason = 0;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
+            }
+            lanes = function () {
+              2 === workInProgressSuspendedReason &&
+                workInProgressRoot === root &&
+                (workInProgressSuspendedReason = 5);
+              ensureRootIsScheduled(root, now());
+            };
+            thrownValue.then(lanes, lanes);
+            break a;
+          case 3:
+            workInProgressSuspendedReason = 5;
+            break a;
+          case 5:
+            isThenableResolved(thrownValue)
+              ? ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                replaySuspendedUnitOfWork(lanes))
+              : ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                unwindSuspendedUnitOfWork(lanes, thrownValue));
+            break;
+          case 4:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, thrownValue);
+            break;
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            throw Error(formatProdErrorMessage(462));
         }
-        i = finishedWork.type;
-        for (nextNode = hoistableRoot.attributes; nextNode.length; )
-          hoistableRoot.removeAttributeNode(nextNode[0]);
-        setInitialProperties(hoistableRoot, i, maybeNodes);
-        hoistableRoot[internalInstanceKey] = finishedWork;
-        hoistableRoot[internalPropsKey] = maybeNodes;
       }
-    case 5:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      if (finishedWork.flags & 32) {
-        root = finishedWork.stateNode;
-        try {
-          setTextContent(root, "");
-        } catch (error$186) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$186);
+      workLoopConcurrent();
+      break;
+    } catch (thrownValue$173) {
+      handleThrow(root, thrownValue$173);
+    }
+  while (1);
+  resetContextDependencies();
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  executionContext = prevExecutionContext;
+  if (null !== workInProgress) return 0;
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+}
+function workLoopConcurrent() {
+  for (; null !== workInProgress && !shouldYield(); )
+    performUnitOfWork(workInProgress);
+}
+function performUnitOfWork(unitOfWork) {
+  var next = beginWork(unitOfWork.alternate, unitOfWork, renderLanes);
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === next ? completeUnitOfWork(unitOfWork) : (workInProgress = next);
+  ReactCurrentOwner.current = null;
+}
+function replaySuspendedUnitOfWork(unitOfWork) {
+  var current = unitOfWork.alternate;
+  switch (unitOfWork.tag) {
+    case 2:
+      unitOfWork.tag = 0;
+    case 0:
+    case 11:
+      var Component = unitOfWork.type,
+        unresolvedProps = unitOfWork.pendingProps;
+      unresolvedProps =
+        unitOfWork.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unresolvedProps,
+        Component,
+        workInProgressRootRenderLanes
+      );
+      break;
+    case 15:
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unitOfWork.pendingProps,
+        unitOfWork.type,
+        workInProgressRootRenderLanes
+      );
+      break;
+    default:
+      unwindInterruptedWork(current, unitOfWork),
+        (unitOfWork = workInProgress =
+          resetWorkInProgress(unitOfWork, renderLanes)),
+        (current = beginWork(current, unitOfWork, renderLanes));
+  }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === current
+    ? completeUnitOfWork(unitOfWork)
+    : (workInProgress = current);
+  ReactCurrentOwner.current = null;
+}
+function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
+  resetContextDependencies();
+  resetHooksOnUnwind();
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+  var returnFiber = unitOfWork.return;
+  if (null === returnFiber || null === workInProgressRoot)
+    (workInProgressRootExitStatus = 1),
+      (workInProgressRootFatalError = thrownValue),
+      (workInProgress = null);
+  else {
+    try {
+      a: {
+        var root = workInProgressRoot,
+          value = thrownValue;
+        thrownValue = workInProgressRootRenderLanes;
+        unitOfWork.flags |= 32768;
+        if (
+          null !== value &&
+          "object" === typeof value &&
+          "function" === typeof value.then
+        ) {
+          var wakeable = value;
+          if (enableLazyContextPropagation) {
+            var currentSourceFiber = unitOfWork.alternate;
+            null !== currentSourceFiber &&
+              propagateParentContextChanges(
+                currentSourceFiber,
+                unitOfWork,
+                thrownValue,
+                !0
+              );
+          }
+          var tag = unitOfWork.tag;
+          if (
+            0 === (unitOfWork.mode & 1) &&
+            (0 === tag || 11 === tag || 15 === tag)
+          ) {
+            var currentSource = unitOfWork.alternate;
+            currentSource
+              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
+                (unitOfWork.memoizedState = currentSource.memoizedState),
+                (unitOfWork.lanes = currentSource.lanes))
+              : ((unitOfWork.updateQueue = null),
+                (unitOfWork.memoizedState = null));
+          }
+          var suspenseBoundary = suspenseHandlerStackCursor.current;
+          if (null !== suspenseBoundary) {
+            switch (suspenseBoundary.tag) {
+              case 13:
+                unitOfWork.mode & 1 &&
+                  (null === shellBoundary
+                    ? renderDidSuspendDelayIfPossible()
+                    : null === suspenseBoundary.alternate &&
+                      0 === workInProgressRootExitStatus &&
+                      (workInProgressRootExitStatus = 3));
+                suspenseBoundary.flags &= -257;
+                markSuspenseBoundaryShouldCapture(
+                  suspenseBoundary,
+                  returnFiber,
+                  unitOfWork,
+                  root,
+                  thrownValue
+                );
+                var wakeables = suspenseBoundary.updateQueue;
+                null === wakeables
+                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
+                  : wakeables.add(wakeable);
+                break;
+              case 22:
+                if (suspenseBoundary.mode & 1) {
+                  suspenseBoundary.flags |= 65536;
+                  var offscreenQueue = suspenseBoundary.updateQueue;
+                  if (null === offscreenQueue) {
+                    var newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      wakeables: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    var wakeables$56 = offscreenQueue.wakeables;
+                    null === wakeables$56
+                      ? (offscreenQueue.wakeables = new Set([wakeable]))
+                      : wakeables$56.add(wakeable);
+                  }
+                  break;
+                }
+              default:
+                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+            }
+            suspenseBoundary.mode & 1 &&
+              attachPingListener(root, wakeable, thrownValue);
+            break a;
+          } else if (1 === root.tag) {
+            attachPingListener(root, wakeable, thrownValue);
+            renderDidSuspendDelayIfPossible();
+            break a;
+          } else value = Error(formatProdErrorMessage(426));
+        } else if (
+          isHydrating &&
+          unitOfWork.mode & 1 &&
+          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
+        ) {
+          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
+          markSuspenseBoundaryShouldCapture(
+            wakeable,
+            returnFiber,
+            unitOfWork,
+            root,
+            thrownValue
+          );
+          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
+          break a;
         }
+        root = value = createCapturedValueAtFiber(value, unitOfWork);
+        4 !== workInProgressRootExitStatus &&
+          (workInProgressRootExitStatus = 2);
+        null === workInProgressRootConcurrentErrors
+          ? (workInProgressRootConcurrentErrors = [root])
+          : workInProgressRootConcurrentErrors.push(root);
+        root = returnFiber;
+        do {
+          switch (root.tag) {
+            case 3:
+              var errorInfo = value;
+              root.flags |= 65536;
+              thrownValue &= -thrownValue;
+              root.lanes |= thrownValue;
+              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
+              enqueueCapturedUpdate(root, update);
+              break a;
+            case 1:
+              currentSourceFiber = value;
+              var ctor = root.type,
+                instance = root.stateNode;
+              if (
+                0 === (root.flags & 128) &&
+                ("function" === typeof ctor.getDerivedStateFromError ||
+                  (null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
+              ) {
+                root.flags |= 65536;
+                update = thrownValue & -thrownValue;
+                root.lanes |= update;
+                errorInfo = createClassErrorUpdate(
+                  root,
+                  currentSourceFiber,
+                  update
+                );
+                enqueueCapturedUpdate(root, errorInfo);
+                break a;
+              }
+          }
+          root = root.return;
+        } while (null !== root);
       }
+    } catch (error) {
+      throw ((workInProgress = returnFiber), error);
+    }
+    completeUnitOfWork(unitOfWork);
+  }
+}
+function completeUnitOfWork(unitOfWork) {
+  var completedWork = unitOfWork;
+  do {
+    var current = completedWork.alternate;
+    unitOfWork = completedWork.return;
+    if (0 === (completedWork.flags & 32768)) {
       if (
-        flags & 4 &&
-        ((flags = finishedWork.stateNode),
-        null != flags &&
-          ((root = finishedWork.memoizedProps),
-          (current = null !== current ? current.memoizedProps : root),
-          (hoistableRoot = finishedWork.type),
-          (maybeNodes = finishedWork.updateQueue),
-          (finishedWork.updateQueue = null),
-          null !== maybeNodes))
-      )
-        try {
-          updateProperties(flags, maybeNodes, hoistableRoot, current, root),
-            (flags[internalPropsKey] = root);
-        } catch (error$189) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$189);
-        }
-      break;
-    case 6:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4) {
-        if (null === finishedWork.stateNode)
-          throw Error(formatProdErrorMessage(162));
-        current = finishedWork.stateNode;
-        flags = finishedWork.memoizedProps;
-        try {
-          current.nodeValue = flags;
-        } catch (error$190) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$190);
-        }
+        ((current = completeWork(current, completedWork, renderLanes)),
+        null !== current)
+      ) {
+        workInProgress = current;
+        return;
       }
-      break;
-    case 3:
-      tagCaches = null;
-      hoistableRoot = currentHoistableRoot;
-      currentHoistableRoot = getHoistableRoot(root.containerInfo);
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      currentHoistableRoot = hoistableRoot;
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
-        try {
-          retryIfBlockedOn(root.containerInfo);
-        } catch (error$191) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$191);
-        }
-      break;
-    case 4:
-      current = currentHoistableRoot;
-      currentHoistableRoot = getHoistableRoot(
-        finishedWork.stateNode.containerInfo
+    } else {
+      current = unwindWork(current, completedWork);
+      if (null !== current) {
+        current.flags &= 16383;
+        workInProgress = current;
+        return;
+      }
+      if (null !== unitOfWork)
+        (unitOfWork.flags |= 32768),
+          (unitOfWork.subtreeFlags = 0),
+          (unitOfWork.deletions = null);
+      else {
+        workInProgressRootExitStatus = 6;
+        workInProgress = null;
+        return;
+      }
+    }
+    completedWork = completedWork.sibling;
+    if (null !== completedWork) {
+      workInProgress = completedWork;
+      return;
+    }
+    workInProgress = completedWork = unitOfWork;
+  } while (null !== completedWork);
+  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+}
+function commitRoot(root, recoverableErrors, transitions) {
+  var previousUpdateLanePriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig$1.transition;
+  try {
+    (ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      commitRootImpl(
+        root,
+        recoverableErrors,
+        transitions,
+        previousUpdateLanePriority
+      );
+  } finally {
+    (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (currentUpdatePriority = previousUpdateLanePriority);
+  }
+  return null;
+}
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
+) {
+  do flushPassiveEffects();
+  while (null !== rootWithPendingPassiveEffects);
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var finishedWork = root.finishedWork,
+    lanes = root.finishedLanes;
+  if (null === finishedWork) return null;
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
+  root.callbackNode = null;
+  root.callbackPriority = 0;
+  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
+  remainingLanes |= concurrentlyUpdatedLanes;
+  markRootFinished(root, remainingLanes);
+  root === workInProgressRoot &&
+    ((workInProgress = workInProgressRoot = null),
+    (workInProgressRootRenderLanes = 0));
+  (0 === (finishedWork.subtreeFlags & 10256) &&
+    0 === (finishedWork.flags & 10256)) ||
+    rootDoesHavePassiveEffects ||
+    ((rootDoesHavePassiveEffects = !0),
+    (pendingPassiveEffectsRemainingLanes = remainingLanes),
+    (pendingPassiveTransitions = transitions),
+    scheduleCallback(NormalPriority$1, function () {
+      flushPassiveEffects();
+      return null;
+    }));
+  transitions = 0 !== (finishedWork.flags & 15990);
+  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
+    transitions = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    var prevExecutionContext = executionContext;
+    executionContext |= 4;
+    ReactCurrentOwner.current = null;
+    var shouldFireAfterActiveInstanceBlur$176 = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
+    commitMutationEffectsOnFiber(finishedWork, root);
+    shouldFireAfterActiveInstanceBlur$176 &&
+      ((_enabled = !0),
+      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
+      (_enabled = !1));
+    restoreSelection(selectionInformation);
+    _enabled = !!eventsEnabled;
+    selectionInformation = eventsEnabled = null;
+    root.current = finishedWork;
+    commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
+    requestPaint();
+    executionContext = prevExecutionContext;
+    currentUpdatePriority = previousPriority;
+    ReactCurrentBatchConfig$1.transition = transitions;
+  } else root.current = finishedWork;
+  rootDoesHavePassiveEffects
+    ? ((rootDoesHavePassiveEffects = !1),
+      (rootWithPendingPassiveEffects = root),
+      (pendingPassiveEffectsLanes = lanes))
+    : releaseRootPooledCache(root, remainingLanes);
+  remainingLanes = root.pendingLanes;
+  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  ensureRootIsScheduled(root, now());
+  if (null !== recoverableErrors)
+    for (
+      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
+      finishedWork < recoverableErrors.length;
+      finishedWork++
+    )
+      (lanes = recoverableErrors[finishedWork]),
+        (remainingLanes = {
+          digest: lanes.digest,
+          componentStack: lanes.stack
+        }),
+        renderPriorityLevel(lanes.value, remainingLanes);
+  if (hasUncaughtError)
+    throw (
+      ((hasUncaughtError = !1),
+      (root = firstUncaughtError),
+      (firstUncaughtError = null),
+      root)
+    );
+  0 !== (pendingPassiveEffectsLanes & 3) &&
+    0 !== root.tag &&
+    flushPassiveEffects();
+  remainingLanes = root.pendingLanes;
+  0 !== (remainingLanes & 3)
+    ? root === rootWithNestedUpdates
+      ? nestedUpdateCount++
+      : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root))
+    : (nestedUpdateCount = 0);
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    null !== prevRootTransitionCallbacks &&
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+        null !== prevPendingTransitionCallbacks
+          ? ((currentPendingTransitionCallbacks = null),
+            scheduleCallback(IdlePriority, function () {
+              processTransitionCallbacks(
+                prevPendingTransitionCallbacks,
+                endTime,
+                prevRootTransitionCallbacks
+              );
+            }))
+          : (currentEndTime = endTime);
+      });
+  }
+  return null;
+}
+function releaseRootPooledCache(root, remainingLanes) {
+  0 === (root.pooledCacheLanes &= remainingLanes) &&
+    ((remainingLanes = root.pooledCache),
+    null != remainingLanes &&
+      ((root.pooledCache = null), releaseCache(remainingLanes)));
+}
+function flushPassiveEffects() {
+  if (null !== rootWithPendingPassiveEffects) {
+    var root$177 = rootWithPendingPassiveEffects,
+      remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = 0;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    renderPriority = 32 > renderPriority ? 32 : renderPriority;
+    var prevTransition = ReactCurrentBatchConfig$1.transition,
+      previousPriority = currentUpdatePriority;
+    try {
+      return (
+        (ReactCurrentBatchConfig$1.transition = null),
+        (currentUpdatePriority = renderPriority),
+        flushPassiveEffectsImpl()
       );
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      currentHoistableRoot = current;
-      break;
-    case 13:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      current = finishedWork.child;
-      current.flags & 8192 &&
-        null !== current.memoizedState &&
-        (null === current.alternate ||
-          null === current.alternate.memoizedState) &&
-        (globalMostRecentFallbackTime = now());
-      if (flags & 4) {
-        try {
-          if (null !== finishedWork.memoizedState) {
-            var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
-            if ("function" === typeof suspenseCallback) {
-              var wakeables = finishedWork.updateQueue;
-              null !== wakeables && suspenseCallback(new Set(wakeables));
-            }
-          }
-        } catch (error$193) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$193);
-        }
-        current = finishedWork.updateQueue;
-        null !== current &&
-          ((finishedWork.updateQueue = null),
-          attachSuspenseRetryListeners(finishedWork, current));
-      }
-      break;
-    case 22:
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      domElement = null !== finishedWork.memoizedState;
-      newProps = null !== current && null !== current.memoizedState;
-      finishedWork.mode & 1
-        ? ((suspenseCallback = offscreenSubtreeIsHidden),
-          (wakeables = offscreenSubtreeWasHidden),
-          (offscreenSubtreeIsHidden = suspenseCallback || domElement),
-          (offscreenSubtreeWasHidden = wakeables || newProps),
-          recursivelyTraverseMutationEffects(root, finishedWork),
-          (offscreenSubtreeWasHidden = wakeables),
-          (offscreenSubtreeIsHidden = suspenseCallback))
-        : recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      root = finishedWork.stateNode;
-      root._current = finishedWork;
-      root._visibility &= -3;
-      root._visibility |= root._pendingVisibility & 2;
-      if (
-        flags & 8192 &&
-        ((root._visibility = domElement
-          ? root._visibility & -2
-          : root._visibility | 1),
-        domElement &&
-          ((root = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden),
-          null === current ||
-            newProps ||
-            root ||
-            (0 !== (finishedWork.mode & 1) &&
-              recursivelyTraverseDisappearLayoutEffects(finishedWork))),
-        null === finishedWork.memoizedProps ||
-          "manual" !== finishedWork.memoizedProps.mode)
-      )
-        a: for (current = null, root = finishedWork; ; ) {
-          if (5 === root.tag || 26 === root.tag || 27 === root.tag) {
-            if (null === current) {
-              current = root;
-              try {
-                (hoistableRoot = root.stateNode),
-                  domElement
-                    ? ((maybeNodes = hoistableRoot.style),
-                      "function" === typeof maybeNodes.setProperty
-                        ? maybeNodes.setProperty("display", "none", "important")
-                        : (maybeNodes.display = "none"))
-                    : ((i = root.stateNode),
-                      (nextNode = root.memoizedProps.style),
-                      (nodeName =
-                        void 0 !== nextNode &&
-                        null !== nextNode &&
-                        nextNode.hasOwnProperty("display")
-                          ? nextNode.display
-                          : null),
-                      (i.style.display = dangerousStyleValue(
-                        "display",
-                        nodeName
-                      )));
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          } else if (6 === root.tag) {
-            if (null === current)
-              try {
-                root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
-              } catch (error$174) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error$174
-                );
-              }
-          } else if (
-            ((22 !== root.tag && 23 !== root.tag) ||
-              null === root.memoizedState ||
-              root === finishedWork) &&
-            null !== root.child
-          ) {
-            root.child.return = root;
-            root = root.child;
-            continue;
-          }
-          if (root === finishedWork) break a;
-          for (; null === root.sibling; ) {
-            if (null === root.return || root.return === finishedWork) break a;
-            current === root && (current = null);
-            root = root.return;
-          }
-          current === root && (current = null);
-          root.sibling.return = root.return;
-          root = root.sibling;
-        }
-      flags & 4 &&
-        ((current = finishedWork.updateQueue),
-        null !== current &&
-          ((flags = current.wakeables),
-          null !== flags &&
-            ((current.wakeables = null),
-            attachSuspenseRetryListeners(finishedWork, flags))));
-      break;
-    case 19:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 4 &&
-        ((current = finishedWork.updateQueue),
-        null !== current &&
-          ((finishedWork.updateQueue = null),
-          attachSuspenseRetryListeners(finishedWork, current)));
-      break;
-    case 21:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        (null !== current && safelyDetachRef(finishedWork, finishedWork.return),
-        safelyAttachRef(finishedWork, finishedWork.return));
-      flags & 4 && (finishedWork.stateNode[internalInstanceKey] = finishedWork);
-      break;
-    default:
-      recursivelyTraverseMutationEffects(root, finishedWork),
-        commitReconciliationEffects(finishedWork);
+    } finally {
+      (currentUpdatePriority = previousPriority),
+        (ReactCurrentBatchConfig$1.transition = prevTransition),
+        releaseRootPooledCache(root$177, remainingLanes);
+    }
   }
+  return !1;
 }
-function commitReconciliationEffects(finishedWork) {
-  var flags = finishedWork.flags;
-  if (flags & 2) {
+function flushPassiveEffectsImpl() {
+  if (null === rootWithPendingPassiveEffects) return !1;
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects,
+    lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null;
+  pendingPassiveEffectsLanes = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
+  var prevExecutionContext = executionContext;
+  executionContext |= 4;
+  commitPassiveUnmountOnFiber(root.current);
+  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
+      prevRootTransitionCallbacks = root.transitionCallbacks,
+      prevEndTime = currentEndTime;
+    null !== prevPendingTransitionCallbacks &&
+      null !== prevRootTransitionCallbacks &&
+      null !== prevEndTime &&
+      ((currentEndTime = currentPendingTransitionCallbacks = null),
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
+        );
+      }));
+  }
+  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
     try {
-      if (27 !== finishedWork.tag) {
-        b: {
-          for (var parent = finishedWork.return; null !== parent; ) {
-            if (isHostParent(parent)) {
-              var JSCompiler_inline_result = parent;
-              break b;
-            }
-            parent = parent.return;
-          }
-          throw Error(formatProdErrorMessage(160));
-        }
-        switch (JSCompiler_inline_result.tag) {
-          case 27:
-            var parent$jscomp$0 = JSCompiler_inline_result.stateNode,
-              before = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
-            break;
-          case 5:
-            var parent$175 = JSCompiler_inline_result.stateNode;
-            JSCompiler_inline_result.flags & 32 &&
-              (setTextContent(parent$175, ""),
-              (JSCompiler_inline_result.flags &= -33));
-            var before$176 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before$176, parent$175);
-            break;
-          case 3:
-          case 4:
-            var parent$177 = JSCompiler_inline_result.stateNode.containerInfo,
-              before$178 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNodeIntoContainer(
-              finishedWork,
-              before$178,
-              parent$177
-            );
-            break;
-          default:
-            throw Error(formatProdErrorMessage(161));
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {}
+  return !0;
+}
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
+  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+  sourceFiber = requestEventTime();
+  null !== rootFiber &&
+    (markRootUpdated(rootFiber, 2, sourceFiber),
+    ensureRootIsScheduled(rootFiber, sourceFiber));
+}
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+  if (3 === sourceFiber.tag)
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+  else
+    for (
+      nearestMountedAncestor = skipUnmountedBoundaries
+        ? nearestMountedAncestor
+        : sourceFiber.return;
+      null !== nearestMountedAncestor;
+
+    ) {
+      if (3 === nearestMountedAncestor.tag) {
+        captureCommitPhaseErrorOnRoot(
+          nearestMountedAncestor,
+          sourceFiber,
+          error
+        );
+        break;
+      } else if (1 === nearestMountedAncestor.tag) {
+        var instance = nearestMountedAncestor.stateNode;
+        if (
+          "function" ===
+            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
+          ("function" === typeof instance.componentDidCatch &&
+            (null === legacyErrorBoundariesThatAlreadyFailed ||
+              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
+        ) {
+          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+          sourceFiber = createClassErrorUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
+          );
+          nearestMountedAncestor = enqueueUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
+          );
+          sourceFiber = requestEventTime();
+          null !== nearestMountedAncestor &&
+            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
+            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
+          break;
         }
       }
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      nearestMountedAncestor = nearestMountedAncestor.return;
     }
-    finishedWork.flags &= -3;
-  }
-  flags & 4096 && (finishedWork.flags &= -4097);
 }
-function recursivelyTraverseLayoutEffects(root, parentFiber) {
-  if (parentFiber.subtreeFlags & 8772)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber),
-        (parentFiber = parentFiber.sibling);
+function attachPingListener(root, wakeable, lanes) {
+  var pingCache = root.pingCache;
+  if (null === pingCache) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    var threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else
+    (threadIDs = pingCache.get(wakeable)),
+      void 0 === threadIDs &&
+        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
+  threadIDs.has(lanes) ||
+    ((workInProgressRootDidAttachPingListener = !0),
+    threadIDs.add(lanes),
+    (root = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
+    wakeable.then(root, root));
 }
-function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var finishedWork = parentFiber;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 14:
-      case 15:
-        commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 1:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        var instance = finishedWork.stateNode;
-        if ("function" === typeof instance.componentWillUnmount) {
-          var current = finishedWork,
-            nearestMountedAncestor = finishedWork.return;
-          try {
-            var current$jscomp$0 = current;
-            instance.props = current$jscomp$0.memoizedProps;
-            instance.state = current$jscomp$0.memoizedState;
-            instance.componentWillUnmount();
-          } catch (error) {
-            captureCommitPhaseError(current, nearestMountedAncestor, error);
-          }
-        }
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 26:
-      case 27:
-      case 5:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 22:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        null === finishedWork.memoizedState &&
-          recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      default:
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-    }
-    parentFiber = parentFiber.sibling;
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
+  null !== pingCache && pingCache.delete(wakeable);
+  wakeable = requestEventTime();
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+  workInProgressRoot === root &&
+    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
+    (4 === workInProgressRootExitStatus ||
+    (3 === workInProgressRootExitStatus &&
+      (workInProgressRootRenderLanes & 125829120) ===
+        workInProgressRootRenderLanes &&
+      500 > now() - globalMostRecentFallbackTime)
+      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
+      : (workInProgressRootPingedLanes |= pingedLanes));
+  ensureRootIsScheduled(root, wakeable);
+}
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  0 === retryLane &&
+    (0 === (boundaryFiber.mode & 1)
+      ? (retryLane = 2)
+      : ((retryLane = nextRetryLane),
+        (nextRetryLane <<= 1),
+        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
+  var eventTime = requestEventTime();
+  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+  null !== boundaryFiber &&
+    (markRootUpdated(boundaryFiber, retryLane, eventTime),
+    ensureRootIsScheduled(boundaryFiber, eventTime));
+}
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState,
+    retryLane = 0;
+  null !== suspenseState && (retryLane = suspenseState.retryLane);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = 0;
+  switch (boundaryFiber.tag) {
+    case 13:
+      var retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
+      null !== suspenseState && (retryLane = suspenseState.retryLane);
+      break;
+    case 19:
+      retryCache = boundaryFiber.stateNode;
+      break;
+    case 22:
+      retryCache = boundaryFiber.stateNode._retryCache;
+      break;
+    default:
+      throw Error(formatProdErrorMessage(314));
   }
+  null !== retryCache && retryCache.delete(wakeable);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
 }
-function recursivelyTraverseReappearLayoutEffects(
-  finishedRoot$jscomp$0,
-  parentFiber,
-  includeWorkInProgressEffects
-) {
-  includeWorkInProgressEffects =
-    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var current = parentFiber.alternate,
-      finishedRoot = finishedRoot$jscomp$0,
-      finishedWork = parentFiber,
-      flags = finishedWork.flags;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 15:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        commitHookLayoutEffects(finishedWork, 4);
-        break;
-      case 1:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        finishedRoot = finishedWork.stateNode;
-        if ("function" === typeof finishedRoot.componentDidMount)
-          try {
-            finishedRoot.componentDidMount();
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        current = finishedWork.updateQueue;
-        if (null !== current) {
-          var hiddenCallbacks = current.shared.hiddenCallbacks;
-          if (null !== hiddenCallbacks)
-            for (
-              current.shared.hiddenCallbacks = null, current = 0;
-              current < hiddenCallbacks.length;
-              current++
-            )
-              callCallback(hiddenCallbacks[current], finishedRoot);
-        }
-        includeWorkInProgressEffects &&
-          flags & 64 &&
-          commitClassCallbacks(finishedWork);
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      case 26:
-      case 27:
-      case 5:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        includeWorkInProgressEffects &&
-          null === current &&
-          flags & 4 &&
-          commitHostComponentMount(finishedWork);
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      case 12:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        break;
-      case 13:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        includeWorkInProgressEffects &&
-          flags & 4 &&
-          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
-        break;
-      case 22:
-        null === finishedWork.memoizedState &&
-          recursivelyTraverseReappearLayoutEffects(
-            finishedRoot,
-            finishedWork,
-            includeWorkInProgressEffects
-          );
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      default:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
+var beginWork;
+beginWork = function (current, workInProgress, renderLanes) {
+  if (null !== current)
+    if (current.memoizedProps !== workInProgress.pendingProps)
+      didReceiveUpdate = !0;
+    else {
+      if (
+        !checkScheduledUpdateOrContext(current, renderLanes) &&
+        0 === (workInProgress.flags & 128)
+      )
+        return (
+          (didReceiveUpdate = !1),
+          attemptEarlyBailoutIfNoScheduledUpdate(
+            current,
+            workInProgress,
+            renderLanes
+          )
         );
+      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
     }
-    parentFiber = parentFiber.sibling;
-  }
-}
-function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  try {
-    commitHookEffectListMount(hookFlags, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
-  }
-}
-function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
-  var previousCache = null;
-  null !== current &&
-    null !== current.memoizedState &&
-    null !== current.memoizedState.cachePool &&
-    (previousCache = current.memoizedState.cachePool.pool);
-  current = null;
-  null !== finishedWork.memoizedState &&
-    null !== finishedWork.memoizedState.cachePool &&
-    (current = finishedWork.memoizedState.cachePool.pool);
-  current !== previousCache &&
-    (null != current && current.refCount++,
-    null != previousCache && releaseCache(previousCache));
-  if (enableTransitionTracing) {
-    current = finishedWork.updateQueue;
-    previousCache = null !== finishedWork.memoizedState;
-    if (null !== current) {
-      if (previousCache) {
-        var transitions = current.transitions;
-        null !== transitions &&
-          transitions.forEach(function (transition) {
-            null === instance._transitions &&
-              (instance._transitions = new Set());
-            instance._transitions.add(transition);
-          });
-        current = current.markerInstances;
-        null !== current &&
-          current.forEach(function (markerInstance) {
-            var markerTransitions = markerInstance.transitions;
-            null !== markerTransitions &&
-              markerTransitions.forEach(function (transition) {
-                null === instance._transitions
-                  ? (instance._transitions = new Set())
-                  : instance._transitions.has(transition) &&
-                    (null === markerInstance.pendingBoundaries &&
-                      (markerInstance.pendingBoundaries = new Map()),
-                    null === instance._pendingMarkers &&
-                      (instance._pendingMarkers = new Set()),
-                    instance._pendingMarkers.add(markerInstance));
-              });
-          });
+  else
+    (didReceiveUpdate = !1),
+      isHydrating &&
+        0 !== (workInProgress.flags & 1048576) &&
+        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
+  workInProgress.lanes = 0;
+  switch (workInProgress.tag) {
+    case 2:
+      var Component = workInProgress.type;
+      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+      current = workInProgress.pendingProps;
+      prepareToReadContext(workInProgress, renderLanes);
+      current = renderWithHooks(
+        null,
+        workInProgress,
+        Component,
+        current,
+        void 0,
+        renderLanes
+      );
+      Component = checkDidRenderIdHook();
+      workInProgress.flags |= 1;
+      workInProgress.tag = 0;
+      isHydrating && Component && pushMaterializedTreeId(workInProgress);
+      reconcileChildren(null, workInProgress, current, renderLanes);
+      workInProgress = workInProgress.child;
+      return workInProgress;
+    case 16:
+      Component = workInProgress.elementType;
+      a: {
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+        current = workInProgress.pendingProps;
+        var init = Component._init;
+        Component = init(Component._payload);
+        workInProgress.type = Component;
+        init = workInProgress.tag = resolveLazyComponentTag(Component);
+        current = resolveDefaultProps(Component, current);
+        switch (init) {
+          case 0:
+            workInProgress = updateFunctionComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 1:
+            workInProgress = updateClassComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 11:
+            workInProgress = updateForwardRef(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 14:
+            workInProgress = updateMemoComponent(
+              null,
+              workInProgress,
+              Component,
+              resolveDefaultProps(Component.type, current),
+              renderLanes
+            );
+            break a;
+        }
+        throw Error(formatProdErrorMessage(306, Component, ""));
+      }
+      return workInProgress;
+    case 0:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateFunctionComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 1:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateClassComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 3:
+      a: {
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        );
+        if (null === current) throw Error(formatProdErrorMessage(387));
+        Component = workInProgress.pendingProps;
+        var prevState = workInProgress.memoizedState;
+        init = prevState.element;
+        cloneUpdateQueue(current, workInProgress);
+        processUpdateQueue(workInProgress, Component, null, renderLanes);
+        var nextState = workInProgress.memoizedState,
+          root = workInProgress.stateNode;
+        enableTransitionTracing &&
+          push(transitionStack, workInProgressTransitions);
+        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+        Component = nextState.cache;
+        pushProvider(workInProgress, CacheContext, Component);
+        Component !== prevState.cache &&
+          propagateContextChange(workInProgress, CacheContext, renderLanes);
+        Component = nextState.element;
+        if (prevState.isDehydrated)
+          if (
+            ((prevState = {
+              element: Component,
+              isDehydrated: !1,
+              cache: nextState.cache
+            }),
+            (workInProgress.updateQueue.baseState = prevState),
+            (workInProgress.memoizedState = prevState),
+            workInProgress.flags & 256)
+          ) {
+            init = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(423)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              init
+            );
+            break a;
+          } else if (Component !== init) {
+            init = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(424)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              init
+            );
+            break a;
+          } else {
+            nextHydratableInstance = getNextHydratable(
+              workInProgress.stateNode.containerInfo.firstChild
+            );
+            hydrationParentFiber = workInProgress;
+            isHydrating = !0;
+            hydrationErrors = null;
+            rootOrSingletonContext = !0;
+            current = root.mutableSourceEagerHydrationData;
+            if (null != current)
+              for (init = 0; init < current.length; init += 2)
+                (prevState = current[init]),
+                  (prevState._workInProgressVersionPrimary = current[init + 1]),
+                  workInProgressSources.push(prevState);
+            renderLanes = mountChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            );
+            for (workInProgress.child = renderLanes; renderLanes; )
+              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
+                (renderLanes = renderLanes.sibling);
+          }
+        else {
+          resetHydrationState();
+          if (Component === init) {
+            workInProgress = bailoutOnAlreadyFinishedWork(
+              current,
+              workInProgress,
+              renderLanes
+            );
+            break a;
+          }
+          reconcileChildren(current, workInProgress, Component, renderLanes);
+        }
+        workInProgress = workInProgress.child;
       }
-      finishedWork.updateQueue = null;
-    }
-    commitTransitionProgress(finishedWork);
-    previousCache ||
-      ((instance._transitions = null), (instance._pendingMarkers = null));
-  }
-}
-function commitCachePassiveMountEffect(current, finishedWork) {
-  current = null;
-  null !== finishedWork.alternate &&
-    (current = finishedWork.alternate.memoizedState.cache);
-  finishedWork = finishedWork.memoizedState.cache;
-  finishedWork !== current &&
-    (finishedWork.refCount++, null != current && releaseCache(current));
-}
-function commitTracingMarkerPassiveMountEffect(finishedWork) {
-  var instance = finishedWork.stateNode;
-  null !== instance.transitions &&
-    null === instance.pendingBoundaries &&
-    (addMarkerCompleteCallbackToPendingTransition(
-      finishedWork.memoizedProps.name,
-      instance.transitions
-    ),
-    (instance.transitions = null),
-    (instance.pendingBoundaries = null),
-    (instance.aborts = null),
-    (instance.name = null));
-}
-function recursivelyTraversePassiveMountEffects(
-  root,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitPassiveMountOnFiber(
-        root,
-        parentFiber,
-        committedLanes,
-        committedTransitions
-      ),
-        (parentFiber = parentFiber.sibling);
-}
-function commitPassiveMountOnFiber(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  var flags = finishedWork.flags;
-  switch (finishedWork.tag) {
-    case 0:
+      return workInProgress;
+    case 26:
+      return (
+        markRef$1(current, workInProgress),
+        (renderLanes = workInProgress.memoizedState =
+          getResource(
+            workInProgress.type,
+            null === current ? null : current.memoizedProps,
+            workInProgress.pendingProps
+          )),
+        null !== current ||
+          isHydrating ||
+          null !== renderLanes ||
+          ((renderLanes = workInProgress.type),
+          (current = workInProgress.pendingProps),
+          (Component = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          )),
+          (Component = createHTMLElement(renderLanes, current, Component)),
+          (Component[internalInstanceKey] = workInProgress),
+          (Component[internalPropsKey] = current),
+          setInitialProperties(Component, renderLanes, current),
+          markNodeAsHoistable(Component),
+          (workInProgress.stateNode = Component)),
+        null
+      );
+    case 27:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          ((Component = workInProgress.stateNode =
+            resolveSingletonInstance(
+              workInProgress.type,
+              workInProgress.pendingProps,
+              rootInstanceStackCursor.current
+            )),
+          (hydrationParentFiber = workInProgress),
+          (rootOrSingletonContext = !0),
+          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
+        (Component = workInProgress.pendingProps.children),
+        null !== current || isHydrating
+          ? reconcileChildren(current, workInProgress, Component, renderLanes)
+          : (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            )),
+        markRef$1(current, workInProgress),
+        workInProgress.child
+      );
+    case 5:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          (((Component = workInProgress.pendingProps),
+          "script" === workInProgress.type
+            ? ((init = Component.onLoad),
+              (prevState = Component.onError),
+              (Component = !(Component.async && (init || prevState))))
+            : (Component = !0),
+          Component)
+            ? ((Component = nextHydratableInstance),
+              rootOrSingletonContext &&
+                advanceToFirstAttemptableInstance(workInProgress),
+              (init = nextHydratableInstance),
+              init)
+              ? tryHydrateInstance(workInProgress, init) ||
+                (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                (nextHydratableInstance = getNextHydratable(init.nextSibling)),
+                (prevState = hydrationParentFiber),
+                rootOrSingletonContext &&
+                  advanceToFirstAttemptableInstance(workInProgress),
+                nextHydratableInstance &&
+                tryHydrateInstance(workInProgress, nextHydratableInstance)
+                  ? deleteHydratableInstance(prevState, init)
+                  : (insertNonHydratedInstance(
+                      hydrationParentFiber,
+                      workInProgress
+                    ),
+                    (isHydrating = !1),
+                    (hydrationParentFiber = workInProgress),
+                    (nextHydratableInstance = Component)))
+              : (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = Component))
+            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress))),
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (prevState = null !== current ? current.memoizedProps : null),
+        (root = init.children),
+        shouldSetTextContent(Component, init)
+          ? (root = null)
+          : null !== prevState &&
+            shouldSetTextContent(Component, prevState) &&
+            (workInProgress.flags |= 32),
+        markRef$1(current, workInProgress),
+        reconcileChildren(current, workInProgress, root, renderLanes),
+        workInProgress.child
+      );
+    case 6:
+      return (
+        null === current &&
+          isHydrating &&
+          (((renderLanes = "" !== workInProgress.pendingProps),
+          (current = nextHydratableInstance),
+          rootOrSingletonContext &&
+            renderLanes &&
+            advanceToFirstAttemptableTextInstance(),
+          (Component = nextHydratableInstance),
+          Component && renderLanes)
+            ? tryHydrateText(workInProgress, Component) ||
+              (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              (nextHydratableInstance = getNextHydratable(
+                Component.nextSibling
+              )),
+              (init = hydrationParentFiber),
+              rootOrSingletonContext &&
+                renderLanes &&
+                advanceToFirstAttemptableTextInstance(),
+              nextHydratableInstance &&
+              tryHydrateText(workInProgress, nextHydratableInstance)
+                ? deleteHydratableInstance(init, Component)
+                : (insertNonHydratedInstance(
+                    hydrationParentFiber,
+                    workInProgress
+                  ),
+                  (isHydrating = !1),
+                  (hydrationParentFiber = workInProgress),
+                  (nextHydratableInstance = current)))
+            : (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress),
+              (nextHydratableInstance = current))),
+        null
+      );
+    case 13:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+    case 4:
+      return (
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        ),
+        (Component = workInProgress.pendingProps),
+        null === current
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            ))
+          : reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
     case 11:
-    case 15:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateForwardRef(current, workInProgress, Component, init, renderLanes)
+      );
+    case 7:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 8:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
       );
-      flags & 2048 && commitHookPassiveMountEffects(finishedWork, 9);
-      break;
-    case 3:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+    case 12:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
       );
-      if (flags & 2048) {
-        flags = null;
-        null !== finishedWork.alternate &&
-          (flags = finishedWork.alternate.memoizedState.cache);
-        var nextCache = finishedWork.memoizedState.cache;
-        nextCache !== flags &&
-          (nextCache.refCount++, null != flags && releaseCache(flags));
-        if (enableTransitionTracing) {
-          var incompleteTransitions =
-            finishedWork.stateNode.incompleteTransitions;
-          null !== committedTransitions &&
-            (committedTransitions.forEach(function (transition) {
-              enableTransitionTracing &&
-                (null === currentPendingTransitionCallbacks &&
-                  (currentPendingTransitionCallbacks = {
-                    transitionStart: [],
-                    transitionProgress: null,
-                    transitionComplete: null,
-                    markerProgress: null,
-                    markerIncomplete: null,
-                    markerComplete: null
-                  }),
-                null === currentPendingTransitionCallbacks.transitionStart &&
-                  (currentPendingTransitionCallbacks.transitionStart = []),
-                currentPendingTransitionCallbacks.transitionStart.push(
-                  transition
-                ));
-            }),
-            clearTransitionsForLanes(finishedRoot, committedLanes));
-          incompleteTransitions.forEach(function (markerInstance, transition) {
-            var pendingBoundaries = markerInstance.pendingBoundaries;
-            if (null === pendingBoundaries || 0 === pendingBoundaries.size)
-              null === markerInstance.aborts &&
-                enableTransitionTracing &&
-                (null === currentPendingTransitionCallbacks &&
-                  (currentPendingTransitionCallbacks = {
-                    transitionStart: null,
-                    transitionProgress: null,
-                    transitionComplete: [],
-                    markerProgress: null,
-                    markerIncomplete: null,
-                    markerComplete: null
-                  }),
-                null === currentPendingTransitionCallbacks.transitionComplete &&
-                  (currentPendingTransitionCallbacks.transitionComplete = []),
-                currentPendingTransitionCallbacks.transitionComplete.push(
-                  transition
-                )),
-                incompleteTransitions.delete(transition);
-          });
-          clearTransitionsForLanes(finishedRoot, committedLanes);
-        }
+    case 10:
+      a: {
+        Component = workInProgress.type._context;
+        init = workInProgress.pendingProps;
+        prevState = workInProgress.memoizedProps;
+        root = init.value;
+        pushProvider(workInProgress, Component, root);
+        if (!enableLazyContextPropagation && null !== prevState)
+          if (objectIs(prevState.value, root)) {
+            if (prevState.children === init.children) {
+              workInProgress = bailoutOnAlreadyFinishedWork(
+                current,
+                workInProgress,
+                renderLanes
+              );
+              break a;
+            }
+          } else propagateContextChange(workInProgress, Component, renderLanes);
+        reconcileChildren(current, workInProgress, init.children, renderLanes);
+        workInProgress = workInProgress.child;
       }
-      break;
-    case 23:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+      return workInProgress;
+    case 9:
+      return (
+        (init = workInProgress.type),
+        (Component = workInProgress.pendingProps.children),
+        prepareToReadContext(workInProgress, renderLanes),
+        (init = readContext(init)),
+        (Component = Component(init)),
+        (workInProgress.flags |= 1),
+        reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 14:
+      return (
+        (Component = workInProgress.type),
+        (init = resolveDefaultProps(Component, workInProgress.pendingProps)),
+        (init = resolveDefaultProps(Component.type, init)),
+        updateMemoComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 15:
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        workInProgress.pendingProps,
+        renderLanes
+      );
+    case 17:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+        (workInProgress.tag = 1),
+        prepareToReadContext(workInProgress, renderLanes),
+        constructClassInstance(workInProgress, Component, init),
+        mountClassInstance(workInProgress, Component, init, renderLanes),
+        finishClassComponent(
+          null,
+          workInProgress,
+          Component,
+          !0,
+          !1,
+          renderLanes
+        )
+      );
+    case 19:
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    case 21:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
       );
-      flags & 2048 &&
-        commitOffscreenPassiveMountEffects(
-          finishedWork.alternate,
-          finishedWork,
-          finishedWork.stateNode
-        );
-      break;
     case 22:
-      nextCache = finishedWork.stateNode;
-      null !== finishedWork.memoizedState
-        ? nextCache._visibility & 4
-          ? recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            )
-          : finishedWork.mode & 1
-          ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
-          : ((nextCache._visibility |= 4),
-            recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            ))
-        : nextCache._visibility & 4
-        ? recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          )
-        : ((nextCache._visibility |= 4),
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            0 !== (finishedWork.subtreeFlags & 10256)
-          ));
-      flags & 2048 &&
-        commitOffscreenPassiveMountEffects(
-          finishedWork.alternate,
-          finishedWork,
-          nextCache
-        );
-      break;
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 23:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
     case 24:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+      return (
+        prepareToReadContext(workInProgress, renderLanes),
+        (Component = readContext(CacheContext)),
+        null === current
+          ? ((init = peekCacheFromPool()),
+            null === init &&
+              ((init = workInProgressRoot),
+              (prevState = createCache()),
+              (init.pooledCache = prevState),
+              prevState.refCount++,
+              null !== prevState && (init.pooledCacheLanes |= renderLanes),
+              (init = prevState)),
+            (workInProgress.memoizedState = { parent: Component, cache: init }),
+            initializeUpdateQueue(workInProgress),
+            pushProvider(workInProgress, CacheContext, init))
+          : (0 !== (current.lanes & renderLanes) &&
+              (cloneUpdateQueue(current, workInProgress),
+              processUpdateQueue(workInProgress, null, null, renderLanes)),
+            (init = current.memoizedState),
+            (prevState = workInProgress.memoizedState),
+            init.parent !== Component
+              ? ((init = { parent: Component, cache: Component }),
+                (workInProgress.memoizedState = init),
+                0 === workInProgress.lanes &&
+                  (workInProgress.memoizedState =
+                    workInProgress.updateQueue.baseState =
+                      init),
+                pushProvider(workInProgress, CacheContext, Component))
+              : ((Component = prevState.cache),
+                pushProvider(workInProgress, CacheContext, Component),
+                Component !== init.cache &&
+                  propagateContextChange(
+                    workInProgress,
+                    CacheContext,
+                    renderLanes
+                  ))),
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
       );
-      flags & 2048 &&
-        commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-      break;
     case 25:
-      if (enableTransitionTracing) {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
+      if (enableTransitionTracing)
+        return (
+          enableTransitionTracing
+            ? (null === current &&
+                ((Component = enableTransitionTracing
+                  ? transitionStack.current
+                  : null),
+                null !== Component &&
+                  ((Component = {
+                    tag: 1,
+                    transitions: new Set(Component),
+                    pendingBoundaries: null,
+                    name: workInProgress.pendingProps.name,
+                    aborts: null
+                  }),
+                  (workInProgress.stateNode = Component),
+                  (workInProgress.flags |= 2048))),
+              (Component = workInProgress.stateNode),
+              null !== Component &&
+                pushMarkerInstance(workInProgress, Component),
+              reconcileChildren(
+                current,
+                workInProgress,
+                workInProgress.pendingProps.children,
+                renderLanes
+              ),
+              (workInProgress = workInProgress.child))
+            : (workInProgress = null),
+          workInProgress
         );
-        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
-        break;
-      }
-    default:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
   }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+};
+function scheduleCallback(priorityLevel, callback) {
+  return scheduleCallback$2(priorityLevel, callback);
 }
-function recursivelyTraverseReconnectPassiveEffects(
-  finishedRoot$jscomp$0,
-  parentFiber,
-  committedLanes$jscomp$0,
-  committedTransitions$jscomp$0,
-  includeWorkInProgressEffects
-) {
-  includeWorkInProgressEffects =
-    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var finishedRoot = finishedRoot$jscomp$0,
-      finishedWork = parentFiber,
-      committedLanes = committedLanes$jscomp$0,
-      committedTransitions = committedTransitions$jscomp$0,
-      flags = finishedWork.flags;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 15:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
-        commitHookPassiveMountEffects(finishedWork, 8);
-        break;
-      case 23:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitOffscreenPassiveMountEffects(
-            finishedWork.alternate,
-            finishedWork,
-            finishedWork.stateNode
-          );
-        break;
-      case 22:
-        var instance$203 = finishedWork.stateNode;
-        null !== finishedWork.memoizedState
-          ? instance$203._visibility & 4
-            ? recursivelyTraverseReconnectPassiveEffects(
-                finishedRoot,
-                finishedWork,
-                committedLanes,
-                committedTransitions,
-                includeWorkInProgressEffects
-              )
-            : finishedWork.mode & 1
-            ? recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              )
-            : ((instance$203._visibility |= 4),
-              recursivelyTraverseReconnectPassiveEffects(
-                finishedRoot,
-                finishedWork,
-                committedLanes,
-                committedTransitions,
-                includeWorkInProgressEffects
-              ))
-          : ((instance$203._visibility |= 4),
-            recursivelyTraverseReconnectPassiveEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions,
-              includeWorkInProgressEffects
-            ));
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitOffscreenPassiveMountEffects(
-            finishedWork.alternate,
-            finishedWork,
-            instance$203
-          );
+function FiberNode(tag, pendingProps, key, mode) {
+  this.tag = tag;
+  this.key = key;
+  this.sibling =
+    this.child =
+    this.return =
+    this.stateNode =
+    this.type =
+    this.elementType =
+      null;
+  this.index = 0;
+  this.refCleanup = this.ref = null;
+  this.pendingProps = pendingProps;
+  this.dependencies =
+    this.memoizedState =
+    this.updateQueue =
+    this.memoizedProps =
+      null;
+  this.mode = mode;
+  this.subtreeFlags = this.flags = 0;
+  this.deletions = null;
+  this.childLanes = this.lanes = 0;
+  this.alternate = null;
+}
+function createFiber(tag, pendingProps, key, mode) {
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+function shouldConstruct(Component) {
+  Component = Component.prototype;
+  return !(!Component || !Component.isReactComponent);
+}
+function resolveLazyComponentTag(Component) {
+  if ("function" === typeof Component)
+    return shouldConstruct(Component) ? 1 : 0;
+  if (void 0 !== Component && null !== Component) {
+    Component = Component.$$typeof;
+    if (Component === REACT_FORWARD_REF_TYPE) return 11;
+    if (Component === REACT_MEMO_TYPE) return 14;
+  }
+  return 2;
+}
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
+  null === workInProgress
+    ? ((workInProgress = createFiber(
+        current.tag,
+        pendingProps,
+        current.key,
+        current.mode
+      )),
+      (workInProgress.elementType = current.elementType),
+      (workInProgress.type = current.type),
+      (workInProgress.stateNode = current.stateNode),
+      (workInProgress.alternate = current),
+      (current.alternate = workInProgress))
+    : ((workInProgress.pendingProps = pendingProps),
+      (workInProgress.type = current.type),
+      (workInProgress.flags = 0),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null));
+  workInProgress.flags = current.flags & 14680064;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue;
+  pendingProps = current.dependencies;
+  workInProgress.dependencies =
+    null === pendingProps
+      ? null
+      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+  return workInProgress;
+}
+function resetWorkInProgress(workInProgress, renderLanes) {
+  workInProgress.flags &= 14680066;
+  var current = workInProgress.alternate;
+  null === current
+    ? ((workInProgress.childLanes = 0),
+      (workInProgress.lanes = renderLanes),
+      (workInProgress.child = null),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.memoizedProps = null),
+      (workInProgress.memoizedState = null),
+      (workInProgress.updateQueue = null),
+      (workInProgress.dependencies = null),
+      (workInProgress.stateNode = null))
+    : ((workInProgress.childLanes = current.childLanes),
+      (workInProgress.lanes = current.lanes),
+      (workInProgress.child = current.child),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null),
+      (workInProgress.memoizedProps = current.memoizedProps),
+      (workInProgress.memoizedState = current.memoizedState),
+      (workInProgress.updateQueue = current.updateQueue),
+      (workInProgress.type = current.type),
+      (renderLanes = current.dependencies),
+      (workInProgress.dependencies =
+        null === renderLanes
+          ? null
+          : {
+              lanes: renderLanes.lanes,
+              firstContext: renderLanes.firstContext
+            }));
+  return workInProgress;
+}
+function createFiberFromTypeAndProps(
+  type,
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
+) {
+  var fiberTag = 2;
+  owner = type;
+  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
+  else if ("string" === typeof type)
+    fiberTag = isHostHoistableType(
+      type,
+      pendingProps,
+      contextStackCursor.current
+    )
+      ? 26
+      : "html" === type || "head" === type || "body" === type
+      ? 27
+      : 5;
+  else
+    a: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = 8;
+        mode |= 8;
+        0 !== (mode & 1) && (mode |= 16);
         break;
-      case 24:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+      case REACT_PROFILER_TYPE:
+        return (
+          (type = createFiber(12, pendingProps, key, mode | 2)),
+          (type.elementType = REACT_PROFILER_TYPE),
+          (type.lanes = lanes),
+          type
         );
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-        break;
-      case 25:
-        if (enableTransitionTracing) {
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
+      case REACT_SUSPENSE_TYPE:
+        return (
+          (type = createFiber(13, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_SUSPENSE_LIST_TYPE:
+        return (
+          (type = createFiber(19, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+      case REACT_LEGACY_HIDDEN_TYPE:
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      case REACT_SCOPE_TYPE:
+        return (
+          (pendingProps = createFiber(21, pendingProps, key, mode)),
+          (pendingProps.type = type),
+          (pendingProps.elementType = type),
+          (pendingProps.lanes = lanes),
+          pendingProps
+        );
+      case REACT_CACHE_TYPE:
+        return (
+          (type = createFiber(24, pendingProps, key, mode)),
+          (type.elementType = REACT_CACHE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing)
+          return (
+            (type = createFiber(25, pendingProps, key, mode)),
+            (type.elementType = REACT_TRACING_MARKER_TYPE),
+            (type.lanes = lanes),
+            (type.stateNode = {
+              tag: 1,
+              transitions: null,
+              pendingBoundaries: null,
+              aborts: null,
+              name: pendingProps.name
+            }),
+            type
           );
-          includeWorkInProgressEffects &&
-            flags & 2048 &&
-            commitTracingMarkerPassiveMountEffect(finishedWork);
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = 8;
+          mode |= 4;
           break;
         }
       default:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+        if ("object" === typeof type && null !== type)
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = 10;
+              break a;
+            case REACT_CONTEXT_TYPE:
+              fiberTag = 9;
+              break a;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = 11;
+              break a;
+            case REACT_MEMO_TYPE:
+              fiberTag = 14;
+              break a;
+            case REACT_LAZY_TYPE:
+              fiberTag = 16;
+              owner = null;
+              break a;
+          }
+        throw Error(
+          formatProdErrorMessage(130, null == type ? type : typeof type, "")
         );
     }
-    parentFiber = parentFiber.sibling;
-  }
-}
-function recursivelyTraverseAtomicPassiveEffects(
-  finishedRoot$jscomp$0,
-  parentFiber
-) {
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-      var finishedRoot = finishedRoot$jscomp$0,
-        finishedWork = parentFiber,
-        flags = finishedWork.flags;
-      switch (finishedWork.tag) {
-        case 22:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-          flags & 2048 &&
-            commitOffscreenPassiveMountEffects(
-              finishedWork.alternate,
-              finishedWork,
-              finishedWork.stateNode
-            );
-          break;
-        case 24:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-          flags & 2048 &&
-            commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-          break;
-        default:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-      }
-      parentFiber = parentFiber.sibling;
-    }
-}
-function detachAlternateSiblings(parentFiber) {
-  var previousFiber = parentFiber.alternate;
-  if (
-    null !== previousFiber &&
-    ((parentFiber = previousFiber.child), null !== parentFiber)
-  ) {
-    previousFiber.child = null;
-    do
-      (previousFiber = parentFiber.sibling),
-        (parentFiber.sibling = null),
-        (parentFiber = previousFiber);
-    while (null !== parentFiber);
-  }
-}
-function recursivelyTraversePassiveUnmountEffects(parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (0 !== (parentFiber.flags & 16)) {
-    if (null !== deletions)
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i];
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    detachAlternateSiblings(parentFiber);
-  }
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitPassiveUnmountOnFiber(parentFiber),
-        (parentFiber = parentFiber.sibling);
-}
-function commitPassiveUnmountOnFiber(finishedWork) {
-  switch (finishedWork.tag) {
-    case 0:
-    case 11:
-    case 15:
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-      finishedWork.flags & 2048 &&
-        commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
-      break;
-    case 22:
-      var instance = finishedWork.stateNode;
-      null !== finishedWork.memoizedState &&
-      instance._visibility & 4 &&
-      (null === finishedWork.return || 13 !== finishedWork.return.tag)
-        ? ((instance._visibility &= -5),
-          recursivelyTraverseDisconnectPassiveEffects(finishedWork))
-        : recursivelyTraversePassiveUnmountEffects(finishedWork);
-      break;
-    default:
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-  }
+  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
+  pendingProps.elementType = type;
+  pendingProps.type = owner;
+  pendingProps.lanes = lanes;
+  return pendingProps;
 }
-function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (0 !== (parentFiber.flags & 16)) {
-    if (null !== deletions)
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i];
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    detachAlternateSiblings(parentFiber);
-  }
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    deletions = parentFiber;
-    switch (deletions.tag) {
-      case 0:
-      case 11:
-      case 15:
-        commitHookEffectListUnmount(8, deletions, deletions.return);
-        recursivelyTraverseDisconnectPassiveEffects(deletions);
-        break;
-      case 22:
-        i = deletions.stateNode;
-        i._visibility & 4 &&
-          ((i._visibility &= -5),
-          recursivelyTraverseDisconnectPassiveEffects(deletions));
-        break;
-      default:
-        recursivelyTraverseDisconnectPassiveEffects(deletions);
+function createFiberFromFragment(elements, mode, lanes, key) {
+  elements = createFiber(7, elements, key, mode);
+  elements.lanes = lanes;
+  return elements;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(22, pendingProps, key, mode);
+  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
+  pendingProps.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
     }
-    parentFiber = parentFiber.sibling;
-  }
+  };
+  pendingProps.stateNode = primaryChildInstance;
+  return pendingProps;
 }
-function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-  deletedSubtreeRoot,
-  nearestMountedAncestor$jscomp$0
-) {
-  for (; null !== nextEffect; ) {
-    var fiber = nextEffect,
-      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
-    switch (fiber.tag) {
-      case 0:
-      case 11:
-      case 15:
-        commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
-        break;
-      case 23:
-      case 22:
-        null !== fiber.memoizedState &&
-          null !== fiber.memoizedState.cachePool &&
-          ((nearestMountedAncestor = fiber.memoizedState.cachePool.pool),
-          null != nearestMountedAncestor && nearestMountedAncestor.refCount++);
-        break;
-      case 13:
-        if (enableTransitionTracing) {
-          var offscreenFiber = fiber.child,
-            instance = offscreenFiber.stateNode,
-            transitions = instance._transitions;
-          if (null !== transitions) {
-            var abortReason = {
-              reason: "suspense",
-              name: fiber.memoizedProps.unstable_name || null
-            };
-            if (
-              null === fiber.memoizedState ||
-              null === fiber.memoizedState.dehydrated
-            )
-              abortParentMarkerTransitionsForDeletedFiber(
-                offscreenFiber,
-                abortReason,
-                transitions,
-                instance,
-                !0
-              ),
-                null !== nearestMountedAncestor &&
-                  abortParentMarkerTransitionsForDeletedFiber(
-                    nearestMountedAncestor,
-                    abortReason,
-                    transitions,
-                    instance,
-                    !1
-                  );
-          }
-        }
-        break;
-      case 24:
-        releaseCache(fiber.memoizedState.cache);
-        break;
-      case 25:
-        enableTransitionTracing &&
-          ((offscreenFiber = fiber.stateNode.transitions),
-          null !== offscreenFiber &&
-            ((instance = { reason: "marker", name: fiber.memoizedProps.name }),
-            abortParentMarkerTransitionsForDeletedFiber(
-              fiber,
-              instance,
-              offscreenFiber,
-              null,
-              !0
-            ),
-            null !== nearestMountedAncestor &&
-              abortParentMarkerTransitionsForDeletedFiber(
-                nearestMountedAncestor,
-                instance,
-                offscreenFiber,
-                null,
-                !1
-              )));
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(23, pendingProps, key, mode);
+  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  pendingProps.lanes = lanes;
+  var instance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
     }
-    nearestMountedAncestor = fiber.child;
-    if (null !== nearestMountedAncestor)
-      (nearestMountedAncestor.return = fiber),
-        (nextEffect = nearestMountedAncestor);
-    else
-      a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
-        nearestMountedAncestor = nextEffect;
-        offscreenFiber = nearestMountedAncestor.sibling;
-        instance = nearestMountedAncestor.return;
-        detachFiberAfterEffects(nearestMountedAncestor);
-        if (nearestMountedAncestor === fiber) {
-          nextEffect = null;
-          break a;
-        }
-        if (null !== offscreenFiber) {
-          offscreenFiber.return = instance;
-          nextEffect = offscreenFiber;
-          break a;
-        }
-        nextEffect = instance;
+  };
+  pendingProps.stateNode = instance;
+  return pendingProps;
+}
+function createFiberFromText(content, mode, lanes) {
+  content = createFiber(6, content, null, mode);
+  content.lanes = lanes;
+  return content;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  mode = createFiber(
+    4,
+    null !== portal.children ? portal.children : [],
+    portal.key,
+    mode
+  );
+  mode.lanes = lanes;
+  mode.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    implementation: portal.implementation
+  };
+  return mode;
+}
+function FiberRootNode(
+  containerInfo,
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
+) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.finishedWork =
+    this.pingCache =
+    this.current =
+    this.pendingChildren =
+      null;
+  this.timeoutHandle = -1;
+  this.callbackNode = this.pendingContext = this.context = null;
+  this.callbackPriority = 0;
+  this.eventTimes = createLaneMap(0);
+  this.expirationTimes = createLaneMap(-1);
+  this.entangledLanes =
+    this.errorRecoveryDisabledLanes =
+    this.finishedLanes =
+    this.mutableReadLanes =
+    this.expiredLanes =
+    this.pingedLanes =
+    this.suspendedLanes =
+    this.pendingLanes =
+      0;
+  this.entanglements = createLaneMap(0);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+  this.pooledCache = null;
+  this.pooledCacheLanes = 0;
+  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
+  this.incompleteTransitions = new Map();
+  if (enableTransitionTracing)
+    for (
+      this.transitionCallbacks = null,
+        containerInfo = this.transitionLanes = [],
+        tag = 0;
+      31 > tag;
+      tag++
+    )
+      containerInfo.push(null);
+}
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  containerInfo = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
+  );
+  containerInfo.hydrationCallbacks = hydrationCallbacks;
+  enableTransitionTracing &&
+    (containerInfo.transitionCallbacks = transitionCallbacks);
+  1 === tag
+    ? ((tag = 1),
+      !0 === isStrictMode && (tag |= 24),
+      concurrentUpdatesByDefaultOverride && (tag |= 32))
+    : (tag = 0);
+  isStrictMode = createFiber(3, null, null, tag);
+  containerInfo.current = isStrictMode;
+  isStrictMode.stateNode = containerInfo;
+  concurrentUpdatesByDefaultOverride = createCache();
+  concurrentUpdatesByDefaultOverride.refCount++;
+  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
+  concurrentUpdatesByDefaultOverride.refCount++;
+  isStrictMode.memoizedState = {
+    element: initialChildren,
+    isDehydrated: hydrate,
+    cache: concurrentUpdatesByDefaultOverride
+  };
+  initializeUpdateQueue(isStrictMode);
+  return containerInfo;
+}
+function createPortal$1(children, containerInfo, implementation) {
+  var key =
+    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+  return {
+    $$typeof: REACT_PORTAL_TYPE,
+    key: null == key ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
+}
+function updateContainer(element, container, parentComponent, callback) {
+  parentComponent = container.current;
+  var lane = requestUpdateLane(parentComponent);
+  null === container.context
+    ? (container.context = emptyContextObject)
+    : (container.pendingContext = emptyContextObject);
+  container = createUpdate(lane);
+  container.payload = { element: element };
+  callback = void 0 === callback ? null : callback;
+  null !== callback && (container.callback = callback);
+  element = enqueueUpdate(parentComponent, container, lane);
+  null !== element &&
+    ((callback = requestEventTime()),
+    scheduleUpdateOnFiber(element, parentComponent, lane, callback),
+    entangleTransitions(element, parentComponent, lane));
+  return lane;
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case 3:
+      var root$179 = fiber.stateNode;
+      if (root$179.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$179.pendingLanes);
+        0 !== lanes &&
+          (markRootEntangled(root$179, lanes | 2),
+          ensureRootIsScheduled(root$179, now()),
+          0 === (executionContext & 6) &&
+            (resetRenderTimer(), flushSyncCallbacks()));
       }
+      break;
+    case 13:
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, 2);
+        if (null !== root) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
+        }
+      }),
+        markRetryLaneIfNotHydrated(fiber, 2);
   }
 }
-var DefaultCacheDispatcher = {
-    getCacheSignal: function () {
-      return readContext(CacheContext).controller.signal;
-    },
-    getCacheForType: function (resourceType) {
-      var cache = readContext(CacheContext),
-        cacheForType = cache.data.get(resourceType);
-      void 0 === cacheForType &&
-        ((cacheForType = resourceType()),
-        cache.data.set(resourceType, cacheForType));
-      return cacheForType;
+function markRetryLaneImpl(fiber, retryLane) {
+  fiber = fiber.memoizedState;
+  if (null !== fiber && null !== fiber.dehydrated) {
+    var a = fiber.retryLane;
+    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+  }
+}
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
+}
+function attemptContinuousHydration(fiber) {
+  if (13 === fiber.tag) {
+    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
+    if (null !== root) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
     }
-  },
-  postPaintCallbackScheduled = !1,
-  callbacks = [];
-function schedulePostPaintCallback(callback) {
-  callbacks.push(callback);
-  postPaintCallbackScheduled ||
-    ((postPaintCallbackScheduled = !0),
-    requestPostPaintCallback(function (endTime) {
-      for (var i = 0; i < callbacks.length; i++) callbacks[i](endTime);
-      postPaintCallbackScheduled = !1;
-      callbacks = [];
-    }));
+    markRetryLaneIfNotHydrated(fiber, 134217728);
+  }
 }
-var ceil = Math.ceil,
-  PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
-  ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
-  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
-  executionContext = 0,
-  workInProgressRoot = null,
-  workInProgress = null,
-  workInProgressRootRenderLanes = 0,
-  workInProgressSuspendedReason = 0,
-  workInProgressThrownValue = null,
-  workInProgressRootDidAttachPingListener = !1,
-  renderLanes = 0,
-  workInProgressRootExitStatus = 0,
-  workInProgressRootFatalError = null,
-  workInProgressRootSkippedLanes = 0,
-  workInProgressRootInterleavedUpdatedLanes = 0,
-  workInProgressRootPingedLanes = 0,
-  workInProgressRootConcurrentErrors = null,
-  workInProgressRootRecoverableErrors = null,
-  globalMostRecentFallbackTime = 0,
-  workInProgressRootRenderTargetTime = Infinity,
-  workInProgressTransitions = null,
-  currentPendingTransitionCallbacks = null,
-  currentEndTime = null;
-function addMarkerProgressCallbackToPendingTransition(
-  markerName,
-  transitions,
-  pendingBoundaries
-) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: new Map(),
-        markerIncomplete: null,
-        markerComplete: null
-      }),
-    null === currentPendingTransitionCallbacks.markerProgress &&
-      (currentPendingTransitionCallbacks.markerProgress = new Map()),
-    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
-      pendingBoundaries: pendingBoundaries,
-      transitions: transitions
-    }));
+function emptyFindFiberByHostInstance() {
+  return null;
 }
-function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: new Map()
-      }),
-    null === currentPendingTransitionCallbacks.markerComplete &&
-      (currentPendingTransitionCallbacks.markerComplete = new Map()),
-    currentPendingTransitionCallbacks.markerComplete.set(
-      markerName,
-      transitions
-    ));
+var isInsideEventHandler = !1;
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) return fn(a, b);
+  isInsideEventHandler = !0;
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    if (
+      ((isInsideEventHandler = !1),
+      null !== restoreTarget || null !== restoreQueue)
+    )
+      flushSync$1(), restoreStateIfNeeded();
+  }
 }
-function addTransitionProgressCallbackToPendingTransition(
-  transition,
-  boundaries
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
+  if (null === stateNode) return null;
+  var props = getFiberCurrentPropsFromNode(stateNode);
+  if (null === props) return null;
+  stateNode = props[registrationName];
+  a: switch (registrationName) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      (props = !props.disabled) ||
+        ((inst = inst.type),
+        (props = !(
+          "button" === inst ||
+          "input" === inst ||
+          "select" === inst ||
+          "textarea" === inst
+        )));
+      inst = !props;
+      break a;
+    default:
+      inst = !1;
+  }
+  if (inst) return null;
+  if (stateNode && "function" !== typeof stateNode)
+    throw Error(
+      formatProdErrorMessage(231, registrationName, typeof stateNode)
+    );
+  return stateNode;
+}
+var passiveBrowserEventsSupported = !1;
+if (canUseDOM)
+  try {
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = !0;
+      }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = !1;
+  }
+var hasScheduledReplayAttempt = !1,
+  queuedDiscreteEvents = [],
+  queuedFocus = null,
+  queuedDrag = null,
+  queuedMouse = null,
+  queuedPointers = new Map(),
+  queuedPointerCaptures = new Map(),
+  queuedExplicitHydrationTargets = [],
+  discreteReplayableEvents =
+    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
+      " "
+    );
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
 ) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: new Map(),
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      }),
-    null === currentPendingTransitionCallbacks.transitionProgress &&
-      (currentPendingTransitionCallbacks.transitionProgress = new Map()),
-    currentPendingTransitionCallbacks.transitionProgress.set(
-      transition,
-      boundaries
-    ));
+  return {
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
+  };
 }
-function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now() + 500;
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
+    ((blockedOn = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )),
+    queuedDiscreteEvents.push(blockedOn),
+    1 === queuedDiscreteEvents.length)
+  )
+    for (; null !== blockedOn.blockedOn; ) {
+      domEventName = getInstanceFromNode$1(blockedOn.blockedOn);
+      if (null === domEventName) break;
+      attemptSynchronousHydration(domEventName);
+      if (null === blockedOn.blockedOn) replayUnblockedEvents();
+      else break;
+    }
 }
-var hasUncaughtError = !1,
-  firstUncaughtError = null,
-  legacyErrorBoundariesThatAlreadyFailed = null,
-  rootDoesHavePassiveEffects = !1,
-  rootWithPendingPassiveEffects = null,
-  pendingPassiveEffectsLanes = 0,
-  pendingPassiveEffectsRemainingLanes = 0,
-  pendingPassiveTransitions = null,
-  nestedUpdateCount = 0,
-  rootWithNestedUpdates = null,
-  currentEventTime = -1,
-  currentEventTransitionLane = 0;
-function requestEventTime() {
-  return 0 !== (executionContext & 6)
-    ? now()
-    : -1 !== currentEventTime
-    ? currentEventTime
-    : (currentEventTime = now());
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
+    case "pointerover":
+    case "pointerout":
+      queuedPointers.delete(nativeEvent.pointerId);
+      break;
+    case "gotpointercapture":
+    case "lostpointercapture":
+      queuedPointerCaptures.delete(nativeEvent.pointerId);
+  }
 }
-function requestUpdateLane(fiber) {
-  if (0 === (fiber.mode & 1)) return 2;
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
   if (
-    !deferRenderPhaseUpdateToNextBatch &&
-    0 !== (executionContext & 2) &&
-    0 !== workInProgressRootRenderLanes
+    null === existingQueuedEvent ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
   )
-    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
-  if (null !== ReactCurrentBatchConfig$1.transition)
     return (
-      0 === currentEventTransitionLane &&
-        (currentEventTransitionLane = claimNextTransitionLane()),
-      currentEventTransitionLane
+      (existingQueuedEvent = createQueuedReplayableEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )),
+      null !== blockedOn &&
+        ((blockedOn = getInstanceFromNode$1(blockedOn)),
+        null !== blockedOn && attemptContinuousHydration(blockedOn)),
+      existingQueuedEvent
     );
-  fiber = currentUpdatePriority;
-  if (0 !== fiber) return fiber;
-  fiber = window.event;
-  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
-  return fiber;
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  blockedOn = existingQueuedEvent.targetContainers;
+  null !== targetContainer &&
+    -1 === blockedOn.indexOf(targetContainer) &&
+    blockedOn.push(targetContainer);
+  return existingQueuedEvent;
 }
-function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
-  2 === workInProgressSuspendedReason &&
-    root === workInProgressRoot &&
-    (prepareFreshStack(root, 0),
-    markRootSuspended(root, workInProgressRootRenderLanes));
-  markRootUpdated(root, lane, eventTime);
-  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
-    if (enableTransitionTracing) {
-      var transition = ReactCurrentBatchConfig.transition;
-      if (
-        null !== transition &&
-        null != transition.name &&
-        (-1 === transition.startTime && (transition.startTime = now()),
-        enableTransitionTracing)
-      ) {
-        var transitionLanesMap = root.transitionLanes,
-          index$15 = 31 - clz32(lane),
-          transitions = transitionLanesMap[index$15];
-        null === transitions && (transitions = new Set());
-        transitions.add(transition);
-        transitionLanesMap[index$15] = transitions;
-      }
-    }
-    if (root === workInProgressRoot) {
-      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
-        workInProgressRootInterleavedUpdatedLanes |= lane;
-      4 === workInProgressRootExitStatus &&
-        markRootSuspended(root, workInProgressRootRenderLanes);
-    }
-    ensureRootIsScheduled(root, eventTime);
-    2 === lane &&
-      0 === executionContext &&
-      0 === (fiber.mode & 1) &&
-      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  switch (domEventName) {
+    case "focusin":
+      return (
+        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedFocus,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "dragenter":
+      return (
+        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedDrag,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "mouseover":
+      return (
+        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedMouse,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "pointerover":
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
+      );
+      return !0;
+    case "gotpointercapture":
+      return (
+        (pointerId = nativeEvent.pointerId),
+        queuedPointerCaptures.set(
+          pointerId,
+          accumulateOrCreateContinuousQueuedReplayableEvent(
+            queuedPointerCaptures.get(pointerId) || null,
+            blockedOn,
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          )
+        ),
+        !0
+      );
   }
+  return !1;
 }
-function ensureRootIsScheduled(root, currentTime) {
-  var existingCallbackNode = root.callbackNode;
-  markStarvedLanesAsExpired(root, currentTime);
-  var nextLanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
-  );
-  if (0 === nextLanes)
-    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
-      (root.callbackNode = null),
-      (root.callbackPriority = 0);
-  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
-    (root.callbackPriority = 0), (root.callbackNode = null);
-  else if (
-    ((currentTime = nextLanes & -nextLanes),
-    root.callbackPriority !== currentTime)
-  ) {
-    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
-    if (0 !== (currentTime & 3))
-      0 === root.tag
-        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
-        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
-        scheduleMicrotask(function () {
-          0 === (executionContext & 6) && flushSyncCallbacks();
-        }),
-        (existingCallbackNode = null);
-    else {
-      switch (lanesToEventPriority(nextLanes)) {
-        case 2:
-          existingCallbackNode = ImmediatePriority;
-          break;
-        case 8:
-          existingCallbackNode = UserBlockingPriority;
-          break;
-        case 32:
-          existingCallbackNode = NormalPriority$1;
-          break;
-        case 536870912:
-          existingCallbackNode = IdlePriority;
-          break;
-        default:
-          existingCallbackNode = NormalPriority$1;
+function attemptExplicitHydrationTarget(queuedTarget) {
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
+  if (null !== targetInst) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
+    if (null !== nearestMounted)
+      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
+        if (
+          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
+          null !== targetInst)
+        ) {
+          queuedTarget.blockedOn = targetInst;
+          runWithPriority(queuedTarget.priority, function () {
+            if (13 === nearestMounted.tag) {
+              var lane = requestUpdateLane(nearestMounted),
+                root = enqueueConcurrentRenderForLane(nearestMounted, lane);
+              if (null !== root) {
+                var eventTime = requestEventTime();
+                scheduleUpdateOnFiber(root, nearestMounted, lane, eventTime);
+              }
+              markRetryLaneIfNotHydrated(nearestMounted, lane);
+            }
+          });
+          return;
+        }
+      } else if (
+        3 === targetInst &&
+        nearestMounted.stateNode.current.memoizedState.isDehydrated
+      ) {
+        queuedTarget.blockedOn =
+          3 === nearestMounted.tag
+            ? nearestMounted.stateNode.containerInfo
+            : null;
+        return;
       }
-      existingCallbackNode = scheduleCallback(
-        existingCallbackNode,
-        performConcurrentWorkOnRoot.bind(null, root)
-      );
-    }
-    root.callbackPriority = currentTime;
-    root.callbackNode = existingCallbackNode;
   }
+  queuedTarget.blockedOn = null;
 }
-function performConcurrentWorkOnRoot(root, didTimeout) {
-  currentEventTime = -1;
-  currentEventTransitionLane = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var originalCallbackNode = root.callbackNode;
-  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
-    return null;
-  var lanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
-  );
-  if (0 === lanes) return null;
-  didTimeout =
-    includesBlockingLane(root, lanes) ||
-    0 !== (lanes & root.expiredLanes) ||
-    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
-      ? renderRootSync(root, lanes)
-      : renderRootConcurrent(root, lanes);
-  if (0 !== didTimeout) {
-    if (2 === didTimeout) {
-      var originallyAttemptedLanes = lanes,
-        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-          root,
-          originallyAttemptedLanes
-        );
-      0 !== errorRetryLanes &&
-        ((lanes = errorRetryLanes),
-        (didTimeout = recoverFromConcurrentError(
-          root,
-          originallyAttemptedLanes,
-          errorRetryLanes
-        )));
-    }
-    if (1 === didTimeout)
-      throw (
-        ((originalCallbackNode = workInProgressRootFatalError),
-        prepareFreshStack(root, 0),
-        markRootSuspended(root, lanes),
-        ensureRootIsScheduled(root, now()),
-        originalCallbackNode)
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (null !== queuedEvent.blockedOn) return !1;
+  for (
+    var targetContainers = queuedEvent.targetContainers;
+    0 < targetContainers.length;
+
+  ) {
+    var targetContainer = targetContainers[0],
+      nextBlockedOn = findInstanceBlockingEvent(
+        queuedEvent.domEventName,
+        queuedEvent.eventSystemFlags,
+        targetContainer,
+        queuedEvent.nativeEvent
       );
-    if (6 === didTimeout) markRootSuspended(root, lanes);
-    else {
-      errorRetryLanes = !includesBlockingLane(root, lanes);
-      originallyAttemptedLanes = root.current.alternate;
-      if (
-        errorRetryLanes &&
-        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
-      ) {
-        didTimeout = renderRootSync(root, lanes);
-        if (2 === didTimeout) {
-          errorRetryLanes = lanes;
-          var errorRetryLanes$212 = getLanesToRetrySynchronouslyOnError(
-            root,
-            errorRetryLanes
-          );
-          0 !== errorRetryLanes$212 &&
-            ((lanes = errorRetryLanes$212),
-            (didTimeout = recoverFromConcurrentError(
-              root,
-              errorRetryLanes,
-              errorRetryLanes$212
-            )));
+    if (null === nextBlockedOn)
+      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
+        ? ((nextBlockedOn = queuedEvent.nativeEvent),
+          (currentReplayingEvent = targetContainer =
+            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
+          nextBlockedOn.target.dispatchEvent(targetContainer))
+        : ((currentReplayingEvent = queuedEvent.nativeEvent),
+          dispatchEventForPluginEventSystem(
+            queuedEvent.domEventName,
+            queuedEvent.eventSystemFlags,
+            queuedEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          )),
+        (currentReplayingEvent = null);
+    else
+      return (
+        (targetContainers = getInstanceFromNode$1(nextBlockedOn)),
+        null !== targetContainers &&
+          attemptContinuousHydration(targetContainers),
+        (queuedEvent.blockedOn = nextBlockedOn),
+        !1
+      );
+    targetContainers.shift();
+  }
+  return !0;
+}
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+}
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = !1;
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
+    for (; 0 < queuedDiscreteEvents.length; ) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
+      if (null !== nextDiscreteEvent.blockedOn) {
+        nextDiscreteEvent = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
+        if (null !== nextDiscreteEvent && 13 === nextDiscreteEvent.tag) {
+          var root = enqueueConcurrentRenderForLane(nextDiscreteEvent, 2);
+          if (null !== root) {
+            var eventTime = requestEventTime();
+            scheduleUpdateOnFiber(root, nextDiscreteEvent, 2, eventTime);
+          }
+          markRetryLaneIfNotHydrated(nextDiscreteEvent, 2);
         }
-        if (1 === didTimeout)
-          throw (
-            ((originalCallbackNode = workInProgressRootFatalError),
-            prepareFreshStack(root, 0),
-            markRootSuspended(root, lanes),
-            ensureRootIsScheduled(root, now()),
-            originalCallbackNode)
-          );
+        break;
       }
-      root.finishedWork = originallyAttemptedLanes;
-      root.finishedLanes = lanes;
-      switch (didTimeout) {
-        case 0:
-        case 1:
-          throw Error(formatProdErrorMessage(345));
-        case 2:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 3:
-          markRootSuspended(root, lanes);
-          if (
-            (lanes & 125829120) === lanes &&
-            ((lanes = globalMostRecentFallbackTime + 500 - now()), 10 < lanes)
-          ) {
-            if (0 !== getNextLanes(root, 0)) break;
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
-          }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 4:
-          markRootSuspended(root, lanes);
-          if ((lanes & 8388480) === lanes) break;
-          didTimeout = root.eventTimes;
-          for (originallyAttemptedLanes = -1; 0 < lanes; )
-            (errorRetryLanes$212 = 31 - clz32(lanes)),
-              (errorRetryLanes = 1 << errorRetryLanes$212),
-              (errorRetryLanes$212 = didTimeout[errorRetryLanes$212]),
-              errorRetryLanes$212 > originallyAttemptedLanes &&
-                (originallyAttemptedLanes = errorRetryLanes$212),
-              (lanes &= ~errorRetryLanes);
-          lanes = originallyAttemptedLanes;
-          lanes = now() - lanes;
-          lanes =
-            (120 > lanes
-              ? 120
-              : 480 > lanes
-              ? 480
-              : 1080 > lanes
-              ? 1080
-              : 1920 > lanes
-              ? 1920
-              : 3e3 > lanes
-              ? 3e3
-              : 4320 > lanes
-              ? 4320
-              : 1960 * ceil(lanes / 1960)) - lanes;
-          if (10 < lanes) {
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
-          }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 5:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
+      for (root = nextDiscreteEvent.targetContainers; 0 < root.length; ) {
+        eventTime = root[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          eventTime,
+          nextDiscreteEvent.nativeEvent
+        );
+        if (null === nextBlockedOn)
+          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
+            dispatchEventForPluginEventSystem(
+              nextDiscreteEvent.domEventName,
+              nextDiscreteEvent.eventSystemFlags,
+              nextDiscreteEvent.nativeEvent,
+              return_targetInst,
+              eventTime
+            ),
+            (currentReplayingEvent = null);
+        else {
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
           break;
-        default:
-          throw Error(formatProdErrorMessage(329));
+        }
+        root.shift();
       }
+      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
+    }
+  null !== queuedFocus &&
+    attemptReplayContinuousQueuedEvent(queuedFocus) &&
+    (queuedFocus = null);
+  null !== queuedDrag &&
+    attemptReplayContinuousQueuedEvent(queuedDrag) &&
+    (queuedDrag = null);
+  null !== queuedMouse &&
+    attemptReplayContinuousQueuedEvent(queuedMouse) &&
+    (queuedMouse = null);
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  queuedEvent.blockedOn === unblocked &&
+    ((queuedEvent.blockedOn = null),
+    hasScheduledReplayAttempt ||
+      ((hasScheduledReplayAttempt = !0),
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      )));
+}
+function retryIfBlockedOn(unblocked) {
+  function unblock(queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  }
+  if (0 < queuedDiscreteEvents.length) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
     }
   }
-  ensureRootIsScheduled(root, now());
-  return root.callbackNode === originalCallbackNode
-    ? performConcurrentWorkOnRoot.bind(null, root)
-    : null;
+  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
+    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
+  for (
+    ;
+    0 < queuedExplicitHydrationTargets.length &&
+    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
+
+  )
+    attemptExplicitHydrationTarget(i),
+      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
 }
-function recoverFromConcurrentError(
-  root,
-  originallyAttemptedLanes,
-  errorRetryLanes
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
+  _enabled = !0;
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
 ) {
-  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
-    wasRootDehydrated = root.current.memoizedState.isDehydrated;
-  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
-  errorRetryLanes = renderRootSync(root, errorRetryLanes);
-  if (2 !== errorRetryLanes) {
-    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
-      return (
-        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
-        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
-        4
-      );
-    root = workInProgressRootRecoverableErrors;
-    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
-    null !== root && queueRecoverableErrors(root);
+  switch (getEventPriority(domEventName)) {
+    case 2:
+      var listenerWrapper = dispatchDiscreteEvent;
+      break;
+    case 8:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+    default:
+      listenerWrapper = dispatchEvent;
   }
-  return errorRetryLanes;
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
+  );
 }
-function queueRecoverableErrors(errors) {
-  null === workInProgressRootRecoverableErrors
-    ? (workInProgressRootRecoverableErrors = errors)
-    : workInProgressRootRecoverableErrors.push.apply(
-        workInProgressRootRecoverableErrors,
-        errors
-      );
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 2),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
+  }
 }
-function isRenderConsistentWithExternalStores(finishedWork) {
-  for (var node = finishedWork; ; ) {
-    if (node.flags & 16384) {
-      var updateQueue = node.updateQueue;
-      if (
-        null !== updateQueue &&
-        ((updateQueue = updateQueue.stores), null !== updateQueue)
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 8),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
+  }
+}
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (_enabled)
+    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+      var blockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
+      if (null === blockedOn)
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          clearIfContinuousEvent(domEventName, nativeEvent);
+      else if (
+        queueIfContinuousEvent(
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
       )
-        for (var i = 0; i < updateQueue.length; i++) {
-          var check = updateQueue[i],
-            getSnapshot = check.getSnapshot;
-          check = check.value;
-          try {
-            if (!objectIs(getSnapshot(), check)) return !1;
-          } catch (error) {
-            return !1;
+        nativeEvent.stopPropagation();
+      else if (
+        (clearIfContinuousEvent(domEventName, nativeEvent),
+        eventSystemFlags & 4 &&
+          -1 < discreteReplayableEvents.indexOf(domEventName))
+      ) {
+        for (; null !== blockedOn; ) {
+          var fiber = getInstanceFromNode$1(blockedOn);
+          null !== fiber && attemptSynchronousHydration(fiber);
+          fiber = findInstanceBlockingEvent(
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          );
+          null === fiber &&
+            dispatchEventForPluginEventSystem(
+              domEventName,
+              eventSystemFlags,
+              nativeEvent,
+              return_targetInst,
+              targetContainer
+            );
+          if (fiber === blockedOn) break;
+          blockedOn = fiber;
+        }
+        null !== blockedOn && nativeEvent.stopPropagation();
+      } else
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+    } else
+      a: if (
+        (blockedOn = 0 === (eventSystemFlags & 4)) &&
+        0 < queuedDiscreteEvents.length &&
+        -1 < discreteReplayableEvents.indexOf(domEventName)
+      )
+        queueDiscreteEvent(
+          null,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        );
+      else if (
+        ((fiber = findInstanceBlockingEvent(
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        null === fiber)
+      )
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
+      else {
+        if (blockedOn) {
+          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
+            queueDiscreteEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            );
+            break a;
           }
+          if (
+            queueIfContinuousEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            )
+          )
+            break a;
+          clearIfContinuousEvent(domEventName, nativeEvent);
         }
-    }
-    updateQueue = node.child;
-    if (node.subtreeFlags & 16384 && null !== updateQueue)
-      (updateQueue.return = node), (node = updateQueue);
-    else {
-      if (node === finishedWork) break;
-      for (; null === node.sibling; ) {
-        if (null === node.return || node.return === finishedWork) return !0;
-        node = node.return;
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
       }
-      node.sibling.return = node.return;
-      node = node.sibling;
-    }
-  }
-  return !0;
-}
-function markRootSuspended(root, suspendedLanes) {
-  suspendedLanes &= ~workInProgressRootPingedLanes;
-  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
-  root.suspendedLanes |= suspendedLanes;
-  root.pingedLanes &= ~suspendedLanes;
-  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
-    var index$12 = 31 - clz32(suspendedLanes),
-      lane = 1 << index$12;
-    root[index$12] = -1;
-    suspendedLanes &= ~lane;
-  }
 }
-function performSyncWorkOnRoot(root) {
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  flushPassiveEffects();
-  var lanes = getNextLanes(root, 0);
-  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now()), null;
-  var exitStatus = renderRootSync(root, lanes);
-  if (0 !== root.tag && 2 === exitStatus) {
-    var originallyAttemptedLanes = lanes,
-      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-        root,
-        originallyAttemptedLanes
-      );
-    0 !== errorRetryLanes &&
-      ((lanes = errorRetryLanes),
-      (exitStatus = recoverFromConcurrentError(
-        root,
-        originallyAttemptedLanes,
-        errorRetryLanes
-      )));
-  }
-  if (1 === exitStatus)
-    throw (
-      ((exitStatus = workInProgressRootFatalError),
-      prepareFreshStack(root, 0),
-      markRootSuspended(root, lanes),
-      ensureRootIsScheduled(root, now()),
-      exitStatus)
-    );
-  if (6 === exitStatus)
-    return (
-      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now()), null
-    );
-  root.finishedWork = root.current.alternate;
-  root.finishedLanes = lanes;
-  commitRoot(
-    root,
-    workInProgressRootRecoverableErrors,
-    workInProgressTransitions
-  );
-  ensureRootIsScheduled(root, now());
+var return_targetInst = null;
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return_targetInst = null;
+  domEventName = getEventTarget(nativeEvent);
+  domEventName = getClosestInstanceFromNode(domEventName);
+  if (null !== domEventName)
+    if (
+      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
+      null === eventSystemFlags)
+    )
+      domEventName = null;
+    else if (
+      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
+    ) {
+      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
+      if (null !== domEventName) return domEventName;
+      domEventName = null;
+    } else if (3 === targetContainer) {
+      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
+        return 3 === eventSystemFlags.tag
+          ? eventSystemFlags.stateNode.containerInfo
+          : null;
+      domEventName = null;
+    } else eventSystemFlags !== domEventName && (domEventName = null);
+  return_targetInst = domEventName;
   return null;
 }
-function batchedUpdates(fn, a) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
-  try {
-    return fn(a);
-  } finally {
-    (executionContext = prevExecutionContext),
-      0 === executionContext &&
-        (resetRenderTimer(),
-        includesLegacySyncCallbacks && flushSyncCallbacks());
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange":
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate":
+    case "beforeblur":
+    case "afterblur":
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return 2;
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel":
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return 8;
+    case "message":
+      switch (getCurrentPriorityLevel()) {
+        case ImmediatePriority:
+          return 2;
+        case UserBlockingPriority:
+          return 8;
+        case NormalPriority$1:
+        case LowPriority:
+          return 32;
+        case IdlePriority:
+          return 536870912;
+        default:
+          return 32;
+      }
+    default:
+      return 32;
   }
 }
-function flushSync$1(fn) {
-  null !== rootWithPendingPassiveEffects &&
-    0 === rootWithPendingPassiveEffects.tag &&
-    0 === (executionContext & 6) &&
-    flushPassiveEffects();
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
-    previousPriority = currentUpdatePriority;
-  try {
-    if (
-      ((ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      fn)
-    )
-      return fn();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
-      (executionContext = prevExecutionContext),
-      0 === (executionContext & 6) && flushSyncCallbacks();
-  }
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, !1);
+  return listener;
 }
-function resetWorkInProgressStack() {
-  if (null !== workInProgress) {
-    if (0 === workInProgressSuspendedReason)
-      var interruptedWork = workInProgress.return;
-    else
-      resetContextDependencies(),
-        resetHooksOnUnwind(),
-        (thenableState$1 = null),
-        (thenableIndexCounter$1 = 0),
-        (interruptedWork = workInProgress);
-    for (; null !== interruptedWork; )
-      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
-        (interruptedWork = interruptedWork.return);
-    workInProgress = null;
-  }
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, !0);
+  return listener;
 }
-function prepareFreshStack(root, lanes) {
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  var timeoutHandle = root.timeoutHandle;
-  -1 !== timeoutHandle &&
-    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
-  resetWorkInProgressStack();
-  workInProgressRoot = root;
-  workInProgress = root = createWorkInProgress(root.current, null);
-  workInProgressRootRenderLanes = renderLanes = lanes;
-  workInProgressSuspendedReason = 0;
-  workInProgressThrownValue = null;
-  workInProgressRootDidAttachPingListener = !1;
-  workInProgressRootExitStatus = 0;
-  workInProgressRootFatalError = null;
-  workInProgressRootPingedLanes =
-    workInProgressRootInterleavedUpdatedLanes =
-    workInProgressRootSkippedLanes =
-      0;
-  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
-    null;
-  finishQueueingConcurrentUpdates();
-  return root;
+function addEventCaptureListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, {
+    capture: !0,
+    passive: passive
+  });
+  return listener;
 }
-function handleThrow(root, thrownValue) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  ReactCurrentOwner.current = null;
-  if (thrownValue === SuspenseException) {
-    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
-    root = suspendedThenable;
-    suspendedThenable = null;
-    thrownValue = root;
-    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
-      ? 2
-      : 3;
-  } else
-    workInProgressSuspendedReason =
-      thrownValue === SelectiveHydrationException
-        ? 6
-        : null !== thrownValue &&
-          "object" === typeof thrownValue &&
-          "function" === typeof thrownValue.then
-        ? 4
-        : 1;
-  workInProgressThrownValue = thrownValue;
-  null === workInProgress &&
-    ((workInProgressRootExitStatus = 1),
-    (workInProgressRootFatalError = thrownValue));
+function addEventBubbleListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, { passive: passive });
+  return listener;
 }
-function shouldAttemptToSuspendUntilDataResolves() {
-  if (
-    0 !== (workInProgressRootSkippedLanes & 268435455) ||
-    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
-  )
-    return !1;
-  if (
-    (workInProgressRootRenderLanes & 8388480) ===
-    workInProgressRootRenderLanes
-  )
-    return null === shellBoundary;
-  var handler = suspenseHandlerStackCursor.current;
-  return null !== handler &&
-    (workInProgressRootRenderLanes & 125829120) ===
-      workInProgressRootRenderLanes
-    ? handler === shellBoundary
-    : !1;
+var root = null,
+  startText = null,
+  fallbackText = null;
+function getData() {
+  if (fallbackText) return fallbackText;
+  var start,
+    startValue = startText,
+    startLength = startValue.length,
+    end,
+    endValue = "value" in root ? root.value : root.textContent,
+    endLength = endValue.length;
+  for (
+    start = 0;
+    start < startLength && startValue[start] === endValue[start];
+    start++
+  );
+  var minEnd = startLength - start;
+  for (
+    end = 1;
+    end <= minEnd &&
+    startValue[startLength - end] === endValue[endLength - end];
+    end++
+  );
+  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
 }
-function pushDispatcher(container) {
-  container = getHoistableRoot(container);
-  lastCurrentDocument = container.ownerDocument || container;
-  previousDispatcher = Dispatcher$1.current;
-  Dispatcher$1.current = ReactDOMClientDispatcher;
-  container = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
-  return null === container ? ContextOnlyDispatcher : container;
+function getEventCharCode(nativeEvent) {
+  var keyCode = nativeEvent.keyCode;
+  "charCode" in nativeEvent
+    ? ((nativeEvent = nativeEvent.charCode),
+      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
+    : (nativeEvent = keyCode);
+  10 === nativeEvent && (nativeEvent = 13);
+  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
 }
-function pushCacheDispatcher() {
-  var prevCacheDispatcher = ReactCurrentCache.current;
-  ReactCurrentCache.current = DefaultCacheDispatcher;
-  return prevCacheDispatcher;
+function functionThatReturnsTrue() {
+  return !0;
 }
-function renderDidSuspendDelayIfPossible() {
-  workInProgressRootExitStatus = 4;
-  null === workInProgressRoot ||
-    (0 === (workInProgressRootSkippedLanes & 268435455) &&
-      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
-    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+function functionThatReturnsFalse() {
+  return !1;
 }
-function renderRootSync(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
-      prepareFreshStack(root, lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
-        lanes = workInProgress;
-        var thrownValue = workInProgressThrownValue;
-        switch (workInProgressSuspendedReason) {
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            (workInProgressSuspendedReason = 0),
-              (workInProgressThrownValue = null),
-              unwindSuspendedUnitOfWork(lanes, thrownValue);
-        }
-      }
-      workLoopSync();
-      break;
-    } catch (thrownValue$215) {
-      handleThrow(root, thrownValue$215);
+function createSyntheticEvent(Interface) {
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  ) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+    for (var propName in Interface)
+      Interface.hasOwnProperty(propName) &&
+        ((reactName = Interface[propName]),
+        (this[propName] = reactName
+          ? reactName(nativeEvent)
+          : nativeEvent[propName]));
+    this.isDefaultPrevented = (
+      null != nativeEvent.defaultPrevented
+        ? nativeEvent.defaultPrevented
+        : !1 === nativeEvent.returnValue
+    )
+      ? functionThatReturnsTrue
+      : functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  }
+  assign(SyntheticBaseEvent.prototype, {
+    preventDefault: function () {
+      this.defaultPrevented = !0;
+      var event = this.nativeEvent;
+      event &&
+        (event.preventDefault
+          ? event.preventDefault()
+          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
+        (this.isDefaultPrevented = functionThatReturnsTrue));
+    },
+    stopPropagation: function () {
+      var event = this.nativeEvent;
+      event &&
+        (event.stopPropagation
+          ? event.stopPropagation()
+          : "unknown" !== typeof event.cancelBubble &&
+            (event.cancelBubble = !0),
+        (this.isPropagationStopped = functionThatReturnsTrue));
+    },
+    persist: function () {},
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+var EventInterface = {
+    eventPhase: 0,
+    bubbles: 0,
+    cancelable: 0,
+    timeStamp: function (event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: 0,
+    isTrusted: 0
+  },
+  SyntheticEvent = createSyntheticEvent(EventInterface),
+  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
+  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
+  lastMovementX,
+  lastMovementY,
+  lastMouseEvent,
+  MouseEventInterface = assign({}, UIEventInterface, {
+    screenX: 0,
+    screenY: 0,
+    clientX: 0,
+    clientY: 0,
+    pageX: 0,
+    pageY: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    getModifierState: getEventModifierState,
+    button: 0,
+    buttons: 0,
+    relatedTarget: function (event) {
+      return void 0 === event.relatedTarget
+        ? event.fromElement === event.srcElement
+          ? event.toElement
+          : event.fromElement
+        : event.relatedTarget;
+    },
+    movementX: function (event) {
+      if ("movementX" in event) return event.movementX;
+      event !== lastMouseEvent &&
+        (lastMouseEvent && "mousemove" === event.type
+          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
+            (lastMovementY = event.screenY - lastMouseEvent.screenY))
+          : (lastMovementY = lastMovementX = 0),
+        (lastMouseEvent = event));
+      return lastMovementX;
+    },
+    movementY: function (event) {
+      return "movementY" in event ? event.movementY : lastMovementY;
+    }
+  }),
+  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
+  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
+  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
+  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
+  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
+  AnimationEventInterface = assign({}, EventInterface, {
+    animationName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
+  ClipboardEventInterface = assign({}, EventInterface, {
+    clipboardData: function (event) {
+      return "clipboardData" in event
+        ? event.clipboardData
+        : window.clipboardData;
     }
-  while (1);
-  resetContextDependencies();
-  executionContext = prevExecutionContext;
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
+  }),
+  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
+  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
+  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
+  normalizeKey = {
+    Esc: "Escape",
+    Spacebar: " ",
+    Left: "ArrowLeft",
+    Up: "ArrowUp",
+    Right: "ArrowRight",
+    Down: "ArrowDown",
+    Del: "Delete",
+    Win: "OS",
+    Menu: "ContextMenu",
+    Apps: "ContextMenu",
+    Scroll: "ScrollLock",
+    MozPrintableKey: "Unidentified"
+  },
+  translateToKey = {
+    8: "Backspace",
+    9: "Tab",
+    12: "Clear",
+    13: "Enter",
+    16: "Shift",
+    17: "Control",
+    18: "Alt",
+    19: "Pause",
+    20: "CapsLock",
+    27: "Escape",
+    32: " ",
+    33: "PageUp",
+    34: "PageDown",
+    35: "End",
+    36: "Home",
+    37: "ArrowLeft",
+    38: "ArrowUp",
+    39: "ArrowRight",
+    40: "ArrowDown",
+    45: "Insert",
+    46: "Delete",
+    112: "F1",
+    113: "F2",
+    114: "F3",
+    115: "F4",
+    116: "F5",
+    117: "F6",
+    118: "F7",
+    119: "F8",
+    120: "F9",
+    121: "F10",
+    122: "F11",
+    123: "F12",
+    144: "NumLock",
+    145: "ScrollLock",
+    224: "Meta"
+  },
+  modifierKeyToProp = {
+    Alt: "altKey",
+    Control: "ctrlKey",
+    Meta: "metaKey",
+    Shift: "shiftKey"
+  };
+function modifierStateGetter(keyArg) {
+  var nativeEvent = this.nativeEvent;
+  return nativeEvent.getModifierState
+    ? nativeEvent.getModifierState(keyArg)
+    : (keyArg = modifierKeyToProp[keyArg])
+    ? !!nativeEvent[keyArg]
+    : !1;
 }
-function workLoopSync() {
-  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+function getEventModifierState() {
+  return modifierStateGetter;
 }
-function renderRootConcurrent(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
-      resetRenderTimer(),
-      prepareFreshStack(root, lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
-        lanes = workInProgress;
-        var thrownValue = workInProgressThrownValue;
-        switch (workInProgressSuspendedReason) {
-          case 1:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, thrownValue);
-            break;
-          case 2:
-            if (isThenableResolved(thrownValue)) {
-              workInProgressSuspendedReason = 0;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(lanes);
-              break;
-            }
-            lanes = function () {
-              2 === workInProgressSuspendedReason &&
-                workInProgressRoot === root &&
-                (workInProgressSuspendedReason = 5);
-              ensureRootIsScheduled(root, now());
-            };
-            thrownValue.then(lanes, lanes);
-            break a;
-          case 3:
-            workInProgressSuspendedReason = 5;
-            break a;
-          case 5:
-            isThenableResolved(thrownValue)
-              ? ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                replaySuspendedUnitOfWork(lanes))
-              : ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                unwindSuspendedUnitOfWork(lanes, thrownValue));
-            break;
-          case 4:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, thrownValue);
-            break;
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            throw Error(formatProdErrorMessage(462));
-        }
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+    key: function (nativeEvent) {
+      if (nativeEvent.key) {
+        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+        if ("Unidentified" !== key) return key;
       }
-      workLoopConcurrent();
-      break;
-    } catch (thrownValue$217) {
-      handleThrow(root, thrownValue$217);
+      return "keypress" === nativeEvent.type
+        ? ((nativeEvent = getEventCharCode(nativeEvent)),
+          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
+        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
+        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
+        : "";
+    },
+    code: 0,
+    location: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    repeat: 0,
+    locale: 0,
+    getModifierState: getEventModifierState,
+    charCode: function (event) {
+      return "keypress" === event.type ? getEventCharCode(event) : 0;
+    },
+    keyCode: function (event) {
+      return "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
+    },
+    which: function (event) {
+      return "keypress" === event.type
+        ? getEventCharCode(event)
+        : "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
     }
-  while (1);
-  resetContextDependencies();
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  executionContext = prevExecutionContext;
-  if (null !== workInProgress) return 0;
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
-}
-function workLoopConcurrent() {
-  for (; null !== workInProgress && !shouldYield(); )
-    performUnitOfWork(workInProgress);
+  }),
+  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
+  PointerEventInterface = assign({}, MouseEventInterface, {
+    pointerId: 0,
+    width: 0,
+    height: 0,
+    pressure: 0,
+    tangentialPressure: 0,
+    tiltX: 0,
+    tiltY: 0,
+    twist: 0,
+    pointerType: 0,
+    isPrimary: 0
+  }),
+  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
+  TouchEventInterface = assign({}, UIEventInterface, {
+    touches: 0,
+    targetTouches: 0,
+    changedTouches: 0,
+    altKey: 0,
+    metaKey: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    getModifierState: getEventModifierState
+  }),
+  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
+  TransitionEventInterface = assign({}, EventInterface, {
+    propertyName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
+  WheelEventInterface = assign({}, MouseEventInterface, {
+    deltaX: function (event) {
+      return "deltaX" in event
+        ? event.deltaX
+        : "wheelDeltaX" in event
+        ? -event.wheelDeltaX
+        : 0;
+    },
+    deltaY: function (event) {
+      return "deltaY" in event
+        ? event.deltaY
+        : "wheelDeltaY" in event
+        ? -event.wheelDeltaY
+        : "wheelDelta" in event
+        ? -event.wheelDelta
+        : 0;
+    },
+    deltaZ: 0,
+    deltaMode: 0
+  }),
+  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
+  END_KEYCODES = [9, 13, 27, 32],
+  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
+  documentMode = null;
+canUseDOM &&
+  "documentMode" in document &&
+  (documentMode = document.documentMode);
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
+  useFallbackCompositionData =
+    canUseDOM &&
+    (!canUseCompositionEvent ||
+      (documentMode && 8 < documentMode && 11 >= documentMode)),
+  SPACEBAR_CHAR = String.fromCharCode(32),
+  hasSpaceKeypress = !1;
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
+    case "keydown":
+      return 229 !== nativeEvent.keyCode;
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      return !0;
+    default:
+      return !1;
+  }
 }
-function performUnitOfWork(unitOfWork) {
-  var next = beginWork(unitOfWork.alternate, unitOfWork, renderLanes);
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === next ? completeUnitOfWork(unitOfWork) : (workInProgress = next);
-  ReactCurrentOwner.current = null;
+function getDataFromCustomEvent(nativeEvent) {
+  nativeEvent = nativeEvent.detail;
+  return "object" === typeof nativeEvent && "data" in nativeEvent
+    ? nativeEvent.data
+    : null;
 }
-function replaySuspendedUnitOfWork(unitOfWork) {
-  var current = unitOfWork.alternate;
-  switch (unitOfWork.tag) {
-    case 2:
-      unitOfWork.tag = 0;
-    case 0:
-    case 11:
-      var Component = unitOfWork.type,
-        unresolvedProps = unitOfWork.pendingProps;
-      unresolvedProps =
-        unitOfWork.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unresolvedProps,
-        Component,
-        workInProgressRootRenderLanes
-      );
-      break;
-    case 15:
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unitOfWork.pendingProps,
-        unitOfWork.type,
-        workInProgressRootRenderLanes
+var isComposing = !1;
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
+    case "keypress":
+      if (32 !== nativeEvent.which) return null;
+      hasSpaceKeypress = !0;
+      return SPACEBAR_CHAR;
+    case "textInput":
+      return (
+        (domEventName = nativeEvent.data),
+        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
       );
-      break;
     default:
-      unwindInterruptedWork(current, unitOfWork),
-        (unitOfWork = workInProgress =
-          resetWorkInProgress(unitOfWork, renderLanes)),
-        (current = beginWork(current, unitOfWork, renderLanes));
+      return null;
   }
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === current
-    ? completeUnitOfWork(unitOfWork)
-    : (workInProgress = current);
-  ReactCurrentOwner.current = null;
 }
-function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
-  resetContextDependencies();
-  resetHooksOnUnwind();
-  thenableState$1 = null;
-  thenableIndexCounter$1 = 0;
-  var returnFiber = unitOfWork.return;
-  if (null === returnFiber || null === workInProgressRoot)
-    (workInProgressRootExitStatus = 1),
-      (workInProgressRootFatalError = thrownValue),
-      (workInProgress = null);
-  else {
-    try {
-      a: {
-        var root = workInProgressRoot,
-          value = thrownValue;
-        thrownValue = workInProgressRootRenderLanes;
-        unitOfWork.flags |= 32768;
-        if (
-          null !== value &&
-          "object" === typeof value &&
-          "function" === typeof value.then
-        ) {
-          var wakeable = value;
-          if (enableLazyContextPropagation) {
-            var currentSourceFiber = unitOfWork.alternate;
-            null !== currentSourceFiber &&
-              propagateParentContextChanges(
-                currentSourceFiber,
-                unitOfWork,
-                thrownValue,
-                !0
-              );
-          }
-          var tag = unitOfWork.tag;
-          if (
-            0 === (unitOfWork.mode & 1) &&
-            (0 === tag || 11 === tag || 15 === tag)
-          ) {
-            var currentSource = unitOfWork.alternate;
-            currentSource
-              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
-                (unitOfWork.memoizedState = currentSource.memoizedState),
-                (unitOfWork.lanes = currentSource.lanes))
-              : ((unitOfWork.updateQueue = null),
-                (unitOfWork.memoizedState = null));
-          }
-          var suspenseBoundary = suspenseHandlerStackCursor.current;
-          if (null !== suspenseBoundary) {
-            switch (suspenseBoundary.tag) {
-              case 13:
-                unitOfWork.mode & 1 &&
-                  (null === shellBoundary
-                    ? renderDidSuspendDelayIfPossible()
-                    : null === suspenseBoundary.alternate &&
-                      0 === workInProgressRootExitStatus &&
-                      (workInProgressRootExitStatus = 3));
-                suspenseBoundary.flags &= -257;
-                markSuspenseBoundaryShouldCapture(
-                  suspenseBoundary,
-                  returnFiber,
-                  unitOfWork,
-                  root,
-                  thrownValue
-                );
-                var wakeables = suspenseBoundary.updateQueue;
-                null === wakeables
-                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
-                  : wakeables.add(wakeable);
-                break;
-              case 22:
-                if (suspenseBoundary.mode & 1) {
-                  suspenseBoundary.flags |= 65536;
-                  var offscreenQueue = suspenseBoundary.updateQueue;
-                  if (null === offscreenQueue) {
-                    var newOffscreenQueue = {
-                      transitions: null,
-                      markerInstances: null,
-                      wakeables: new Set([wakeable])
-                    };
-                    suspenseBoundary.updateQueue = newOffscreenQueue;
-                  } else {
-                    var wakeables$100 = offscreenQueue.wakeables;
-                    null === wakeables$100
-                      ? (offscreenQueue.wakeables = new Set([wakeable]))
-                      : wakeables$100.add(wakeable);
-                  }
-                  break;
-                }
-              default:
-                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
-            }
-            suspenseBoundary.mode & 1 &&
-              attachPingListener(root, wakeable, thrownValue);
-            break a;
-          } else if (1 === root.tag) {
-            attachPingListener(root, wakeable, thrownValue);
-            renderDidSuspendDelayIfPossible();
-            break a;
-          } else value = Error(formatProdErrorMessage(426));
-        } else if (
-          isHydrating &&
-          unitOfWork.mode & 1 &&
-          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
-        ) {
-          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
-          markSuspenseBoundaryShouldCapture(
-            wakeable,
-            returnFiber,
-            unitOfWork,
-            root,
-            thrownValue
-          );
-          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  if (isComposing)
+    return "compositionend" === domEventName ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+      ? ((domEventName = getData()),
+        (fallbackText = startText = root = null),
+        (isComposing = !1),
+        domEventName)
+      : null;
+  switch (domEventName) {
+    case "paste":
+      return null;
+    case "keypress":
+      if (
+        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
+        (nativeEvent.ctrlKey && nativeEvent.altKey)
+      ) {
+        if (nativeEvent.char && 1 < nativeEvent.char.length)
+          return nativeEvent.char;
+        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
+      }
+      return null;
+    case "compositionend":
+      return useFallbackCompositionData && "ko" !== nativeEvent.locale
+        ? null
+        : nativeEvent.data;
+    default:
+      return null;
+  }
+}
+var supportedInputTypes = {
+  color: !0,
+  date: !0,
+  datetime: !0,
+  "datetime-local": !0,
+  email: !0,
+  month: !0,
+  number: !0,
+  password: !0,
+  range: !0,
+  search: !0,
+  tel: !0,
+  text: !0,
+  time: !0,
+  url: !0,
+  week: !0
+};
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return "input" === nodeName
+    ? !!supportedInputTypes[elem.type]
+    : "textarea" === nodeName
+    ? !0
+    : !1;
+}
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
+) {
+  enqueueStateRestore(target);
+  inst = accumulateTwoPhaseListeners(inst, "onChange");
+  0 < inst.length &&
+    ((nativeEvent = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    )),
+    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+}
+var activeElement$1 = null,
+  activeElementInst$1 = null;
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
+  if (updateValueIfChanged(targetNode)) return targetInst;
+}
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if ("change" === domEventName) return targetInst;
+}
+var isInputEventSupported = !1;
+if (canUseDOM) {
+  var JSCompiler_inline_result$jscomp$292;
+  if (canUseDOM) {
+    var isSupported$jscomp$inline_1489 = "oninput" in document;
+    if (!isSupported$jscomp$inline_1489) {
+      var element$jscomp$inline_1490 = document.createElement("div");
+      element$jscomp$inline_1490.setAttribute("oninput", "return;");
+      isSupported$jscomp$inline_1489 =
+        "function" === typeof element$jscomp$inline_1490.oninput;
+    }
+    JSCompiler_inline_result$jscomp$292 = isSupported$jscomp$inline_1489;
+  } else JSCompiler_inline_result$jscomp$292 = !1;
+  isInputEventSupported =
+    JSCompiler_inline_result$jscomp$292 &&
+    (!document.documentMode || 9 < document.documentMode);
+}
+function stopWatchingForValueChange() {
+  activeElement$1 &&
+    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
+    (activeElementInst$1 = activeElement$1 = null));
+}
+function handlePropertyChange(nativeEvent) {
+  if (
+    "value" === nativeEvent.propertyName &&
+    getInstIfValueChanged(activeElementInst$1)
+  ) {
+    var dispatchQueue = [];
+    createAndAccumulateChangeEvent(
+      dispatchQueue,
+      activeElementInst$1,
+      nativeEvent,
+      getEventTarget(nativeEvent)
+    );
+    batchedUpdates(runEventInBatch, dispatchQueue);
+  }
+}
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  "focusin" === domEventName
+    ? (stopWatchingForValueChange(),
+      (activeElement$1 = target),
+      (activeElementInst$1 = targetInst),
+      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
+    : "focusout" === domEventName && stopWatchingForValueChange();
+}
+function getTargetInstForInputEventPolyfill(domEventName) {
+  if (
+    "selectionchange" === domEventName ||
+    "keyup" === domEventName ||
+    "keydown" === domEventName
+  )
+    return getInstIfValueChanged(activeElementInst$1);
+}
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
+}
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if ("input" === domEventName || "change" === domEventName)
+    return getInstIfValueChanged(targetInst);
+}
+function getLeafNode(node) {
+  for (; node && node.firstChild; ) node = node.firstChild;
+  return node;
+}
+function getNodeForCharacterOffset(root, offset) {
+  var node = getLeafNode(root);
+  root = 0;
+  for (var nodeEnd; node; ) {
+    if (3 === node.nodeType) {
+      nodeEnd = root + node.textContent.length;
+      if (root <= offset && nodeEnd >= offset)
+        return { node: node, offset: offset - root };
+      root = nodeEnd;
+    }
+    a: {
+      for (; node; ) {
+        if (node.nextSibling) {
+          node = node.nextSibling;
           break a;
         }
-        root = value = createCapturedValueAtFiber(value, unitOfWork);
-        4 !== workInProgressRootExitStatus &&
-          (workInProgressRootExitStatus = 2);
-        null === workInProgressRootConcurrentErrors
-          ? (workInProgressRootConcurrentErrors = [root])
-          : workInProgressRootConcurrentErrors.push(root);
-        root = returnFiber;
-        do {
-          switch (root.tag) {
-            case 3:
-              var errorInfo = value;
-              root.flags |= 65536;
-              thrownValue &= -thrownValue;
-              root.lanes |= thrownValue;
-              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
-              enqueueCapturedUpdate(root, update);
-              break a;
-            case 1:
-              currentSourceFiber = value;
-              var ctor = root.type,
-                instance = root.stateNode;
-              if (
-                0 === (root.flags & 128) &&
-                ("function" === typeof ctor.getDerivedStateFromError ||
-                  (null !== instance &&
-                    "function" === typeof instance.componentDidCatch &&
-                    (null === legacyErrorBoundariesThatAlreadyFailed ||
-                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
-              ) {
-                root.flags |= 65536;
-                update = thrownValue & -thrownValue;
-                root.lanes |= update;
-                errorInfo = createClassErrorUpdate(
-                  root,
-                  currentSourceFiber,
-                  update
-                );
-                enqueueCapturedUpdate(root, errorInfo);
-                break a;
-              }
-          }
-          root = root.return;
-        } while (null !== root);
+        node = node.parentNode;
       }
-    } catch (error) {
-      throw ((workInProgress = returnFiber), error);
+      node = void 0;
     }
-    completeUnitOfWork(unitOfWork);
+    node = getLeafNode(node);
   }
 }
-function completeUnitOfWork(unitOfWork) {
-  var completedWork = unitOfWork;
-  do {
-    var current = completedWork.alternate;
-    unitOfWork = completedWork.return;
-    if (0 === (completedWork.flags & 32768)) {
+function containsNode(outerNode, innerNode) {
+  return outerNode && innerNode
+    ? outerNode === innerNode
+      ? !0
+      : outerNode && 3 === outerNode.nodeType
+      ? !1
+      : innerNode && 3 === innerNode.nodeType
+      ? containsNode(outerNode, innerNode.parentNode)
+      : "contains" in outerNode
+      ? outerNode.contains(innerNode)
+      : outerNode.compareDocumentPosition
+      ? !!(outerNode.compareDocumentPosition(innerNode) & 16)
+      : !1
+    : !1;
+}
+function getActiveElementDeep() {
+  for (
+    var win = window, element = getActiveElement();
+    element instanceof win.HTMLIFrameElement;
+
+  ) {
+    try {
+      var JSCompiler_inline_result =
+        "string" === typeof element.contentWindow.location.href;
+    } catch (err) {
+      JSCompiler_inline_result = !1;
+    }
+    if (JSCompiler_inline_result) win = element.contentWindow;
+    else break;
+    element = getActiveElement(win.document);
+  }
+  return element;
+}
+function hasSelectionCapabilities(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName &&
+    (("input" === nodeName &&
+      ("text" === elem.type ||
+        "search" === elem.type ||
+        "tel" === elem.type ||
+        "url" === elem.type ||
+        "password" === elem.type)) ||
+      "textarea" === nodeName ||
+      "true" === elem.contentEditable)
+  );
+}
+function restoreSelection(priorSelectionInformation) {
+  var curFocusedElem = getActiveElementDeep(),
+    priorFocusedElem = priorSelectionInformation.focusedElem,
+    priorSelectionRange = priorSelectionInformation.selectionRange;
+  if (
+    curFocusedElem !== priorFocusedElem &&
+    priorFocusedElem &&
+    priorFocusedElem.ownerDocument &&
+    containsNode(
+      priorFocusedElem.ownerDocument.documentElement,
+      priorFocusedElem
+    )
+  ) {
+    if (
+      null !== priorSelectionRange &&
+      hasSelectionCapabilities(priorFocusedElem)
+    )
       if (
-        ((current = completeWork(current, completedWork, renderLanes)),
-        null !== current)
+        ((curFocusedElem = priorSelectionRange.start),
+        (priorSelectionInformation = priorSelectionRange.end),
+        void 0 === priorSelectionInformation &&
+          (priorSelectionInformation = curFocusedElem),
+        "selectionStart" in priorFocusedElem)
+      )
+        (priorFocusedElem.selectionStart = curFocusedElem),
+          (priorFocusedElem.selectionEnd = Math.min(
+            priorSelectionInformation,
+            priorFocusedElem.value.length
+          ));
+      else if (
+        ((priorSelectionInformation =
+          ((curFocusedElem = priorFocusedElem.ownerDocument || document) &&
+            curFocusedElem.defaultView) ||
+          window),
+        priorSelectionInformation.getSelection)
       ) {
-        workInProgress = current;
-        return;
-      }
-    } else {
-      current = unwindWork(current, completedWork);
-      if (null !== current) {
-        current.flags &= 16383;
-        workInProgress = current;
-        return;
-      }
-      if (null !== unitOfWork)
-        (unitOfWork.flags |= 32768),
-          (unitOfWork.subtreeFlags = 0),
-          (unitOfWork.deletions = null);
-      else {
-        workInProgressRootExitStatus = 6;
-        workInProgress = null;
-        return;
+        priorSelectionInformation = priorSelectionInformation.getSelection();
+        var length = priorFocusedElem.textContent.length,
+          start = Math.min(priorSelectionRange.start, length);
+        priorSelectionRange =
+          void 0 === priorSelectionRange.end
+            ? start
+            : Math.min(priorSelectionRange.end, length);
+        !priorSelectionInformation.extend &&
+          start > priorSelectionRange &&
+          ((length = priorSelectionRange),
+          (priorSelectionRange = start),
+          (start = length));
+        length = getNodeForCharacterOffset(priorFocusedElem, start);
+        var endMarker = getNodeForCharacterOffset(
+          priorFocusedElem,
+          priorSelectionRange
+        );
+        length &&
+          endMarker &&
+          (1 !== priorSelectionInformation.rangeCount ||
+            priorSelectionInformation.anchorNode !== length.node ||
+            priorSelectionInformation.anchorOffset !== length.offset ||
+            priorSelectionInformation.focusNode !== endMarker.node ||
+            priorSelectionInformation.focusOffset !== endMarker.offset) &&
+          ((curFocusedElem = curFocusedElem.createRange()),
+          curFocusedElem.setStart(length.node, length.offset),
+          priorSelectionInformation.removeAllRanges(),
+          start > priorSelectionRange
+            ? (priorSelectionInformation.addRange(curFocusedElem),
+              priorSelectionInformation.extend(
+                endMarker.node,
+                endMarker.offset
+              ))
+            : (curFocusedElem.setEnd(endMarker.node, endMarker.offset),
+              priorSelectionInformation.addRange(curFocusedElem)));
       }
-    }
-    completedWork = completedWork.sibling;
-    if (null !== completedWork) {
-      workInProgress = completedWork;
-      return;
-    }
-    workInProgress = completedWork = unitOfWork;
-  } while (null !== completedWork);
-  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
-}
-function commitRoot(root, recoverableErrors, transitions) {
-  var previousUpdateLanePriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig.transition;
-  try {
-    (ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      commitRootImpl(
-        root,
-        recoverableErrors,
-        transitions,
-        previousUpdateLanePriority
-      );
-  } finally {
-    (ReactCurrentBatchConfig.transition = prevTransition),
-      (currentUpdatePriority = previousUpdateLanePriority);
-  }
-  return null;
-}
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
-) {
-  do flushPassiveEffects();
-  while (null !== rootWithPendingPassiveEffects);
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var finishedWork = root.finishedWork,
-    lanes = root.finishedLanes;
-  if (null === finishedWork) return null;
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
-  root.callbackNode = null;
-  root.callbackPriority = 0;
-  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
-  remainingLanes |= concurrentlyUpdatedLanes;
-  markRootFinished(root, remainingLanes);
-  root === workInProgressRoot &&
-    ((workInProgress = workInProgressRoot = null),
-    (workInProgressRootRenderLanes = 0));
-  (0 === (finishedWork.subtreeFlags & 10256) &&
-    0 === (finishedWork.flags & 10256)) ||
-    rootDoesHavePassiveEffects ||
-    ((rootDoesHavePassiveEffects = !0),
-    (pendingPassiveEffectsRemainingLanes = remainingLanes),
-    (pendingPassiveTransitions = transitions),
-    scheduleCallback(NormalPriority$1, function () {
-      flushPassiveEffects();
-      return null;
-    }));
-  transitions = 0 !== (finishedWork.flags & 15990);
-  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
-    transitions = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    var prevExecutionContext = executionContext;
-    executionContext |= 4;
-    ReactCurrentOwner.current = null;
-    var shouldFireAfterActiveInstanceBlur$220 = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
-    commitMutationEffectsOnFiber(finishedWork, root);
-    shouldFireAfterActiveInstanceBlur$220 &&
-      ((_enabled = !0),
-      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
-      (_enabled = !1));
-    restoreSelection(selectionInformation);
-    _enabled = !!eventsEnabled;
-    selectionInformation = eventsEnabled = null;
-    root.current = finishedWork;
-    commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
-    requestPaint();
-    executionContext = prevExecutionContext;
-    currentUpdatePriority = previousPriority;
-    ReactCurrentBatchConfig.transition = transitions;
-  } else root.current = finishedWork;
-  rootDoesHavePassiveEffects
-    ? ((rootDoesHavePassiveEffects = !1),
-      (rootWithPendingPassiveEffects = root),
-      (pendingPassiveEffectsLanes = lanes))
-    : releaseRootPooledCache(root, remainingLanes);
-  remainingLanes = root.pendingLanes;
-  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
-  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
-  ensureRootIsScheduled(root, now());
-  if (null !== recoverableErrors)
+    curFocusedElem = [];
     for (
-      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
-      finishedWork < recoverableErrors.length;
-      finishedWork++
+      priorSelectionInformation = priorFocusedElem;
+      (priorSelectionInformation = priorSelectionInformation.parentNode);
+
     )
-      (lanes = recoverableErrors[finishedWork]),
-        (remainingLanes = {
-          digest: lanes.digest,
-          componentStack: lanes.stack
-        }),
-        renderPriorityLevel(lanes.value, remainingLanes);
-  if (hasUncaughtError)
-    throw (
-      ((hasUncaughtError = !1),
-      (root = firstUncaughtError),
-      (firstUncaughtError = null),
-      root)
-    );
-  0 !== (pendingPassiveEffectsLanes & 3) &&
-    0 !== root.tag &&
-    flushPassiveEffects();
-  remainingLanes = root.pendingLanes;
-  0 !== (remainingLanes & 3)
-    ? root === rootWithNestedUpdates
-      ? nestedUpdateCount++
-      : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root))
-    : (nestedUpdateCount = 0);
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    null !== prevRootTransitionCallbacks &&
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-        null !== prevPendingTransitionCallbacks
-          ? ((currentPendingTransitionCallbacks = null),
-            scheduleCallback(IdlePriority, function () {
-              processTransitionCallbacks(
-                prevPendingTransitionCallbacks,
-                endTime,
-                prevRootTransitionCallbacks
-              );
-            }))
-          : (currentEndTime = endTime);
-      });
+      1 === priorSelectionInformation.nodeType &&
+        curFocusedElem.push({
+          element: priorSelectionInformation,
+          left: priorSelectionInformation.scrollLeft,
+          top: priorSelectionInformation.scrollTop
+        });
+    "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
+    for (
+      priorFocusedElem = 0;
+      priorFocusedElem < curFocusedElem.length;
+      priorFocusedElem++
+    )
+      (priorSelectionInformation = curFocusedElem[priorFocusedElem]),
+        (priorSelectionInformation.element.scrollLeft =
+          priorSelectionInformation.left),
+        (priorSelectionInformation.element.scrollTop =
+          priorSelectionInformation.top);
   }
-  return null;
 }
-function releaseRootPooledCache(root, remainingLanes) {
-  0 === (root.pooledCacheLanes &= remainingLanes) &&
-    ((remainingLanes = root.pooledCache),
-    null != remainingLanes &&
-      ((root.pooledCache = null), releaseCache(remainingLanes)));
+var skipSelectionChangeEvent =
+    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
+  activeElement = null,
+  activeElementInst = null,
+  lastSelection = null,
+  mouseDown = !1;
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  var doc =
+    nativeEventTarget.window === nativeEventTarget
+      ? nativeEventTarget.document
+      : 9 === nativeEventTarget.nodeType
+      ? nativeEventTarget
+      : nativeEventTarget.ownerDocument;
+  mouseDown ||
+    null == activeElement ||
+    activeElement !== getActiveElement(doc) ||
+    ((doc = activeElement),
+    "selectionStart" in doc && hasSelectionCapabilities(doc)
+      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
+      : ((doc = (
+          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
+          window
+        ).getSelection()),
+        (doc = {
+          anchorNode: doc.anchorNode,
+          anchorOffset: doc.anchorOffset,
+          focusNode: doc.focusNode,
+          focusOffset: doc.focusOffset
+        })),
+    (lastSelection && shallowEqual(lastSelection, doc)) ||
+      ((lastSelection = doc),
+      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
+      0 < doc.length &&
+        ((nativeEvent = new SyntheticEvent(
+          "onSelect",
+          "select",
+          null,
+          nativeEvent,
+          nativeEventTarget
+        )),
+        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
+        (nativeEvent.target = activeElement))));
+}
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
+}
+var vendorPrefixes = {
+    animationend: makePrefixMap("Animation", "AnimationEnd"),
+    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+    animationstart: makePrefixMap("Animation", "AnimationStart"),
+    transitionend: makePrefixMap("Transition", "TransitionEnd")
+  },
+  prefixedEventNames = {},
+  style = {};
+canUseDOM &&
+  ((style = document.createElement("div").style),
+  "AnimationEvent" in window ||
+    (delete vendorPrefixes.animationend.animation,
+    delete vendorPrefixes.animationiteration.animation,
+    delete vendorPrefixes.animationstart.animation),
+  "TransitionEvent" in window ||
+    delete vendorPrefixes.transitionend.transition);
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
+  if (!vendorPrefixes[eventName]) return eventName;
+  var prefixMap = vendorPrefixes[eventName],
+    styleProp;
+  for (styleProp in prefixMap)
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
+  return eventName;
 }
-function flushPassiveEffects() {
-  if (null !== rootWithPendingPassiveEffects) {
-    var root$221 = rootWithPendingPassiveEffects,
-      remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = 0;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    renderPriority = 32 > renderPriority ? 32 : renderPriority;
-    var prevTransition = ReactCurrentBatchConfig.transition,
-      previousPriority = currentUpdatePriority;
-    try {
-      return (
-        (ReactCurrentBatchConfig.transition = null),
-        (currentUpdatePriority = renderPriority),
-        flushPassiveEffectsImpl()
-      );
-    } finally {
-      (currentUpdatePriority = previousPriority),
-        (ReactCurrentBatchConfig.transition = prevTransition),
-        releaseRootPooledCache(root$221, remainingLanes);
-    }
-  }
-  return !1;
+var ANIMATION_END = getVendorPrefixedEventName("animationend"),
+  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
+  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
+  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
+  topLevelEventsToReactNames = new Map(),
+  simpleEventPluginEvents =
+    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
+      " "
+    );
+topLevelEventsToReactNames.set("beforeblur", null);
+topLevelEventsToReactNames.set("afterblur", null);
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
 }
-function flushPassiveEffectsImpl() {
-  if (null === rootWithPendingPassiveEffects) return !1;
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects,
-    lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null;
-  pendingPassiveEffectsLanes = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
-  var prevExecutionContext = executionContext;
-  executionContext |= 4;
-  commitPassiveUnmountOnFiber(root.current);
-  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
-      prevRootTransitionCallbacks = root.transitionCallbacks,
-      prevEndTime = currentEndTime;
-    null !== prevPendingTransitionCallbacks &&
-      null !== prevRootTransitionCallbacks &&
-      null !== prevEndTime &&
-      ((currentEndTime = currentPendingTransitionCallbacks = null),
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
-        );
-      }));
-  }
-  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
-    try {
-      injectedHook.onPostCommitFiberRoot(rendererID, root);
-    } catch (err) {}
-  return !0;
+for (
+  var i$jscomp$inline_1530 = 0;
+  i$jscomp$inline_1530 < simpleEventPluginEvents.length;
+  i$jscomp$inline_1530++
+) {
+  var eventName$jscomp$inline_1531 =
+      simpleEventPluginEvents[i$jscomp$inline_1530],
+    domEventName$jscomp$inline_1532 =
+      eventName$jscomp$inline_1531.toLowerCase(),
+    capitalizedEvent$jscomp$inline_1533 =
+      eventName$jscomp$inline_1531[0].toUpperCase() +
+      eventName$jscomp$inline_1531.slice(1);
+  registerSimpleEvent(
+    domEventName$jscomp$inline_1532,
+    "on" + capitalizedEvent$jscomp$inline_1533
+  );
 }
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
-  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
-  sourceFiber = requestEventTime();
-  null !== rootFiber &&
-    (markRootUpdated(rootFiber, 2, sourceFiber),
-    ensureRootIsScheduled(rootFiber, sourceFiber));
+registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+registerSimpleEvent("dblclick", "onDoubleClick");
+registerSimpleEvent("focusin", "onFocus");
+registerSimpleEvent("focusout", "onBlur");
+registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+registerTwoPhaseEvent(
+  "onChange",
+  "change click focusin focusout input keydown keyup selectionchange".split(" ")
+);
+registerTwoPhaseEvent(
+  "onSelect",
+  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
+    " "
+  )
+);
+registerTwoPhaseEvent("onBeforeInput", [
+  "compositionend",
+  "keypress",
+  "textInput",
+  "paste"
+]);
+registerTwoPhaseEvent(
+  "onCompositionEnd",
+  "compositionend focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionStart",
+  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionUpdate",
+  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
+);
+var mediaEventTypes =
+    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
+      " "
+    ),
+  nonDelegatedEvents = new Set(
+    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
+  );
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+  event.currentTarget = null;
 }
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
-  if (3 === sourceFiber.tag)
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
-  else
-    for (
-      nearestMountedAncestor = skipUnmountedBoundaries
-        ? nearestMountedAncestor
-        : sourceFiber.return;
-      null !== nearestMountedAncestor;
-
-    ) {
-      if (3 === nearestMountedAncestor.tag) {
-        captureCommitPhaseErrorOnRoot(
-          nearestMountedAncestor,
-          sourceFiber,
-          error
-        );
-        break;
-      } else if (1 === nearestMountedAncestor.tag) {
-        var instance = nearestMountedAncestor.stateNode;
-        if (
-          "function" ===
-            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
-          ("function" === typeof instance.componentDidCatch &&
-            (null === legacyErrorBoundariesThatAlreadyFailed ||
-              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  eventSystemFlags = 0 !== (eventSystemFlags & 4);
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event;
+    _dispatchQueue$i = _dispatchQueue$i.listeners;
+    a: {
+      var previousInstance = void 0;
+      if (eventSystemFlags)
+        for (
+          var i$jscomp$0 = _dispatchQueue$i.length - 1;
+          0 <= i$jscomp$0;
+          i$jscomp$0--
         ) {
-          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-          sourceFiber = createClassErrorUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          nearestMountedAncestor = enqueueUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          sourceFiber = requestEventTime();
-          null !== nearestMountedAncestor &&
-            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
-            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
-          break;
+          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
+        }
+      else
+        for (
+          i$jscomp$0 = 0;
+          i$jscomp$0 < _dispatchQueue$i.length;
+          i$jscomp$0++
+        ) {
+          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
+          instance = _dispatchListeners$i.instance;
+          currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
         }
-      }
-      nearestMountedAncestor = nearestMountedAncestor.return;
     }
+  }
+  if (hasRethrowError)
+    throw (
+      ((dispatchQueue = rethrowError),
+      (hasRethrowError = !1),
+      (rethrowError = null),
+      dispatchQueue)
+    );
 }
-function attachPingListener(root, wakeable, lanes) {
-  var pingCache = root.pingCache;
-  if (null === pingCache) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    var threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else
-    (threadIDs = pingCache.get(wakeable)),
-      void 0 === threadIDs &&
-        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
-  threadIDs.has(lanes) ||
-    ((workInProgressRootDidAttachPingListener = !0),
-    threadIDs.add(lanes),
-    (root = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
-    wakeable.then(root, root));
-}
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
-  null !== pingCache && pingCache.delete(wakeable);
-  wakeable = requestEventTime();
-  root.pingedLanes |= root.suspendedLanes & pingedLanes;
-  workInProgressRoot === root &&
-    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
-    (4 === workInProgressRootExitStatus ||
-    (3 === workInProgressRootExitStatus &&
-      (workInProgressRootRenderLanes & 125829120) ===
-        workInProgressRootRenderLanes &&
-      500 > now() - globalMostRecentFallbackTime)
-      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
-      : (workInProgressRootPingedLanes |= pingedLanes));
-  ensureRootIsScheduled(root, wakeable);
-}
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  0 === retryLane &&
-    (0 === (boundaryFiber.mode & 1)
-      ? (retryLane = 2)
-      : ((retryLane = nextRetryLane),
-        (nextRetryLane <<= 1),
-        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
-  var eventTime = requestEventTime();
-  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
-  null !== boundaryFiber &&
-    (markRootUpdated(boundaryFiber, retryLane, eventTime),
-    ensureRootIsScheduled(boundaryFiber, eventTime));
-}
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState,
-    retryLane = 0;
-  null !== suspenseState && (retryLane = suspenseState.retryLane);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+  var listenerSet = getEventListenerSet(targetElement),
+    listenerSetKey = domEventName + "__bubble";
+  listenerSet.has(listenerSetKey) ||
+    (addTrappedEventListener(targetElement, domEventName, 2, !1),
+    listenerSet.add(listenerSetKey));
 }
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = 0;
-  switch (boundaryFiber.tag) {
-    case 13:
-      var retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
-      null !== suspenseState && (retryLane = suspenseState.retryLane);
-      break;
-    case 19:
-      retryCache = boundaryFiber.stateNode;
-      break;
-    case 22:
-      retryCache = boundaryFiber.stateNode._retryCache;
-      break;
-    default:
-      throw Error(formatProdErrorMessage(314));
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+  var eventSystemFlags = 0;
+  isCapturePhaseListener && (eventSystemFlags |= 4);
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
+}
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = !0;
+    allNativeEvents.forEach(function (domEventName) {
+      "selectionchange" !== domEventName &&
+        (nonDelegatedEvents.has(domEventName) ||
+          listenToNativeEvent(domEventName, !1, rootContainerElement),
+        listenToNativeEvent(domEventName, !0, rootContainerElement));
+    });
+    var ownerDocument =
+      9 === rootContainerElement.nodeType
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
+    null === ownerDocument ||
+      ownerDocument[listeningMarker] ||
+      ((ownerDocument[listeningMarker] = !0),
+      listenToNativeEvent("selectionchange", !1, ownerDocument));
   }
-  null !== retryCache && retryCache.delete(wakeable);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
 }
-var beginWork;
-beginWork = function (current, workInProgress, renderLanes) {
-  if (null !== current)
-    if (current.memoizedProps !== workInProgress.pendingProps)
-      didReceiveUpdate = !0;
-    else {
-      if (
-        !checkScheduledUpdateOrContext(current, renderLanes) &&
-        0 === (workInProgress.flags & 128)
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  eventSystemFlags = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  );
+  var isPassiveListener = void 0;
+  !passiveBrowserEventsSupported ||
+    ("touchstart" !== domEventName &&
+      "touchmove" !== domEventName &&
+      "wheel" !== domEventName) ||
+    (isPassiveListener = !0);
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = eventSystemFlags;
+    eventSystemFlags = function () {
+      targetContainer.removeEventListener(
+        domEventName,
+        unsubscribeListener,
+        isCapturePhaseListener
+      );
+      for (
+        var _len = arguments.length, p = Array(_len), _key = 0;
+        _key < _len;
+        _key++
       )
-        return (
-          (didReceiveUpdate = !1),
-          attemptEarlyBailoutIfNoScheduledUpdate(
-            current,
-            workInProgress,
-            renderLanes
+        p[_key] = arguments[_key];
+      return originalListener.apply(this, p);
+    };
+  }
+  var unsubscribeListener = isCapturePhaseListener
+    ? void 0 !== isPassiveListener
+      ? addEventCaptureListenerWithPassiveFlag(
+          targetContainer,
+          domEventName,
+          eventSystemFlags,
+          isPassiveListener
+        )
+      : addEventCaptureListener(targetContainer, domEventName, eventSystemFlags)
+    : void 0 !== isPassiveListener
+    ? addEventBubbleListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        eventSystemFlags,
+        isPassiveListener
+      )
+    : addEventBubbleListener(targetContainer, domEventName, eventSystemFlags);
+}
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst$jscomp$0,
+  targetContainer
+) {
+  var ancestorInst = targetInst$jscomp$0;
+  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+    if (
+      enableLegacyFBSupport &&
+      "click" === domEventName &&
+      0 === (eventSystemFlags & 20) &&
+      nativeEvent !== currentReplayingEvent
+    ) {
+      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
+      return;
+    }
+    if (null !== targetInst$jscomp$0)
+      a: for (;;) {
+        if (null === targetInst$jscomp$0) return;
+        var nodeTag = targetInst$jscomp$0.tag;
+        if (3 === nodeTag || 4 === nodeTag) {
+          var container = targetInst$jscomp$0.stateNode.containerInfo;
+          if (
+            container === targetContainer ||
+            (8 === container.nodeType &&
+              container.parentNode === targetContainer)
           )
-        );
-      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+            break;
+          if (4 === nodeTag)
+            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
+              var grandTag = nodeTag.tag;
+              if (3 === grandTag || 4 === grandTag)
+                if (
+                  ((grandTag = nodeTag.stateNode.containerInfo),
+                  grandTag === targetContainer ||
+                    (8 === grandTag.nodeType &&
+                      grandTag.parentNode === targetContainer))
+                )
+                  return;
+              nodeTag = nodeTag.return;
+            }
+          for (; null !== container; ) {
+            nodeTag = getClosestInstanceFromNode(container);
+            if (null === nodeTag) return;
+            grandTag = nodeTag.tag;
+            if (
+              5 === grandTag ||
+              6 === grandTag ||
+              26 === grandTag ||
+              27 === grandTag
+            ) {
+              targetInst$jscomp$0 = ancestorInst = nodeTag;
+              continue a;
+            }
+            container = container.parentNode;
+          }
+        }
+        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+      }
+  }
+  batchedUpdates(function () {
+    var targetInst = ancestorInst,
+      nativeEventTarget = getEventTarget(nativeEvent),
+      dispatchQueue = [];
+    a: {
+      var reactName = topLevelEventsToReactNames.get(domEventName);
+      if (void 0 !== reactName) {
+        var SyntheticEventCtor = SyntheticEvent,
+          reactEventType = domEventName;
+        switch (domEventName) {
+          case "keypress":
+            if (0 === getEventCharCode(nativeEvent)) break a;
+          case "keydown":
+          case "keyup":
+            SyntheticEventCtor = SyntheticKeyboardEvent;
+            break;
+          case "focusin":
+            reactEventType = "focus";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "focusout":
+            reactEventType = "blur";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "beforeblur":
+          case "afterblur":
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "click":
+            if (2 === nativeEvent.button) break a;
+          case "auxclick":
+          case "dblclick":
+          case "mousedown":
+          case "mousemove":
+          case "mouseup":
+          case "mouseout":
+          case "mouseover":
+          case "contextmenu":
+            SyntheticEventCtor = SyntheticMouseEvent;
+            break;
+          case "drag":
+          case "dragend":
+          case "dragenter":
+          case "dragexit":
+          case "dragleave":
+          case "dragover":
+          case "dragstart":
+          case "drop":
+            SyntheticEventCtor = SyntheticDragEvent;
+            break;
+          case "touchcancel":
+          case "touchend":
+          case "touchmove":
+          case "touchstart":
+            SyntheticEventCtor = SyntheticTouchEvent;
+            break;
+          case ANIMATION_END:
+          case ANIMATION_ITERATION:
+          case ANIMATION_START:
+            SyntheticEventCtor = SyntheticAnimationEvent;
+            break;
+          case TRANSITION_END:
+            SyntheticEventCtor = SyntheticTransitionEvent;
+            break;
+          case "scroll":
+            SyntheticEventCtor = SyntheticUIEvent;
+            break;
+          case "wheel":
+            SyntheticEventCtor = SyntheticWheelEvent;
+            break;
+          case "copy":
+          case "cut":
+          case "paste":
+            SyntheticEventCtor = SyntheticClipboardEvent;
+            break;
+          case "gotpointercapture":
+          case "lostpointercapture":
+          case "pointercancel":
+          case "pointerdown":
+          case "pointermove":
+          case "pointerout":
+          case "pointerover":
+          case "pointerup":
+            SyntheticEventCtor = SyntheticPointerEvent;
+        }
+        var inCapturePhase = 0 !== (eventSystemFlags & 4);
+        eventSystemFlags & 1
+          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
+              reactEventType,
+              targetContainer,
+              inCapturePhase
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })))
+          : ((inCapturePhase = accumulateSinglePhaseListeners(
+              targetInst,
+              reactName,
+              nativeEvent.type,
+              inCapturePhase,
+              !inCapturePhase && "scroll" === domEventName,
+              nativeEvent
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })));
+      }
     }
-  else
-    (didReceiveUpdate = !1),
-      isHydrating &&
-        0 !== (workInProgress.flags & 1048576) &&
-        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
-  workInProgress.lanes = 0;
-  switch (workInProgress.tag) {
-    case 2:
-      var Component = workInProgress.type;
-      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-      current = workInProgress.pendingProps;
-      prepareToReadContext(workInProgress, renderLanes);
-      current = renderWithHooks(
-        null,
-        workInProgress,
-        Component,
-        current,
-        void 0,
-        renderLanes
-      );
-      Component = checkDidRenderIdHook();
-      workInProgress.flags |= 1;
-      workInProgress.tag = 0;
-      isHydrating && Component && pushMaterializedTreeId(workInProgress);
-      reconcileChildren(null, workInProgress, current, renderLanes);
-      workInProgress = workInProgress.child;
-      return workInProgress;
-    case 16:
-      Component = workInProgress.elementType;
+    if (0 === (eventSystemFlags & 7)) {
       a: {
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-        current = workInProgress.pendingProps;
-        var init = Component._init;
-        Component = init(Component._payload);
-        workInProgress.type = Component;
-        init = workInProgress.tag = resolveLazyComponentTag(Component);
-        current = resolveDefaultProps(Component, current);
-        switch (init) {
-          case 0:
-            workInProgress = updateFunctionComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 1:
-            workInProgress = updateClassComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 11:
-            workInProgress = updateForwardRef(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 14:
-            workInProgress = updateMemoComponent(
-              null,
-              workInProgress,
-              Component,
-              resolveDefaultProps(Component.type, current),
-              renderLanes
+        reactName =
+          "mouseover" === domEventName || "pointerover" === domEventName;
+        SyntheticEventCtor =
+          "mouseout" === domEventName || "pointerout" === domEventName;
+        if (
+          reactName &&
+          nativeEvent !== currentReplayingEvent &&
+          (reactEventType =
+            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
+          (getClosestInstanceFromNode(reactEventType) ||
+            reactEventType[internalContainerInstanceKey])
+        )
+          break a;
+        if (SyntheticEventCtor || reactName) {
+          reactName =
+            nativeEventTarget.window === nativeEventTarget
+              ? nativeEventTarget
+              : (reactName = nativeEventTarget.ownerDocument)
+              ? reactName.defaultView || reactName.parentWindow
+              : window;
+          if (SyntheticEventCtor) {
+            if (
+              ((reactEventType =
+                nativeEvent.relatedTarget || nativeEvent.toElement),
+              (SyntheticEventCtor = targetInst),
+              (reactEventType = reactEventType
+                ? getClosestInstanceFromNode(reactEventType)
+                : null),
+              null !== reactEventType)
+            ) {
+              inCapturePhase = getNearestMountedFiber(reactEventType);
+              var tag = reactEventType.tag;
+              if (
+                reactEventType !== inCapturePhase ||
+                (5 !== tag && 27 !== tag && 6 !== tag)
+              )
+                reactEventType = null;
+            }
+          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
+          if (SyntheticEventCtor !== reactEventType) {
+            tag = SyntheticMouseEvent;
+            var leaveEventType = "onMouseLeave",
+              enterEventType = "onMouseEnter",
+              eventTypePrefix = "mouse";
+            if ("pointerout" === domEventName || "pointerover" === domEventName)
+              (tag = SyntheticPointerEvent),
+                (leaveEventType = "onPointerLeave"),
+                (enterEventType = "onPointerEnter"),
+                (eventTypePrefix = "pointer");
+            inCapturePhase =
+              null == SyntheticEventCtor
+                ? reactName
+                : getNodeFromInstance(SyntheticEventCtor);
+            var toNode =
+              null == reactEventType
+                ? reactName
+                : getNodeFromInstance(reactEventType);
+            reactName = new tag(
+              leaveEventType,
+              eventTypePrefix + "leave",
+              SyntheticEventCtor,
+              nativeEvent,
+              nativeEventTarget
             );
-            break a;
+            reactName.target = inCapturePhase;
+            reactName.relatedTarget = toNode;
+            leaveEventType = null;
+            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
+              ((tag = new tag(
+                enterEventType,
+                eventTypePrefix + "enter",
+                reactEventType,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              (tag.target = toNode),
+              (tag.relatedTarget = inCapturePhase),
+              (leaveEventType = tag));
+            inCapturePhase = leaveEventType;
+            if (SyntheticEventCtor && reactEventType)
+              b: {
+                tag = SyntheticEventCtor;
+                enterEventType = reactEventType;
+                eventTypePrefix = 0;
+                for (toNode = tag; toNode; toNode = getParent(toNode))
+                  eventTypePrefix++;
+                toNode = 0;
+                for (
+                  leaveEventType = enterEventType;
+                  leaveEventType;
+                  leaveEventType = getParent(leaveEventType)
+                )
+                  toNode++;
+                for (; 0 < eventTypePrefix - toNode; )
+                  (tag = getParent(tag)), eventTypePrefix--;
+                for (; 0 < toNode - eventTypePrefix; )
+                  (enterEventType = getParent(enterEventType)), toNode--;
+                for (; eventTypePrefix--; ) {
+                  if (
+                    tag === enterEventType ||
+                    (null !== enterEventType &&
+                      tag === enterEventType.alternate)
+                  )
+                    break b;
+                  tag = getParent(tag);
+                  enterEventType = getParent(enterEventType);
+                }
+                tag = null;
+              }
+            else tag = null;
+            null !== SyntheticEventCtor &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                reactName,
+                SyntheticEventCtor,
+                tag,
+                !1
+              );
+            null !== reactEventType &&
+              null !== inCapturePhase &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                inCapturePhase,
+                reactEventType,
+                tag,
+                !0
+              );
+          }
         }
-        throw Error(formatProdErrorMessage(306, Component, ""));
       }
-      return workInProgress;
-    case 0:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateFunctionComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 1:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateClassComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 3:
       a: {
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
-        );
-        if (null === current) throw Error(formatProdErrorMessage(387));
-        Component = workInProgress.pendingProps;
-        var prevState = workInProgress.memoizedState;
-        init = prevState.element;
-        cloneUpdateQueue(current, workInProgress);
-        processUpdateQueue(workInProgress, Component, null, renderLanes);
-        var nextState = workInProgress.memoizedState,
-          root = workInProgress.stateNode;
-        enableTransitionTracing &&
-          push(transitionStack, workInProgressTransitions);
-        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-        Component = nextState.cache;
-        pushProvider(workInProgress, CacheContext, Component);
-        Component !== prevState.cache &&
-          propagateContextChange(workInProgress, CacheContext, renderLanes);
-        Component = nextState.element;
-        if (prevState.isDehydrated)
-          if (
-            ((prevState = {
-              element: Component,
-              isDehydrated: !1,
-              cache: nextState.cache
-            }),
-            (workInProgress.updateQueue.baseState = prevState),
-            (workInProgress.memoizedState = prevState),
-            workInProgress.flags & 256)
-          ) {
-            init = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(423)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              init
-            );
-            break a;
-          } else if (Component !== init) {
-            init = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(424)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              init
-            );
-            break a;
-          } else {
-            nextHydratableInstance = getNextHydratable(
-              workInProgress.stateNode.containerInfo.firstChild
-            );
-            hydrationParentFiber = workInProgress;
-            isHydrating = !0;
-            hydrationErrors = null;
-            rootOrSingletonContext = !0;
-            current = root.mutableSourceEagerHydrationData;
-            if (null != current)
-              for (init = 0; init < current.length; init += 2)
-                (prevState = current[init]),
-                  (prevState._workInProgressVersionPrimary = current[init + 1]),
-                  workInProgressSources.push(prevState);
-            renderLanes = mountChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            );
-            for (workInProgress.child = renderLanes; renderLanes; )
-              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
-                (renderLanes = renderLanes.sibling);
-          }
-        else {
-          resetHydrationState();
-          if (Component === init) {
-            workInProgress = bailoutOnAlreadyFinishedWork(
-              current,
-              workInProgress,
-              renderLanes
-            );
-            break a;
+        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
+        SyntheticEventCtor =
+          reactName.nodeName && reactName.nodeName.toLowerCase();
+        if (
+          "select" === SyntheticEventCtor ||
+          ("input" === SyntheticEventCtor && "file" === reactName.type)
+        )
+          var getTargetInstFunc = getTargetInstForChangeEvent;
+        else if (isTextInputElement(reactName))
+          if (isInputEventSupported)
+            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+          else {
+            getTargetInstFunc = getTargetInstForInputEventPolyfill;
+            var handleEventFunc = handleEventsForInputEventPolyfill;
           }
-          reconcileChildren(current, workInProgress, Component, renderLanes);
+        else
+          (SyntheticEventCtor = reactName.nodeName),
+            !SyntheticEventCtor ||
+            "input" !== SyntheticEventCtor.toLowerCase() ||
+            ("checkbox" !== reactName.type && "radio" !== reactName.type)
+              ? enableCustomElementPropertySupport &&
+                targetInst &&
+                isCustomComponent(
+                  targetInst.elementType,
+                  targetInst.memoizedProps
+                ) &&
+                (getTargetInstFunc = getTargetInstForChangeEvent)
+              : (getTargetInstFunc = getTargetInstForClickEvent);
+        if (
+          getTargetInstFunc &&
+          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
+        ) {
+          createAndAccumulateChangeEvent(
+            dispatchQueue,
+            getTargetInstFunc,
+            nativeEvent,
+            nativeEventTarget
+          );
+          break a;
         }
-        workInProgress = workInProgress.child;
+        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
+        "focusout" === domEventName &&
+          (handleEventFunc = reactName._wrapperState) &&
+          handleEventFunc.controlled &&
+          "number" === reactName.type &&
+          (disableInputAttributeSyncing ||
+            setDefaultValue(reactName, "number", reactName.value));
       }
-      return workInProgress;
-    case 26:
-      return (
-        markRef$1(current, workInProgress),
-        (renderLanes = workInProgress.memoizedState =
-          getResource(
-            workInProgress.type,
-            null === current ? null : current.memoizedProps,
-            workInProgress.pendingProps
-          )),
-        null !== current ||
-          isHydrating ||
-          null !== renderLanes ||
-          ((renderLanes = workInProgress.type),
-          (current = workInProgress.pendingProps),
-          (Component = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
+      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
+      switch (domEventName) {
+        case "focusin":
+          if (
+            isTextInputElement(handleEventFunc) ||
+            "true" === handleEventFunc.contentEditable
+          )
+            (activeElement = handleEventFunc),
+              (activeElementInst = targetInst),
+              (lastSelection = null);
+          break;
+        case "focusout":
+          lastSelection = activeElementInst = activeElement = null;
+          break;
+        case "mousedown":
+          mouseDown = !0;
+          break;
+        case "contextmenu":
+        case "mouseup":
+        case "dragend":
+          mouseDown = !1;
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+          break;
+        case "selectionchange":
+          if (skipSelectionChangeEvent) break;
+        case "keydown":
+        case "keyup":
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      }
+      var fallbackData;
+      if (canUseCompositionEvent)
+        b: {
+          switch (domEventName) {
+            case "compositionstart":
+              var eventType = "onCompositionStart";
+              break b;
+            case "compositionend":
+              eventType = "onCompositionEnd";
+              break b;
+            case "compositionupdate":
+              eventType = "onCompositionUpdate";
+              break b;
+          }
+          eventType = void 0;
+        }
+      else
+        isComposing
+          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
+            (eventType = "onCompositionEnd")
+          : "keydown" === domEventName &&
+            229 === nativeEvent.keyCode &&
+            (eventType = "onCompositionStart");
+      eventType &&
+        (useFallbackCompositionData &&
+          "ko" !== nativeEvent.locale &&
+          (isComposing || "onCompositionStart" !== eventType
+            ? "onCompositionEnd" === eventType &&
+              isComposing &&
+              (fallbackData = getData())
+            : ((root = nativeEventTarget),
+              (startText = "value" in root ? root.value : root.textContent),
+              (isComposing = !0))),
+        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
+        0 < handleEventFunc.length &&
+          ((eventType = new SyntheticCompositionEvent(
+            eventType,
+            domEventName,
+            null,
+            nativeEvent,
+            nativeEventTarget
           )),
-          (Component = createHTMLElement(renderLanes, current, Component)),
-          (Component[internalInstanceKey] = workInProgress),
-          (Component[internalPropsKey] = current),
-          setInitialProperties(Component, renderLanes, current),
-          markNodeAsHoistable(Component),
-          (workInProgress.stateNode = Component)),
-        null
-      );
-    case 27:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          ((Component = workInProgress.stateNode =
-            resolveSingletonInstance(
-              workInProgress.type,
-              workInProgress.pendingProps,
-              rootInstanceStackCursor.current
-            )),
-          (hydrationParentFiber = workInProgress),
-          (rootOrSingletonContext = !0),
-          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
-        (Component = workInProgress.pendingProps.children),
-        null !== current || isHydrating
-          ? reconcileChildren(current, workInProgress, Component, renderLanes)
-          : (workInProgress.child = reconcileChildFibers(
-              workInProgress,
+          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
+          fallbackData
+            ? (eventType.data = fallbackData)
+            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
+              null !== fallbackData && (eventType.data = fallbackData))));
+      if (
+        (fallbackData = canUseTextInputEvent
+          ? getNativeBeforeInputChars(domEventName, nativeEvent)
+          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+      )
+        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
+          0 < targetInst.length &&
+            ((nativeEventTarget = new SyntheticCompositionEvent(
+              "onBeforeInput",
+              "beforeinput",
               null,
-              Component,
-              renderLanes
+              nativeEvent,
+              nativeEventTarget
             )),
-        markRef$1(current, workInProgress),
-        workInProgress.child
-      );
-    case 5:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          (((Component = workInProgress.pendingProps),
-          "script" === workInProgress.type
-            ? ((init = Component.onLoad),
-              (prevState = Component.onError),
-              (Component = !(Component.async && (init || prevState))))
-            : (Component = !0),
-          Component)
-            ? ((Component = nextHydratableInstance),
-              rootOrSingletonContext &&
-                advanceToFirstAttemptableInstance(workInProgress),
-              (init = nextHydratableInstance),
-              init)
-              ? tryHydrateInstance(workInProgress, init) ||
-                (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                (nextHydratableInstance = getNextHydratable(init.nextSibling)),
-                (prevState = hydrationParentFiber),
-                rootOrSingletonContext &&
-                  advanceToFirstAttemptableInstance(workInProgress),
-                nextHydratableInstance &&
-                tryHydrateInstance(workInProgress, nextHydratableInstance)
-                  ? deleteHydratableInstance(prevState, init)
-                  : (insertNonHydratedInstance(
-                      hydrationParentFiber,
-                      workInProgress
-                    ),
-                    (isHydrating = !1),
-                    (hydrationParentFiber = workInProgress),
-                    (nextHydratableInstance = Component)))
-              : (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = Component))
-            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress))),
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (prevState = null !== current ? current.memoizedProps : null),
-        (root = init.children),
-        shouldSetTextContent(Component, init)
-          ? (root = null)
-          : null !== prevState &&
-            shouldSetTextContent(Component, prevState) &&
-            (workInProgress.flags |= 32),
-        markRef$1(current, workInProgress),
-        reconcileChildren(current, workInProgress, root, renderLanes),
-        workInProgress.child
-      );
-    case 6:
-      return (
-        null === current &&
-          isHydrating &&
-          (((renderLanes = "" !== workInProgress.pendingProps),
-          (current = nextHydratableInstance),
-          rootOrSingletonContext &&
-            renderLanes &&
-            advanceToFirstAttemptableTextInstance(),
-          (Component = nextHydratableInstance),
-          Component && renderLanes)
-            ? tryHydrateText(workInProgress, Component) ||
-              (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              (nextHydratableInstance = getNextHydratable(
-                Component.nextSibling
-              )),
-              (init = hydrationParentFiber),
-              rootOrSingletonContext &&
-                renderLanes &&
-                advanceToFirstAttemptableTextInstance(),
-              nextHydratableInstance &&
-              tryHydrateText(workInProgress, nextHydratableInstance)
-                ? deleteHydratableInstance(init, Component)
-                : (insertNonHydratedInstance(
-                    hydrationParentFiber,
-                    workInProgress
-                  ),
-                  (isHydrating = !1),
-                  (hydrationParentFiber = workInProgress),
-                  (nextHydratableInstance = current)))
-            : (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress),
-              (nextHydratableInstance = current))),
-        null
-      );
-    case 13:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
-    case 4:
-      return (
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
-        ),
-        (Component = workInProgress.pendingProps),
-        null === current
-          ? (workInProgress.child = reconcileChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            ))
-          : reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 11:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateForwardRef(current, workInProgress, Component, init, renderLanes)
-      );
-    case 7:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 8:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 12:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 10:
-      a: {
-        Component = workInProgress.type._context;
-        init = workInProgress.pendingProps;
-        prevState = workInProgress.memoizedProps;
-        root = init.value;
-        pushProvider(workInProgress, Component, root);
-        if (!enableLazyContextPropagation && null !== prevState)
-          if (objectIs(prevState.value, root)) {
-            if (prevState.children === init.children) {
-              workInProgress = bailoutOnAlreadyFinishedWork(
-                current,
-                workInProgress,
-                renderLanes
+            dispatchQueue.push({
+              event: nativeEventTarget,
+              listeners: targetInst
+            }),
+            (nativeEventTarget.data = fallbackData));
+    }
+    processDispatchQueue(dispatchQueue, eventSystemFlags);
+  });
+}
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  reactName = inCapturePhase
+    ? null !== reactName
+      ? reactName + "Capture"
+      : null
+    : reactName;
+  for (
+    var listeners = [], instance = targetFiber, lastHostComponent = null;
+    null !== instance;
+
+  ) {
+    var _instance = instance;
+    targetFiber = _instance.stateNode;
+    _instance = _instance.tag;
+    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
+    null === targetFiber
+      ? 21 === _instance &&
+        null !== lastHostComponent &&
+        null !== targetFiber &&
+        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
               );
-              break a;
-            }
-          } else propagateContextChange(workInProgress, Component, renderLanes);
-        reconcileChildren(current, workInProgress, init.children, renderLanes);
-        workInProgress = workInProgress.child;
-      }
-      return workInProgress;
-    case 9:
-      return (
-        (init = workInProgress.type),
-        (Component = workInProgress.pendingProps.children),
-        prepareToReadContext(workInProgress, renderLanes),
-        (init = readContext(init)),
-        (Component = Component(init)),
-        (workInProgress.flags |= 1),
-        reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 14:
-      return (
-        (Component = workInProgress.type),
-        (init = resolveDefaultProps(Component, workInProgress.pendingProps)),
-        (init = resolveDefaultProps(Component.type, init)),
-        updateMemoComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 15:
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
-      );
-    case 17:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-        (workInProgress.tag = 1),
-        prepareToReadContext(workInProgress, renderLanes),
-        constructClassInstance(workInProgress, Component, init),
-        mountClassInstance(workInProgress, Component, init, renderLanes),
-        finishClassComponent(
-          null,
-          workInProgress,
-          Component,
-          !0,
-          !1,
-          renderLanes
-        )
-      );
-    case 19:
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    case 21:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 22:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 23:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 24:
-      return (
-        prepareToReadContext(workInProgress, renderLanes),
-        (Component = readContext(CacheContext)),
-        null === current
-          ? ((init = peekCacheFromPool()),
-            null === init &&
-              ((init = workInProgressRoot),
-              (prevState = createCache()),
-              (init.pooledCache = prevState),
-              prevState.refCount++,
-              null !== prevState && (init.pooledCacheLanes |= renderLanes),
-              (init = prevState)),
-            (workInProgress.memoizedState = { parent: Component, cache: init }),
-            initializeUpdateQueue(workInProgress),
-            pushProvider(workInProgress, CacheContext, init))
-          : (0 !== (current.lanes & renderLanes) &&
-              (cloneUpdateQueue(current, workInProgress),
-              processUpdateQueue(workInProgress, null, null, renderLanes)),
-            (init = current.memoizedState),
-            (prevState = workInProgress.memoizedState),
-            init.parent !== Component
-              ? ((init = { parent: Component, cache: Component }),
-                (workInProgress.memoizedState = init),
-                0 === workInProgress.lanes &&
-                  (workInProgress.memoizedState =
-                    workInProgress.updateQueue.baseState =
-                      init),
-                pushProvider(workInProgress, CacheContext, Component))
-              : ((Component = prevState.cache),
-                pushProvider(workInProgress, CacheContext, Component),
-                Component !== init.cache &&
-                  propagateContextChange(
-                    workInProgress,
-                    CacheContext,
-                    renderLanes
-                  ))),
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
+          }))
+      : ((lastHostComponent = targetFiber),
+        (targetFiber =
+          lastHostComponent[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }),
+        null !== reactName &&
+          ((targetFiber = getListener(instance, reactName)),
+          null != targetFiber &&
+            listeners.push(
+              createDispatchListener(instance, targetFiber, lastHostComponent)
+            )));
+    if (accumulateTargetOnly) break;
+    "beforeblur" === nativeEvent.type &&
+      ((targetFiber = nativeEvent._detachedInterceptFiber),
+      null === targetFiber ||
+        (targetFiber !== instance && targetFiber !== instance.alternate) ||
+        (listeners = []));
+    instance = instance.return;
+  }
+  return listeners;
+}
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  for (
+    var captureName = reactName + "Capture", listeners = [];
+    null !== targetFiber;
+
+  ) {
+    var _instance2 = targetFiber,
+      stateNode = _instance2.stateNode;
+    _instance2 = _instance2.tag;
+    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
+      null === stateNode ||
+      ((_instance2 = getListener(targetFiber, captureName)),
+      null != _instance2 &&
+        listeners.unshift(
+          createDispatchListener(targetFiber, _instance2, stateNode)
         ),
-        workInProgress.child
-      );
-    case 25:
-      if (enableTransitionTracing)
-        return (
-          enableTransitionTracing
-            ? (null === current &&
-                ((Component = enableTransitionTracing
-                  ? transitionStack.current
-                  : null),
-                null !== Component &&
-                  ((Component = {
-                    tag: 1,
-                    transitions: new Set(Component),
-                    pendingBoundaries: null,
-                    name: workInProgress.pendingProps.name,
-                    aborts: null
-                  }),
-                  (workInProgress.stateNode = Component),
-                  (workInProgress.flags |= 2048))),
-              (Component = workInProgress.stateNode),
-              null !== Component &&
-                pushMarkerInstance(workInProgress, Component),
-              reconcileChildren(
-                current,
-                workInProgress,
-                workInProgress.pendingProps.children,
-                renderLanes
-              ),
-              (workInProgress = workInProgress.child))
-            : (workInProgress = null),
-          workInProgress
+      (_instance2 = getListener(targetFiber, reactName)),
+      null != _instance2 &&
+        listeners.push(
+          createDispatchListener(targetFiber, _instance2, stateNode)
+        ));
+    targetFiber = targetFiber.return;
+  }
+  return listeners;
+}
+function getParent(inst) {
+  if (null === inst) return null;
+  do inst = inst.return;
+  while (inst && 5 !== inst.tag && 27 !== inst.tag);
+  return inst ? inst : null;
+}
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
+) {
+  for (
+    var registrationName = event._reactName, listeners = [];
+    null !== target && target !== common;
+
+  ) {
+    var _instance3 = target,
+      alternate = _instance3.alternate,
+      stateNode = _instance3.stateNode;
+    _instance3 = _instance3.tag;
+    if (null !== alternate && alternate === common) break;
+    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
+      null === stateNode ||
+      ((alternate = stateNode),
+      inCapturePhase
+        ? ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.unshift(
+              createDispatchListener(target, stateNode, alternate)
+            ))
+        : inCapturePhase ||
+          ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.push(
+              createDispatchListener(target, stateNode, alternate)
+            )));
+    target = target.return;
+  }
+  0 !== listeners.length &&
+    dispatchQueue.push({ event: event, listeners: listeners });
+}
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
+) {
+  var listeners = [],
+    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
+  null !== eventListeners &&
+    eventListeners.forEach(function (entry) {
+      entry.type === reactEventType &&
+        entry.capture === inCapturePhase &&
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
         );
+    });
+  return listeners;
+}
+var NORMALIZE_NEWLINES_REGEX = /\r\n?/g,
+  NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+function normalizeMarkupForTextOrAttribute(markup) {
+  return ("string" === typeof markup ? markup : "" + markup)
+    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
+    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
+}
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return 9 === rootContainerElement.nodeType
+    ? rootContainerElement
+    : rootContainerElement.ownerDocument;
+}
+function noop() {}
+function createHTMLElement(type, props, ownerDocument) {
+  return "string" === typeof props.is
+    ? ownerDocument.createElement(type, { is: props.is })
+    : ownerDocument.createElement(type);
+}
+function setInitialProperties(domElement, tag, rawProps) {
+  var isCustomComponentTag = isCustomComponent(tag, rawProps);
+  switch (tag) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", domElement);
+      listenToNonDelegatedEvent("close", domElement);
+      var props = rawProps;
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
+    case "video":
+    case "audio":
+      for (props = 0; props < mediaEventTypes.length; props++)
+        listenToNonDelegatedEvent(mediaEventTypes[props], domElement);
+      props = rawProps;
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", domElement);
+      props = rawProps;
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", domElement);
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", domElement);
+      props = rawProps;
+      break;
+    case "input":
+      initWrapperState$2(domElement, rawProps);
+      props = getHostProps$2(domElement, rawProps);
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    case "option":
+      props = rawProps;
+      break;
+    case "select":
+      domElement._wrapperState = { wasMultiple: !!rawProps.multiple };
+      props = assign({}, rawProps, { value: void 0 });
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    case "textarea":
+      initWrapperState(domElement, rawProps);
+      props = getHostProps(domElement, rawProps);
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    default:
+      props = rawProps;
+  }
+  assertValidProps(tag, props);
+  var nextProps = props,
+    propKey;
+  for (propKey in nextProps)
+    if (nextProps.hasOwnProperty(propKey)) {
+      var nextProp = nextProps[propKey];
+      "style" === propKey
+        ? setValueForStyles(domElement, nextProp)
+        : "dangerouslySetInnerHTML" === propKey
+        ? ((nextProp = nextProp ? nextProp.__html : void 0),
+          null != nextProp &&
+            (disableIEWorkarounds
+              ? (domElement.innerHTML = nextProp)
+              : setInnerHTML$1(domElement, nextProp)))
+        : "children" === propKey
+        ? "string" === typeof nextProp
+          ? "body" === tag ||
+            ("textarea" === tag && "" === nextProp) ||
+            setTextContent(domElement, nextProp)
+          : "number" === typeof nextProp &&
+            "body" !== tag &&
+            setTextContent(domElement, "" + nextProp)
+        : "suppressContentEditableWarning" !== propKey &&
+          "suppressHydrationWarning" !== propKey &&
+          "autoFocus" !== propKey &&
+          (registrationNameDependencies.hasOwnProperty(propKey)
+            ? null != nextProp &&
+              "onScroll" === propKey &&
+              listenToNonDelegatedEvent("scroll", domElement)
+            : null != nextProp &&
+              setValueForProperty(
+                domElement,
+                propKey,
+                nextProp,
+                isCustomComponentTag
+              ));
+    }
+  switch (tag) {
+    case "input":
+      track(domElement);
+      postMountWrapper$3(domElement, rawProps, !1);
+      break;
+    case "textarea":
+      track(domElement);
+      postMountWrapper(domElement);
+      break;
+    case "option":
+      null != rawProps.value &&
+        domElement.setAttribute("value", "" + getToStringValue(rawProps.value));
+      break;
+    case "select":
+      domElement.multiple = !!rawProps.multiple;
+      tag = rawProps.value;
+      null != tag
+        ? updateOptions(domElement, !!rawProps.multiple, tag, !1)
+        : null != rawProps.defaultValue &&
+          updateOptions(
+            domElement,
+            !!rawProps.multiple,
+            rawProps.defaultValue,
+            !0
+          );
+      break;
+    default:
+      "function" === typeof props.onClick && (domElement.onclick = noop);
+  }
+}
+function updateProperties(
+  domElement,
+  updatePayload,
+  tag,
+  lastRawProps,
+  nextRawProps
+) {
+  "input" === tag &&
+    "radio" === nextRawProps.type &&
+    null != nextRawProps.name &&
+    updateChecked(domElement, nextRawProps);
+  isCustomComponent(tag, lastRawProps);
+  lastRawProps = isCustomComponent(tag, nextRawProps);
+  for (var i = 0; i < updatePayload.length; i += 2) {
+    var propKey = updatePayload[i],
+      propValue = updatePayload[i + 1];
+    "style" === propKey
+      ? setValueForStyles(domElement, propValue)
+      : "dangerouslySetInnerHTML" === propKey
+      ? disableIEWorkarounds
+        ? (domElement.innerHTML = propValue)
+        : setInnerHTML$1(domElement, propValue)
+      : "children" === propKey
+      ? setTextContent(domElement, propValue)
+      : setValueForProperty(domElement, propKey, propValue, lastRawProps);
+  }
+  switch (tag) {
+    case "input":
+      updateWrapper$1(domElement, nextRawProps);
+      break;
+    case "textarea":
+      updateWrapper(domElement, nextRawProps);
+      break;
+    case "select":
+      (updatePayload = domElement._wrapperState.wasMultiple),
+        (domElement._wrapperState.wasMultiple = !!nextRawProps.multiple),
+        (tag = nextRawProps.value),
+        null != tag
+          ? updateOptions(domElement, !!nextRawProps.multiple, tag, !1)
+          : updatePayload !== !!nextRawProps.multiple &&
+            (null != nextRawProps.defaultValue
+              ? updateOptions(
+                  domElement,
+                  !!nextRawProps.multiple,
+                  nextRawProps.defaultValue,
+                  !0
+                )
+              : updateOptions(
+                  domElement,
+                  !!nextRawProps.multiple,
+                  nextRawProps.multiple ? [] : "",
+                  !1
+                ));
+  }
+}
+var Dispatcher$1 = Internals.Dispatcher,
+  lastCurrentDocument = null,
+  previousDispatcher = null,
+  ReactDOMClientDispatcher = {
+    prefetchDNS: prefetchDNS$1,
+    preconnect: preconnect$1,
+    preload: preload$1,
+    preinit: preinit$1
+  },
+  preloadPropsMap = new Map(),
+  preconnectsSet = new Set();
+function getHoistableRoot(container) {
+  return "function" === typeof container.getRootNode
+    ? container.getRootNode()
+    : container.ownerDocument;
+}
+function getCurrentResourceRoot() {
+  var currentContainer = rootInstanceStackCursor.current;
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+function getDocumentForPreloads() {
+  var root = getCurrentResourceRoot();
+  if (root) return root.ownerDocument || root;
+  try {
+    return lastCurrentDocument || window.document;
+  } catch (error) {
+    return null;
+  }
+}
+function preconnectAs(rel, crossOrigin, href) {
+  var ownerDocument = getDocumentForPreloads();
+  if ("string" === typeof href && href && ownerDocument) {
+    var limitedEscapedHref =
+      escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    limitedEscapedHref =
+      'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
+    "string" === typeof crossOrigin &&
+      (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
+    preconnectsSet.has(limitedEscapedHref) ||
+      (preconnectsSet.add(limitedEscapedHref),
+      (rel = { rel: rel, crossOrigin: crossOrigin, href: href }),
+      null === ownerDocument.querySelector(limitedEscapedHref) &&
+        ((crossOrigin = ownerDocument.createElement("link")),
+        setInitialProperties(crossOrigin, "link", rel),
+        markNodeAsHoistable(crossOrigin),
+        ownerDocument.head.appendChild(crossOrigin)));
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
-};
-function scheduleCallback(priorityLevel, callback) {
-  return scheduleCallback$2(priorityLevel, callback);
 }
-function FiberNode(tag, pendingProps, key, mode) {
-  this.tag = tag;
-  this.key = key;
-  this.sibling =
-    this.child =
-    this.return =
-    this.stateNode =
-    this.type =
-    this.elementType =
-      null;
-  this.index = 0;
-  this.refCleanup = this.ref = null;
-  this.pendingProps = pendingProps;
-  this.dependencies =
-    this.memoizedState =
-    this.updateQueue =
-    this.memoizedProps =
-      null;
-  this.mode = mode;
-  this.subtreeFlags = this.flags = 0;
-  this.deletions = null;
-  this.childLanes = this.lanes = 0;
-  this.alternate = null;
+function prefetchDNS$1(href) {
+  preconnectAs("dns-prefetch", null, href);
 }
-function createFiber(tag, pendingProps, key, mode) {
-  return new FiberNode(tag, pendingProps, key, mode);
+function preconnect$1(href, options) {
+  preconnectAs(
+    "preconnect",
+    null == options || "string" !== typeof options.crossOrigin
+      ? null
+      : "use-credentials" === options.crossOrigin
+      ? "use-credentials"
+      : "",
+    href
+  );
 }
-function shouldConstruct(Component) {
-  Component = Component.prototype;
-  return !(!Component || !Component.isReactComponent);
+function preload$1(href, options) {
+  var ownerDocument = getDocumentForPreloads();
+  if (
+    "string" === typeof href &&
+    href &&
+    "object" === typeof options &&
+    null !== options &&
+    ownerDocument
+  ) {
+    var as = options.as,
+      limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href),
+      key = (limitedEscapedHref =
+        'link[rel="preload"][as="' +
+        as +
+        '"][href="' +
+        limitedEscapedHref +
+        '"]');
+    switch (as) {
+      case "style":
+        key = getStyleKey(href);
+        break;
+      case "script":
+        key = getScriptKey(href);
+    }
+    preloadPropsMap.has(key) ||
+      ((href = {
+        href: href,
+        rel: "preload",
+        as: as,
+        crossOrigin: "font" === as ? "" : options.crossOrigin,
+        integrity: options.integrity,
+        type: options.type
+      }),
+      preloadPropsMap.set(key, href),
+      null === ownerDocument.querySelector(limitedEscapedHref) &&
+        ((options = ownerDocument.createElement("link")),
+        setInitialProperties(options, "link", href),
+        markNodeAsHoistable(options),
+        ownerDocument.head.appendChild(options)));
+  }
 }
-function resolveLazyComponentTag(Component) {
-  if ("function" === typeof Component)
-    return shouldConstruct(Component) ? 1 : 0;
-  if (void 0 !== Component && null !== Component) {
-    Component = Component.$$typeof;
-    if (Component === REACT_FORWARD_REF_TYPE) return 11;
-    if (Component === REACT_MEMO_TYPE) return 14;
+function preinit$1(href, options) {
+  if (
+    "string" === typeof href &&
+    href &&
+    "object" === typeof options &&
+    null !== options
+  ) {
+    var resourceRoot = getCurrentResourceRoot(),
+      as = options.as;
+    if (resourceRoot)
+      switch (as) {
+        case "style":
+          as = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          var key$196 = getStyleKey(href),
+            precedence = options.precedence || "default",
+            resource = as.get(key$196);
+          if (resource) break;
+          resource = resourceRoot.querySelector(
+            getStylesheetSelectorFromKey(key$196)
+          );
+          resource ||
+            ((href = {
+              rel: "stylesheet",
+              href: href,
+              "data-precedence": precedence,
+              crossOrigin: options.crossOrigin
+            }),
+            (options = preloadPropsMap.get(key$196)) &&
+              adoptPreloadPropsForStylesheet(href, options),
+            (resource = (
+              resourceRoot.ownerDocument || resourceRoot
+            ).createElement("link")),
+            markNodeAsHoistable(resource),
+            setInitialProperties(resource, "link", href),
+            insertStylesheet(resource, precedence, resourceRoot));
+          resource = { type: "stylesheet", instance: resource, count: 1 };
+          as.set(key$196, resource);
+          break;
+        case "script":
+          (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
+            (key$196 = getScriptKey(href)),
+            (precedence = as.get(key$196)),
+            precedence ||
+              ((precedence = resourceRoot.querySelector(
+                "script[async]" + key$196
+              )),
+              precedence ||
+                ((href = {
+                  src: href,
+                  async: !0,
+                  crossOrigin: options.crossOrigin,
+                  integrity: options.integrity
+                }),
+                (options = preloadPropsMap.get(key$196)) &&
+                  adoptPreloadPropsForScript(href, options),
+                (options = resourceRoot.ownerDocument || resourceRoot),
+                (precedence = options.createElement("script")),
+                markNodeAsHoistable(precedence),
+                setInitialProperties(precedence, "link", href),
+                options.head.appendChild(precedence)),
+              (precedence = { type: "script", instance: precedence, count: 1 }),
+              as.set(key$196, precedence));
+      }
+    else if ("style" === as || "script" === as)
+      if ((resourceRoot = getDocumentForPreloads())) {
+        key$196 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+        precedence = key$196 =
+          'link[rel="preload"][as="' + as + '"][href="' + key$196 + '"]';
+        switch (as) {
+          case "style":
+            precedence = getStyleKey(href);
+            break;
+          case "script":
+            precedence = getScriptKey(href);
+        }
+        preloadPropsMap.has(precedence) ||
+          ((href = {
+            href: href,
+            rel: "preload",
+            as: as,
+            crossOrigin: "font" === as ? "" : options.crossOrigin,
+            integrity: options.integrity
+          }),
+          preloadPropsMap.set(precedence, href),
+          null === resourceRoot.querySelector(key$196) &&
+            ((options = resourceRoot.createElement("link")),
+            setInitialProperties(options, "link", href),
+            markNodeAsHoistable(options),
+            resourceRoot.head.appendChild(options)));
+      }
   }
-  return 2;
 }
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
-  null === workInProgress
-    ? ((workInProgress = createFiber(
-        current.tag,
-        pendingProps,
-        current.key,
-        current.mode
-      )),
-      (workInProgress.elementType = current.elementType),
-      (workInProgress.type = current.type),
-      (workInProgress.stateNode = current.stateNode),
-      (workInProgress.alternate = current),
-      (current.alternate = workInProgress))
-    : ((workInProgress.pendingProps = pendingProps),
-      (workInProgress.type = current.type),
-      (workInProgress.flags = 0),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null));
-  workInProgress.flags = current.flags & 14680064;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue;
-  pendingProps = current.dependencies;
-  workInProgress.dependencies =
-    null === pendingProps
-      ? null
-      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
-  return workInProgress;
+function getResource(type, currentProps, pendingProps) {
+  currentProps = getCurrentResourceRoot();
+  if (!currentProps) throw Error(formatProdErrorMessage(446));
+  switch (type) {
+    case "meta":
+    case "title":
+      return null;
+    case "style":
+      return "string" === typeof pendingProps.precedence &&
+        "string" === typeof pendingProps.href
+        ? ((pendingProps = getStyleKey(pendingProps.href)),
+          (currentProps = getResourcesFromRoot(currentProps).hoistableStyles),
+          (type = currentProps.get(pendingProps)),
+          type ||
+            ((type = { type: "style", instance: null, count: 0 }),
+            currentProps.set(pendingProps, type)),
+          type)
+        : { type: "void", instance: null, count: 0 };
+    case "link":
+      if (
+        "stylesheet" === pendingProps.rel &&
+        "string" === typeof pendingProps.href &&
+        "string" === typeof pendingProps.precedence
+      ) {
+        var key$203 = getStyleKey(pendingProps.href),
+          styles$204 = getResourcesFromRoot(currentProps).hoistableStyles;
+        type = styles$204.get(key$203);
+        type ||
+          ((currentProps = currentProps.ownerDocument || currentProps),
+          (type = { type: "stylesheet", instance: null, count: 0 }),
+          styles$204.set(key$203, type),
+          preloadPropsMap.has(key$203) ||
+            ((pendingProps = {
+              rel: "preload",
+              as: "style",
+              href: pendingProps.href,
+              crossOrigin: pendingProps.crossOrigin,
+              integrity: pendingProps.integrity,
+              media: pendingProps.media,
+              hrefLang: pendingProps.hrefLang,
+              referrerPolicy: pendingProps.referrerPolicy
+            }),
+            preloadPropsMap.set(key$203, pendingProps),
+            currentProps.querySelector(getStylesheetSelectorFromKey(key$203)) ||
+              null !==
+                currentProps.querySelector(
+                  'link[rel="preload"][as="style"][' + key$203 + "]"
+                ) ||
+              ((key$203 = currentProps.createElement("link")),
+              setInitialProperties(key$203, "link", pendingProps),
+              markNodeAsHoistable(key$203),
+              currentProps.head.appendChild(key$203))));
+        return type;
+      }
+      return null;
+    case "script":
+      return "string" === typeof pendingProps.src && !0 === pendingProps.async
+        ? ((pendingProps = getScriptKey(pendingProps.src)),
+          (currentProps = getResourcesFromRoot(currentProps).hoistableScripts),
+          (type = currentProps.get(pendingProps)),
+          type ||
+            ((type = { type: "script", instance: null, count: 0 }),
+            currentProps.set(pendingProps, type)),
+          type)
+        : { type: "void", instance: null, count: 0 };
+    default:
+      throw Error(formatProdErrorMessage(444, type));
+  }
 }
-function resetWorkInProgress(workInProgress, renderLanes) {
-  workInProgress.flags &= 14680066;
-  var current = workInProgress.alternate;
-  null === current
-    ? ((workInProgress.childLanes = 0),
-      (workInProgress.lanes = renderLanes),
-      (workInProgress.child = null),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.memoizedProps = null),
-      (workInProgress.memoizedState = null),
-      (workInProgress.updateQueue = null),
-      (workInProgress.dependencies = null),
-      (workInProgress.stateNode = null))
-    : ((workInProgress.childLanes = current.childLanes),
-      (workInProgress.lanes = current.lanes),
-      (workInProgress.child = current.child),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null),
-      (workInProgress.memoizedProps = current.memoizedProps),
-      (workInProgress.memoizedState = current.memoizedState),
-      (workInProgress.updateQueue = current.updateQueue),
-      (workInProgress.type = current.type),
-      (renderLanes = current.dependencies),
-      (workInProgress.dependencies =
-        null === renderLanes
-          ? null
-          : {
-              lanes: renderLanes.lanes,
-              firstContext: renderLanes.firstContext
-            }));
-  return workInProgress;
+function getStyleKey(href) {
+  return 'href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
 }
-function createFiberFromTypeAndProps(
-  type,
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = 2;
-  owner = type;
-  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
-  else if ("string" === typeof type)
-    fiberTag = isHostHoistableType(
-      type,
-      pendingProps,
-      contextStackCursor.current
-    )
-      ? 26
-      : "html" === type || "head" === type || "body" === type
-      ? 27
-      : 5;
-  else
-    a: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = 8;
-        mode |= 8;
-        0 !== (mode & 1) && (mode |= 16);
-        break;
-      case REACT_PROFILER_TYPE:
-        return (
-          (type = createFiber(12, pendingProps, key, mode | 2)),
-          (type.elementType = REACT_PROFILER_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_TYPE:
-        return (
-          (type = createFiber(13, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_LIST_TYPE:
-        return (
-          (type = createFiber(19, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
-      case REACT_LEGACY_HIDDEN_TYPE:
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      case REACT_SCOPE_TYPE:
-        return (
-          (pendingProps = createFiber(21, pendingProps, key, mode)),
-          (pendingProps.type = type),
-          (pendingProps.elementType = type),
-          (pendingProps.lanes = lanes),
-          pendingProps
+function getStylesheetSelectorFromKey(key) {
+  return 'link[rel="stylesheet"][' + key + "]";
+}
+function getScriptKey(src) {
+  return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
+}
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+  if (null === resource.instance)
+    switch (resource.type) {
+      case "style":
+        var key = getStyleKey(props.href);
+        if ((key = hoistableRoot.querySelector("style[data-" + key + "]")))
+          return (resource.instance = key), markNodeAsHoistable(key), key;
+        var styleProps = assign({}, props, {
+          "data-href": props.href,
+          "data-precedence": props.precedence,
+          href: null,
+          precedence: null
+        });
+        key = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
+          "style"
         );
-      case REACT_CACHE_TYPE:
-        return (
-          (type = createFiber(24, pendingProps, key, mode)),
-          (type.elementType = REACT_CACHE_TYPE),
-          (type.lanes = lanes),
-          type
+        markNodeAsHoistable(key);
+        setInitialProperties(key, "style", styleProps);
+        insertStylesheet(key, props.precedence, hoistableRoot);
+        return (resource.instance = key);
+      case "stylesheet":
+        styleProps = getStyleKey(props.href);
+        var instance$210 = hoistableRoot.querySelector(
+          getStylesheetSelectorFromKey(styleProps)
         );
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing)
+        if (instance$210)
           return (
-            (type = createFiber(25, pendingProps, key, mode)),
-            (type.elementType = REACT_TRACING_MARKER_TYPE),
-            (type.lanes = lanes),
-            (type.stateNode = {
-              tag: 1,
-              transitions: null,
-              pendingBoundaries: null,
-              aborts: null,
-              name: pendingProps.name
-            }),
-            type
+            (resource.instance = instance$210),
+            markNodeAsHoistable(instance$210),
+            instance$210
           );
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = 8;
-          mode |= 4;
-          break;
-        }
-      default:
-        if ("object" === typeof type && null !== type)
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = 10;
-              break a;
-            case REACT_CONTEXT_TYPE:
-              fiberTag = 9;
-              break a;
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = 11;
-              break a;
-            case REACT_MEMO_TYPE:
-              fiberTag = 14;
-              break a;
-            case REACT_LAZY_TYPE:
-              fiberTag = 16;
-              owner = null;
-              break a;
+        key = assign({}, props, {
+          "data-precedence": props.precedence,
+          precedence: null
+        });
+        (styleProps = preloadPropsMap.get(styleProps)) &&
+          adoptPreloadPropsForStylesheet(key, styleProps);
+        instance$210 = (
+          hoistableRoot.ownerDocument || hoistableRoot
+        ).createElement("link");
+        markNodeAsHoistable(instance$210);
+        var linkInstance = instance$210;
+        linkInstance._p = new Promise(function (resolve, reject) {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        }).then(
+          function () {
+            return (linkInstance._p.s = "l");
+          },
+          function () {
+            return (linkInstance._p.s = "e");
           }
-        throw Error(
-          formatProdErrorMessage(130, null == type ? type : typeof type, "")
         );
+        setInitialProperties(instance$210, "link", key);
+        insertStylesheet(instance$210, props.precedence, hoistableRoot);
+        return (resource.instance = instance$210);
+      case "script":
+        instance$210 = getScriptKey(props.src);
+        if (
+          (styleProps = hoistableRoot.querySelector(
+            "script[async]" + instance$210
+          ))
+        )
+          return (
+            (resource.instance = styleProps),
+            markNodeAsHoistable(styleProps),
+            styleProps
+          );
+        key = props;
+        if ((styleProps = preloadPropsMap.get(instance$210)))
+          (key = assign({}, props)),
+            adoptPreloadPropsForScript(key, styleProps);
+        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+        styleProps = hoistableRoot.createElement("script");
+        markNodeAsHoistable(styleProps);
+        setInitialProperties(styleProps, "link", key);
+        hoistableRoot.head.appendChild(styleProps);
+        return (resource.instance = styleProps);
+      case "void":
+        return null;
+      default:
+        throw Error(formatProdErrorMessage(443, resource.type));
     }
-  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
-  pendingProps.elementType = type;
-  pendingProps.type = owner;
-  pendingProps.lanes = lanes;
-  return pendingProps;
+  return resource.instance;
+}
+function insertStylesheet(instance, precedence, root) {
+  for (
+    var nodes = root.querySelectorAll(
+        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
+      ),
+      last = nodes.length ? nodes[nodes.length - 1] : null,
+      prior = last,
+      i = 0;
+    i < nodes.length;
+    i++
+  ) {
+    var node = nodes[i];
+    if (node.dataset.precedence === precedence) prior = node;
+    else if (prior !== last) break;
+  }
+  prior
+    ? prior.parentNode.insertBefore(instance, prior.nextSibling)
+    : ((precedence = 9 === root.nodeType ? root.head : root),
+      precedence.insertBefore(instance, precedence.firstChild));
+}
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  null == stylesheetProps.crossOrigin &&
+    (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
+  null == stylesheetProps.referrerPolicy &&
+    (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
+  null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
 }
-function createFiberFromFragment(elements, mode, lanes, key) {
-  elements = createFiber(7, elements, key, mode);
-  elements.lanes = lanes;
-  return elements;
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  null == scriptProps.crossOrigin &&
+    (scriptProps.crossOrigin = preloadProps.crossOrigin);
+  null == scriptProps.referrerPolicy &&
+    (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
+  null == scriptProps.integrity &&
+    (scriptProps.referrerPolicy = preloadProps.integrity);
 }
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(22, pendingProps, key, mode);
-  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
-  pendingProps.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
+var tagCaches = null;
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  if (null === tagCaches) {
+    var cache = new Map();
+    var caches = (tagCaches = new Map());
+    caches.set(ownerDocument, cache);
+  } else
+    (caches = tagCaches),
+      (cache = caches.get(ownerDocument)),
+      cache || ((cache = new Map()), caches.set(ownerDocument, cache));
+  if (cache.has(type)) return cache;
+  cache.set(type, null);
+  ownerDocument = ownerDocument.getElementsByTagName(type);
+  for (caches = 0; caches < ownerDocument.length; caches++) {
+    var node = ownerDocument[caches];
+    if (
+      !(
+        node[internalHoistableMarker] ||
+        node[internalInstanceKey] ||
+        ("link" === type && "stylesheet" === node.getAttribute("rel"))
+      ) &&
+      "http://www.w3.org/2000/svg" !== node.namespaceURI
+    ) {
+      var nodeKey = node.getAttribute(keyAttribute) || "";
+      nodeKey = type + nodeKey;
+      var existing = cache.get(nodeKey);
+      existing ? existing.push(node) : cache.set(nodeKey, [node]);
     }
-  };
-  pendingProps.stateNode = primaryChildInstance;
-  return pendingProps;
+  }
+  return cache;
 }
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(23, pendingProps, key, mode);
-  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  pendingProps.lanes = lanes;
-  var instance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
+function mountHoistable(hoistableRoot, type, instance) {
+  hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+  hoistableRoot.head.insertBefore(
+    instance,
+    "title" === type ? hoistableRoot.querySelector("head > title") : null
+  );
+}
+var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(
+    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
+    function (ch) {
+      return "\\" + ch.charCodeAt(0).toString(16);
     }
-  };
-  pendingProps.stateNode = instance;
-  return pendingProps;
+  );
 }
-function createFiberFromText(content, mode, lanes) {
-  content = createFiber(6, content, null, mode);
-  content.lanes = lanes;
-  return content;
+var eventsEnabled = null,
+  selectionInformation = null;
+function beforeActiveInstanceBlur(internalInstanceHandle) {
+  _enabled = !0;
+  var target = selectionInformation.focusedElem,
+    event = createEvent("beforeblur", !0);
+  event._detachedInterceptFiber = internalInstanceHandle;
+  target.dispatchEvent(event);
+  _enabled = !1;
 }
-function createFiberFromPortal(portal, mode, lanes) {
-  mode = createFiber(
-    4,
-    null !== portal.children ? portal.children : [],
-    portal.key,
-    mode
+function shouldSetTextContent(type, props) {
+  return (
+    "textarea" === type ||
+    "noscript" === type ||
+    "string" === typeof props.children ||
+    "number" === typeof props.children ||
+    ("object" === typeof props.dangerouslySetInnerHTML &&
+      null !== props.dangerouslySetInnerHTML &&
+      null != props.dangerouslySetInnerHTML.__html)
   );
-  mode.lanes = lanes;
-  mode.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    implementation: portal.implementation
-  };
-  return mode;
 }
-function FiberRootNode(
-  containerInfo,
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
-) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.finishedWork =
-    this.pingCache =
-    this.current =
-    this.pendingChildren =
-      null;
-  this.timeoutHandle = -1;
-  this.callbackNode = this.pendingContext = this.context = null;
-  this.callbackPriority = 0;
-  this.eventTimes = createLaneMap(0);
-  this.expirationTimes = createLaneMap(-1);
-  this.entangledLanes =
-    this.errorRecoveryDisabledLanes =
-    this.finishedLanes =
-    this.mutableReadLanes =
-    this.expiredLanes =
-    this.pingedLanes =
-    this.suspendedLanes =
-    this.pendingLanes =
-      0;
-  this.entanglements = createLaneMap(0);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
-  this.pooledCache = null;
-  this.pooledCacheLanes = 0;
-  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
-  this.incompleteTransitions = new Map();
-  if (enableTransitionTracing)
-    for (
-      this.transitionCallbacks = null,
-        containerInfo = this.transitionLanes = [],
-        tag = 0;
-      31 > tag;
-      tag++
-    )
-      containerInfo.push(null);
+var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
+  cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
+  localPromise = "function" === typeof Promise ? Promise : void 0,
+  localRequestAnimationFrame =
+    "function" === typeof requestAnimationFrame
+      ? requestAnimationFrame
+      : scheduleTimeout;
+function getInstanceFromScope(scopeInstance) {
+  scopeInstance = scopeInstance[internalInstanceKey] || null;
+  return scopeInstance;
 }
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
-) {
-  containerInfo = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
-  );
-  containerInfo.hydrationCallbacks = hydrationCallbacks;
-  enableTransitionTracing &&
-    (containerInfo.transitionCallbacks = transitionCallbacks);
-  1 === tag
-    ? ((tag = 1),
-      !0 === isStrictMode && (tag |= 24),
-      concurrentUpdatesByDefaultOverride && (tag |= 32))
-    : (tag = 0);
-  isStrictMode = createFiber(3, null, null, tag);
-  containerInfo.current = isStrictMode;
-  isStrictMode.stateNode = containerInfo;
-  concurrentUpdatesByDefaultOverride = createCache();
-  concurrentUpdatesByDefaultOverride.refCount++;
-  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
-  concurrentUpdatesByDefaultOverride.refCount++;
-  isStrictMode.memoizedState = {
-    element: initialChildren,
-    isDehydrated: hydrate,
-    cache: concurrentUpdatesByDefaultOverride
-  };
-  initializeUpdateQueue(isStrictMode);
-  return containerInfo;
+var scheduleMicrotask =
+  "function" === typeof queueMicrotask
+    ? queueMicrotask
+    : "undefined" !== typeof localPromise
+    ? function (callback) {
+        return localPromise
+          .resolve(null)
+          .then(callback)
+          .catch(handleErrorInNextTick);
+      }
+    : scheduleTimeout;
+function handleErrorInNextTick(error) {
+  setTimeout(function () {
+    throw error;
+  });
 }
-function createPortal$1(children, containerInfo, implementation) {
-  var key =
-    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
-  return {
-    $$typeof: REACT_PORTAL_TYPE,
-    key: null == key ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
-  };
+function createEvent(type, bubbles) {
+  var event = document.createEvent("Event");
+  event.initEvent(type, bubbles, !1);
+  return event;
+}
+function dispatchAfterDetachedBlur(target) {
+  var event = createEvent("afterblur", !1);
+  event.relatedTarget = target;
+  document.dispatchEvent(event);
 }
-function updateContainer(element, container, parentComponent, callback) {
-  parentComponent = container.current;
-  var lane = requestUpdateLane(parentComponent);
-  null === container.context
-    ? (container.context = emptyContextObject)
-    : (container.pendingContext = emptyContextObject);
-  container = createUpdate(lane);
-  container.payload = { element: element };
-  callback = void 0 === callback ? null : callback;
-  null !== callback && (container.callback = callback);
-  element = enqueueUpdate(parentComponent, container, lane);
-  null !== element &&
-    ((callback = requestEventTime()),
-    scheduleUpdateOnFiber(element, parentComponent, lane, callback),
-    entangleTransitions(element, parentComponent, lane));
-  return lane;
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  var node = suspenseInstance,
+    depth = 0;
+  do {
+    var nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+    if (nextNode && 8 === nextNode.nodeType)
+      if (((node = nextNode.data), "/$" === node)) {
+        if (0 === depth) {
+          parentInstance.removeChild(nextNode);
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        }
+        depth--;
+      } else ("$" !== node && "$?" !== node && "$!" !== node) || depth++;
+    node = nextNode;
+  } while (node);
+  retryIfBlockedOn(suspenseInstance);
 }
-function markRetryLaneImpl(fiber, retryLane) {
-  fiber = fiber.memoizedState;
-  if (null !== fiber && null !== fiber.dehydrated) {
-    var a = fiber.retryLane;
-    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+function clearContainerSparingly(container) {
+  var nextNode = container.firstChild;
+  nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
+  for (; nextNode; ) {
+    var node = nextNode;
+    nextNode = nextNode.nextSibling;
+    switch (node.nodeName) {
+      case "HTML":
+      case "HEAD":
+      case "BODY":
+        clearContainerSparingly(node);
+        detachDeletedInstance(node);
+        continue;
+      case "STYLE":
+        continue;
+      case "LINK":
+        if ("stylesheet" === node.rel.toLowerCase()) continue;
+    }
+    container.removeChild(node);
   }
 }
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
+function shouldSkipHydratableForInstance(instance, type, props) {
+  if (1 !== instance.nodeType) return !1;
+  if (
+    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
+    instance[internalHoistableMarker]
+  )
+    return !0;
+  switch (type) {
+    case "meta":
+      if (!instance.hasAttribute("itemprop")) return !0;
+      break;
+    case "link":
+      type = instance.getAttribute("rel");
+      if (
+        ("stylesheet" === type && instance.hasAttribute("data-precedence")) ||
+        type !== props.rel ||
+        instance.getAttribute("href") !==
+          (null == props.href ? null : props.href) ||
+        instance.getAttribute("crossorigin") !==
+          (null == props.crossOrigin ? null : props.crossOrigin) ||
+        instance.getAttribute("title") !==
+          (null == props.title ? null : props.title)
+      )
+        return !0;
+      break;
+    case "style":
+      if (instance.hasAttribute("data-precedence")) return !0;
+      break;
+    case "script":
+      if (
+        ((type = instance.getAttribute("src")) &&
+          instance.hasAttribute("async") &&
+          !instance.hasAttribute("itemprop")) ||
+        type !== (null == props.src ? null : props.src) ||
+        instance.getAttribute("type") !==
+          (null == props.type ? null : props.type) ||
+        instance.getAttribute("crossorigin") !==
+          (null == props.crossOrigin ? null : props.crossOrigin)
+      )
+        return !0;
+  }
+  return !1;
 }
-function emptyFindFiberByHostInstance() {
+function getNextHydratable(node) {
+  for (; null != node; node = node.nextSibling) {
+    var nodeType = node.nodeType;
+    if (1 === nodeType || 3 === nodeType) break;
+    if (8 === nodeType) {
+      nodeType = node.data;
+      if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType) break;
+      if ("/$" === nodeType) return null;
+    }
+  }
+  return node;
+}
+function getParentSuspenseInstance(targetInstance) {
+  targetInstance = targetInstance.previousSibling;
+  for (var depth = 0; targetInstance; ) {
+    if (8 === targetInstance.nodeType) {
+      var data = targetInstance.data;
+      if ("$" === data || "$!" === data || "$?" === data) {
+        if (0 === depth) return targetInstance;
+        depth--;
+      } else "/$" === data && depth++;
+    }
+    targetInstance = targetInstance.previousSibling;
+  }
   return null;
 }
+function requestPostPaintCallback(callback) {
+  localRequestAnimationFrame(function () {
+    localRequestAnimationFrame(function (time) {
+      return callback(time);
+    });
+  });
+}
+function isHostHoistableType(type, props, hostContext) {
+  if ("http://www.w3.org/2000/svg" === hostContext || null != props.itemProp)
+    return !1;
+  switch (type) {
+    case "meta":
+    case "title":
+      return !0;
+    case "style":
+      if (
+        "string" !== typeof props.precedence ||
+        "string" !== typeof props.href ||
+        "" === props.href
+      )
+        break;
+      return !0;
+    case "link":
+      if (
+        "string" !== typeof props.rel ||
+        "string" !== typeof props.href ||
+        "" === props.href ||
+        props.onLoad ||
+        props.onError
+      )
+        break;
+      switch (props.rel) {
+        case "stylesheet":
+          return (
+            (type = props.disabled),
+            "string" === typeof props.precedence && null == type
+          );
+        default:
+          return !0;
+      }
+    case "script":
+      if (
+        !0 === props.async &&
+        !props.onLoad &&
+        !props.onError &&
+        "string" === typeof props.src &&
+        props.src
+      )
+        return !0;
+  }
+  return !1;
+}
+function resolveSingletonInstance(type, props, rootContainerInstance) {
+  props = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  switch (type) {
+    case "html":
+      type = props.documentElement;
+      if (!type) throw Error(formatProdErrorMessage(452));
+      return type;
+    case "head":
+      type = props.head;
+      if (!type) throw Error(formatProdErrorMessage(453));
+      return type;
+    case "body":
+      type = props.body;
+      if (!type) throw Error(formatProdErrorMessage(454));
+      return type;
+    default:
+      throw Error(formatProdErrorMessage(451));
+  }
+}
 var Dispatcher = Internals.Dispatcher,
   defaultOnRecoverableError =
     "function" === typeof reportError
@@ -15105,7 +15171,7 @@ function ReactDOMHydrationRoot(internalRoot) {
 }
 ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
   if (target) {
-    var updatePriority = getCurrentUpdatePriority();
+    var updatePriority = currentUpdatePriority;
     target = { blockedOn: null, target: target, priority: updatePriority };
     for (
       var i = 0;
@@ -15149,115 +15215,25 @@ function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
         listenerSet.add(listenerSetKey));
     } else throw Error(formatProdErrorMessage(369));
 }
-_attemptSynchronousHydration = function (fiber) {
-  switch (fiber.tag) {
-    case 3:
-      var root$223 = fiber.stateNode;
-      if (root$223.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$223.pendingLanes);
-        0 !== lanes &&
-          (markRootEntangled(root$223, lanes | 2),
-          ensureRootIsScheduled(root$223, now()),
-          0 === (executionContext & 6) &&
-            (resetRenderTimer(), flushSyncCallbacks()));
-      }
-      break;
-    case 13:
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        if (null !== root) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-        }
-      }),
-        markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptDiscreteHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptContinuousHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 134217728);
-  }
-};
-attemptHydrationAtCurrentPriority$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var lane = requestUpdateLane(fiber),
-      root = enqueueConcurrentRenderForLane(fiber, lane);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, lane);
-  }
-};
-getCurrentUpdatePriority = function () {
-  return currentUpdatePriority;
-};
-attemptHydrationAtPriority = runWithPriority;
-restoreImpl = function (domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, props);
-      tag = props.name;
-      if ("radio" === props.type && null != tag) {
-        for (props = domElement; props.parentNode; ) props = props.parentNode;
-        props = props.querySelectorAll(
-          "input[name=" + JSON.stringify("" + tag) + '][type="radio"]'
-        );
-        for (tag = 0; tag < props.length; tag++) {
-          var otherNode = props[tag];
-          if (otherNode !== domElement && otherNode.form === domElement.form) {
-            var otherProps = getFiberCurrentPropsFromNode(otherNode);
-            if (!otherProps) throw Error(formatProdErrorMessage(90));
-            updateValueIfChanged(otherNode);
-            updateWrapper$1(otherNode, otherProps);
-          }
-        }
-      }
-      break;
-    case "textarea":
-      updateWrapper(domElement, props);
-      break;
-    case "select":
-      (tag = props.value),
-        null != tag && updateOptions(domElement, !!props.multiple, tag, !1);
-  }
-};
-batchedUpdatesImpl = batchedUpdates;
-flushSyncImpl = flushSync$1;
 Internals.Events = [
   getInstanceFromNode$1,
   getNodeFromInstance,
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
-var devToolsConfig$jscomp$inline_1720 = {
+var devToolsConfig$jscomp$inline_1709 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-modern-502a5528",
+  version: "18.3.0-www-modern-d994d737",
   rendererPackageName: "react-dom"
 };
 var internals$jscomp$inline_2115 = {
-  bundleType: devToolsConfig$jscomp$inline_1720.bundleType,
-  version: devToolsConfig$jscomp$inline_1720.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1720.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1720.rendererConfig,
+  bundleType: devToolsConfig$jscomp$inline_1709.bundleType,
+  version: devToolsConfig$jscomp$inline_1709.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1709.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1709.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -15274,14 +15250,14 @@ var internals$jscomp$inline_2115 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1720.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1709.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-modern-502a5528"
+  reconcilerVersion: "18.3.0-www-modern-d994d737"
 };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
   var hook$jscomp$inline_2116 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
@@ -15419,7 +15395,7 @@ exports.preload = function () {
   var dispatcher = Internals.Dispatcher.current;
   dispatcher && dispatcher.preload.apply(this, arguments);
 };
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = function (type, options) {
   function eventHandle(target, callback) {
     if ("function" !== typeof callback)
@@ -15452,18 +15428,18 @@ exports.unstable_createEventHandle = function (type, options) {
 exports.unstable_flushControlled = function (fn) {
   var prevExecutionContext = executionContext;
   executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
     previousPriority = currentUpdatePriority;
   try {
-    (ReactCurrentBatchConfig.transition = null),
+    (ReactCurrentBatchConfig$1.transition = null),
       (currentUpdatePriority = 2),
       fn();
   } finally {
     (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
       (executionContext = prevExecutionContext),
       0 === executionContext && (resetRenderTimer(), flushSyncCallbacks());
   }
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-modern-502a5528";
+exports.version = "18.3.0-www-modern-d994d737";
diff --git a/compiled/facebook-www/ReactDOM-profiling.classic.js b/compiled/facebook-www/ReactDOM-profiling.classic.js
index 51071c18db7b5..840aeeff7c269 100644
--- a/compiled/facebook-www/ReactDOM-profiling.classic.js
+++ b/compiled/facebook-www/ReactDOM-profiling.classic.js
@@ -31,6 +31,7 @@ var Scheduler = require("scheduler"),
   dynamicFeatureFlags = require("ReactFeatureFlags"),
   disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   enableFilterEmptyStringAttributesDOM =
@@ -1368,7 +1369,10 @@ function setInitialProperties(domElement, tag, rawProps) {
         ? setValueForStyles(domElement, nextProp)
         : "dangerouslySetInnerHTML" === propKey
         ? ((nextProp = nextProp ? nextProp.__html : void 0),
-          null != nextProp && setInnerHTML$1(domElement, nextProp))
+          null != nextProp &&
+            (disableIEWorkarounds
+              ? (domElement.innerHTML = nextProp)
+              : setInnerHTML$1(domElement, nextProp)))
         : "children" === propKey
         ? "string" === typeof nextProp
           ? "body" === tag ||
@@ -1441,7 +1445,9 @@ function updateProperties(
     "style" === propKey
       ? setValueForStyles(domElement, propValue)
       : "dangerouslySetInnerHTML" === propKey
-      ? setInnerHTML$1(domElement, propValue)
+      ? disableIEWorkarounds
+        ? (domElement.innerHTML = propValue)
+        : setInnerHTML$1(domElement, propValue)
       : "children" === propKey
       ? setTextContent(domElement, propValue)
       : setValueForProperty(domElement, propKey, propValue, lastRawProps);
@@ -2925,17 +2931,46 @@ function getResourcesFromRoot(root) {
 function markNodeAsHoistable(node) {
   node[internalHoistableMarker] = !0;
 }
-var restoreImpl = null,
-  restoreTarget = null,
+var restoreTarget = null,
   restoreQueue = null;
 function restoreStateOfTarget(target) {
-  if ((target = getInstanceFromNode(target))) {
-    if ("function" !== typeof restoreImpl)
-      throw Error(formatProdErrorMessage(280));
-    var stateNode = target.stateNode;
-    stateNode &&
-      ((stateNode = getFiberCurrentPropsFromNode(stateNode)),
-      restoreImpl(target.stateNode, target.type, stateNode));
+  var internalInstance = getInstanceFromNode(target);
+  if (internalInstance && (target = internalInstance.stateNode)) {
+    var props = getFiberCurrentPropsFromNode(target);
+    a: switch (((target = internalInstance.stateNode), internalInstance.type)) {
+      case "input":
+        updateWrapper$1(target, props);
+        internalInstance = props.name;
+        if ("radio" === props.type && null != internalInstance) {
+          for (props = target; props.parentNode; ) props = props.parentNode;
+          props = props.querySelectorAll(
+            "input[name=" +
+              JSON.stringify("" + internalInstance) +
+              '][type="radio"]'
+          );
+          for (
+            internalInstance = 0;
+            internalInstance < props.length;
+            internalInstance++
+          ) {
+            var otherNode = props[internalInstance];
+            if (otherNode !== target && otherNode.form === target.form) {
+              var otherProps = getFiberCurrentPropsFromNode(otherNode);
+              if (!otherProps) throw Error(formatProdErrorMessage(90));
+              updateValueIfChanged(otherNode);
+              updateWrapper$1(otherNode, otherProps);
+            }
+          }
+        }
+        break a;
+      case "textarea":
+        updateWrapper(target, props);
+        break a;
+      case "select":
+        (internalInstance = props.value),
+          null != internalInstance &&
+            updateOptions(target, !!props.multiple, internalInstance, !1);
+    }
   }
 }
 function enqueueStateRestore(target) {
@@ -2956,7937 +2991,5701 @@ function restoreStateIfNeeded() {
         restoreStateOfTarget(queuedTargets[target]);
   }
 }
-function batchedUpdatesImpl(fn, bookkeeping) {
-  return fn(bookkeeping);
+var emptyContextObject = {},
+  contextStackCursor = createCursor(emptyContextObject),
+  didPerformWorkStackCursor = createCursor(!1),
+  previousContext = emptyContextObject;
+function getMaskedContext(workInProgress, unmaskedContext) {
+  var contextTypes = workInProgress.type.contextTypes;
+  if (!contextTypes) return emptyContextObject;
+  var instance = workInProgress.stateNode;
+  if (
+    instance &&
+    instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
+  )
+    return instance.__reactInternalMemoizedMaskedChildContext;
+  var context = {},
+    key;
+  for (key in contextTypes) context[key] = unmaskedContext[key];
+  instance &&
+    ((workInProgress = workInProgress.stateNode),
+    (workInProgress.__reactInternalMemoizedUnmaskedChildContext =
+      unmaskedContext),
+    (workInProgress.__reactInternalMemoizedMaskedChildContext = context));
+  return context;
 }
-function flushSyncImpl() {}
-var isInsideEventHandler = !1;
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) return fn(a, b);
-  isInsideEventHandler = !0;
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    if (
-      ((isInsideEventHandler = !1),
-      null !== restoreTarget || null !== restoreQueue)
-    )
-      flushSyncImpl(), restoreStateIfNeeded();
-  }
+function isContextProvider(type) {
+  type = type.childContextTypes;
+  return null !== type && void 0 !== type;
 }
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-  if (null === stateNode) return null;
-  var props = getFiberCurrentPropsFromNode(stateNode);
-  if (null === props) return null;
-  stateNode = props[registrationName];
-  a: switch (registrationName) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      (props = !props.disabled) ||
-        ((inst = inst.type),
-        (props = !(
-          "button" === inst ||
-          "input" === inst ||
-          "select" === inst ||
-          "textarea" === inst
-        )));
-      inst = !props;
-      break a;
-    default:
-      inst = !1;
-  }
-  if (inst) return null;
-  if (stateNode && "function" !== typeof stateNode)
-    throw Error(
-      formatProdErrorMessage(231, registrationName, typeof stateNode)
-    );
-  return stateNode;
+function popContext() {
+  pop(didPerformWorkStackCursor);
+  pop(contextStackCursor);
 }
-var passiveBrowserEventsSupported = !1;
-if (canUseDOM)
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = !0;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = !1;
-  }
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
-  throw Error(formatProdErrorMessage(255));
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
+function pushTopLevelContextObject(fiber, context, didChange) {
+  if (contextStackCursor.current !== emptyContextObject)
+    throw Error(formatProdErrorMessage(168));
+  push(contextStackCursor, context);
+  push(didPerformWorkStackCursor, didChange);
 }
-var hasError = !1,
-  caughtError = null,
-  hasRethrowError = !1,
-  rethrowError = null,
-  reporter = {
-    onError: function (error) {
-      hasError = !0;
-      caughtError = error;
-    }
-  };
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = !1;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
+function processChildContext(fiber, type, parentContext) {
+  var instance = fiber.stateNode;
+  type = type.childContextTypes;
+  if ("function" !== typeof instance.getChildContext) return parentContext;
+  instance = instance.getChildContext();
+  for (var contextKey in instance)
+    if (!(contextKey in type))
+      throw Error(
+        formatProdErrorMessage(
+          108,
+          getComponentNameFromFiber(fiber) || "Unknown",
+          contextKey
+        )
+      );
+  return assign({}, parentContext, instance);
 }
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
-  if (hasError) {
-    if (hasError) {
-      var error = caughtError;
-      hasError = !1;
-      caughtError = null;
-    } else throw Error(formatProdErrorMessage(198));
-    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
-  }
+function pushContextProvider(workInProgress) {
+  workInProgress =
+    ((workInProgress = workInProgress.stateNode) &&
+      workInProgress.__reactInternalMemoizedMergedChildContext) ||
+    emptyContextObject;
+  previousContext = contextStackCursor.current;
+  push(contextStackCursor, workInProgress);
+  push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
+  return !0;
 }
-var EventListenerWWW = require("EventListener"),
-  root = null,
-  startText = null,
-  fallbackText = null;
-function getData() {
-  if (fallbackText) return fallbackText;
-  var start,
-    startValue = startText,
-    startLength = startValue.length,
-    end,
-    endValue = "value" in root ? root.value : root.textContent,
-    endLength = endValue.length;
-  for (
-    start = 0;
-    start < startLength && startValue[start] === endValue[start];
-    start++
-  );
-  var minEnd = startLength - start;
-  for (
-    end = 1;
-    end <= minEnd &&
-    startValue[startLength - end] === endValue[endLength - end];
-    end++
-  );
-  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
+function invalidateContextProvider(workInProgress, type, didChange) {
+  var instance = workInProgress.stateNode;
+  if (!instance) throw Error(formatProdErrorMessage(169));
+  didChange
+    ? ((workInProgress = processChildContext(
+        workInProgress,
+        type,
+        previousContext
+      )),
+      (instance.__reactInternalMemoizedMergedChildContext = workInProgress),
+      pop(didPerformWorkStackCursor),
+      pop(contextStackCursor),
+      push(contextStackCursor, workInProgress))
+    : pop(didPerformWorkStackCursor);
+  push(didPerformWorkStackCursor, didChange);
 }
-function getEventCharCode(nativeEvent) {
-  var keyCode = nativeEvent.keyCode;
-  "charCode" in nativeEvent
-    ? ((nativeEvent = nativeEvent.charCode),
-      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
-    : (nativeEvent = keyCode);
-  10 === nativeEvent && (nativeEvent = 13);
-  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
+function is(x, y) {
+  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
 }
-function functionThatReturnsTrue() {
-  return !0;
+var objectIs = "function" === typeof Object.is ? Object.is : is,
+  syncQueue = null,
+  includesLegacySyncCallbacks = !1,
+  isFlushingSyncQueue = !1;
+function scheduleSyncCallback(callback) {
+  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
 }
-function functionThatReturnsFalse() {
-  return !1;
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = !0;
+  scheduleSyncCallback(callback);
 }
-function createSyntheticEvent(Interface) {
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-    for (var propName in Interface)
-      Interface.hasOwnProperty(propName) &&
-        ((reactName = Interface[propName]),
-        (this[propName] = reactName
-          ? reactName(nativeEvent)
-          : nativeEvent[propName]));
-    this.isDefaultPrevented = (
-      null != nativeEvent.defaultPrevented
-        ? nativeEvent.defaultPrevented
-        : !1 === nativeEvent.returnValue
-    )
-      ? functionThatReturnsTrue
-      : functionThatReturnsFalse;
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  }
-  assign(SyntheticBaseEvent.prototype, {
-    preventDefault: function () {
-      this.defaultPrevented = !0;
-      var event = this.nativeEvent;
-      event &&
-        (event.preventDefault
-          ? event.preventDefault()
-          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
-        (this.isDefaultPrevented = functionThatReturnsTrue));
-    },
-    stopPropagation: function () {
-      var event = this.nativeEvent;
-      event &&
-        (event.stopPropagation
-          ? event.stopPropagation()
-          : "unknown" !== typeof event.cancelBubble &&
-            (event.cancelBubble = !0),
-        (this.isPropagationStopped = functionThatReturnsTrue));
-    },
-    persist: function () {},
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
-}
-var EventInterface = {
-    eventPhase: 0,
-    bubbles: 0,
-    cancelable: 0,
-    timeStamp: function (event) {
-      return event.timeStamp || Date.now();
-    },
-    defaultPrevented: 0,
-    isTrusted: 0
-  },
-  SyntheticEvent = createSyntheticEvent(EventInterface),
-  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
-  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
-  lastMovementX,
-  lastMovementY,
-  lastMouseEvent,
-  MouseEventInterface = assign({}, UIEventInterface, {
-    screenX: 0,
-    screenY: 0,
-    clientX: 0,
-    clientY: 0,
-    pageX: 0,
-    pageY: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    getModifierState: getEventModifierState,
-    button: 0,
-    buttons: 0,
-    relatedTarget: function (event) {
-      return void 0 === event.relatedTarget
-        ? event.fromElement === event.srcElement
-          ? event.toElement
-          : event.fromElement
-        : event.relatedTarget;
-    },
-    movementX: function (event) {
-      if ("movementX" in event) return event.movementX;
-      event !== lastMouseEvent &&
-        (lastMouseEvent && "mousemove" === event.type
-          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
-            (lastMovementY = event.screenY - lastMouseEvent.screenY))
-          : (lastMovementY = lastMovementX = 0),
-        (lastMouseEvent = event));
-      return lastMovementX;
-    },
-    movementY: function (event) {
-      return "movementY" in event ? event.movementY : lastMovementY;
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && null !== syncQueue) {
+    isFlushingSyncQueue = !0;
+    var previousUpdatePriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
+      var callback = queue[i];
+      try {
+        do callback = callback(!0);
+        while (null !== callback);
+      } catch (error) {
+        null === errors ? (errors = [error]) : errors.push(error);
+      }
     }
-  }),
-  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
-  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
-  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
-  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
-  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
-  AnimationEventInterface = assign({}, EventInterface, {
-    animationName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
-  ClipboardEventInterface = assign({}, EventInterface, {
-    clipboardData: function (event) {
-      return "clipboardData" in event
-        ? event.clipboardData
-        : window.clipboardData;
+    syncQueue = null;
+    includesLegacySyncCallbacks = !1;
+    currentUpdatePriority = previousUpdatePriority;
+    isFlushingSyncQueue = !1;
+    if (null !== errors) {
+      if (1 < errors.length) {
+        if ("function" === typeof AggregateError)
+          throw new AggregateError(errors);
+        for (
+          previousUpdatePriority = 1;
+          previousUpdatePriority < errors.length;
+          previousUpdatePriority++
+        )
+          scheduleCallback$2(
+            ImmediatePriority,
+            throwError.bind(null, errors[previousUpdatePriority])
+          );
+      }
+      throw errors[0];
     }
-  }),
-  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
-  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
-  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
-  normalizeKey = {
-    Esc: "Escape",
-    Spacebar: " ",
-    Left: "ArrowLeft",
-    Up: "ArrowUp",
-    Right: "ArrowRight",
-    Down: "ArrowDown",
-    Del: "Delete",
-    Win: "OS",
-    Menu: "ContextMenu",
-    Apps: "ContextMenu",
-    Scroll: "ScrollLock",
-    MozPrintableKey: "Unidentified"
-  },
-  translateToKey = {
-    8: "Backspace",
-    9: "Tab",
-    12: "Clear",
-    13: "Enter",
-    16: "Shift",
-    17: "Control",
-    18: "Alt",
-    19: "Pause",
-    20: "CapsLock",
-    27: "Escape",
-    32: " ",
-    33: "PageUp",
-    34: "PageDown",
-    35: "End",
-    36: "Home",
-    37: "ArrowLeft",
-    38: "ArrowUp",
-    39: "ArrowRight",
-    40: "ArrowDown",
-    45: "Insert",
-    46: "Delete",
-    112: "F1",
-    113: "F2",
-    114: "F3",
-    115: "F4",
-    116: "F5",
-    117: "F6",
-    118: "F7",
-    119: "F8",
-    120: "F9",
-    121: "F10",
-    122: "F11",
-    123: "F12",
-    144: "NumLock",
-    145: "ScrollLock",
-    224: "Meta"
-  },
-  modifierKeyToProp = {
-    Alt: "altKey",
-    Control: "ctrlKey",
-    Meta: "metaKey",
-    Shift: "shiftKey"
-  };
-function modifierStateGetter(keyArg) {
-  var nativeEvent = this.nativeEvent;
-  return nativeEvent.getModifierState
-    ? nativeEvent.getModifierState(keyArg)
-    : (keyArg = modifierKeyToProp[keyArg])
-    ? !!nativeEvent[keyArg]
-    : !1;
+  }
+  return null;
 }
-function getEventModifierState() {
-  return modifierStateGetter;
+function throwError(error) {
+  throw error;
 }
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-    key: function (nativeEvent) {
-      if (nativeEvent.key) {
-        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
-        if ("Unidentified" !== key) return key;
-      }
-      return "keypress" === nativeEvent.type
-        ? ((nativeEvent = getEventCharCode(nativeEvent)),
-          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
-        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
-        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
-        : "";
-    },
-    code: 0,
-    location: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    repeat: 0,
-    locale: 0,
-    getModifierState: getEventModifierState,
-    charCode: function (event) {
-      return "keypress" === event.type ? getEventCharCode(event) : 0;
-    },
-    keyCode: function (event) {
-      return "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    },
-    which: function (event) {
-      return "keypress" === event.type
-        ? getEventCharCode(event)
-        : "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    }
-  }),
-  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
-  PointerEventInterface = assign({}, MouseEventInterface, {
-    pointerId: 0,
-    width: 0,
-    height: 0,
-    pressure: 0,
-    tangentialPressure: 0,
-    tiltX: 0,
-    tiltY: 0,
-    twist: 0,
-    pointerType: 0,
-    isPrimary: 0
-  }),
-  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
-  TouchEventInterface = assign({}, UIEventInterface, {
-    touches: 0,
-    targetTouches: 0,
-    changedTouches: 0,
-    altKey: 0,
-    metaKey: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    getModifierState: getEventModifierState
-  }),
-  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
-  TransitionEventInterface = assign({}, EventInterface, {
-    propertyName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
-  WheelEventInterface = assign({}, MouseEventInterface, {
-    deltaX: function (event) {
-      return "deltaX" in event
-        ? event.deltaX
-        : "wheelDeltaX" in event
-        ? -event.wheelDeltaX
-        : 0;
-    },
-    deltaY: function (event) {
-      return "deltaY" in event
-        ? event.deltaY
-        : "wheelDeltaY" in event
-        ? -event.wheelDeltaY
-        : "wheelDelta" in event
-        ? -event.wheelDelta
-        : 0;
-    },
-    deltaZ: 0,
-    deltaMode: 0
-  }),
-  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
-  END_KEYCODES = [9, 13, 27, 32],
-  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
-  documentMode = null;
-canUseDOM &&
-  "documentMode" in document &&
-  (documentMode = document.documentMode);
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
-  useFallbackCompositionData =
-    canUseDOM &&
-    (!canUseCompositionEvent ||
-      (documentMode && 8 < documentMode && 11 >= documentMode)),
-  SPACEBAR_CHAR = String.fromCharCode(32),
-  hasSpaceKeypress = !1;
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
-    case "keydown":
-      return 229 !== nativeEvent.keyCode;
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      return !0;
-    default:
-      return !1;
-  }
-}
-function getDataFromCustomEvent(nativeEvent) {
-  nativeEvent = nativeEvent.detail;
-  return "object" === typeof nativeEvent && "data" in nativeEvent
-    ? nativeEvent.data
-    : null;
-}
-var isComposing = !1;
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
-    case "keypress":
-      if (32 !== nativeEvent.which) return null;
-      hasSpaceKeypress = !0;
-      return SPACEBAR_CHAR;
-    case "textInput":
-      return (
-        (domEventName = nativeEvent.data),
-        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
-      );
-    default:
-      return null;
-  }
+var forkStack = [],
+  forkStackIndex = 0,
+  treeForkProvider = null,
+  treeForkCount = 0,
+  idStack = [],
+  idStackIndex = 0,
+  treeContextProvider = null,
+  treeContextId = 1,
+  treeContextOverflow = "";
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
 }
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  if (isComposing)
-    return "compositionend" === domEventName ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-      ? ((domEventName = getData()),
-        (fallbackText = startText = root = null),
-        (isComposing = !1),
-        domEventName)
-      : null;
-  switch (domEventName) {
-    case "paste":
-      return null;
-    case "keypress":
-      if (
-        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
-        (nativeEvent.ctrlKey && nativeEvent.altKey)
-      ) {
-        if (nativeEvent.char && 1 < nativeEvent.char.length)
-          return nativeEvent.char;
-        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
-      }
-      return null;
-    case "compositionend":
-      return useFallbackCompositionData && "ko" !== nativeEvent.locale
-        ? null
-        : nativeEvent.data;
-    default:
-      return null;
-  }
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  workInProgress = treeContextOverflow;
+  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
+  baseIdWithLeadingBit &= ~(1 << baseLength);
+  index += 1;
+  var length = 32 - clz32(totalChildren) + baseLength;
+  if (30 < length) {
+    var numberOfOverflowBits = baseLength - (baseLength % 5);
+    length = (
+      baseIdWithLeadingBit &
+      ((1 << numberOfOverflowBits) - 1)
+    ).toString(32);
+    baseIdWithLeadingBit >>= numberOfOverflowBits;
+    baseLength -= numberOfOverflowBits;
+    treeContextId =
+      (1 << (32 - clz32(totalChildren) + baseLength)) |
+      (index << baseLength) |
+      baseIdWithLeadingBit;
+    treeContextOverflow = length + workInProgress;
+  } else
+    (treeContextId =
+      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
+      (treeContextOverflow = workInProgress);
 }
-var supportedInputTypes = {
-  color: !0,
-  date: !0,
-  datetime: !0,
-  "datetime-local": !0,
-  email: !0,
-  month: !0,
-  number: !0,
-  password: !0,
-  range: !0,
-  search: !0,
-  tel: !0,
-  text: !0,
-  time: !0,
-  url: !0,
-  week: !0
-};
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return "input" === nodeName
-    ? !!supportedInputTypes[elem.type]
-    : "textarea" === nodeName
-    ? !0
-    : !1;
+function pushMaterializedTreeId(workInProgress) {
+  null !== workInProgress.return &&
+    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
 }
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
-) {
-  enqueueStateRestore(target);
-  inst = accumulateTwoPhaseListeners(inst, "onChange");
-  0 < inst.length &&
-    ((nativeEvent = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    )),
-    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+function popTreeContext(workInProgress) {
+  for (; workInProgress === treeForkProvider; )
+    (treeForkProvider = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null),
+      (treeForkCount = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null);
+  for (; workInProgress === treeContextProvider; )
+    (treeContextProvider = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextOverflow = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextId = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null);
 }
-var activeElement$1 = null,
-  activeElementInst$1 = null;
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
+var hydrationParentFiber = null,
+  nextHydratableInstance = null,
+  isHydrating = !1,
+  hydrationErrors = null,
+  rootOrSingletonContext = !1;
+function deleteHydratableInstance(returnFiber, instance) {
+  var fiber = createFiber(5, null, null, 0);
+  fiber.elementType = "DELETED";
+  fiber.stateNode = instance;
+  fiber.return = returnFiber;
+  instance = returnFiber.deletions;
+  null === instance
+    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
+    : instance.push(fiber);
 }
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
-  if (updateValueIfChanged(targetNode)) return targetInst;
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & -4097) | 2;
 }
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if ("change" === domEventName) return targetInst;
+function tryHydrateInstance(fiber, nextInstance) {
+  var type = fiber.type;
+  nextInstance =
+    1 !== nextInstance.nodeType ||
+    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
+      (rootOrSingletonContext = !1),
+      !0)
+    : !1;
 }
-var isInputEventSupported = !1;
-if (canUseDOM) {
-  var JSCompiler_inline_result$jscomp$280;
-  if (canUseDOM) {
-    var isSupported$jscomp$inline_509 = "oninput" in document;
-    if (!isSupported$jscomp$inline_509) {
-      var element$jscomp$inline_510 = document.createElement("div");
-      element$jscomp$inline_510.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_509 =
-        "function" === typeof element$jscomp$inline_510.oninput;
-    }
-    JSCompiler_inline_result$jscomp$280 = isSupported$jscomp$inline_509;
-  } else JSCompiler_inline_result$jscomp$280 = !1;
-  isInputEventSupported =
-    JSCompiler_inline_result$jscomp$280 &&
-    (!document.documentMode || 9 < document.documentMode);
-}
-function stopWatchingForValueChange() {
-  activeElement$1 &&
-    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
-    (activeElementInst$1 = activeElement$1 = null));
+function tryHydrateText(fiber, nextInstance) {
+  nextInstance =
+    "" === fiber.pendingProps
+      ? null
+      : 3 !== nextInstance.nodeType
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = null),
+      !0)
+    : !1;
 }
-function handlePropertyChange(nativeEvent) {
-  if (
-    "value" === nativeEvent.propertyName &&
-    getInstIfValueChanged(activeElementInst$1)
-  ) {
-    var dispatchQueue = [];
-    createAndAccumulateChangeEvent(
-      dispatchQueue,
-      activeElementInst$1,
-      nativeEvent,
-      getEventTarget(nativeEvent)
-    );
-    batchedUpdates$1(runEventInBatch, dispatchQueue);
+function tryHydrateSuspense(fiber, nextInstance) {
+  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
+  if (null !== nextInstance) {
+    var JSCompiler_inline_result =
+      null !== treeContextProvider
+        ? { id: treeContextId, overflow: treeContextOverflow }
+        : null;
+    fiber.memoizedState = {
+      dehydrated: nextInstance,
+      treeContext: JSCompiler_inline_result,
+      retryLane: 1073741824
+    };
+    JSCompiler_inline_result = createFiber(18, null, null, 0);
+    JSCompiler_inline_result.stateNode = nextInstance;
+    JSCompiler_inline_result.return = fiber;
+    fiber.child = JSCompiler_inline_result;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = null;
+    return !0;
   }
+  return !1;
 }
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  "focusin" === domEventName
-    ? (stopWatchingForValueChange(),
-      (activeElement$1 = target),
-      (activeElementInst$1 = targetInst),
-      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
-    : "focusout" === domEventName && stopWatchingForValueChange();
-}
-function getTargetInstForInputEventPolyfill(domEventName) {
-  if (
-    "selectionchange" === domEventName ||
-    "keyup" === domEventName ||
-    "keydown" === domEventName
-  )
-    return getInstIfValueChanged(activeElementInst$1);
-}
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
-}
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if ("input" === domEventName || "change" === domEventName)
-    return getInstIfValueChanged(targetInst);
+function shouldClientRenderOnMismatch(fiber) {
+  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
 }
-function is(x, y) {
-  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+function throwOnHydrationMismatch() {
+  throw Error(formatProdErrorMessage(418));
 }
-var objectIs = "function" === typeof Object.is ? Object.is : is;
-function shallowEqual(objA, objB) {
-  if (objectIs(objA, objB)) return !0;
-  if (
-    "object" !== typeof objA ||
-    null === objA ||
-    "object" !== typeof objB ||
-    null === objB
+function advanceToFirstAttemptableInstance(fiber) {
+  for (
+    ;
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    );
+
   )
-    return !1;
-  var keysA = Object.keys(objA),
-    keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) return !1;
-  for (keysB = 0; keysB < keysA.length; keysB++) {
-    var currentKey = keysA[keysB];
-    if (
-      !hasOwnProperty.call(objB, currentKey) ||
-      !objectIs(objA[currentKey], objB[currentKey])
-    )
-      return !1;
-  }
-  return !0;
-}
-var skipSelectionChangeEvent =
-    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
-  activeElement = null,
-  activeElementInst = null,
-  lastSelection = null,
-  mouseDown = !1;
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  var doc =
-    nativeEventTarget.window === nativeEventTarget
-      ? nativeEventTarget.document
-      : 9 === nativeEventTarget.nodeType
-      ? nativeEventTarget
-      : nativeEventTarget.ownerDocument;
-  mouseDown ||
-    null == activeElement ||
-    activeElement !== getActiveElement(doc) ||
-    ((doc = activeElement),
-    "selectionStart" in doc && hasSelectionCapabilities(doc)
-      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
-      : ((doc = (
-          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
-          window
-        ).getSelection()),
-        (doc = {
-          anchorNode: doc.anchorNode,
-          anchorOffset: doc.anchorOffset,
-          focusNode: doc.focusNode,
-          focusOffset: doc.focusOffset
-        })),
-    (lastSelection && shallowEqual(lastSelection, doc)) ||
-      ((lastSelection = doc),
-      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
-      0 < doc.length &&
-        ((nativeEvent = new SyntheticEvent(
-          "onSelect",
-          "select",
-          null,
-          nativeEvent,
-          nativeEventTarget
-        )),
-        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
-        (nativeEvent.target = activeElement))));
-}
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
-}
-var vendorPrefixes = {
-    animationend: makePrefixMap("Animation", "AnimationEnd"),
-    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-    animationstart: makePrefixMap("Animation", "AnimationStart"),
-    transitionend: makePrefixMap("Transition", "TransitionEnd")
-  },
-  prefixedEventNames = {},
-  style = {};
-canUseDOM &&
-  ((style = document.createElement("div").style),
-  "AnimationEvent" in window ||
-    (delete vendorPrefixes.animationend.animation,
-    delete vendorPrefixes.animationiteration.animation,
-    delete vendorPrefixes.animationstart.animation),
-  "TransitionEvent" in window ||
-    delete vendorPrefixes.transitionend.transition);
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
-  if (!vendorPrefixes[eventName]) return eventName;
-  var prefixMap = vendorPrefixes[eventName],
-    styleProp;
-  for (styleProp in prefixMap)
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
-  return eventName;
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-var ANIMATION_END = getVendorPrefixedEventName("animationend"),
-  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
-  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
-  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
-  topLevelEventsToReactNames = new Map(),
-  simpleEventPluginEvents =
-    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
-      " "
+function advanceToFirstAttemptableTextInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
     );
-topLevelEventsToReactNames.set("beforeblur", null);
-topLevelEventsToReactNames.set("afterblur", null);
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
 }
-for (
-  var i$jscomp$inline_522 = 0;
-  i$jscomp$inline_522 < simpleEventPluginEvents.length;
-  i$jscomp$inline_522++
-) {
-  var eventName$jscomp$inline_523 =
-      simpleEventPluginEvents[i$jscomp$inline_522],
-    domEventName$jscomp$inline_524 = eventName$jscomp$inline_523.toLowerCase(),
-    capitalizedEvent$jscomp$inline_525 =
-      eventName$jscomp$inline_523[0].toUpperCase() +
-      eventName$jscomp$inline_523.slice(1);
-  registerSimpleEvent(
-    domEventName$jscomp$inline_524,
-    "on" + capitalizedEvent$jscomp$inline_525
-  );
+function advanceToFirstAttemptableSuspenseInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-registerSimpleEvent("dblclick", "onDoubleClick");
-registerSimpleEvent("focusin", "onFocus");
-registerSimpleEvent("focusout", "onBlur");
-registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
-registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
-registerTwoPhaseEvent(
-  "onChange",
-  "change click focusin focusout input keydown keyup selectionchange".split(" ")
-);
-registerTwoPhaseEvent(
-  "onSelect",
-  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
-    " "
-  )
-);
-registerTwoPhaseEvent("onBeforeInput", [
-  "compositionend",
-  "keypress",
-  "textInput",
-  "paste"
-]);
-registerTwoPhaseEvent(
-  "onCompositionEnd",
-  "compositionend focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionStart",
-  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionUpdate",
-  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
-);
-var mediaEventTypes =
-    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
-      " "
-    ),
-  nonDelegatedEvents = new Set(
-    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
-  );
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
-  event.currentTarget = null;
+function prepareToHydrateHostInstance(fiber) {
+  var instance = fiber.stateNode,
+    type = fiber.type,
+    props = fiber.memoizedProps;
+  instance[internalInstanceKey] = fiber;
+  instance[internalPropsKey] = props;
+  switch (type) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", instance);
+      listenToNonDelegatedEvent("close", instance);
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "video":
+    case "audio":
+      for (var i = 0; i < mediaEventTypes.length; i++)
+        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", instance);
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", instance);
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", instance);
+      break;
+    case "input":
+      initWrapperState$2(instance, props);
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "select":
+      instance._wrapperState = { wasMultiple: !!props.multiple };
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "textarea":
+      initWrapperState(instance, props),
+        listenToNonDelegatedEvent("invalid", instance);
+  }
+  assertValidProps(type, props);
+  var updatePayload = null,
+    propKey;
+  for (propKey in props)
+    props.hasOwnProperty(propKey) &&
+      ((i = props[propKey]),
+      "children" === propKey
+        ? "string" === typeof i
+          ? instance.textContent !== i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", i]))
+          : "number" === typeof i &&
+            instance.textContent !== "" + i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", "" + i]))
+        : registrationNameDependencies.hasOwnProperty(propKey) &&
+          null != i &&
+          "onScroll" === propKey &&
+          listenToNonDelegatedEvent("scroll", instance));
+  switch (type) {
+    case "input":
+      track(instance);
+      postMountWrapper$3(instance, props, !0);
+      break;
+    case "textarea":
+      track(instance);
+      postMountWrapper(instance);
+      break;
+    case "select":
+    case "option":
+      break;
+    default:
+      "function" === typeof props.onClick && (instance.onclick = noop$1);
+  }
+  instance = updatePayload;
+  fiber.updateQueue = instance;
+  return null !== instance ? !0 : !1;
 }
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  eventSystemFlags = 0 !== (eventSystemFlags & 4);
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event;
-    _dispatchQueue$i = _dispatchQueue$i.listeners;
+function popToNextHostParent(fiber) {
+  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
+    switch (hydrationParentFiber.tag) {
+      case 3:
+      case 27:
+        rootOrSingletonContext = !0;
+        return;
+      case 5:
+      case 13:
+        rootOrSingletonContext = !1;
+        return;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
+}
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) return !1;
+  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
+  var shouldClear = !1;
+  3 === fiber.tag ||
+    27 === fiber.tag ||
+    (5 === fiber.tag &&
+      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
+    (shouldClear = !0);
+  if (shouldClear && (shouldClear = nextHydratableInstance))
+    if (shouldClientRenderOnMismatch(fiber))
+      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
+    else
+      for (; shouldClear; )
+        deleteHydratableInstance(fiber, shouldClear),
+          (shouldClear = getNextHydratable(shouldClear.nextSibling));
+  popToNextHostParent(fiber);
+  if (13 === fiber.tag) {
+    fiber = fiber.memoizedState;
+    fiber = null !== fiber ? fiber.dehydrated : null;
+    if (!fiber) throw Error(formatProdErrorMessage(317));
     a: {
-      var previousInstance = void 0;
-      if (eventSystemFlags)
-        for (
-          var i$jscomp$0 = _dispatchQueue$i.length - 1;
-          0 <= i$jscomp$0;
-          i$jscomp$0--
-        ) {
-          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
-            instance = _dispatchListeners$i.instance,
-            currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
-      else
-        for (
-          i$jscomp$0 = 0;
-          i$jscomp$0 < _dispatchQueue$i.length;
-          i$jscomp$0++
-        ) {
-          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
-          instance = _dispatchListeners$i.instance;
-          currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
+      fiber = fiber.nextSibling;
+      for (shouldClear = 0; fiber; ) {
+        if (8 === fiber.nodeType) {
+          var data = fiber.data;
+          if ("/$" === data) {
+            if (0 === shouldClear) {
+              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
+              break a;
+            }
+            shouldClear--;
+          } else
+            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
         }
+        fiber = fiber.nextSibling;
+      }
+      nextHydratableInstance = null;
     }
-  }
-  if (hasRethrowError)
-    throw (
-      ((dispatchQueue = rethrowError),
-      (hasRethrowError = !1),
-      (rethrowError = null),
-      dispatchQueue)
-    );
+  } else
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratable(fiber.stateNode.nextSibling)
+      : null;
+  return !0;
 }
-function listenToNonDelegatedEvent(domEventName, targetElement) {
-  var listenerSet = getEventListenerSet(targetElement),
-    listenerSetKey = domEventName + "__bubble";
-  listenerSet.has(listenerSetKey) ||
-    (addTrappedEventListener(targetElement, domEventName, 2, !1),
-    listenerSet.add(listenerSetKey));
+function warnIfUnhydratedTailNodes() {
+  for (var nextInstance = nextHydratableInstance; nextInstance; )
+    nextInstance = getNextHydratable(nextInstance.nextSibling);
 }
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
-  var eventSystemFlags = 0;
-  isCapturePhaseListener && (eventSystemFlags |= 4);
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
+function resetHydrationState() {
+  nextHydratableInstance = hydrationParentFiber = null;
+  isHydrating = !1;
 }
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = !0;
-    allNativeEvents.forEach(function (domEventName) {
-      "selectionchange" !== domEventName &&
-        (nonDelegatedEvents.has(domEventName) ||
-          listenToNativeEvent(domEventName, !1, rootContainerElement),
-        listenToNativeEvent(domEventName, !0, rootContainerElement));
-    });
-    var ownerDocument =
-      9 === rootContainerElement.nodeType
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
-    null === ownerDocument ||
-      ownerDocument[listeningMarker] ||
-      ((ownerDocument[listeningMarker] = !0),
-      listenToNativeEvent("selectionchange", !1, ownerDocument));
-  }
+function queueHydrationError(error) {
+  null === hydrationErrors
+    ? (hydrationErrors = [error])
+    : hydrationErrors.push(error);
 }
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  eventSystemFlags = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  );
-  var isPassiveListener = void 0;
-  !passiveBrowserEventsSupported ||
-    ("touchstart" !== domEventName &&
-      "touchmove" !== domEventName &&
-      "wheel" !== domEventName) ||
-    (isPassiveListener = !0);
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = eventSystemFlags;
-    eventSystemFlags = function () {
-      unsubscribeListener.remove();
-      for (
-        var _len = arguments.length, p = Array(_len), _key = 0;
-        _key < _len;
-        _key++
-      )
-        p[_key] = arguments[_key];
-      return originalListener.apply(this, p);
+var concurrentQueues = [],
+  concurrentQueuesIndex = 0,
+  concurrentlyUpdatedLanes = 0;
+function finishQueueingConcurrentUpdates() {
+  for (
+    var endIndex = concurrentQueuesIndex,
+      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
+    i < endIndex;
+
+  ) {
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    if (null !== queue && null !== update) {
+      var pending = queue.pending;
+      null === pending
+        ? (update.next = update)
+        : ((update.next = pending.next), (pending.next = update));
+      queue.pending = update;
+    }
+    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+  }
+}
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes |= lane;
+  fiber.lanes |= lane;
+  fiber = fiber.alternate;
+  null !== fiber && (fiber.lanes |= lane);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  sourceFiber.lanes |= lane;
+  var alternate = sourceFiber.alternate;
+  null !== alternate && (alternate.lanes |= lane);
+  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
+    (parent.childLanes |= lane),
+      (alternate = parent.alternate),
+      null !== alternate && (alternate.childLanes |= lane),
+      22 === parent.tag &&
+        ((sourceFiber = parent.stateNode),
+        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
+      (sourceFiber = parent),
+      (parent = parent.return);
+  isHidden &&
+    null !== update &&
+    3 === sourceFiber.tag &&
+    ((parent = sourceFiber.stateNode),
+    (isHidden = 31 - clz32(lane)),
+    (parent = parent.hiddenUpdates),
+    (sourceFiber = parent[isHidden]),
+    null === sourceFiber
+      ? (parent[isHidden] = [update])
+      : sourceFiber.push(update),
+    (update.lane = lane | 1073741824));
+}
+function getRootForUpdatedFiber(sourceFiber) {
+  if (50 < nestedUpdateCount)
+    throw (
+      ((nestedUpdateCount = 0),
+      (rootWithNestedUpdates = null),
+      Error(formatProdErrorMessage(185)))
+    );
+  for (var parent = sourceFiber.return; null !== parent; )
+    (sourceFiber = parent), (parent = sourceFiber.return);
+  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
+}
+var hasForceUpdate = !1;
+function initializeUpdateQueue(fiber) {
+  fiber.updateQueue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
+    callbacks: null
+  };
+}
+function cloneUpdateQueue(current, workInProgress) {
+  current = current.updateQueue;
+  workInProgress.updateQueue === current &&
+    (workInProgress.updateQueue = {
+      baseState: current.baseState,
+      firstBaseUpdate: current.firstBaseUpdate,
+      lastBaseUpdate: current.lastBaseUpdate,
+      shared: current.shared,
+      callbacks: null
+    });
+}
+function createUpdate(lane) {
+  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
+}
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
+  if (null === updateQueue) return null;
+  updateQueue = updateQueue.shared;
+  if (
+    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
+    0 === (executionContext & 2)
+  )
+    return (
+      enqueueUpdate$1(fiber, updateQueue, update, lane),
+      getRootForUpdatedFiber(fiber)
+    );
+  var pending = updateQueue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  updateQueue.pending = update;
+  update = getRootForUpdatedFiber(fiber);
+  markUpdateLaneFromFiberToRoot(fiber, null, lane);
+  return update;
+}
+function entangleTransitions(root, fiber, lane) {
+  fiber = fiber.updateQueue;
+  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
+    var queueLanes = fiber.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    fiber.lanes = lane;
+    markRootEntangled(root, lane);
+  }
+}
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  var queue = workInProgress.updateQueue,
+    current = workInProgress.alternate;
+  if (
+    null !== current &&
+    ((current = current.updateQueue), queue === current)
+  ) {
+    var newFirst = null,
+      newLast = null;
+    queue = queue.firstBaseUpdate;
+    if (null !== queue) {
+      do {
+        var clone = {
+          lane: queue.lane,
+          tag: queue.tag,
+          payload: queue.payload,
+          callback: null,
+          next: null
+        };
+        null === newLast
+          ? (newFirst = newLast = clone)
+          : (newLast = newLast.next = clone);
+        queue = queue.next;
+      } while (null !== queue);
+      null === newLast
+        ? (newFirst = newLast = capturedUpdate)
+        : (newLast = newLast.next = capturedUpdate);
+    } else newFirst = newLast = capturedUpdate;
+    queue = {
+      baseState: current.baseState,
+      firstBaseUpdate: newFirst,
+      lastBaseUpdate: newLast,
+      shared: current.shared,
+      callbacks: current.callbacks
     };
+    workInProgress.updateQueue = queue;
+    return;
   }
-  var unsubscribeListener = isCapturePhaseListener
-    ? void 0 !== isPassiveListener
-      ? EventListenerWWW.captureWithPassiveFlag(
-          targetContainer,
-          domEventName,
-          eventSystemFlags,
-          isPassiveListener
-        )
-      : EventListenerWWW.capture(
-          targetContainer,
-          domEventName,
-          eventSystemFlags
-        )
-    : void 0 !== isPassiveListener
-    ? EventListenerWWW.bubbleWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        eventSystemFlags,
-        isPassiveListener
-      )
-    : EventListenerWWW.listen(targetContainer, domEventName, eventSystemFlags);
+  workInProgress = queue.lastBaseUpdate;
+  null === workInProgress
+    ? (queue.firstBaseUpdate = capturedUpdate)
+    : (workInProgress.next = capturedUpdate);
+  queue.lastBaseUpdate = capturedUpdate;
 }
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst$jscomp$0,
-  targetContainer
+function processUpdateQueue(
+  workInProgress$jscomp$0,
+  props,
+  instance$jscomp$0,
+  renderLanes
 ) {
-  var ancestorInst = targetInst$jscomp$0;
-  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
-    if (
-      enableLegacyFBSupport &&
-      "click" === domEventName &&
-      0 === (eventSystemFlags & 20) &&
-      nativeEvent !== currentReplayingEvent
-    ) {
-      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
-      return;
-    }
-    if (null !== targetInst$jscomp$0)
-      a: for (;;) {
-        if (null === targetInst$jscomp$0) return;
-        var nodeTag = targetInst$jscomp$0.tag;
-        if (3 === nodeTag || 4 === nodeTag) {
-          var container = targetInst$jscomp$0.stateNode.containerInfo;
-          if (
-            container === targetContainer ||
-            (8 === container.nodeType &&
-              container.parentNode === targetContainer)
-          )
-            break;
-          if (4 === nodeTag)
-            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
-              var grandTag = nodeTag.tag;
-              if (3 === grandTag || 4 === grandTag)
-                if (
-                  ((grandTag = nodeTag.stateNode.containerInfo),
-                  grandTag === targetContainer ||
-                    (8 === grandTag.nodeType &&
-                      grandTag.parentNode === targetContainer))
-                )
-                  return;
-              nodeTag = nodeTag.return;
-            }
-          for (; null !== container; ) {
-            nodeTag = getClosestInstanceFromNode(container);
-            if (null === nodeTag) return;
-            grandTag = nodeTag.tag;
-            if (
-              5 === grandTag ||
-              6 === grandTag ||
-              26 === grandTag ||
-              27 === grandTag
-            ) {
-              targetInst$jscomp$0 = ancestorInst = nodeTag;
-              continue a;
-            }
-            container = container.parentNode;
+  var queue = workInProgress$jscomp$0.updateQueue;
+  hasForceUpdate = !1;
+  var firstBaseUpdate = queue.firstBaseUpdate,
+    lastBaseUpdate = queue.lastBaseUpdate,
+    pendingQueue = queue.shared.pending;
+  if (null !== pendingQueue) {
+    queue.shared.pending = null;
+    var lastPendingUpdate = pendingQueue,
+      firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null;
+    null === lastBaseUpdate
+      ? (firstBaseUpdate = firstPendingUpdate)
+      : (lastBaseUpdate.next = firstPendingUpdate);
+    lastBaseUpdate = lastPendingUpdate;
+    var current = workInProgress$jscomp$0.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      (pendingQueue = current.lastBaseUpdate),
+      pendingQueue !== lastBaseUpdate &&
+        (null === pendingQueue
+          ? (current.firstBaseUpdate = firstPendingUpdate)
+          : (pendingQueue.next = firstPendingUpdate),
+        (current.lastBaseUpdate = lastPendingUpdate)));
+  }
+  if (null !== firstBaseUpdate) {
+    var newState = queue.baseState;
+    lastBaseUpdate = 0;
+    current = firstPendingUpdate = lastPendingUpdate = null;
+    pendingQueue = firstBaseUpdate;
+    do {
+      var updateLane = pendingQueue.lane & -1073741825,
+        isHiddenUpdate = updateLane !== pendingQueue.lane;
+      if (
+        isHiddenUpdate
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes & updateLane) === updateLane
+      ) {
+        null !== current &&
+          (current = current.next =
+            {
+              lane: 0,
+              tag: pendingQueue.tag,
+              payload: pendingQueue.payload,
+              callback: null,
+              next: null
+            });
+        a: {
+          var workInProgress = workInProgress$jscomp$0,
+            update = pendingQueue;
+          updateLane = props;
+          var instance = instance$jscomp$0;
+          switch (update.tag) {
+            case 1:
+              workInProgress = update.payload;
+              if ("function" === typeof workInProgress) {
+                newState = workInProgress.call(instance, newState, updateLane);
+                break a;
+              }
+              newState = workInProgress;
+              break a;
+            case 3:
+              workInProgress.flags = (workInProgress.flags & -65537) | 128;
+            case 0:
+              workInProgress = update.payload;
+              updateLane =
+                "function" === typeof workInProgress
+                  ? workInProgress.call(instance, newState, updateLane)
+                  : workInProgress;
+              if (null === updateLane || void 0 === updateLane) break a;
+              newState = assign({}, newState, updateLane);
+              break a;
+            case 2:
+              hasForceUpdate = !0;
           }
         }
-        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+        updateLane = pendingQueue.callback;
+        null !== updateLane &&
+          ((workInProgress$jscomp$0.flags |= 64),
+          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
+          (isHiddenUpdate = queue.callbacks),
+          null === isHiddenUpdate
+            ? (queue.callbacks = [updateLane])
+            : isHiddenUpdate.push(updateLane));
+      } else
+        (isHiddenUpdate = {
+          lane: updateLane,
+          tag: pendingQueue.tag,
+          payload: pendingQueue.payload,
+          callback: pendingQueue.callback,
+          next: null
+        }),
+          null === current
+            ? ((firstPendingUpdate = current = isHiddenUpdate),
+              (lastPendingUpdate = newState))
+            : (current = current.next = isHiddenUpdate),
+          (lastBaseUpdate |= updateLane);
+      pendingQueue = pendingQueue.next;
+      if (null === pendingQueue)
+        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
+          break;
+        else
+          (isHiddenUpdate = pendingQueue),
+            (pendingQueue = isHiddenUpdate.next),
+            (isHiddenUpdate.next = null),
+            (queue.lastBaseUpdate = isHiddenUpdate),
+            (queue.shared.pending = null);
+    } while (1);
+    null === current && (lastPendingUpdate = newState);
+    queue.baseState = lastPendingUpdate;
+    queue.firstBaseUpdate = firstPendingUpdate;
+    queue.lastBaseUpdate = current;
+    null === firstBaseUpdate && (queue.shared.lanes = 0);
+    workInProgressRootSkippedLanes |= lastBaseUpdate;
+    workInProgress$jscomp$0.lanes = lastBaseUpdate;
+    workInProgress$jscomp$0.memoizedState = newState;
+  }
+}
+function callCallback(callback, context) {
+  if ("function" !== typeof callback)
+    throw Error(formatProdErrorMessage(191, callback));
+  callback.call(context);
+}
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
+  if (null !== callbacks)
+    for (
+      updateQueue.callbacks = null, updateQueue = 0;
+      updateQueue < callbacks.length;
+      updateQueue++
+    )
+      callCallback(callbacks[updateQueue], context);
+}
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) return !0;
+  if (
+    "object" !== typeof objA ||
+    null === objA ||
+    "object" !== typeof objB ||
+    null === objB
+  )
+    return !1;
+  var keysA = Object.keys(objA),
+    keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return !1;
+  for (keysB = 0; keysB < keysA.length; keysB++) {
+    var currentKey = keysA[keysB];
+    if (
+      !hasOwnProperty.call(objB, currentKey) ||
+      !objectIs(objA[currentKey], objB[currentKey])
+    )
+      return !1;
+  }
+  return !0;
+}
+var SuspenseException = Error(formatProdErrorMessage(460));
+function isThenableResolved(thenable) {
+  thenable = thenable.status;
+  return "fulfilled" === thenable || "rejected" === thenable;
+}
+function noop() {}
+function trackUsedThenable(thenableState, thenable, index) {
+  index = thenableState[index];
+  void 0 === index
+    ? thenableState.push(thenable)
+    : index !== thenable && (thenable.then(noop, noop), (thenable = index));
+  switch (thenable.status) {
+    case "fulfilled":
+      return thenable.value;
+    case "rejected":
+      throw thenable.reason;
+    default:
+      "string" === typeof thenable.status
+        ? thenable.then(noop, noop)
+        : ((thenableState = thenable),
+          (thenableState.status = "pending"),
+          thenableState.then(
+            function (fulfilledValue) {
+              if ("pending" === thenable.status) {
+                var fulfilledThenable = thenable;
+                fulfilledThenable.status = "fulfilled";
+                fulfilledThenable.value = fulfilledValue;
+              }
+            },
+            function (error) {
+              if ("pending" === thenable.status) {
+                var rejectedThenable = thenable;
+                rejectedThenable.status = "rejected";
+                rejectedThenable.reason = error;
+              }
+            }
+          ));
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
       }
+      suspendedThenable = thenable;
+      throw SuspenseException;
   }
-  batchedUpdates$1(function () {
-    var targetInst = ancestorInst,
-      nativeEventTarget = getEventTarget(nativeEvent),
-      dispatchQueue = [];
-    a: {
-      var reactName = topLevelEventsToReactNames.get(domEventName);
-      if (void 0 !== reactName) {
-        var SyntheticEventCtor = SyntheticEvent,
-          reactEventType = domEventName;
-        switch (domEventName) {
-          case "keypress":
-            if (0 === getEventCharCode(nativeEvent)) break a;
-          case "keydown":
-          case "keyup":
-            SyntheticEventCtor = SyntheticKeyboardEvent;
-            break;
-          case "focusin":
-            reactEventType = "focus";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "focusout":
-            reactEventType = "blur";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "beforeblur":
-          case "afterblur":
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "click":
-            if (2 === nativeEvent.button) break a;
-          case "auxclick":
-          case "dblclick":
-          case "mousedown":
-          case "mousemove":
-          case "mouseup":
-          case "mouseout":
-          case "mouseover":
-          case "contextmenu":
-            SyntheticEventCtor = SyntheticMouseEvent;
-            break;
-          case "drag":
-          case "dragend":
-          case "dragenter":
-          case "dragexit":
-          case "dragleave":
-          case "dragover":
-          case "dragstart":
-          case "drop":
-            SyntheticEventCtor = SyntheticDragEvent;
-            break;
-          case "touchcancel":
-          case "touchend":
-          case "touchmove":
-          case "touchstart":
-            SyntheticEventCtor = SyntheticTouchEvent;
-            break;
-          case ANIMATION_END:
-          case ANIMATION_ITERATION:
-          case ANIMATION_START:
-            SyntheticEventCtor = SyntheticAnimationEvent;
-            break;
-          case TRANSITION_END:
-            SyntheticEventCtor = SyntheticTransitionEvent;
-            break;
-          case "scroll":
-            SyntheticEventCtor = SyntheticUIEvent;
-            break;
-          case "wheel":
-            SyntheticEventCtor = SyntheticWheelEvent;
-            break;
-          case "copy":
-          case "cut":
-          case "paste":
-            SyntheticEventCtor = SyntheticClipboardEvent;
-            break;
-          case "gotpointercapture":
-          case "lostpointercapture":
-          case "pointercancel":
-          case "pointerdown":
-          case "pointermove":
-          case "pointerout":
-          case "pointerover":
-          case "pointerup":
-            SyntheticEventCtor = SyntheticPointerEvent;
-        }
-        var inCapturePhase = 0 !== (eventSystemFlags & 4);
-        eventSystemFlags & 1
-          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
-              reactEventType,
-              targetContainer,
-              inCapturePhase
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })))
-          : ((inCapturePhase = accumulateSinglePhaseListeners(
-              targetInst,
-              reactName,
-              nativeEvent.type,
-              inCapturePhase,
-              !inCapturePhase && "scroll" === domEventName,
-              nativeEvent
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })));
+}
+var suspendedThenable = null,
+  thenableState$1 = null,
+  thenableIndexCounter$1 = 0;
+function unwrapThenable(thenable) {
+  var index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+  null === thenableState$1 && (thenableState$1 = []);
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
+function coerceRef(returnFiber, current, element) {
+  returnFiber = element.ref;
+  if (
+    null !== returnFiber &&
+    "function" !== typeof returnFiber &&
+    "object" !== typeof returnFiber
+  ) {
+    if (element._owner) {
+      element = element._owner;
+      if (element) {
+        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
+        var inst = element.stateNode;
       }
+      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
+      var resolvedInst = inst,
+        stringRef = "" + returnFiber;
+      if (
+        null !== current &&
+        null !== current.ref &&
+        "function" === typeof current.ref &&
+        current.ref._stringRef === stringRef
+      )
+        return current.ref;
+      current = function (value) {
+        var refs = resolvedInst.refs;
+        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
+      };
+      current._stringRef = stringRef;
+      return current;
     }
-    if (0 === (eventSystemFlags & 7)) {
-      a: {
-        reactName =
-          "mouseover" === domEventName || "pointerover" === domEventName;
-        SyntheticEventCtor =
-          "mouseout" === domEventName || "pointerout" === domEventName;
-        if (
-          reactName &&
-          nativeEvent !== currentReplayingEvent &&
-          (reactEventType =
-            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
-          (getClosestInstanceFromNode(reactEventType) ||
-            reactEventType[internalContainerInstanceKey])
-        )
-          break a;
-        if (SyntheticEventCtor || reactName) {
-          reactName =
-            nativeEventTarget.window === nativeEventTarget
-              ? nativeEventTarget
-              : (reactName = nativeEventTarget.ownerDocument)
-              ? reactName.defaultView || reactName.parentWindow
-              : window;
-          if (SyntheticEventCtor) {
-            if (
-              ((reactEventType =
-                nativeEvent.relatedTarget || nativeEvent.toElement),
-              (SyntheticEventCtor = targetInst),
-              (reactEventType = reactEventType
-                ? getClosestInstanceFromNode(reactEventType)
-                : null),
-              null !== reactEventType)
-            ) {
-              inCapturePhase = getNearestMountedFiber(reactEventType);
-              var tag = reactEventType.tag;
-              if (
-                reactEventType !== inCapturePhase ||
-                (5 !== tag && 27 !== tag && 6 !== tag)
-              )
-                reactEventType = null;
-            }
-          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
-          if (SyntheticEventCtor !== reactEventType) {
-            tag = SyntheticMouseEvent;
-            var leaveEventType = "onMouseLeave",
-              enterEventType = "onMouseEnter",
-              eventTypePrefix = "mouse";
-            if ("pointerout" === domEventName || "pointerover" === domEventName)
-              (tag = SyntheticPointerEvent),
-                (leaveEventType = "onPointerLeave"),
-                (enterEventType = "onPointerEnter"),
-                (eventTypePrefix = "pointer");
-            inCapturePhase =
-              null == SyntheticEventCtor
-                ? reactName
-                : getNodeFromInstance(SyntheticEventCtor);
-            var toNode =
-              null == reactEventType
-                ? reactName
-                : getNodeFromInstance(reactEventType);
-            reactName = new tag(
-              leaveEventType,
-              eventTypePrefix + "leave",
-              SyntheticEventCtor,
-              nativeEvent,
-              nativeEventTarget
-            );
-            reactName.target = inCapturePhase;
-            reactName.relatedTarget = toNode;
-            leaveEventType = null;
-            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
-              ((tag = new tag(
-                enterEventType,
-                eventTypePrefix + "enter",
-                reactEventType,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              (tag.target = toNode),
-              (tag.relatedTarget = inCapturePhase),
-              (leaveEventType = tag));
-            inCapturePhase = leaveEventType;
-            if (SyntheticEventCtor && reactEventType)
-              b: {
-                tag = SyntheticEventCtor;
-                enterEventType = reactEventType;
-                eventTypePrefix = 0;
-                for (toNode = tag; toNode; toNode = getParent(toNode))
-                  eventTypePrefix++;
-                toNode = 0;
-                for (
-                  leaveEventType = enterEventType;
-                  leaveEventType;
-                  leaveEventType = getParent(leaveEventType)
-                )
-                  toNode++;
-                for (; 0 < eventTypePrefix - toNode; )
-                  (tag = getParent(tag)), eventTypePrefix--;
-                for (; 0 < toNode - eventTypePrefix; )
-                  (enterEventType = getParent(enterEventType)), toNode--;
-                for (; eventTypePrefix--; ) {
-                  if (
-                    tag === enterEventType ||
-                    (null !== enterEventType &&
-                      tag === enterEventType.alternate)
-                  )
-                    break b;
-                  tag = getParent(tag);
-                  enterEventType = getParent(enterEventType);
-                }
-                tag = null;
-              }
-            else tag = null;
-            null !== SyntheticEventCtor &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                reactName,
-                SyntheticEventCtor,
-                tag,
-                !1
-              );
-            null !== reactEventType &&
-              null !== inCapturePhase &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                inCapturePhase,
-                reactEventType,
-                tag,
-                !0
-              );
-          }
-        }
-      }
-      a: {
-        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
-        SyntheticEventCtor =
-          reactName.nodeName && reactName.nodeName.toLowerCase();
-        if (
-          "select" === SyntheticEventCtor ||
-          ("input" === SyntheticEventCtor && "file" === reactName.type)
-        )
-          var getTargetInstFunc = getTargetInstForChangeEvent;
-        else if (isTextInputElement(reactName))
-          if (isInputEventSupported)
-            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-          else {
-            getTargetInstFunc = getTargetInstForInputEventPolyfill;
-            var handleEventFunc = handleEventsForInputEventPolyfill;
-          }
-        else
-          (SyntheticEventCtor = reactName.nodeName),
-            !SyntheticEventCtor ||
-            "input" !== SyntheticEventCtor.toLowerCase() ||
-            ("checkbox" !== reactName.type && "radio" !== reactName.type)
-              ? enableCustomElementPropertySupport &&
-                targetInst &&
-                isCustomComponent(
-                  targetInst.elementType,
-                  targetInst.memoizedProps
-                ) &&
-                (getTargetInstFunc = getTargetInstForChangeEvent)
-              : (getTargetInstFunc = getTargetInstForClickEvent);
-        if (
-          getTargetInstFunc &&
-          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
-        ) {
-          createAndAccumulateChangeEvent(
-            dispatchQueue,
-            getTargetInstFunc,
-            nativeEvent,
-            nativeEventTarget
-          );
-          break a;
-        }
-        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
-        "focusout" === domEventName &&
-          (handleEventFunc = reactName._wrapperState) &&
-          handleEventFunc.controlled &&
-          "number" === reactName.type &&
-          (disableInputAttributeSyncing ||
-            setDefaultValue(reactName, "number", reactName.value));
-      }
-      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
-      switch (domEventName) {
-        case "focusin":
-          if (
-            isTextInputElement(handleEventFunc) ||
-            "true" === handleEventFunc.contentEditable
-          )
-            (activeElement = handleEventFunc),
-              (activeElementInst = targetInst),
-              (lastSelection = null);
-          break;
-        case "focusout":
-          lastSelection = activeElementInst = activeElement = null;
-          break;
-        case "mousedown":
-          mouseDown = !0;
-          break;
-        case "contextmenu":
-        case "mouseup":
-        case "dragend":
-          mouseDown = !1;
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-          break;
-        case "selectionchange":
-          if (skipSelectionChangeEvent) break;
-        case "keydown":
-        case "keyup":
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-      }
-      var fallbackData;
-      if (canUseCompositionEvent)
-        b: {
-          switch (domEventName) {
-            case "compositionstart":
-              var eventType = "onCompositionStart";
-              break b;
-            case "compositionend":
-              eventType = "onCompositionEnd";
-              break b;
-            case "compositionupdate":
-              eventType = "onCompositionUpdate";
-              break b;
-          }
-          eventType = void 0;
-        }
-      else
-        isComposing
-          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
-            (eventType = "onCompositionEnd")
-          : "keydown" === domEventName &&
-            229 === nativeEvent.keyCode &&
-            (eventType = "onCompositionStart");
-      eventType &&
-        (useFallbackCompositionData &&
-          "ko" !== nativeEvent.locale &&
-          (isComposing || "onCompositionStart" !== eventType
-            ? "onCompositionEnd" === eventType &&
-              isComposing &&
-              (fallbackData = getData())
-            : ((root = nativeEventTarget),
-              (startText = "value" in root ? root.value : root.textContent),
-              (isComposing = !0))),
-        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
-        0 < handleEventFunc.length &&
-          ((eventType = new SyntheticCompositionEvent(
-            eventType,
-            domEventName,
-            null,
-            nativeEvent,
-            nativeEventTarget
-          )),
-          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
-          fallbackData
-            ? (eventType.data = fallbackData)
-            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
-              null !== fallbackData && (eventType.data = fallbackData))));
-      if (
-        (fallbackData = canUseTextInputEvent
-          ? getNativeBeforeInputChars(domEventName, nativeEvent)
-          : getFallbackBeforeInputChars(domEventName, nativeEvent))
-      )
-        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
-          0 < targetInst.length &&
-            ((nativeEventTarget = new SyntheticCompositionEvent(
-              "onBeforeInput",
-              "beforeinput",
-              null,
-              nativeEvent,
-              nativeEventTarget
-            )),
-            dispatchQueue.push({
-              event: nativeEventTarget,
-              listeners: targetInst
-            }),
-            (nativeEventTarget.data = fallbackData));
-    }
-    processDispatchQueue(dispatchQueue, eventSystemFlags);
-  });
+    if ("string" !== typeof returnFiber)
+      throw Error(formatProdErrorMessage(284));
+    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
+  }
+  return returnFiber;
 }
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  returnFiber = Object.prototype.toString.call(newChild);
+  throw Error(
+    formatProdErrorMessage(
+      31,
+      "[object Object]" === returnFiber
+        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
+        : returnFiber
+    )
+  );
 }
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  reactName = inCapturePhase
-    ? null !== reactName
-      ? reactName + "Capture"
-      : null
-    : reactName;
-  for (
-    var listeners = [], instance = targetFiber, lastHostComponent = null;
-    null !== instance;
-
-  ) {
-    var _instance = instance;
-    targetFiber = _instance.stateNode;
-    _instance = _instance.tag;
-    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
-    null === targetFiber
-      ? 21 === _instance &&
-        null !== lastHostComponent &&
-        null !== targetFiber &&
-        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }))
-      : ((lastHostComponent = targetFiber),
-        (targetFiber =
-          lastHostComponent[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }),
-        null !== reactName &&
-          ((targetFiber = getListener(instance, reactName)),
-          null != targetFiber &&
-            listeners.push(
-              createDispatchListener(instance, targetFiber, lastHostComponent)
-            )));
-    if (accumulateTargetOnly) break;
-    "beforeblur" === nativeEvent.type &&
-      ((targetFiber = nativeEvent._detachedInterceptFiber),
-      null === targetFiber ||
-        (targetFiber !== instance && targetFiber !== instance.alternate) ||
-        (listeners = []));
-    instance = instance.return;
-  }
-  return listeners;
+function resolveLazy(lazyType) {
+  var init = lazyType._init;
+  return init(lazyType._payload);
 }
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  for (
-    var captureName = reactName + "Capture", listeners = [];
-    null !== targetFiber;
-
-  ) {
-    var _instance2 = targetFiber,
-      stateNode = _instance2.stateNode;
-    _instance2 = _instance2.tag;
-    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
-      null === stateNode ||
-      ((_instance2 = getListener(targetFiber, captureName)),
-      null != _instance2 &&
-        listeners.unshift(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ),
-      (_instance2 = getListener(targetFiber, reactName)),
-      null != _instance2 &&
-        listeners.push(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ));
-    targetFiber = targetFiber.return;
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (shouldTrackSideEffects) {
+      var deletions = returnFiber.deletions;
+      null === deletions
+        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
+        : deletions.push(childToDelete);
+    }
   }
-  return listeners;
-}
-function getParent(inst) {
-  if (null === inst) return null;
-  do inst = inst.return;
-  while (inst && 5 !== inst.tag && 27 !== inst.tag);
-  return inst ? inst : null;
-}
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  for (
-    var registrationName = event._reactName, listeners = [];
-    null !== target && target !== common;
-
-  ) {
-    var _instance3 = target,
-      alternate = _instance3.alternate,
-      stateNode = _instance3.stateNode;
-    _instance3 = _instance3.tag;
-    if (null !== alternate && alternate === common) break;
-    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
-      null === stateNode ||
-      ((alternate = stateNode),
-      inCapturePhase
-        ? ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.unshift(
-              createDispatchListener(target, stateNode, alternate)
-            ))
-        : inCapturePhase ||
-          ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.push(
-              createDispatchListener(target, stateNode, alternate)
-            )));
-    target = target.return;
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) return null;
+    for (; null !== currentFirstChild; )
+      deleteChild(returnFiber, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return null;
   }
-  0 !== listeners.length &&
-    dispatchQueue.push({ event: event, listeners: listeners });
-}
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [],
-    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
-  null !== eventListeners &&
-    eventListeners.forEach(function (entry) {
-      entry.type === reactEventType &&
-        entry.capture === inCapturePhase &&
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
-        );
-    });
-  return listeners;
-}
-var _attemptSynchronousHydration,
-  attemptDiscreteHydration$1,
-  attemptContinuousHydration$1,
-  attemptHydrationAtCurrentPriority$1,
-  getCurrentUpdatePriority,
-  attemptHydrationAtPriority,
-  hasScheduledReplayAttempt = !1,
-  queuedDiscreteEvents = [],
-  queuedFocus = null,
-  queuedDrag = null,
-  queuedMouse = null,
-  queuedPointers = new Map(),
-  queuedPointerCaptures = new Map(),
-  queuedExplicitHydrationTargets = [],
-  discreteReplayableEvents =
-    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
-      " "
-    );
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
-}
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
-    ((blockedOn = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )),
-    queuedDiscreteEvents.push(blockedOn),
-    1 === queuedDiscreteEvents.length)
-  )
-    for (; null !== blockedOn.blockedOn; ) {
-      domEventName = getInstanceFromNode(blockedOn.blockedOn);
-      if (null === domEventName) break;
-      _attemptSynchronousHydration(domEventName);
-      if (null === blockedOn.blockedOn) replayUnblockedEvents();
-      else break;
-    }
-}
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
-    case "pointerover":
-    case "pointerout":
-      queuedPointers.delete(nativeEvent.pointerId);
-      break;
-    case "gotpointercapture":
-    case "lostpointercapture":
-      queuedPointerCaptures.delete(nativeEvent.pointerId);
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    for (returnFiber = new Map(); null !== currentFirstChild; )
+      null !== currentFirstChild.key
+        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
+        : returnFiber.set(currentFirstChild.index, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return returnFiber;
   }
-}
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    null === existingQueuedEvent ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
-  )
-    return (
-      (existingQueuedEvent = createQueuedReplayableEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )),
-      null !== blockedOn &&
-        ((blockedOn = getInstanceFromNode(blockedOn)),
-        null !== blockedOn && attemptContinuousHydration$1(blockedOn)),
-      existingQueuedEvent
-    );
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  blockedOn = existingQueuedEvent.targetContainers;
-  null !== targetContainer &&
-    -1 === blockedOn.indexOf(targetContainer) &&
-    blockedOn.push(targetContainer);
-  return existingQueuedEvent;
-}
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  switch (domEventName) {
-    case "focusin":
+  function useFiber(fiber, pendingProps) {
+    fiber = createWorkInProgress(fiber, pendingProps);
+    fiber.index = 0;
+    fiber.sibling = null;
+    return fiber;
+  }
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+    if (!shouldTrackSideEffects)
+      return (newFiber.flags |= 1048576), lastPlacedIndex;
+    newIndex = newFiber.alternate;
+    if (null !== newIndex)
       return (
-        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedFocus,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
+        (newIndex = newIndex.index),
+        newIndex < lastPlacedIndex
+          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
+          : newIndex
       );
-    case "dragenter":
+    newFiber.flags |= 16777218;
+    return lastPlacedIndex;
+  }
+  function placeSingleChild(newFiber) {
+    shouldTrackSideEffects &&
+      null === newFiber.alternate &&
+      (newFiber.flags |= 16777218);
+    return newFiber;
+  }
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (null === current || 6 !== current.tag)
       return (
-        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedDrag,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
+        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
       );
-    case "mouseover":
-      return (
-        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedMouse,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "pointerover":
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
+    current = useFiber(current, textContent);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateElement(returnFiber, current, element, lanes) {
+    var elementType = element.type;
+    if (elementType === REACT_FRAGMENT_TYPE)
+      return updateFragment(
+        returnFiber,
+        current,
+        element.props.children,
+        lanes,
+        element.key
       );
-      return !0;
-    case "gotpointercapture":
+    if (
+      null !== current &&
+      (current.elementType === elementType ||
+        ("object" === typeof elementType &&
+          null !== elementType &&
+          elementType.$$typeof === REACT_LAZY_TYPE &&
+          resolveLazy(elementType) === current.type))
+    )
       return (
-        (pointerId = nativeEvent.pointerId),
-        queuedPointerCaptures.set(
-          pointerId,
-          accumulateOrCreateContinuousQueuedReplayableEvent(
-            queuedPointerCaptures.get(pointerId) || null,
-            blockedOn,
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          )
-        ),
-        !0
+        (lanes = useFiber(current, element.props)),
+        (lanes.ref = coerceRef(returnFiber, current, element)),
+        (lanes.return = returnFiber),
+        lanes
       );
+    lanes = createFiberFromTypeAndProps(
+      element.type,
+      element.key,
+      element.props,
+      null,
+      returnFiber.mode,
+      lanes
+    );
+    lanes.ref = coerceRef(returnFiber, current, element);
+    lanes.return = returnFiber;
+    return lanes;
   }
-  return !1;
-}
-function attemptExplicitHydrationTarget(queuedTarget) {
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
-  if (null !== targetInst) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-    if (null !== nearestMounted)
-      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
-        if (
-          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
-          null !== targetInst)
-        ) {
-          queuedTarget.blockedOn = targetInst;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (
-        3 === targetInst &&
-        nearestMounted.stateNode.current.memoizedState.isDehydrated
-      ) {
-        queuedTarget.blockedOn =
-          3 === nearestMounted.tag
-            ? nearestMounted.stateNode.containerInfo
-            : null;
-        return;
-      }
-  }
-  queuedTarget.blockedOn = null;
-}
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (null !== queuedEvent.blockedOn) return !1;
-  for (
-    var targetContainers = queuedEvent.targetContainers;
-    0 < targetContainers.length;
-
-  ) {
-    var targetContainer = targetContainers[0],
-      nextBlockedOn = findInstanceBlockingEvent(
-        queuedEvent.domEventName,
-        queuedEvent.eventSystemFlags,
-        targetContainer,
-        queuedEvent.nativeEvent
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (
+      null === current ||
+      4 !== current.tag ||
+      current.stateNode.containerInfo !== portal.containerInfo ||
+      current.stateNode.implementation !== portal.implementation
+    )
+      return (
+        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
       );
-    if (null === nextBlockedOn)
-      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
-        ? ((nextBlockedOn = queuedEvent.nativeEvent),
-          (currentReplayingEvent = targetContainer =
-            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
-          nextBlockedOn.target.dispatchEvent(targetContainer))
-        : ((currentReplayingEvent = queuedEvent.nativeEvent),
-          dispatchEventForPluginEventSystem(
-            queuedEvent.domEventName,
-            queuedEvent.eventSystemFlags,
-            queuedEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          )),
-        (currentReplayingEvent = null);
-    else
+    current = useFiber(current, portal.children || []);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (null === current || 7 !== current.tag)
       return (
-        (targetContainers = getInstanceFromNode(nextBlockedOn)),
-        null !== targetContainers &&
-          attemptContinuousHydration$1(targetContainers),
-        (queuedEvent.blockedOn = nextBlockedOn),
-        !1
+        (current = createFiberFromFragment(
+          fragment,
+          returnFiber.mode,
+          lanes,
+          key
+        )),
+        (current.return = returnFiber),
+        current
       );
-    targetContainers.shift();
+    current = useFiber(current, fragment);
+    current.return = returnFiber;
+    return current;
   }
-  return !0;
-}
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
-}
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = !1;
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
-    for (; 0 < queuedDiscreteEvents.length; ) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
-      if (null !== nextDiscreteEvent.blockedOn) {
-        nextDiscreteEvent = getInstanceFromNode(nextDiscreteEvent.blockedOn);
-        null !== nextDiscreteEvent &&
-          attemptDiscreteHydration$1(nextDiscreteEvent);
-        break;
-      }
-      for (
-        var targetContainers = nextDiscreteEvent.targetContainers;
-        0 < targetContainers.length;
-
-      ) {
-        var targetContainer = targetContainers[0],
-          nextBlockedOn = findInstanceBlockingEvent(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            targetContainer,
-            nextDiscreteEvent.nativeEvent
+  function createChild(returnFiber, newChild, lanes) {
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return (
+        (newChild = createFiberFromText(
+          "" + newChild,
+          returnFiber.mode,
+          lanes
+        )),
+        (newChild.return = returnFiber),
+        newChild
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (lanes = createFiberFromTypeAndProps(
+              newChild.type,
+              newChild.key,
+              newChild.props,
+              null,
+              returnFiber.mode,
+              lanes
+            )),
+            (lanes.ref = coerceRef(returnFiber, null, newChild)),
+            (lanes.return = returnFiber),
+            lanes
           );
-        if (null === nextBlockedOn)
-          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
-            dispatchEventForPluginEventSystem(
-              nextDiscreteEvent.domEventName,
-              nextDiscreteEvent.eventSystemFlags,
-              nextDiscreteEvent.nativeEvent,
-              return_targetInst,
-              targetContainer
-            ),
-            (currentReplayingEvent = null);
-        else {
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        }
-        targetContainers.shift();
+        case REACT_PORTAL_TYPE:
+          return (
+            (newChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
+            )),
+            (newChild.return = returnFiber),
+            newChild
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return createChild(returnFiber, init(newChild._payload), lanes);
       }
-      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (newChild = createFiberFromFragment(
+            newChild,
+            returnFiber.mode,
+            lanes,
+            null
+          )),
+          (newChild.return = returnFiber),
+          newChild
+        );
+      if ("function" === typeof newChild.then)
+        return createChild(returnFiber, unwrapThenable(newChild), lanes);
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return createChild(
+          returnFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-  null !== queuedFocus &&
-    attemptReplayContinuousQueuedEvent(queuedFocus) &&
-    (queuedFocus = null);
-  null !== queuedDrag &&
-    attemptReplayContinuousQueuedEvent(queuedDrag) &&
-    (queuedDrag = null);
-  null !== queuedMouse &&
-    attemptReplayContinuousQueuedEvent(queuedMouse) &&
-    (queuedMouse = null);
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
-}
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  queuedEvent.blockedOn === unblocked &&
-    ((queuedEvent.blockedOn = null),
-    hasScheduledReplayAttempt ||
-      ((hasScheduledReplayAttempt = !0),
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      )));
-}
-function retryIfBlockedOn(unblocked) {
-  function unblock(queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
-  }
-  if (0 < queuedDiscreteEvents.length) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
-    }
-  }
-  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
-  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
-  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
-    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
-  for (
-    ;
-    0 < queuedExplicitHydrationTargets.length &&
-    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
-
-  )
-    attemptExplicitHydrationTarget(i),
-      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
-}
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
-  _enabled = !0;
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  switch (getEventPriority(domEventName)) {
-    case 2:
-      var listenerWrapper = dispatchDiscreteEvent;
-      break;
-    case 8:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
-    default:
-      listenerWrapper = dispatchEvent;
-  }
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
-}
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 2),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
-  }
-}
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 8),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
+    return null;
   }
-}
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (_enabled)
-    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-      var blockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
-      if (null === blockedOn)
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          clearIfContinuousEvent(domEventName, nativeEvent);
-      else if (
-        queueIfContinuousEvent(
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
-      )
-        nativeEvent.stopPropagation();
-      else if (
-        (clearIfContinuousEvent(domEventName, nativeEvent),
-        eventSystemFlags & 4 &&
-          -1 < discreteReplayableEvents.indexOf(domEventName))
-      ) {
-        for (; null !== blockedOn; ) {
-          var fiber = getInstanceFromNode(blockedOn);
-          null !== fiber && _attemptSynchronousHydration(fiber);
-          fiber = findInstanceBlockingEvent(
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    var key = null !== oldFiber ? oldFiber.key : null;
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return null !== key
+        ? null
+        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return newChild.key === key
+            ? updateElement(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_PORTAL_TYPE:
+          return newChild.key === key
+            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_LAZY_TYPE:
+          return (
+            (key = newChild._init),
+            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
           );
-          null === fiber &&
-            dispatchEventForPluginEventSystem(
-              domEventName,
-              eventSystemFlags,
-              nativeEvent,
-              return_targetInst,
-              targetContainer
-            );
-          if (fiber === blockedOn) break;
-          blockedOn = fiber;
-        }
-        null !== blockedOn && nativeEvent.stopPropagation();
-      } else
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
+      }
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return null !== key
+          ? null
+          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      if ("function" === typeof newChild.then)
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          unwrapThenable(newChild),
+          lanes
         );
-    } else
-      a: if (
-        (blockedOn = 0 === (eventSystemFlags & 4)) &&
-        0 < queuedDiscreteEvents.length &&
-        -1 < discreteReplayableEvents.indexOf(domEventName)
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
       )
-        queueDiscreteEvent(
-          null,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
         );
-      else if (
-        ((fiber = findInstanceBlockingEvent(
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        null === fiber)
-      )
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
-      else {
-        if (blockedOn) {
-          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
-            queueDiscreteEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            );
-            break a;
-          }
-          if (
-            queueIfContinuousEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            )
-          )
-            break a;
-          clearIfContinuousEvent(domEventName, nativeEvent);
-        }
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-      }
-}
-var return_targetInst = null;
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return_targetInst = null;
-  domEventName = getEventTarget(nativeEvent);
-  domEventName = getClosestInstanceFromNode(domEventName);
-  if (null !== domEventName)
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return null;
+  }
+  function updateFromMap(
+    existingChildren,
+    returnFiber,
+    newIdx,
+    newChild,
+    lanes
+  ) {
     if (
-      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
-      null === eventSystemFlags)
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
     )
-      domEventName = null;
-    else if (
-      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
-    ) {
-      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
-      if (null !== domEventName) return domEventName;
-      domEventName = null;
-    } else if (3 === targetContainer) {
-      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
-        return 3 === eventSystemFlags.tag
-          ? eventSystemFlags.stateNode.containerInfo
-          : null;
-      domEventName = null;
-    } else eventSystemFlags !== domEventName && (domEventName = null);
-  return_targetInst = domEventName;
-  return null;
-}
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange":
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate":
-    case "beforeblur":
-    case "afterblur":
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return 2;
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel":
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return 8;
-    case "message":
-      switch (getCurrentPriorityLevel()) {
-        case ImmediatePriority:
-          return 2;
-        case UserBlockingPriority:
-          return 8;
-        case NormalPriority$1:
-        case LowPriority:
-          return 32;
-        case IdlePriority:
-          return 536870912;
-        default:
-          return 32;
+      return (
+        (existingChildren = existingChildren.get(newIdx) || null),
+        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updateElement(returnFiber, existingChildren, newChild, lanes)
+          );
+        case REACT_PORTAL_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updatePortal(returnFiber, existingChildren, newChild, lanes)
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return updateFromMap(
+            existingChildren,
+            returnFiber,
+            newIdx,
+            init(newChild._payload),
+            lanes
+          );
       }
-    default:
-      return 32;
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (existingChildren = existingChildren.get(newIdx) || null),
+          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
+        );
+      if ("function" === typeof newChild.then)
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return null;
   }
-}
-var emptyContextObject = {},
-  contextStackCursor = createCursor(emptyContextObject),
-  didPerformWorkStackCursor = createCursor(!1),
-  previousContext = emptyContextObject;
-function getMaskedContext(workInProgress, unmaskedContext) {
-  var contextTypes = workInProgress.type.contextTypes;
-  if (!contextTypes) return emptyContextObject;
-  var instance = workInProgress.stateNode;
-  if (
-    instance &&
-    instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext
-  )
-    return instance.__reactInternalMemoizedMaskedChildContext;
-  var context = {},
-    key;
-  for (key in contextTypes) context[key] = unmaskedContext[key];
-  instance &&
-    ((workInProgress = workInProgress.stateNode),
-    (workInProgress.__reactInternalMemoizedUnmaskedChildContext =
-      unmaskedContext),
-    (workInProgress.__reactInternalMemoizedMaskedChildContext = context));
-  return context;
-}
-function isContextProvider(type) {
-  type = type.childContextTypes;
-  return null !== type && void 0 !== type;
-}
-function popContext() {
-  pop(didPerformWorkStackCursor);
-  pop(contextStackCursor);
-}
-function pushTopLevelContextObject(fiber, context, didChange) {
-  if (contextStackCursor.current !== emptyContextObject)
-    throw Error(formatProdErrorMessage(168));
-  push(contextStackCursor, context);
-  push(didPerformWorkStackCursor, didChange);
-}
-function processChildContext(fiber, type, parentContext) {
-  var instance = fiber.stateNode;
-  type = type.childContextTypes;
-  if ("function" !== typeof instance.getChildContext) return parentContext;
-  instance = instance.getChildContext();
-  for (var contextKey in instance)
-    if (!(contextKey in type))
-      throw Error(
-        formatProdErrorMessage(
-          108,
-          getComponentNameFromFiber(fiber) || "Unknown",
-          contextKey
-        )
+  function reconcileChildrenArray(
+    returnFiber,
+    currentFirstChild,
+    newChildren,
+    lanes
+  ) {
+    for (
+      var resultingFirstChild = null,
+        previousNewFiber = null,
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null;
+      null !== oldFiber && newIdx < newChildren.length;
+      newIdx++
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(
+        returnFiber,
+        oldFiber,
+        newChildren[newIdx],
+        lanes
       );
-  return assign({}, parentContext, instance);
-}
-function pushContextProvider(workInProgress) {
-  workInProgress =
-    ((workInProgress = workInProgress.stateNode) &&
-      workInProgress.__reactInternalMemoizedMergedChildContext) ||
-    emptyContextObject;
-  previousContext = contextStackCursor.current;
-  push(contextStackCursor, workInProgress);
-  push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);
-  return !0;
-}
-function invalidateContextProvider(workInProgress, type, didChange) {
-  var instance = workInProgress.stateNode;
-  if (!instance) throw Error(formatProdErrorMessage(169));
-  didChange
-    ? ((workInProgress = processChildContext(
-        workInProgress,
-        type,
-        previousContext
-      )),
-      (instance.__reactInternalMemoizedMergedChildContext = workInProgress),
-      pop(didPerformWorkStackCursor),
-      pop(contextStackCursor),
-      push(contextStackCursor, workInProgress))
-    : pop(didPerformWorkStackCursor);
-  push(didPerformWorkStackCursor, didChange);
-}
-var syncQueue = null,
-  includesLegacySyncCallbacks = !1,
-  isFlushingSyncQueue = !1;
-function scheduleSyncCallback(callback) {
-  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
-}
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = !0;
-  scheduleSyncCallback(callback);
-}
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && null !== syncQueue) {
-    isFlushingSyncQueue = !0;
-    var previousUpdatePriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
-      var callback = queue[i];
-      try {
-        do callback = callback(!0);
-        while (null !== callback);
-      } catch (error) {
-        null === errors ? (errors = [error]) : errors.push(error);
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
+        break;
       }
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (resultingFirstChild = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
     }
-    syncQueue = null;
-    includesLegacySyncCallbacks = !1;
-    currentUpdatePriority = previousUpdatePriority;
-    isFlushingSyncQueue = !1;
-    if (null !== errors) {
-      if (1 < errors.length) {
-        if ("function" === typeof AggregateError)
-          throw new AggregateError(errors);
-        for (
-          previousUpdatePriority = 1;
-          previousUpdatePriority < errors.length;
-          previousUpdatePriority++
-        )
-          scheduleCallback$2(
-            ImmediatePriority,
-            throwError.bind(null, errors[previousUpdatePriority])
-          );
+    if (newIdx === newChildren.length)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        resultingFirstChild
+      );
+    if (null === oldFiber) {
+      for (; newIdx < newChildren.length; newIdx++)
+        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
+          null !== oldFiber &&
+            ((currentFirstChild = placeChild(
+              oldFiber,
+              currentFirstChild,
+              newIdx
+            )),
+            null === previousNewFiber
+              ? (resultingFirstChild = oldFiber)
+              : (previousNewFiber.sibling = oldFiber),
+            (previousNewFiber = oldFiber));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return resultingFirstChild;
+    }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      newIdx < newChildren.length;
+      newIdx++
+    )
+      (nextOldFiber = updateFromMap(
+        oldFiber,
+        returnFiber,
+        newIdx,
+        newChildren[newIdx],
+        lanes
+      )),
+        null !== nextOldFiber &&
+          (shouldTrackSideEffects &&
+            null !== nextOldFiber.alternate &&
+            oldFiber.delete(
+              null === nextOldFiber.key ? newIdx : nextOldFiber.key
+            ),
+          (currentFirstChild = placeChild(
+            nextOldFiber,
+            currentFirstChild,
+            newIdx
+          )),
+          null === previousNewFiber
+            ? (resultingFirstChild = nextOldFiber)
+            : (previousNewFiber.sibling = nextOldFiber),
+          (previousNewFiber = nextOldFiber));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return resultingFirstChild;
+  }
+  function reconcileChildrenIterator(
+    returnFiber,
+    currentFirstChild,
+    newChildrenIterable,
+    lanes
+  ) {
+    var iteratorFn = getIteratorFn(newChildrenIterable);
+    if ("function" !== typeof iteratorFn)
+      throw Error(formatProdErrorMessage(150));
+    newChildrenIterable = iteratorFn.call(newChildrenIterable);
+    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
+    for (
+      var previousNewFiber = (iteratorFn = null),
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null,
+        step = newChildrenIterable.next();
+      null !== oldFiber && !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
+        break;
       }
-      throw errors[0];
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (iteratorFn = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+    if (step.done)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        iteratorFn
+      );
+    if (null === oldFiber) {
+      for (; !step.done; newIdx++, step = newChildrenIterable.next())
+        (step = createChild(returnFiber, step.value, lanes)),
+          null !== step &&
+            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+            null === previousNewFiber
+              ? (iteratorFn = step)
+              : (previousNewFiber.sibling = step),
+            (previousNewFiber = step));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return iteratorFn;
     }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    )
+      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
+        null !== step &&
+          (shouldTrackSideEffects &&
+            null !== step.alternate &&
+            oldFiber.delete(null === step.key ? newIdx : step.key),
+          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+          null === previousNewFiber
+            ? (iteratorFn = step)
+            : (previousNewFiber.sibling = step),
+          (previousNewFiber = step));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return iteratorFn;
   }
-  return null;
-}
-function throwError(error) {
-  throw error;
-}
-var forkStack = [],
-  forkStackIndex = 0,
-  treeForkProvider = null,
-  treeForkCount = 0,
-  idStack = [],
-  idStackIndex = 0,
-  treeContextProvider = null,
-  treeContextId = 1,
-  treeContextOverflow = "";
-function pushTreeFork(workInProgress, totalChildren) {
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
-}
-function pushTreeId(workInProgress, totalChildren, index) {
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  workInProgress = treeContextOverflow;
-  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
-  baseIdWithLeadingBit &= ~(1 << baseLength);
-  index += 1;
-  var length = 32 - clz32(totalChildren) + baseLength;
-  if (30 < length) {
-    var numberOfOverflowBits = baseLength - (baseLength % 5);
-    length = (
-      baseIdWithLeadingBit &
-      ((1 << numberOfOverflowBits) - 1)
-    ).toString(32);
-    baseIdWithLeadingBit >>= numberOfOverflowBits;
-    baseLength -= numberOfOverflowBits;
-    treeContextId =
-      (1 << (32 - clz32(totalChildren) + baseLength)) |
-      (index << baseLength) |
-      baseIdWithLeadingBit;
-    treeContextOverflow = length + workInProgress;
-  } else
-    (treeContextId =
-      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
-      (treeContextOverflow = workInProgress);
+  function reconcileChildFibersImpl(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    "object" === typeof newChild &&
+      null !== newChild &&
+      newChild.type === REACT_FRAGMENT_TYPE &&
+      null === newChild.key &&
+      (newChild = newChild.props.children);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          a: {
+            for (
+              var key = newChild.key, child = currentFirstChild;
+              null !== child;
+
+            ) {
+              if (child.key === key) {
+                key = newChild.type;
+                if (key === REACT_FRAGMENT_TYPE) {
+                  if (7 === child.tag) {
+                    deleteRemainingChildren(returnFiber, child.sibling);
+                    currentFirstChild = useFiber(
+                      child,
+                      newChild.props.children
+                    );
+                    currentFirstChild.return = returnFiber;
+                    returnFiber = currentFirstChild;
+                    break a;
+                  }
+                } else if (
+                  child.elementType === key ||
+                  ("object" === typeof key &&
+                    null !== key &&
+                    key.$$typeof === REACT_LAZY_TYPE &&
+                    resolveLazy(key) === child.type)
+                ) {
+                  deleteRemainingChildren(returnFiber, child.sibling);
+                  currentFirstChild = useFiber(child, newChild.props);
+                  currentFirstChild.ref = coerceRef(
+                    returnFiber,
+                    child,
+                    newChild
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                }
+                deleteRemainingChildren(returnFiber, child);
+                break;
+              } else deleteChild(returnFiber, child);
+              child = child.sibling;
+            }
+            newChild.type === REACT_FRAGMENT_TYPE
+              ? ((currentFirstChild = createFiberFromFragment(
+                  newChild.props.children,
+                  returnFiber.mode,
+                  lanes,
+                  newChild.key
+                )),
+                (currentFirstChild.return = returnFiber),
+                (returnFiber = currentFirstChild))
+              : ((lanes = createFiberFromTypeAndProps(
+                  newChild.type,
+                  newChild.key,
+                  newChild.props,
+                  null,
+                  returnFiber.mode,
+                  lanes
+                )),
+                (lanes.ref = coerceRef(
+                  returnFiber,
+                  currentFirstChild,
+                  newChild
+                )),
+                (lanes.return = returnFiber),
+                (returnFiber = lanes));
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_PORTAL_TYPE:
+          a: {
+            for (child = newChild.key; null !== currentFirstChild; ) {
+              if (currentFirstChild.key === child)
+                if (
+                  4 === currentFirstChild.tag &&
+                  currentFirstChild.stateNode.containerInfo ===
+                    newChild.containerInfo &&
+                  currentFirstChild.stateNode.implementation ===
+                    newChild.implementation
+                ) {
+                  deleteRemainingChildren(
+                    returnFiber,
+                    currentFirstChild.sibling
+                  );
+                  currentFirstChild = useFiber(
+                    currentFirstChild,
+                    newChild.children || []
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                } else {
+                  deleteRemainingChildren(returnFiber, currentFirstChild);
+                  break;
+                }
+              else deleteChild(returnFiber, currentFirstChild);
+              currentFirstChild = currentFirstChild.sibling;
+            }
+            currentFirstChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
+            );
+            currentFirstChild.return = returnFiber;
+            returnFiber = currentFirstChild;
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_LAZY_TYPE:
+          return (
+            (child = newChild._init),
+            reconcileChildFibers(
+              returnFiber,
+              currentFirstChild,
+              child(newChild._payload),
+              lanes
+            )
+          );
+      }
+      if (isArrayImpl(newChild))
+        return reconcileChildrenArray(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if (getIteratorFn(newChild))
+        return reconcileChildrenIterator(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if ("function" === typeof newChild.then)
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+      ? ((newChild = "" + newChild),
+        null !== currentFirstChild && 6 === currentFirstChild.tag
+          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
+            (currentFirstChild = useFiber(currentFirstChild, newChild)),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild))
+          : (deleteRemainingChildren(returnFiber, currentFirstChild),
+            (currentFirstChild = createFiberFromText(
+              newChild,
+              returnFiber.mode,
+              lanes
+            )),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild)),
+        placeSingleChild(returnFiber))
+      : deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
+  function reconcileChildFibers(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    thenableIndexCounter$1 = 0;
+    returnFiber = reconcileChildFibersImpl(
+      returnFiber,
+      currentFirstChild,
+      newChild,
+      lanes
+    );
+    thenableState$1 = null;
+    return returnFiber;
+  }
+  return reconcileChildFibers;
 }
-function pushMaterializedTreeId(workInProgress) {
-  null !== workInProgress.return &&
-    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
+var reconcileChildFibers = createChildReconciler(!0),
+  mountChildFibers = createChildReconciler(!1),
+  currentTreeHiddenStackCursor = createCursor(null),
+  prevRenderLanesStackCursor = createCursor(0);
+function pushHiddenContext(fiber, context) {
+  fiber = renderLanes;
+  push(prevRenderLanesStackCursor, fiber);
+  push(currentTreeHiddenStackCursor, context);
+  renderLanes = fiber | context.baseLanes;
 }
-function popTreeContext(workInProgress) {
-  for (; workInProgress === treeForkProvider; )
-    (treeForkProvider = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null),
-      (treeForkCount = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null);
-  for (; workInProgress === treeContextProvider; )
-    (treeContextProvider = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextOverflow = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextId = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null);
+function reuseHiddenContextOnStack() {
+  push(prevRenderLanesStackCursor, renderLanes);
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
 }
-var hydrationParentFiber = null,
-  nextHydratableInstance = null,
-  isHydrating = !1,
-  hydrationErrors = null,
-  rootOrSingletonContext = !1;
-function deleteHydratableInstance(returnFiber, instance) {
-  var fiber = createFiber(5, null, null, 0);
-  fiber.elementType = "DELETED";
-  fiber.stateNode = instance;
-  fiber.return = returnFiber;
-  instance = returnFiber.deletions;
-  null === instance
-    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
-    : instance.push(fiber);
+function popHiddenContext() {
+  renderLanes = prevRenderLanesStackCursor.current;
+  pop(currentTreeHiddenStackCursor);
+  pop(prevRenderLanesStackCursor);
 }
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & -4097) | 2;
+var suspenseHandlerStackCursor = createCursor(null),
+  shellBoundary = null;
+function pushPrimaryTreeSuspenseHandler(handler) {
+  var current = handler.alternate;
+  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
+  (null !== current && null === currentTreeHiddenStackCursor.current)
+    ? (push(suspenseHandlerStackCursor, handler),
+      null === shellBoundary &&
+        (null === current || null !== currentTreeHiddenStackCursor.current
+          ? (shellBoundary = handler)
+          : null !== current.memoizedState && (shellBoundary = handler)))
+    : null === shellBoundary
+    ? push(suspenseHandlerStackCursor, handler)
+    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
 }
-function tryHydrateInstance(fiber, nextInstance) {
-  var type = fiber.type;
-  nextInstance =
-    1 !== nextInstance.nodeType ||
-    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
-      (rootOrSingletonContext = !1),
-      !0)
-    : !1;
+function pushOffscreenSuspenseHandler(fiber) {
+  if (22 === fiber.tag) {
+    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
+      var current = fiber.alternate;
+      null !== current &&
+        null !== current.memoizedState &&
+        (shellBoundary = fiber);
+    }
+  } else reuseSuspenseHandlerOnStack();
 }
-function tryHydrateText(fiber, nextInstance) {
-  nextInstance =
-    "" === fiber.pendingProps
-      ? null
-      : 3 !== nextInstance.nodeType
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = null),
-      !0)
-    : !1;
+function reuseSuspenseHandlerOnStack() {
+  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
 }
-function tryHydrateSuspense(fiber, nextInstance) {
-  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
-  if (null !== nextInstance) {
-    var JSCompiler_inline_result =
-      null !== treeContextProvider
-        ? { id: treeContextId, overflow: treeContextOverflow }
-        : null;
-    fiber.memoizedState = {
-      dehydrated: nextInstance,
-      treeContext: JSCompiler_inline_result,
-      retryLane: 1073741824
-    };
-    JSCompiler_inline_result = createFiber(18, null, null, 0);
-    JSCompiler_inline_result.stateNode = nextInstance;
-    JSCompiler_inline_result.return = fiber;
-    fiber.child = JSCompiler_inline_result;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = null;
-    return !0;
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+  shellBoundary === fiber && (shellBoundary = null);
+}
+var suspenseStackCursor = createCursor(0);
+function findFirstSuspended(row) {
+  for (var node = row; null !== node; ) {
+    if (13 === node.tag) {
+      var state = node.memoizedState;
+      if (
+        null !== state &&
+        ((state = state.dehydrated),
+        null === state || "$?" === state.data || "$!" === state.data)
+      )
+        return node;
+    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+      if (0 !== (node.flags & 128)) return node;
+    } else if (null !== node.child) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+    if (node === row) break;
+    for (; null === node.sibling; ) {
+      if (null === node.return || node.return === row) return null;
+      node = node.return;
+    }
+    node.sibling.return = node.return;
+    node = node.sibling;
   }
-  return !1;
+  return null;
 }
-function shouldClientRenderOnMismatch(fiber) {
-  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
+var workInProgressSources = [];
+function resetWorkInProgressVersions() {
+  for (var i = 0; i < workInProgressSources.length; i++)
+    workInProgressSources[i]._workInProgressVersionPrimary = null;
+  workInProgressSources.length = 0;
 }
-function throwOnHydrationMismatch() {
-  throw Error(formatProdErrorMessage(418));
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
+  renderLanes$1 = 0,
+  currentlyRenderingFiber$1 = null,
+  currentHook = null,
+  workInProgressHook = null,
+  didScheduleRenderPhaseUpdate = !1,
+  didScheduleRenderPhaseUpdateDuringThisPass = !1,
+  shouldDoubleInvokeUserFnsInHooksDEV = !1,
+  localIdCounter = 0,
+  thenableIndexCounter = 0,
+  thenableState = null,
+  globalClientIdCounter = 0;
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
 }
-function advanceToFirstAttemptableInstance(fiber) {
-  for (
-    ;
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    );
-
-  )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (null === prevDeps) return !1;
+  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
+    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+  return !0;
 }
-function advanceToFirstAttemptableTextInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function renderWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg,
+  nextRenderLanes
+) {
+  renderLanes$1 = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = 0;
+  ReactCurrentDispatcher$1.current =
+    null === current || null === current.memoizedState
+      ? HooksDispatcherOnMount
+      : HooksDispatcherOnUpdate;
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  nextRenderLanes = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  didScheduleRenderPhaseUpdateDuringThisPass &&
+    (nextRenderLanes = renderWithHooksAgain(
+      workInProgress,
+      Component,
+      props,
+      secondArg
+    ));
+  finishRenderingHooks(current);
+  return nextRenderLanes;
 }
-function advanceToFirstAttemptableSuspenseInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function finishRenderingHooks(current) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdate = !1;
+  thenableIndexCounter = 0;
+  thenableState = null;
+  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
+  enableLazyContextPropagation &&
+    null !== current &&
+    !didReceiveUpdate &&
+    ((current = current.dependencies),
+    null !== current &&
+      checkIfContextChanged(current) &&
+      (didReceiveUpdate = !0));
 }
-function prepareToHydrateHostInstance(fiber) {
-  var instance = fiber.stateNode,
-    type = fiber.type,
-    props = fiber.memoizedProps;
-  instance[internalInstanceKey] = fiber;
-  instance[internalPropsKey] = props;
-  switch (type) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", instance);
-      listenToNonDelegatedEvent("close", instance);
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "video":
-    case "audio":
-      for (var i = 0; i < mediaEventTypes.length; i++)
-        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", instance);
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", instance);
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", instance);
-      break;
-    case "input":
-      initWrapperState$2(instance, props);
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "select":
-      instance._wrapperState = { wasMultiple: !!props.multiple };
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "textarea":
-      initWrapperState(instance, props),
-        listenToNonDelegatedEvent("invalid", instance);
-  }
-  assertValidProps(type, props);
-  var updatePayload = null,
-    propKey;
-  for (propKey in props)
-    props.hasOwnProperty(propKey) &&
-      ((i = props[propKey]),
-      "children" === propKey
-        ? "string" === typeof i
-          ? instance.textContent !== i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", i]))
-          : "number" === typeof i &&
-            instance.textContent !== "" + i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", "" + i]))
-        : registrationNameDependencies.hasOwnProperty(propKey) &&
-          null != i &&
-          "onScroll" === propKey &&
-          listenToNonDelegatedEvent("scroll", instance));
-  switch (type) {
-    case "input":
-      track(instance);
-      postMountWrapper$3(instance, props, !0);
-      break;
-    case "textarea":
-      track(instance);
-      postMountWrapper(instance);
-      break;
-    case "select":
-    case "option":
-      break;
-    default:
-      "function" === typeof props.onClick && (instance.onclick = noop$1);
-  }
-  instance = updatePayload;
-  fiber.updateQueue = instance;
-  return null !== instance ? !0 : !1;
-}
-function popToNextHostParent(fiber) {
-  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
-    switch (hydrationParentFiber.tag) {
-      case 3:
-      case 27:
-        rootOrSingletonContext = !0;
-        return;
-      case 5:
-      case 13:
-        rootOrSingletonContext = !1;
-        return;
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
-    }
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  var numberOfReRenders = 0;
+  do {
+    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = !1;
+    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
+    numberOfReRenders += 1;
+    workInProgressHook = currentHook = null;
+    workInProgress.updateQueue = null;
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    var children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+  return children;
 }
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) return !1;
-  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
-  var shouldClear = !1;
-  3 === fiber.tag ||
-    27 === fiber.tag ||
-    (5 === fiber.tag &&
-      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
-    (shouldClear = !0);
-  if (shouldClear && (shouldClear = nextHydratableInstance))
-    if (shouldClientRenderOnMismatch(fiber))
-      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
-    else
-      for (; shouldClear; )
-        deleteHydratableInstance(fiber, shouldClear),
-          (shouldClear = getNextHydratable(shouldClear.nextSibling));
-  popToNextHostParent(fiber);
-  if (13 === fiber.tag) {
-    fiber = fiber.memoizedState;
-    fiber = null !== fiber ? fiber.dehydrated : null;
-    if (!fiber) throw Error(formatProdErrorMessage(317));
-    a: {
-      fiber = fiber.nextSibling;
-      for (shouldClear = 0; fiber; ) {
-        if (8 === fiber.nodeType) {
-          var data = fiber.data;
-          if ("/$" === data) {
-            if (0 === shouldClear) {
-              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
-              break a;
-            }
-            shouldClear--;
-          } else
-            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
-        }
-        fiber = fiber.nextSibling;
-      }
-      nextHydratableInstance = null;
-    }
-  } else
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratable(fiber.stateNode.nextSibling)
-      : null;
-  return !0;
+function checkDidRenderIdHook() {
+  var didRenderIdHook = 0 !== localIdCounter;
+  localIdCounter = 0;
+  return didRenderIdHook;
 }
-function warnIfUnhydratedTailNodes() {
-  for (var nextInstance = nextHydratableInstance; nextInstance; )
-    nextInstance = getNextHydratable(nextInstance.nextSibling);
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue;
+  workInProgress.flags &= -2053;
+  current.lanes &= ~lanes;
 }
-function resetHydrationState() {
-  nextHydratableInstance = hydrationParentFiber = null;
-  isHydrating = !1;
+function resetHooksOnUnwind() {
+  if (didScheduleRenderPhaseUpdate) {
+    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
+      var queue = hook.queue;
+      null !== queue && (queue.pending = null);
+      hook = hook.next;
+    }
+    didScheduleRenderPhaseUpdate = !1;
+  }
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdateDuringThisPass = !1;
+  thenableIndexCounter = localIdCounter = 0;
+  thenableState = null;
 }
-function queueHydrationError(error) {
-  null === hydrationErrors
-    ? (hydrationErrors = [error])
-    : hydrationErrors.push(error);
+function mountWorkInProgressHook() {
+  var hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+  null === workInProgressHook
+    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
+    : (workInProgressHook = workInProgressHook.next = hook);
+  return workInProgressHook;
 }
-var concurrentQueues = [],
-  concurrentQueuesIndex = 0,
-  concurrentlyUpdatedLanes = 0;
-function finishQueueingConcurrentUpdates() {
-  for (
-    var endIndex = concurrentQueuesIndex,
-      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
-    i < endIndex;
-
-  ) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    if (null !== queue && null !== update) {
-      var pending = queue.pending;
-      null === pending
-        ? (update.next = update)
-        : ((update.next = pending.next), (pending.next = update));
-      queue.pending = update;
+function updateWorkInProgressHook() {
+  if (null === currentHook) {
+    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
+    nextCurrentHook =
+      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+  } else nextCurrentHook = currentHook.next;
+  var nextWorkInProgressHook =
+    null === workInProgressHook
+      ? currentlyRenderingFiber$1.memoizedState
+      : workInProgressHook.next;
+  if (null !== nextWorkInProgressHook)
+    (workInProgressHook = nextWorkInProgressHook),
+      (currentHook = nextCurrentHook);
+  else {
+    if (null === nextCurrentHook) {
+      if (null === currentlyRenderingFiber$1.alternate)
+        throw Error(formatProdErrorMessage(467));
+      throw Error(formatProdErrorMessage(310));
     }
-    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    currentHook = nextCurrentHook;
+    nextCurrentHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+    null === workInProgressHook
+      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
+          nextCurrentHook)
+      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
   }
+  return workInProgressHook;
 }
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes |= lane;
-  fiber.lanes |= lane;
-  fiber = fiber.alternate;
-  null !== fiber && (fiber.lanes |= lane);
+var createFunctionComponentUpdateQueue;
+createFunctionComponentUpdateQueue = function () {
+  return { lastEffect: null, events: null, stores: null, memoCache: null };
+};
+function use(usable) {
+  if (null !== usable && "object" === typeof usable) {
+    if ("function" === typeof usable.then) {
+      var index$76 = thenableIndexCounter;
+      thenableIndexCounter += 1;
+      null === thenableState && (thenableState = []);
+      usable = trackUsedThenable(thenableState, usable, index$76);
+      null === currentlyRenderingFiber$1.alternate &&
+        (null === workInProgressHook
+          ? null === currentlyRenderingFiber$1.memoizedState
+          : null === workInProgressHook.next) &&
+        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
+      return usable;
+    }
+    if (
+      usable.$$typeof === REACT_CONTEXT_TYPE ||
+      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    )
+      return readContext(usable);
+  }
+  throw Error(formatProdErrorMessage(438, String(usable)));
 }
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  sourceFiber.lanes |= lane;
-  var alternate = sourceFiber.alternate;
-  null !== alternate && (alternate.lanes |= lane);
-  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
-    (parent.childLanes |= lane),
-      (alternate = parent.alternate),
-      null !== alternate && (alternate.childLanes |= lane),
-      22 === parent.tag &&
-        ((sourceFiber = parent.stateNode),
-        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
-      (sourceFiber = parent),
-      (parent = parent.return);
-  isHidden &&
-    null !== update &&
-    3 === sourceFiber.tag &&
-    ((parent = sourceFiber.stateNode),
-    (isHidden = 31 - clz32(lane)),
-    (parent = parent.hiddenUpdates),
-    (sourceFiber = parent[isHidden]),
-    null === sourceFiber
-      ? (parent[isHidden] = [update])
-      : sourceFiber.push(update),
-    (update.lane = lane | 1073741824));
-}
-function getRootForUpdatedFiber(sourceFiber) {
-  if (50 < nestedUpdateCount)
-    throw (
-      ((nestedUpdateCount = 0),
-      (rootWithNestedUpdates = null),
-      Error(formatProdErrorMessage(185)))
-    );
-  for (var parent = sourceFiber.return; null !== parent; )
-    (sourceFiber = parent), (parent = sourceFiber.return);
-  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
-}
-var hasForceUpdate = !1;
-function initializeUpdateQueue(fiber) {
-  fiber.updateQueue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
-    callbacks: null
-  };
-}
-function cloneUpdateQueue(current, workInProgress) {
-  current = current.updateQueue;
-  workInProgress.updateQueue === current &&
-    (workInProgress.updateQueue = {
-      baseState: current.baseState,
-      firstBaseUpdate: current.firstBaseUpdate,
-      lastBaseUpdate: current.lastBaseUpdate,
-      shared: current.shared,
-      callbacks: null
-    });
-}
-function createUpdate(lane) {
-  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
-}
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
-  if (null === updateQueue) return null;
-  updateQueue = updateQueue.shared;
-  if (
-    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
-    0 === (executionContext & 2)
-  )
-    return (
-      enqueueUpdate$1(fiber, updateQueue, update, lane),
-      getRootForUpdatedFiber(fiber)
-    );
-  var pending = updateQueue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  updateQueue.pending = update;
-  update = getRootForUpdatedFiber(fiber);
-  markUpdateLaneFromFiberToRoot(fiber, null, lane);
-  return update;
-}
-function entangleTransitions(root, fiber, lane) {
-  fiber = fiber.updateQueue;
-  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
-    var queueLanes = fiber.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    fiber.lanes = lane;
-    markRootEntangled(root, lane);
-  }
-}
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  var queue = workInProgress.updateQueue,
-    current = workInProgress.alternate;
-  if (
+function useMemoCache(size) {
+  var memoCache = null,
+    updateQueue = currentlyRenderingFiber$1.updateQueue;
+  null !== updateQueue && (memoCache = updateQueue.memoCache);
+  if (null == memoCache) {
+    var current = currentlyRenderingFiber$1.alternate;
     null !== current &&
-    ((current = current.updateQueue), queue === current)
-  ) {
-    var newFirst = null,
-      newLast = null;
-    queue = queue.firstBaseUpdate;
-    if (null !== queue) {
-      do {
-        var clone = {
-          lane: queue.lane,
-          tag: queue.tag,
-          payload: queue.payload,
-          callback: null,
-          next: null
-        };
-        null === newLast
-          ? (newFirst = newLast = clone)
-          : (newLast = newLast.next = clone);
-        queue = queue.next;
-      } while (null !== queue);
-      null === newLast
-        ? (newFirst = newLast = capturedUpdate)
-        : (newLast = newLast.next = capturedUpdate);
-    } else newFirst = newLast = capturedUpdate;
-    queue = {
-      baseState: current.baseState,
-      firstBaseUpdate: newFirst,
-      lastBaseUpdate: newLast,
-      shared: current.shared,
-      callbacks: current.callbacks
-    };
-    workInProgress.updateQueue = queue;
-    return;
+      ((current = current.updateQueue),
+      null !== current &&
+        ((current = current.memoCache),
+        null != current &&
+          (memoCache = {
+            data: current.data.map(function (array) {
+              return array.slice();
+            }),
+            index: 0
+          })));
   }
-  workInProgress = queue.lastBaseUpdate;
-  null === workInProgress
-    ? (queue.firstBaseUpdate = capturedUpdate)
-    : (workInProgress.next = capturedUpdate);
-  queue.lastBaseUpdate = capturedUpdate;
+  null == memoCache && (memoCache = { data: [], index: 0 });
+  null === updateQueue &&
+    ((updateQueue = createFunctionComponentUpdateQueue()),
+    (currentlyRenderingFiber$1.updateQueue = updateQueue));
+  updateQueue.memoCache = memoCache;
+  updateQueue = memoCache.data[memoCache.index];
+  if (void 0 === updateQueue)
+    for (
+      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
+      current < size;
+      current++
+    )
+      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
+  memoCache.index++;
+  return updateQueue;
 }
-function processUpdateQueue(
-  workInProgress$jscomp$0,
-  props,
-  instance$jscomp$0,
-  renderLanes
-) {
-  var queue = workInProgress$jscomp$0.updateQueue;
-  hasForceUpdate = !1;
-  var firstBaseUpdate = queue.firstBaseUpdate,
-    lastBaseUpdate = queue.lastBaseUpdate,
-    pendingQueue = queue.shared.pending;
+function basicStateReducer(state, action) {
+  return "function" === typeof action ? action(state) : action;
+}
+function updateReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var current = currentHook,
+    baseQueue = current.baseQueue,
+    pendingQueue = queue.pending;
   if (null !== pendingQueue) {
-    queue.shared.pending = null;
-    var lastPendingUpdate = pendingQueue,
-      firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null;
-    null === lastBaseUpdate
-      ? (firstBaseUpdate = firstPendingUpdate)
-      : (lastBaseUpdate.next = firstPendingUpdate);
-    lastBaseUpdate = lastPendingUpdate;
-    var current = workInProgress$jscomp$0.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      (pendingQueue = current.lastBaseUpdate),
-      pendingQueue !== lastBaseUpdate &&
-        (null === pendingQueue
-          ? (current.firstBaseUpdate = firstPendingUpdate)
-          : (pendingQueue.next = firstPendingUpdate),
-        (current.lastBaseUpdate = lastPendingUpdate)));
+    if (null !== baseQueue) {
+      var baseFirst = baseQueue.next;
+      baseQueue.next = pendingQueue.next;
+      pendingQueue.next = baseFirst;
+    }
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
   }
-  if (null !== firstBaseUpdate) {
-    var newState = queue.baseState;
-    lastBaseUpdate = 0;
-    current = firstPendingUpdate = lastPendingUpdate = null;
-    pendingQueue = firstBaseUpdate;
+  if (null !== baseQueue) {
+    pendingQueue = baseQueue.next;
+    current = current.baseState;
+    var newBaseQueueFirst = (baseFirst = null),
+      newBaseQueueLast = null,
+      update = pendingQueue;
     do {
-      var updateLane = pendingQueue.lane & -1073741825,
-        isHiddenUpdate = updateLane !== pendingQueue.lane;
+      var updateLane = update.lane & -1073741825;
       if (
-        isHiddenUpdate
+        updateLane !== update.lane
           ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes & updateLane) === updateLane
-      ) {
-        null !== current &&
-          (current = current.next =
+          : (renderLanes$1 & updateLane) === updateLane
+      )
+        null !== newBaseQueueLast &&
+          (newBaseQueueLast = newBaseQueueLast.next =
             {
               lane: 0,
-              tag: pendingQueue.tag,
-              payload: pendingQueue.payload,
-              callback: null,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
               next: null
-            });
-        a: {
-          var workInProgress = workInProgress$jscomp$0,
-            update = pendingQueue;
-          updateLane = props;
-          var instance = instance$jscomp$0;
-          switch (update.tag) {
-            case 1:
-              workInProgress = update.payload;
-              if ("function" === typeof workInProgress) {
-                newState = workInProgress.call(instance, newState, updateLane);
-                break a;
-              }
-              newState = workInProgress;
-              break a;
-            case 3:
-              workInProgress.flags = (workInProgress.flags & -65537) | 128;
-            case 0:
-              workInProgress = update.payload;
-              updateLane =
-                "function" === typeof workInProgress
-                  ? workInProgress.call(instance, newState, updateLane)
-                  : workInProgress;
-              if (null === updateLane || void 0 === updateLane) break a;
-              newState = assign({}, newState, updateLane);
-              break a;
-            case 2:
-              hasForceUpdate = !0;
-          }
-        }
-        updateLane = pendingQueue.callback;
-        null !== updateLane &&
-          ((workInProgress$jscomp$0.flags |= 64),
-          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
-          (isHiddenUpdate = queue.callbacks),
-          null === isHiddenUpdate
-            ? (queue.callbacks = [updateLane])
-            : isHiddenUpdate.push(updateLane));
-      } else
-        (isHiddenUpdate = {
+            }),
+          (updateLane = update.action),
+          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
+          (current = update.hasEagerState
+            ? update.eagerState
+            : reducer(current, updateLane));
+      else {
+        var clone = {
           lane: updateLane,
-          tag: pendingQueue.tag,
-          payload: pendingQueue.payload,
-          callback: pendingQueue.callback,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
           next: null
-        }),
-          null === current
-            ? ((firstPendingUpdate = current = isHiddenUpdate),
-              (lastPendingUpdate = newState))
-            : (current = current.next = isHiddenUpdate),
-          (lastBaseUpdate |= updateLane);
-      pendingQueue = pendingQueue.next;
-      if (null === pendingQueue)
-        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
-          break;
-        else
-          (isHiddenUpdate = pendingQueue),
-            (pendingQueue = isHiddenUpdate.next),
-            (isHiddenUpdate.next = null),
-            (queue.lastBaseUpdate = isHiddenUpdate),
-            (queue.shared.pending = null);
-    } while (1);
-    null === current && (lastPendingUpdate = newState);
-    queue.baseState = lastPendingUpdate;
-    queue.firstBaseUpdate = firstPendingUpdate;
-    queue.lastBaseUpdate = current;
-    null === firstBaseUpdate && (queue.shared.lanes = 0);
-    workInProgressRootSkippedLanes |= lastBaseUpdate;
-    workInProgress$jscomp$0.lanes = lastBaseUpdate;
-    workInProgress$jscomp$0.memoizedState = newState;
-  }
-}
-function callCallback(callback, context) {
-  if ("function" !== typeof callback)
-    throw Error(formatProdErrorMessage(191, callback));
-  callback.call(context);
-}
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
-  if (null !== callbacks)
-    for (
-      updateQueue.callbacks = null, updateQueue = 0;
-      updateQueue < callbacks.length;
-      updateQueue++
-    )
-      callCallback(callbacks[updateQueue], context);
-}
-var SuspenseException = Error(formatProdErrorMessage(460));
-function isThenableResolved(thenable) {
-  thenable = thenable.status;
-  return "fulfilled" === thenable || "rejected" === thenable;
-}
-function noop() {}
-function trackUsedThenable(thenableState, thenable, index) {
-  index = thenableState[index];
-  void 0 === index
-    ? thenableState.push(thenable)
-    : index !== thenable && (thenable.then(noop, noop), (thenable = index));
-  switch (thenable.status) {
-    case "fulfilled":
-      return thenable.value;
-    case "rejected":
-      throw thenable.reason;
-    default:
-      "string" === typeof thenable.status
-        ? thenable.then(noop, noop)
-        : ((thenableState = thenable),
-          (thenableState.status = "pending"),
-          thenableState.then(
-            function (fulfilledValue) {
-              if ("pending" === thenable.status) {
-                var fulfilledThenable = thenable;
-                fulfilledThenable.status = "fulfilled";
-                fulfilledThenable.value = fulfilledValue;
-              }
-            },
-            function (error) {
-              if ("pending" === thenable.status) {
-                var rejectedThenable = thenable;
-                rejectedThenable.status = "rejected";
-                rejectedThenable.reason = error;
-              }
-            }
-          ));
-      switch (thenable.status) {
-        case "fulfilled":
-          return thenable.value;
-        case "rejected":
-          throw thenable.reason;
+        };
+        null === newBaseQueueLast
+          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
+            (baseFirst = current))
+          : (newBaseQueueLast = newBaseQueueLast.next = clone);
+        currentlyRenderingFiber$1.lanes |= updateLane;
+        workInProgressRootSkippedLanes |= updateLane;
       }
-      suspendedThenable = thenable;
-      throw SuspenseException;
+      update = update.next;
+    } while (null !== update && update !== pendingQueue);
+    null === newBaseQueueLast
+      ? (baseFirst = current)
+      : (newBaseQueueLast.next = newBaseQueueFirst);
+    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = current;
+    hook.baseState = baseFirst;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = current;
   }
+  null === baseQueue && (queue.lanes = 0);
+  return [hook.memoizedState, queue.dispatch];
 }
-var suspendedThenable = null,
-  thenableState$1 = null,
-  thenableIndexCounter$1 = 0;
-function unwrapThenable(thenable) {
-  var index = thenableIndexCounter$1;
-  thenableIndexCounter$1 += 1;
-  null === thenableState$1 && (thenableState$1 = []);
-  return trackUsedThenable(thenableState$1, thenable, index);
-}
-function coerceRef(returnFiber, current, element) {
-  returnFiber = element.ref;
-  if (
-    null !== returnFiber &&
-    "function" !== typeof returnFiber &&
-    "object" !== typeof returnFiber
-  ) {
-    if (element._owner) {
-      element = element._owner;
-      if (element) {
-        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
-        var inst = element.stateNode;
-      }
-      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
-      var resolvedInst = inst,
-        stringRef = "" + returnFiber;
-      if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
-      )
-        return current.ref;
-      current = function (value) {
-        var refs = resolvedInst.refs;
-        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
-      };
-      current._stringRef = stringRef;
-      return current;
-    }
-    if ("string" !== typeof returnFiber)
-      throw Error(formatProdErrorMessage(284));
-    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
+function rerenderReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var dispatch = queue.dispatch,
+    lastRenderPhaseUpdate = queue.pending,
+    newState = hook.memoizedState;
+  if (null !== lastRenderPhaseUpdate) {
+    queue.pending = null;
+    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
+    do (newState = reducer(newState, update.action)), (update = update.next);
+    while (update !== lastRenderPhaseUpdate);
+    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = newState;
+    null === hook.baseQueue && (hook.baseState = newState);
+    queue.lastRenderedState = newState;
   }
-  return returnFiber;
-}
-function throwOnInvalidObjectType(returnFiber, newChild) {
-  returnFiber = Object.prototype.toString.call(newChild);
-  throw Error(
-    formatProdErrorMessage(
-      31,
-      "[object Object]" === returnFiber
-        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
-        : returnFiber
-    )
-  );
+  return [newState, dispatch];
 }
-function resolveLazy(lazyType) {
-  var init = lazyType._init;
-  return init(lazyType._payload);
+function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+  var getVersion = source._getVersion;
+  getVersion = getVersion(source._source);
+  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
+  if (null !== JSCompiler_inline_result)
+    root = JSCompiler_inline_result === getVersion;
+  else if (
+    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
+  )
+    (source._workInProgressVersionPrimary = getVersion),
+      workInProgressSources.push(source);
+  if (root) return getSnapshot(source._source);
+  workInProgressSources.push(source);
+  throw Error(formatProdErrorMessage(350));
 }
-function createChildReconciler(shouldTrackSideEffects) {
-  function deleteChild(returnFiber, childToDelete) {
-    if (shouldTrackSideEffects) {
-      var deletions = returnFiber.deletions;
-      null === deletions
-        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
-        : deletions.push(childToDelete);
-    }
-  }
-  function deleteRemainingChildren(returnFiber, currentFirstChild) {
-    if (!shouldTrackSideEffects) return null;
-    for (; null !== currentFirstChild; )
-      deleteChild(returnFiber, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return null;
-  }
-  function mapRemainingChildren(returnFiber, currentFirstChild) {
-    for (returnFiber = new Map(); null !== currentFirstChild; )
-      null !== currentFirstChild.key
-        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
-        : returnFiber.set(currentFirstChild.index, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return returnFiber;
+function useMutableSource(hook, source, getSnapshot, subscribe) {
+  var root = workInProgressRoot;
+  if (null === root) throw Error(formatProdErrorMessage(349));
+  var getVersion = source._getVersion,
+    version = getVersion(source._source),
+    dispatcher = ReactCurrentDispatcher$1.current,
+    _dispatcher$useState = dispatcher.useState(function () {
+      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    }),
+    setSnapshot = _dispatcher$useState[1],
+    snapshot = _dispatcher$useState[0];
+  _dispatcher$useState = workInProgressHook;
+  var memoizedState = hook.memoizedState,
+    refs = memoizedState.refs,
+    prevGetSnapshot = refs.getSnapshot,
+    prevSource = memoizedState.source;
+  memoizedState = memoizedState.subscribe;
+  var fiber = currentlyRenderingFiber$1;
+  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
+  dispatcher.useEffect(
+    function () {
+      refs.getSnapshot = getSnapshot;
+      refs.setSnapshot = setSnapshot;
+      var maybeNewVersion = getVersion(source._source);
+      objectIs(version, maybeNewVersion) ||
+        ((maybeNewVersion = getSnapshot(source._source)),
+        objectIs(snapshot, maybeNewVersion) ||
+          (setSnapshot(maybeNewVersion),
+          (maybeNewVersion = requestUpdateLane(fiber)),
+          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
+        markRootEntangled(root, root.mutableReadLanes));
+    },
+    [getSnapshot, source, subscribe]
+  );
+  dispatcher.useEffect(
+    function () {
+      return subscribe(source._source, function () {
+        var latestGetSnapshot = refs.getSnapshot,
+          latestSetSnapshot = refs.setSnapshot;
+        try {
+          latestSetSnapshot(latestGetSnapshot(source._source));
+          var lane = requestUpdateLane(fiber);
+          root.mutableReadLanes |= lane & root.pendingLanes;
+        } catch (error) {
+          latestSetSnapshot(function () {
+            throw error;
+          });
+        }
+      });
+    },
+    [source, subscribe]
+  );
+  (objectIs(prevGetSnapshot, getSnapshot) &&
+    objectIs(prevSource, source) &&
+    objectIs(memoizedState, subscribe)) ||
+    ((hook = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: snapshot
+    }),
+    (hook.dispatch = setSnapshot =
+      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
+    (_dispatcher$useState.queue = hook),
+    (_dispatcher$useState.baseQueue = null),
+    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
+    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
+      snapshot));
+  return snapshot;
+}
+function updateMutableSource(source, getSnapshot, subscribe) {
+  var hook = updateWorkInProgressHook();
+  return useMutableSource(hook, source, getSnapshot, subscribe);
+}
+function updateSyncExternalStore(subscribe, getSnapshot) {
+  var fiber = currentlyRenderingFiber$1,
+    hook = updateWorkInProgressHook(),
+    nextSnapshot = getSnapshot(),
+    snapshotChanged = !objectIs(
+      (currentHook || hook).memoizedState,
+      nextSnapshot
+    );
+  snapshotChanged &&
+    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
+  hook = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
+    subscribe
+  ]);
+  if (
+    hook.getSnapshot !== getSnapshot ||
+    snapshotChanged ||
+    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
+  ) {
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
+      void 0,
+      null
+    );
+    subscribe = workInProgressRoot;
+    if (null === subscribe) throw Error(formatProdErrorMessage(349));
+    includesBlockingLane(subscribe, renderLanes$1) ||
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
   }
-  function useFiber(fiber, pendingProps) {
-    fiber = createWorkInProgress(fiber, pendingProps);
-    fiber.index = 0;
-    fiber.sibling = null;
-    return fiber;
+  return nextSnapshot;
+}
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= 16384;
+  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
+  getSnapshot = currentlyRenderingFiber$1.updateQueue;
+  null === getSnapshot
+    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
+      (getSnapshot.stores = [fiber]))
+    : ((renderedSnapshot = getSnapshot.stores),
+      null === renderedSnapshot
+        ? (getSnapshot.stores = [fiber])
+        : renderedSnapshot.push(fiber));
+}
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot;
+  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+}
+function subscribeToStore(fiber, inst, subscribe) {
+  return subscribe(function () {
+    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+  });
+}
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  inst = inst.value;
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(inst, nextValue);
+  } catch (error) {
+    return !0;
   }
-  function placeChild(newFiber, lastPlacedIndex, newIndex) {
-    newFiber.index = newIndex;
-    if (!shouldTrackSideEffects)
-      return (newFiber.flags |= 1048576), lastPlacedIndex;
-    newIndex = newFiber.alternate;
-    if (null !== newIndex)
-      return (
-        (newIndex = newIndex.index),
-        newIndex < lastPlacedIndex
-          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
-          : newIndex
-      );
-    newFiber.flags |= 16777218;
-    return lastPlacedIndex;
+}
+function forceStoreRerender(fiber) {
+  var root = enqueueConcurrentRenderForLane(fiber, 2);
+  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
+}
+function mountState(initialState) {
+  var hook = mountWorkInProgressHook();
+  "function" === typeof initialState && (initialState = initialState());
+  hook.memoizedState = hook.baseState = initialState;
+  initialState = {
+    pending: null,
+    lanes: 0,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = initialState;
+  initialState = initialState.dispatch = dispatchSetState.bind(
+    null,
+    currentlyRenderingFiber$1,
+    initialState
+  );
+  return [hook.memoizedState, initialState];
+}
+function pushEffect(tag, create, destroy, deps) {
+  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
+  create = currentlyRenderingFiber$1.updateQueue;
+  null === create
+    ? ((create = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = create),
+      (create.lastEffect = tag.next = tag))
+    : ((destroy = create.lastEffect),
+      null === destroy
+        ? (create.lastEffect = tag.next = tag)
+        : ((deps = destroy.next),
+          (destroy.next = tag),
+          (tag.next = deps),
+          (create.lastEffect = tag)));
+  return tag;
+}
+function updateRef() {
+  return updateWorkInProgressHook().memoizedState;
+}
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = mountWorkInProgressHook();
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    1 | hookFlags,
+    create,
+    void 0,
+    void 0 === deps ? null : deps
+  );
+}
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var destroy = void 0;
+  if (null !== currentHook) {
+    var prevEffect = currentHook.memoizedState;
+    destroy = prevEffect.destroy;
+    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
+      return;
+    }
   }
-  function placeSingleChild(newFiber) {
-    shouldTrackSideEffects &&
-      null === newFiber.alternate &&
-      (newFiber.flags |= 16777218);
-    return newFiber;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
+}
+function mountEffect(create, deps) {
+  mountEffectImpl(8390656, 8, create, deps);
+}
+function updateEffect(create, deps) {
+  updateEffectImpl(2048, 8, create, deps);
+}
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= 4;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+  if (null === componentUpdateQueue)
+    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
+      (componentUpdateQueue.events = [payload]);
+  else {
+    var events = componentUpdateQueue.events;
+    null === events
+      ? (componentUpdateQueue.events = [payload])
+      : events.push(payload);
   }
-  function updateTextNode(returnFiber, current, textContent, lanes) {
-    if (null === current || 6 !== current.tag)
-      return (
-        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, textContent);
-    current.return = returnFiber;
-    return current;
-  }
-  function updateElement(returnFiber, current, element, lanes) {
-    var elementType = element.type;
-    if (elementType === REACT_FRAGMENT_TYPE)
-      return updateFragment(
-        returnFiber,
-        current,
-        element.props.children,
-        lanes,
-        element.key
-      );
-    if (
-      null !== current &&
-      (current.elementType === elementType ||
-        ("object" === typeof elementType &&
-          null !== elementType &&
-          elementType.$$typeof === REACT_LAZY_TYPE &&
-          resolveLazy(elementType) === current.type))
-    )
-      return (
-        (lanes = useFiber(current, element.props)),
-        (lanes.ref = coerceRef(returnFiber, current, element)),
-        (lanes.return = returnFiber),
-        lanes
-      );
-    lanes = createFiberFromTypeAndProps(
-      element.type,
-      element.key,
-      element.props,
-      null,
-      returnFiber.mode,
-      lanes
+}
+function updateEvent(callback) {
+  var ref = updateWorkInProgressHook().memoizedState;
+  useEffectEventImpl({ ref: ref, nextImpl: callback });
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
+}
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(4, 2, create, deps);
+}
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(4, 4, create, deps);
+}
+function imperativeHandleEffect(create, ref) {
+  if ("function" === typeof ref)
+    return (
+      (create = create()),
+      ref(create),
+      function () {
+        ref(null);
+      }
     );
-    lanes.ref = coerceRef(returnFiber, current, element);
-    lanes.return = returnFiber;
-    return lanes;
+  if (null !== ref && void 0 !== ref)
+    return (
+      (create = create()),
+      (ref.current = create),
+      function () {
+        ref.current = null;
+      }
+    );
+}
+function updateImperativeHandle(ref, create, deps) {
+  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+}
+function mountDebugValue() {}
+function updateCallback(callback, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  hook.memoizedState = [callback, deps];
+  return callback;
+}
+function updateMemo(nextCreate, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+  nextCreate = nextCreate();
+  hook.memoizedState = [nextCreate, deps];
+  return nextCreate;
+}
+function updateDeferredValueImpl(hook, prevValue, value) {
+  if (0 === (renderLanes$1 & 42))
+    return (
+      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
+      (hook.memoizedState = value)
+    );
+  objectIs(value, prevValue) ||
+    ((value = claimNextTransitionLane()),
+    (currentlyRenderingFiber$1.lanes |= value),
+    (workInProgressRootSkippedLanes |= value),
+    (hook.baseState = !0));
+  return prevValue;
+}
+function startTransition(setPending, callback, options) {
+  var previousPriority = currentUpdatePriority;
+  currentUpdatePriority =
+    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
+  setPending(!0);
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+  enableTransitionTracing &&
+    void 0 !== options &&
+    void 0 !== options.name &&
+    ((ReactCurrentBatchConfig$3.transition.name = options.name),
+    (ReactCurrentBatchConfig$3.transition.startTime = now$1()));
+  try {
+    setPending(!1), callback();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$3.transition = prevTransition);
   }
-  function updatePortal(returnFiber, current, portal, lanes) {
-    if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
-    )
-      return (
-        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, portal.children || []);
-    current.return = returnFiber;
-    return current;
+}
+function updateId() {
+  return updateWorkInProgressHook().memoizedState;
+}
+function updateRefresh() {
+  return updateWorkInProgressHook().memoizedState;
+}
+function refreshCache(fiber, seedKey, seedValue) {
+  for (var provider = fiber.return; null !== provider; ) {
+    switch (provider.tag) {
+      case 24:
+      case 3:
+        var lane = requestUpdateLane(provider);
+        fiber = createUpdate(lane);
+        var root$82 = enqueueUpdate(provider, fiber, lane);
+        if (null !== root$82) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root$82, provider, lane, eventTime);
+          entangleTransitions(root$82, provider, lane);
+        }
+        provider = createCache();
+        null !== seedKey &&
+          void 0 !== seedKey &&
+          null !== root$82 &&
+          provider.data.set(seedKey, seedValue);
+        fiber.payload = { cache: provider };
+        return;
+    }
+    provider = provider.return;
   }
-  function updateFragment(returnFiber, current, fragment, lanes, key) {
-    if (null === current || 7 !== current.tag)
-      return (
-        (current = createFiberFromFragment(
-          fragment,
-          returnFiber.mode,
-          lanes,
-          key
-        )),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, fragment);
-    current.return = returnFiber;
-    return current;
+}
+function dispatchReducerAction(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber);
+  action = {
+    lane: lane,
+    action: action,
+    hasEagerState: !1,
+    eagerState: null,
+    next: null
+  };
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
+  else if (
+    (enqueueUpdate$1(fiber, queue, action, lane),
+    (action = getRootForUpdatedFiber(fiber)),
+    null !== action)
+  ) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
+    entangleTransitionUpdate(action, queue, lane);
   }
-  function createChild(returnFiber, newChild, lanes) {
+  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
+}
+function dispatchSetState(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber),
+    update = {
+      lane: lane,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
+  else {
+    var alternate = fiber.alternate;
     if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
+      0 === fiber.lanes &&
+      (null === alternate || 0 === alternate.lanes) &&
+      ((alternate = queue.lastRenderedReducer), null !== alternate)
     )
-      return (
-        (newChild = createFiberFromText(
-          "" + newChild,
-          returnFiber.mode,
-          lanes
-        )),
-        (newChild.return = returnFiber),
-        newChild
-      );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (lanes = createFiberFromTypeAndProps(
-              newChild.type,
-              newChild.key,
-              newChild.props,
-              null,
-              returnFiber.mode,
-              lanes
-            )),
-            (lanes.ref = coerceRef(returnFiber, null, newChild)),
-            (lanes.return = returnFiber),
-            lanes
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (newChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (newChild.return = returnFiber),
-            newChild
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return createChild(returnFiber, init(newChild._payload), lanes);
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (newChild = createFiberFromFragment(
-            newChild,
-            returnFiber.mode,
-            lanes,
-            null
-          )),
-          (newChild.return = returnFiber),
-          newChild
-        );
-      if ("function" === typeof newChild.then)
-        return createChild(returnFiber, unwrapThenable(newChild), lanes);
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return createChild(
-          returnFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
-  }
-  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
-    var key = null !== oldFiber ? oldFiber.key : null;
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return null !== key
-        ? null
-        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return newChild.key === key
-            ? updateElement(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_PORTAL_TYPE:
-          return newChild.key === key
-            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_LAZY_TYPE:
-          return (
-            (key = newChild._init),
-            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
-          );
+      try {
+        var currentState = queue.lastRenderedState,
+          eagerState = alternate(currentState, action);
+        update.hasEagerState = !0;
+        update.eagerState = eagerState;
+        if (objectIs(eagerState, currentState)) {
+          enqueueUpdate$1(fiber, queue, update, 0);
+          null === workInProgressRoot && finishQueueingConcurrentUpdates();
+          return;
+        }
+      } catch (error) {
+      } finally {
       }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return null !== key
-          ? null
-          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
-      if ("function" === typeof newChild.then)
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
+    enqueueUpdate$1(fiber, queue, update, lane);
+    action = getRootForUpdatedFiber(fiber);
+    null !== action &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(action, fiber, lane, update),
+      entangleTransitionUpdate(action, queue, lane));
   }
-  function updateFromMap(
-    existingChildren,
-    returnFiber,
-    newIdx,
-    newChild,
-    lanes
-  ) {
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
+  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
+}
+function isRenderPhaseUpdate(fiber) {
+  var alternate = fiber.alternate;
+  return (
+    fiber === currentlyRenderingFiber$1 ||
+    (null !== alternate && alternate === currentlyRenderingFiber$1)
+  );
+}
+function enqueueRenderPhaseUpdate(queue, update) {
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
+    !0;
+  var pending = queue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  queue.pending = update;
+}
+function entangleTransitionUpdate(root, queue, lane) {
+  if (0 !== (lane & 8388480)) {
+    var queueLanes = queue.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    queue.lanes = lane;
+    markRootEntangled(root, lane);
+  }
+}
+var ContextOnlyDispatcher = {
+  readContext: readContext,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useMutableSource: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+ContextOnlyDispatcher.use = throwInvalidHookError;
+ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+var HooksDispatcherOnMount = {
+  readContext: readContext,
+  useCallback: function (callback, deps) {
+    mountWorkInProgressHook().memoizedState = [
+      callback,
+      void 0 === deps ? null : deps
+    ];
+    return callback;
+  },
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: function (ref, create, deps) {
+    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+    mountEffectImpl(
+      4194308,
+      4,
+      imperativeHandleEffect.bind(null, create, ref),
+      deps
+    );
+  },
+  useLayoutEffect: function (create, deps) {
+    return mountEffectImpl(4194308, 4, create, deps);
+  },
+  useInsertionEffect: function (create, deps) {
+    mountEffectImpl(4, 2, create, deps);
+  },
+  useMemo: function (nextCreate, deps) {
+    var hook = mountWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+    nextCreate = nextCreate();
+    hook.memoizedState = [nextCreate, deps];
+    return nextCreate;
+  },
+  useReducer: function (reducer, initialArg, init) {
+    var hook = mountWorkInProgressHook();
+    initialArg = void 0 !== init ? init(initialArg) : initialArg;
+    hook.memoizedState = hook.baseState = initialArg;
+    reducer = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: reducer,
+      lastRenderedState: initialArg
+    };
+    hook.queue = reducer;
+    reducer = reducer.dispatch = dispatchReducerAction.bind(
+      null,
+      currentlyRenderingFiber$1,
+      reducer
+    );
+    return [hook.memoizedState, reducer];
+  },
+  useRef: function (initialValue) {
+    var hook = mountWorkInProgressHook();
+    if (enableUseRefAccessWarning)
       return (
-        (existingChildren = existingChildren.get(newIdx) || null),
-        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
+        (initialValue = { current: initialValue }),
+        (hook.memoizedState = initialValue)
       );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updateElement(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updatePortal(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return updateFromMap(
-            existingChildren,
-            returnFiber,
-            newIdx,
-            init(newChild._payload),
-            lanes
-          );
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (existingChildren = existingChildren.get(newIdx) || null),
-          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
-        );
-      if ("function" === typeof newChild.then)
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
+    initialValue = { current: initialValue };
+    return (hook.memoizedState = initialValue);
+  },
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    return (mountWorkInProgressHook().memoizedState = value);
+  },
+  useTransition: function () {
+    var _mountState = mountState(!1),
+      isPending = _mountState[0];
+    _mountState = startTransition.bind(null, _mountState[1]);
+    mountWorkInProgressHook().memoizedState = _mountState;
+    return [isPending, _mountState];
+  },
+  useMutableSource: function (source, getSnapshot, subscribe) {
+    var hook = mountWorkInProgressHook();
+    hook.memoizedState = {
+      refs: { getSnapshot: getSnapshot, setSnapshot: null },
+      source: source,
+      subscribe: subscribe
+    };
+    return useMutableSource(hook, source, getSnapshot, subscribe);
+  },
+  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+    var fiber = currentlyRenderingFiber$1,
+      hook = mountWorkInProgressHook();
+    if (isHydrating) {
+      if (void 0 === getServerSnapshot)
+        throw Error(formatProdErrorMessage(407));
+      getServerSnapshot = getServerSnapshot();
+    } else {
+      getServerSnapshot = getSnapshot();
+      var root$78 = workInProgressRoot;
+      if (null === root$78) throw Error(formatProdErrorMessage(349));
+      includesBlockingLane(root$78, renderLanes$1) ||
+        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
     }
-    return null;
+    hook.memoizedState = getServerSnapshot;
+    root$78 = { value: getServerSnapshot, getSnapshot: getSnapshot };
+    hook.queue = root$78;
+    mountEffect(subscribeToStore.bind(null, fiber, root$78, subscribe), [
+      subscribe
+    ]);
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(
+        null,
+        fiber,
+        root$78,
+        getServerSnapshot,
+        getSnapshot
+      ),
+      void 0,
+      null
+    );
+    return getServerSnapshot;
+  },
+  useId: function () {
+    var hook = mountWorkInProgressHook(),
+      identifierPrefix = workInProgressRoot.identifierPrefix;
+    if (isHydrating) {
+      var JSCompiler_inline_result = treeContextOverflow;
+      var idWithLeadingBit = treeContextId;
+      JSCompiler_inline_result =
+        (
+          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
+        ).toString(32) + JSCompiler_inline_result;
+      identifierPrefix =
+        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
+      JSCompiler_inline_result = localIdCounter++;
+      0 < JSCompiler_inline_result &&
+        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
+      identifierPrefix += ":";
+    } else
+      (JSCompiler_inline_result = globalClientIdCounter++),
+        (identifierPrefix =
+          ":" +
+          identifierPrefix +
+          "r" +
+          JSCompiler_inline_result.toString(32) +
+          ":");
+    return (hook.memoizedState = identifierPrefix);
+  },
+  useCacheRefresh: function () {
+    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
+      null,
+      currentlyRenderingFiber$1
+    ));
   }
-  function reconcileChildrenArray(
-    returnFiber,
-    currentFirstChild,
-    newChildren,
-    lanes
-  ) {
-    for (
-      var resultingFirstChild = null,
-        previousNewFiber = null,
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null;
-      null !== oldFiber && newIdx < newChildren.length;
-      newIdx++
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(
-        returnFiber,
-        oldFiber,
-        newChildren[newIdx],
-        lanes
-      );
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
+};
+HooksDispatcherOnMount.use = use;
+HooksDispatcherOnMount.useMemoCache = useMemoCache;
+HooksDispatcherOnMount.useEffectEvent = function (callback) {
+  var hook = mountWorkInProgressHook(),
+    ref = { impl: callback };
+  hook.memoizedState = ref;
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
+};
+var HooksDispatcherOnUpdate = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: function () {
+    return updateReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = updateReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
+HooksDispatcherOnUpdate.use = use;
+HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+var HooksDispatcherOnRerender = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: function () {
+    return rerenderReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return null === currentHook
+      ? (hook.memoizedState = value)
+      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = rerenderReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+HooksDispatcherOnRerender.use = use;
+HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+var now = Scheduler.unstable_now,
+  commitTime = 0,
+  layoutEffectStartTime = -1,
+  profilerStartTime = -1,
+  passiveEffectStartTime = -1,
+  currentUpdateIsNested = !1,
+  nestedUpdateScheduled = !1;
+function startProfilerTimer(fiber) {
+  profilerStartTime = now();
+  0 > fiber.actualStartTime && (fiber.actualStartTime = now());
+}
+function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+  if (0 <= profilerStartTime) {
+    var elapsedTime = now() - profilerStartTime;
+    fiber.actualDuration += elapsedTime;
+    overrideBaseTime && (fiber.selfBaseDuration = elapsedTime);
+    profilerStartTime = -1;
+  }
+}
+function recordLayoutEffectDuration(fiber) {
+  if (0 <= layoutEffectStartTime) {
+    var elapsedTime = now() - layoutEffectStartTime;
+    layoutEffectStartTime = -1;
+    for (fiber = fiber.return; null !== fiber; ) {
+      switch (fiber.tag) {
+        case 3:
+          fiber.stateNode.effectDuration += elapsedTime;
+          return;
+        case 12:
+          fiber.stateNode.effectDuration += elapsedTime;
+          return;
       }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (resultingFirstChild = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
+      fiber = fiber.return;
     }
-    if (newIdx === newChildren.length)
-      return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        resultingFirstChild
-      );
-    if (null === oldFiber) {
-      for (; newIdx < newChildren.length; newIdx++)
-        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
-          null !== oldFiber &&
-            ((currentFirstChild = placeChild(
-              oldFiber,
-              currentFirstChild,
-              newIdx
-            )),
-            null === previousNewFiber
-              ? (resultingFirstChild = oldFiber)
-              : (previousNewFiber.sibling = oldFiber),
-            (previousNewFiber = oldFiber));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return resultingFirstChild;
-    }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      newIdx < newChildren.length;
-      newIdx++
-    )
-      (nextOldFiber = updateFromMap(
-        oldFiber,
-        returnFiber,
-        newIdx,
-        newChildren[newIdx],
-        lanes
-      )),
-        null !== nextOldFiber &&
-          (shouldTrackSideEffects &&
-            null !== nextOldFiber.alternate &&
-            oldFiber.delete(
-              null === nextOldFiber.key ? newIdx : nextOldFiber.key
-            ),
-          (currentFirstChild = placeChild(
-            nextOldFiber,
-            currentFirstChild,
-            newIdx
-          )),
-          null === previousNewFiber
-            ? (resultingFirstChild = nextOldFiber)
-            : (previousNewFiber.sibling = nextOldFiber),
-          (previousNewFiber = nextOldFiber));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return resultingFirstChild;
   }
-  function reconcileChildrenIterator(
-    returnFiber,
-    currentFirstChild,
-    newChildrenIterable,
-    lanes
-  ) {
-    var iteratorFn = getIteratorFn(newChildrenIterable);
-    if ("function" !== typeof iteratorFn)
-      throw Error(formatProdErrorMessage(150));
-    newChildrenIterable = iteratorFn.call(newChildrenIterable);
-    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
-    for (
-      var previousNewFiber = (iteratorFn = null),
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null,
-        step = newChildrenIterable.next();
-      null !== oldFiber && !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
+}
+function recordPassiveEffectDuration(fiber) {
+  if (0 <= passiveEffectStartTime) {
+    var elapsedTime = now() - passiveEffectStartTime;
+    passiveEffectStartTime = -1;
+    for (fiber = fiber.return; null !== fiber; ) {
+      switch (fiber.tag) {
+        case 3:
+          fiber = fiber.stateNode;
+          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
+          return;
+        case 12:
+          fiber = fiber.stateNode;
+          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
+          return;
       }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (iteratorFn = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
-    }
-    if (step.done)
-      return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        iteratorFn
-      );
-    if (null === oldFiber) {
-      for (; !step.done; newIdx++, step = newChildrenIterable.next())
-        (step = createChild(returnFiber, step.value, lanes)),
-          null !== step &&
-            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-            null === previousNewFiber
-              ? (iteratorFn = step)
-              : (previousNewFiber.sibling = step),
-            (previousNewFiber = step));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return iteratorFn;
+      fiber = fiber.return;
     }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    )
-      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
-        null !== step &&
-          (shouldTrackSideEffects &&
-            null !== step.alternate &&
-            oldFiber.delete(null === step.key ? newIdx : step.key),
-          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-          null === previousNewFiber
-            ? (iteratorFn = step)
-            : (previousNewFiber.sibling = step),
-          (previousNewFiber = step));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return iteratorFn;
   }
-  function reconcileChildFibersImpl(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    "object" === typeof newChild &&
-      null !== newChild &&
-      newChild.type === REACT_FRAGMENT_TYPE &&
-      null === newChild.key &&
-      (newChild = newChild.props.children);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          a: {
-            for (
-              var key = newChild.key, child = currentFirstChild;
-              null !== child;
-
-            ) {
-              if (child.key === key) {
-                key = newChild.type;
-                if (key === REACT_FRAGMENT_TYPE) {
-                  if (7 === child.tag) {
-                    deleteRemainingChildren(returnFiber, child.sibling);
-                    currentFirstChild = useFiber(
-                      child,
-                      newChild.props.children
-                    );
-                    currentFirstChild.return = returnFiber;
-                    returnFiber = currentFirstChild;
-                    break a;
-                  }
-                } else if (
-                  child.elementType === key ||
-                  ("object" === typeof key &&
-                    null !== key &&
-                    key.$$typeof === REACT_LAZY_TYPE &&
-                    resolveLazy(key) === child.type)
-                ) {
-                  deleteRemainingChildren(returnFiber, child.sibling);
-                  currentFirstChild = useFiber(child, newChild.props);
-                  currentFirstChild.ref = coerceRef(
-                    returnFiber,
-                    child,
-                    newChild
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                }
-                deleteRemainingChildren(returnFiber, child);
-                break;
-              } else deleteChild(returnFiber, child);
-              child = child.sibling;
-            }
-            newChild.type === REACT_FRAGMENT_TYPE
-              ? ((currentFirstChild = createFiberFromFragment(
-                  newChild.props.children,
-                  returnFiber.mode,
-                  lanes,
-                  newChild.key
-                )),
-                (currentFirstChild.return = returnFiber),
-                (returnFiber = currentFirstChild))
-              : ((lanes = createFiberFromTypeAndProps(
-                  newChild.type,
-                  newChild.key,
-                  newChild.props,
-                  null,
-                  returnFiber.mode,
-                  lanes
-                )),
-                (lanes.ref = coerceRef(
-                  returnFiber,
-                  currentFirstChild,
-                  newChild
-                )),
-                (lanes.return = returnFiber),
-                (returnFiber = lanes));
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_PORTAL_TYPE:
-          a: {
-            for (child = newChild.key; null !== currentFirstChild; ) {
-              if (currentFirstChild.key === child)
-                if (
-                  4 === currentFirstChild.tag &&
-                  currentFirstChild.stateNode.containerInfo ===
-                    newChild.containerInfo &&
-                  currentFirstChild.stateNode.implementation ===
-                    newChild.implementation
-                ) {
-                  deleteRemainingChildren(
-                    returnFiber,
-                    currentFirstChild.sibling
-                  );
-                  currentFirstChild = useFiber(
-                    currentFirstChild,
-                    newChild.children || []
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                } else {
-                  deleteRemainingChildren(returnFiber, currentFirstChild);
-                  break;
-                }
-              else deleteChild(returnFiber, currentFirstChild);
-              currentFirstChild = currentFirstChild.sibling;
-            }
-            currentFirstChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            );
-            currentFirstChild.return = returnFiber;
-            returnFiber = currentFirstChild;
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_LAZY_TYPE:
-          return (
-            (child = newChild._init),
-            reconcileChildFibers(
-              returnFiber,
-              currentFirstChild,
-              child(newChild._payload),
-              lanes
-            )
-          );
-      }
-      if (isArrayImpl(newChild))
-        return reconcileChildrenArray(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if (getIteratorFn(newChild))
-        return reconcileChildrenIterator(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if ("function" === typeof newChild.then)
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-      ? ((newChild = "" + newChild),
-        null !== currentFirstChild && 6 === currentFirstChild.tag
-          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
-            (currentFirstChild = useFiber(currentFirstChild, newChild)),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild))
-          : (deleteRemainingChildren(returnFiber, currentFirstChild),
-            (currentFirstChild = createFiberFromText(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild)),
-        placeSingleChild(returnFiber))
-      : deleteRemainingChildren(returnFiber, currentFirstChild);
-  }
-  function reconcileChildFibers(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    thenableIndexCounter$1 = 0;
-    returnFiber = reconcileChildFibersImpl(
-      returnFiber,
-      currentFirstChild,
-      newChild,
-      lanes
-    );
-    thenableState$1 = null;
-    return returnFiber;
-  }
-  return reconcileChildFibers;
-}
-var reconcileChildFibers = createChildReconciler(!0),
-  mountChildFibers = createChildReconciler(!1),
-  currentTreeHiddenStackCursor = createCursor(null),
-  prevRenderLanesStackCursor = createCursor(0);
-function pushHiddenContext(fiber, context) {
-  fiber = renderLanes;
-  push(prevRenderLanesStackCursor, fiber);
-  push(currentTreeHiddenStackCursor, context);
-  renderLanes = fiber | context.baseLanes;
-}
-function reuseHiddenContextOnStack() {
-  push(prevRenderLanesStackCursor, renderLanes);
-  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
-}
-function popHiddenContext() {
-  renderLanes = prevRenderLanesStackCursor.current;
-  pop(currentTreeHiddenStackCursor);
-  pop(prevRenderLanesStackCursor);
-}
-var suspenseHandlerStackCursor = createCursor(null),
-  shellBoundary = null;
-function pushPrimaryTreeSuspenseHandler(handler) {
-  var current = handler.alternate;
-  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
-  (null !== current && null === currentTreeHiddenStackCursor.current)
-    ? (push(suspenseHandlerStackCursor, handler),
-      null === shellBoundary &&
-        (null === current || null !== currentTreeHiddenStackCursor.current
-          ? (shellBoundary = handler)
-          : null !== current.memoizedState && (shellBoundary = handler)))
-    : null === shellBoundary
-    ? push(suspenseHandlerStackCursor, handler)
-    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
-}
-function pushOffscreenSuspenseHandler(fiber) {
-  if (22 === fiber.tag) {
-    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
-      var current = fiber.alternate;
-      null !== current &&
-        null !== current.memoizedState &&
-        (shellBoundary = fiber);
-    }
-  } else reuseSuspenseHandlerOnStack();
 }
-function reuseSuspenseHandlerOnStack() {
-  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+function startLayoutEffectTimer() {
+  layoutEffectStartTime = now();
 }
-function popSuspenseHandler(fiber) {
-  pop(suspenseHandlerStackCursor);
-  shellBoundary === fiber && (shellBoundary = null);
+function transferActualDuration(fiber) {
+  for (var child = fiber.child; child; )
+    (fiber.actualDuration += child.actualDuration), (child = child.sibling);
 }
-var suspenseStackCursor = createCursor(0);
-function findFirstSuspended(row) {
-  for (var node = row; null !== node; ) {
-    if (13 === node.tag) {
-      var state = node.memoizedState;
-      if (
-        null !== state &&
-        ((state = state.dehydrated),
-        null === state || "$?" === state.data || "$!" === state.data)
-      )
-        return node;
-    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
-      if (0 !== (node.flags & 128)) return node;
-    } else if (null !== node.child) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
-    if (node === row) break;
-    for (; null === node.sibling; ) {
-      if (null === node.return || node.return === row) return null;
-      node = node.return;
-    }
-    node.sibling.return = node.return;
-    node = node.sibling;
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    baseProps = assign({}, baseProps);
+    Component = Component.defaultProps;
+    for (var propName in Component)
+      void 0 === baseProps[propName] &&
+        (baseProps[propName] = Component[propName]);
+    return baseProps;
   }
-  return null;
-}
-var workInProgressSources = [];
-function resetWorkInProgressVersions() {
-  for (var i = 0; i < workInProgressSources.length; i++)
-    workInProgressSources[i]._workInProgressVersionPrimary = null;
-  workInProgressSources.length = 0;
-}
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
-  renderLanes$1 = 0,
-  currentlyRenderingFiber$1 = null,
-  currentHook = null,
-  workInProgressHook = null,
-  didScheduleRenderPhaseUpdate = !1,
-  didScheduleRenderPhaseUpdateDuringThisPass = !1,
-  shouldDoubleInvokeUserFnsInHooksDEV = !1,
-  localIdCounter = 0,
-  thenableIndexCounter = 0,
-  thenableState = null,
-  globalClientIdCounter = 0;
-function throwInvalidHookError() {
-  throw Error(formatProdErrorMessage(321));
-}
-function areHookInputsEqual(nextDeps, prevDeps) {
-  if (null === prevDeps) return !1;
-  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
-    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
-  return !0;
+  return baseProps;
 }
-function renderWithHooks(
-  current,
+function applyDerivedStateFromProps(
   workInProgress,
-  Component,
-  props,
-  secondArg,
-  nextRenderLanes
+  ctor,
+  getDerivedStateFromProps,
+  nextProps
 ) {
-  renderLanes$1 = nextRenderLanes;
-  currentlyRenderingFiber$1 = workInProgress;
-  workInProgress.memoizedState = null;
-  workInProgress.updateQueue = null;
-  workInProgress.lanes = 0;
-  ReactCurrentDispatcher$1.current =
-    null === current || null === current.memoizedState
-      ? HooksDispatcherOnMount
-      : HooksDispatcherOnUpdate;
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  nextRenderLanes = Component(props, secondArg);
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  didScheduleRenderPhaseUpdateDuringThisPass &&
-    (nextRenderLanes = renderWithHooksAgain(
-      workInProgress,
-      Component,
-      props,
-      secondArg
-    ));
-  finishRenderingHooks(current);
-  return nextRenderLanes;
-}
-function finishRenderingHooks(current) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdate = !1;
-  thenableIndexCounter = 0;
-  thenableState = null;
-  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
-  enableLazyContextPropagation &&
-    null !== current &&
-    !didReceiveUpdate &&
-    ((current = current.dependencies),
-    null !== current &&
-      checkIfContextChanged(current) &&
-      (didReceiveUpdate = !0));
+  ctor = workInProgress.memoizedState;
+  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+  getDerivedStateFromProps =
+    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
+      ? ctor
+      : assign({}, ctor, getDerivedStateFromProps);
+  workInProgress.memoizedState = getDerivedStateFromProps;
+  0 === workInProgress.lanes &&
+    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
 }
-function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
-  var numberOfReRenders = 0;
-  do {
-    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
-    thenableIndexCounter = 0;
-    didScheduleRenderPhaseUpdateDuringThisPass = !1;
-    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
-    numberOfReRenders += 1;
-    workInProgressHook = currentHook = null;
-    workInProgress.updateQueue = null;
-    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
-    var children = Component(props, secondArg);
-  } while (didScheduleRenderPhaseUpdateDuringThisPass);
-  return children;
+var classComponentUpdater = {
+  isMounted: function (component) {
+    return (component = component._reactInternals)
+      ? getNearestMountedFiber(component) === component
+      : !1;
+  },
+  enqueueSetState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
+  },
+  enqueueReplaceState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 1;
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
+  },
+  enqueueForceUpdate: function (inst, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 2;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    callback = enqueueUpdate(inst, update, lane);
+    null !== callback &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(callback, inst, lane, update),
+      entangleTransitions(callback, inst, lane));
+    enableSchedulingProfiler &&
+      enableSchedulingProfiler &&
+      null !== injectedProfilingHooks &&
+      "function" === typeof injectedProfilingHooks.markForceUpdateScheduled &&
+      injectedProfilingHooks.markForceUpdateScheduled(inst, lane);
+  }
+};
+function checkShouldComponentUpdate(
+  workInProgress,
+  ctor,
+  oldProps,
+  newProps,
+  oldState,
+  newState,
+  nextContext
+) {
+  workInProgress = workInProgress.stateNode;
+  return "function" === typeof workInProgress.shouldComponentUpdate
+    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
+    : ctor.prototype && ctor.prototype.isPureReactComponent
+    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
+    : !0;
 }
-function checkDidRenderIdHook() {
-  var didRenderIdHook = 0 !== localIdCounter;
-  localIdCounter = 0;
-  return didRenderIdHook;
+function constructClassInstance(workInProgress, ctor, props) {
+  var isLegacyContextConsumer = !1,
+    unmaskedContext = emptyContextObject;
+  var context = ctor.contextType;
+  "object" === typeof context && null !== context
+    ? (context = readContext(context))
+    : ((unmaskedContext = isContextProvider(ctor)
+        ? previousContext
+        : contextStackCursor.current),
+      (isLegacyContextConsumer = ctor.contextTypes),
+      (context = (isLegacyContextConsumer =
+        null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer)
+        ? getMaskedContext(workInProgress, unmaskedContext)
+        : emptyContextObject));
+  ctor = new ctor(props, context);
+  workInProgress.memoizedState =
+    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+  ctor.updater = classComponentUpdater;
+  workInProgress.stateNode = ctor;
+  ctor._reactInternals = workInProgress;
+  isLegacyContextConsumer &&
+    ((workInProgress = workInProgress.stateNode),
+    (workInProgress.__reactInternalMemoizedUnmaskedChildContext =
+      unmaskedContext),
+    (workInProgress.__reactInternalMemoizedMaskedChildContext = context));
+  return ctor;
 }
-function bailoutHooks(current, workInProgress, lanes) {
-  workInProgress.updateQueue = current.updateQueue;
-  workInProgress.flags &= -2053;
-  current.lanes &= ~lanes;
+function callComponentWillReceiveProps(
+  workInProgress,
+  instance,
+  newProps,
+  nextContext
+) {
+  workInProgress = instance.state;
+  "function" === typeof instance.componentWillReceiveProps &&
+    instance.componentWillReceiveProps(newProps, nextContext);
+  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  instance.state !== workInProgress &&
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
 }
-function resetHooksOnUnwind() {
-  if (didScheduleRenderPhaseUpdate) {
-    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
-      var queue = hook.queue;
-      null !== queue && (queue.pending = null);
-      hook = hook.next;
-    }
-    didScheduleRenderPhaseUpdate = !1;
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  var instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  var contextType = ctor.contextType;
+  "object" === typeof contextType && null !== contextType
+    ? (instance.context = readContext(contextType))
+    : ((contextType = isContextProvider(ctor)
+        ? previousContext
+        : contextStackCursor.current),
+      (instance.context = getMaskedContext(workInProgress, contextType)));
+  instance.state = workInProgress.memoizedState;
+  contextType = ctor.getDerivedStateFromProps;
+  "function" === typeof contextType &&
+    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof ctor.getDerivedStateFromProps ||
+    "function" === typeof instance.getSnapshotBeforeUpdate ||
+    ("function" !== typeof instance.UNSAFE_componentWillMount &&
+      "function" !== typeof instance.componentWillMount) ||
+    ((ctor = instance.state),
+    "function" === typeof instance.componentWillMount &&
+      instance.componentWillMount(),
+    "function" === typeof instance.UNSAFE_componentWillMount &&
+      instance.UNSAFE_componentWillMount(),
+    ctor !== instance.state &&
+      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof instance.componentDidMount &&
+    (workInProgress.flags |= 4194308);
+}
+function createCapturedValueAtFiber(value, source) {
+  try {
+    var info = "",
+      node = source;
+    do (info += describeFiber(node)), (node = node.return);
+    while (node);
+    var JSCompiler_inline_result = info;
+  } catch (x) {
+    JSCompiler_inline_result =
+      "\nError generating stack: " + x.message + "\n" + x.stack;
   }
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdateDuringThisPass = !1;
-  thenableIndexCounter = localIdCounter = 0;
-  thenableState = null;
+  return {
+    value: value,
+    source: source,
+    stack: JSCompiler_inline_result,
+    digest: null
+  };
 }
-function mountWorkInProgressHook() {
-  var hook = {
-    memoizedState: null,
-    baseState: null,
-    baseQueue: null,
-    queue: null,
-    next: null
+function createCapturedValue(value, digest, stack) {
+  return {
+    value: value,
+    source: null,
+    stack: null != stack ? stack : null,
+    digest: null != digest ? digest : null
   };
-  null === workInProgressHook
-    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
-    : (workInProgressHook = workInProgressHook.next = hook);
-  return workInProgressHook;
 }
-function updateWorkInProgressHook() {
-  if (null === currentHook) {
-    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
-    nextCurrentHook =
-      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
-  } else nextCurrentHook = currentHook.next;
-  var nextWorkInProgressHook =
-    null === workInProgressHook
-      ? currentlyRenderingFiber$1.memoizedState
-      : workInProgressHook.next;
-  if (null !== nextWorkInProgressHook)
-    (workInProgressHook = nextWorkInProgressHook),
-      (currentHook = nextCurrentHook);
-  else {
-    if (null === nextCurrentHook) {
-      if (null === currentlyRenderingFiber$1.alternate)
-        throw Error(formatProdErrorMessage(467));
-      throw Error(formatProdErrorMessage(310));
-    }
-    currentHook = nextCurrentHook;
-    nextCurrentHook = {
-      memoizedState: currentHook.memoizedState,
-      baseState: currentHook.baseState,
-      baseQueue: currentHook.baseQueue,
-      queue: currentHook.queue,
-      next: null
-    };
-    null === workInProgressHook
-      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
-          nextCurrentHook)
-      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
+var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
+if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
+  throw Error(formatProdErrorMessage(320));
+function logCapturedError(boundary, errorInfo) {
+  try {
+    !1 !==
+      ReactFiberErrorDialogWWW.showErrorDialog({
+        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
+        error: errorInfo.value,
+        errorBoundary:
+          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
+      }) && console.error(errorInfo.value);
+  } catch (e) {
+    setTimeout(function () {
+      throw e;
+    });
   }
-  return workInProgressHook;
 }
-var createFunctionComponentUpdateQueue;
-createFunctionComponentUpdateQueue = function () {
-  return { lastEffect: null, events: null, stores: null, memoCache: null };
-};
-function use(usable) {
-  if (null !== usable && "object" === typeof usable) {
-    if ("function" === typeof usable.then) {
-      var index$90 = thenableIndexCounter;
-      thenableIndexCounter += 1;
-      null === thenableState && (thenableState = []);
-      usable = trackUsedThenable(thenableState, usable, index$90);
-      null === currentlyRenderingFiber$1.alternate &&
-        (null === workInProgressHook
-          ? null === currentlyRenderingFiber$1.memoizedState
-          : null === workInProgressHook.next) &&
-        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
-      return usable;
-    }
-    if (
-      usable.$$typeof === REACT_CONTEXT_TYPE ||
-      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
-    )
-      return readContext(usable);
-  }
-  throw Error(formatProdErrorMessage(438, String(usable)));
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  lane.payload = { element: null };
+  var error = errorInfo.value;
+  lane.callback = function () {
+    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
+    logCapturedError(fiber, errorInfo);
+  };
+  return lane;
 }
-function useMemoCache(size) {
-  var memoCache = null,
-    updateQueue = currentlyRenderingFiber$1.updateQueue;
-  null !== updateQueue && (memoCache = updateQueue.memoCache);
-  if (null == memoCache) {
-    var current = currentlyRenderingFiber$1.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      null !== current &&
-        ((current = current.memoCache),
-        null != current &&
-          (memoCache = {
-            data: current.data.map(function (array) {
-              return array.slice();
-            }),
-            index: 0
-          })));
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+  if ("function" === typeof getDerivedStateFromError) {
+    var error = errorInfo.value;
+    lane.payload = function () {
+      return getDerivedStateFromError(error);
+    };
+    lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+    };
   }
-  null == memoCache && (memoCache = { data: [], index: 0 });
-  null === updateQueue &&
-    ((updateQueue = createFunctionComponentUpdateQueue()),
-    (currentlyRenderingFiber$1.updateQueue = updateQueue));
-  updateQueue.memoCache = memoCache;
-  updateQueue = memoCache.data[memoCache.index];
-  if (void 0 === updateQueue)
-    for (
-      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
-      current < size;
-      current++
-    )
-      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
-  memoCache.index++;
-  return updateQueue;
+  var inst = fiber.stateNode;
+  null !== inst &&
+    "function" === typeof inst.componentDidCatch &&
+    (lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+      "function" !== typeof getDerivedStateFromError &&
+        (null === legacyErrorBoundariesThatAlreadyFailed
+          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
+          : legacyErrorBoundariesThatAlreadyFailed.add(this));
+      var stack = errorInfo.stack;
+      this.componentDidCatch(errorInfo.value, {
+        componentStack: null !== stack ? stack : ""
+      });
+    });
+  return lane;
 }
-function basicStateReducer(state, action) {
-  return "function" === typeof action ? action(state) : action;
+function markSuspenseBoundaryShouldCapture(
+  suspenseBoundary,
+  returnFiber,
+  sourceFiber,
+  root,
+  rootRenderLanes
+) {
+  if (0 === (suspenseBoundary.mode & 1))
+    return (
+      suspenseBoundary === returnFiber
+        ? (suspenseBoundary.flags |= 65536)
+        : ((suspenseBoundary.flags |= 128),
+          (sourceFiber.flags |= 131072),
+          (sourceFiber.flags &= -52805),
+          1 === sourceFiber.tag &&
+            (null === sourceFiber.alternate
+              ? (sourceFiber.tag = 17)
+              : ((returnFiber = createUpdate(2)),
+                (returnFiber.tag = 2),
+                enqueueUpdate(sourceFiber, returnFiber, 2))),
+          (sourceFiber.lanes |= 2)),
+      suspenseBoundary
+    );
+  suspenseBoundary.flags |= 65536;
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
 }
-function updateReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var current = currentHook,
-    baseQueue = current.baseQueue,
-    pendingQueue = queue.pending;
-  if (null !== pendingQueue) {
-    if (null !== baseQueue) {
-      var baseFirst = baseQueue.next;
-      baseQueue.next = pendingQueue.next;
-      pendingQueue.next = baseFirst;
-    }
-    current.baseQueue = baseQueue = pendingQueue;
-    queue.pending = null;
+function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
+  if (enableTransitionTracing && null !== pendingTransitions) {
+    var transitionStart = pendingTransitions.transitionStart,
+      onTransitionStart = callbacks.onTransitionStart;
+    null !== transitionStart &&
+      null != onTransitionStart &&
+      transitionStart.forEach(function (transition) {
+        return onTransitionStart(transition.name, transition.startTime);
+      });
+    transitionStart = pendingTransitions.markerProgress;
+    var onMarkerProgress = callbacks.onMarkerProgress;
+    null != onMarkerProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (markerInstance, markerName) {
+        if (null !== markerInstance.transitions) {
+          var pending =
+            null !== markerInstance.pendingBoundaries
+              ? Array.from(markerInstance.pendingBoundaries.values())
+              : [];
+          markerInstance.transitions.forEach(function (transition) {
+            onMarkerProgress(
+              transition.name,
+              markerName,
+              transition.startTime,
+              endTime,
+              pending
+            );
+          });
+        }
+      });
+    transitionStart = pendingTransitions.markerComplete;
+    var onMarkerComplete = callbacks.onMarkerComplete;
+    null !== transitionStart &&
+      null != onMarkerComplete &&
+      transitionStart.forEach(function (transitions, markerName) {
+        transitions.forEach(function (transition) {
+          onMarkerComplete(
+            transition.name,
+            markerName,
+            transition.startTime,
+            endTime
+          );
+        });
+      });
+    transitionStart = pendingTransitions.markerIncomplete;
+    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
+    null != onMarkerIncomplete &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (_ref, markerName) {
+        var aborts = _ref.aborts;
+        _ref.transitions.forEach(function (transition) {
+          var filteredAborts = [];
+          aborts.forEach(function (abort) {
+            switch (abort.reason) {
+              case "marker":
+                filteredAborts.push({
+                  type: "marker",
+                  name: abort.name,
+                  endTime: endTime
+                });
+                break;
+              case "suspense":
+                filteredAborts.push({
+                  type: "suspense",
+                  name: abort.name,
+                  endTime: endTime
+                });
+            }
+          });
+          0 < filteredAborts.length &&
+            onMarkerIncomplete(
+              transition.name,
+              markerName,
+              transition.startTime,
+              filteredAborts
+            );
+        });
+      });
+    transitionStart = pendingTransitions.transitionProgress;
+    var onTransitionProgress = callbacks.onTransitionProgress;
+    null != onTransitionProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (pending, transition) {
+        onTransitionProgress(
+          transition.name,
+          transition.startTime,
+          endTime,
+          Array.from(pending.values())
+        );
+      });
+    pendingTransitions = pendingTransitions.transitionComplete;
+    var onTransitionComplete = callbacks.onTransitionComplete;
+    null !== pendingTransitions &&
+      null != onTransitionComplete &&
+      pendingTransitions.forEach(function (transition) {
+        return onTransitionComplete(
+          transition.name,
+          transition.startTime,
+          endTime
+        );
+      });
   }
-  if (null !== baseQueue) {
-    pendingQueue = baseQueue.next;
-    current = current.baseState;
-    var newBaseQueueFirst = (baseFirst = null),
-      newBaseQueueLast = null,
-      update = pendingQueue;
-    do {
-      var updateLane = update.lane & -1073741825;
-      if (
-        updateLane !== update.lane
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes$1 & updateLane) === updateLane
-      )
-        null !== newBaseQueueLast &&
-          (newBaseQueueLast = newBaseQueueLast.next =
-            {
-              lane: 0,
-              action: update.action,
-              hasEagerState: update.hasEagerState,
-              eagerState: update.eagerState,
-              next: null
-            }),
-          (updateLane = update.action),
-          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
-          (current = update.hasEagerState
-            ? update.eagerState
-            : reducer(current, updateLane));
-      else {
-        var clone = {
-          lane: updateLane,
-          action: update.action,
-          hasEagerState: update.hasEagerState,
-          eagerState: update.eagerState,
-          next: null
-        };
-        null === newBaseQueueLast
-          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
-            (baseFirst = current))
-          : (newBaseQueueLast = newBaseQueueLast.next = clone);
-        currentlyRenderingFiber$1.lanes |= updateLane;
-        workInProgressRootSkippedLanes |= updateLane;
-      }
-      update = update.next;
-    } while (null !== update && update !== pendingQueue);
-    null === newBaseQueueLast
-      ? (baseFirst = current)
-      : (newBaseQueueLast.next = newBaseQueueFirst);
-    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = current;
-    hook.baseState = baseFirst;
-    hook.baseQueue = newBaseQueueLast;
-    queue.lastRenderedState = current;
-  }
-  null === baseQueue && (queue.lanes = 0);
-  return [hook.memoizedState, queue.dispatch];
-}
-function rerenderReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var dispatch = queue.dispatch,
-    lastRenderPhaseUpdate = queue.pending,
-    newState = hook.memoizedState;
-  if (null !== lastRenderPhaseUpdate) {
-    queue.pending = null;
-    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
-    do (newState = reducer(newState, update.action)), (update = update.next);
-    while (update !== lastRenderPhaseUpdate);
-    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = newState;
-    null === hook.baseQueue && (hook.baseState = newState);
-    queue.lastRenderedState = newState;
-  }
-  return [newState, dispatch];
-}
-function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
-  var getVersion = source._getVersion;
-  getVersion = getVersion(source._source);
-  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
-  if (null !== JSCompiler_inline_result)
-    root = JSCompiler_inline_result === getVersion;
-  else if (
-    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
-  )
-    (source._workInProgressVersionPrimary = getVersion),
-      workInProgressSources.push(source);
-  if (root) return getSnapshot(source._source);
-  workInProgressSources.push(source);
-  throw Error(formatProdErrorMessage(350));
 }
-function useMutableSource(hook, source, getSnapshot, subscribe) {
-  var root = workInProgressRoot;
-  if (null === root) throw Error(formatProdErrorMessage(349));
-  var getVersion = source._getVersion,
-    version = getVersion(source._source),
-    dispatcher = ReactCurrentDispatcher$1.current,
-    _dispatcher$useState = dispatcher.useState(function () {
-      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    }),
-    setSnapshot = _dispatcher$useState[1],
-    snapshot = _dispatcher$useState[0];
-  _dispatcher$useState = workInProgressHook;
-  var memoizedState = hook.memoizedState,
-    refs = memoizedState.refs,
-    prevGetSnapshot = refs.getSnapshot,
-    prevSource = memoizedState.source;
-  memoizedState = memoizedState.subscribe;
-  var fiber = currentlyRenderingFiber$1;
-  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
-  dispatcher.useEffect(
-    function () {
-      refs.getSnapshot = getSnapshot;
-      refs.setSnapshot = setSnapshot;
-      var maybeNewVersion = getVersion(source._source);
-      objectIs(version, maybeNewVersion) ||
-        ((maybeNewVersion = getSnapshot(source._source)),
-        objectIs(snapshot, maybeNewVersion) ||
-          (setSnapshot(maybeNewVersion),
-          (maybeNewVersion = requestUpdateLane(fiber)),
-          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
-        markRootEntangled(root, root.mutableReadLanes));
-    },
-    [getSnapshot, source, subscribe]
-  );
-  dispatcher.useEffect(
-    function () {
-      return subscribe(source._source, function () {
-        var latestGetSnapshot = refs.getSnapshot,
-          latestSetSnapshot = refs.setSnapshot;
-        try {
-          latestSetSnapshot(latestGetSnapshot(source._source));
-          var lane = requestUpdateLane(fiber);
-          root.mutableReadLanes |= lane & root.pendingLanes;
-        } catch (error) {
-          latestSetSnapshot(function () {
-            throw error;
-          });
+var markerInstanceStack = createCursor(null);
+function pushRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    var transitions = workInProgressTransitions,
+      root$94 = workInProgress.stateNode;
+    null !== transitions &&
+      transitions.forEach(function (transition) {
+        if (!root$94.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: 0,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root$94.incompleteTransitions.set(transition, markerInstance);
         }
       });
-    },
-    [source, subscribe]
-  );
-  (objectIs(prevGetSnapshot, getSnapshot) &&
-    objectIs(prevSource, source) &&
-    objectIs(memoizedState, subscribe)) ||
-    ((hook = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: basicStateReducer,
-      lastRenderedState: snapshot
-    }),
-    (hook.dispatch = setSnapshot =
-      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
-    (_dispatcher$useState.queue = hook),
-    (_dispatcher$useState.baseQueue = null),
-    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
-    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
-      snapshot));
-  return snapshot;
-}
-function updateMutableSource(source, getSnapshot, subscribe) {
-  var hook = updateWorkInProgressHook();
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
-function updateSyncExternalStore(subscribe, getSnapshot) {
-  var fiber = currentlyRenderingFiber$1,
-    hook = updateWorkInProgressHook(),
-    nextSnapshot = getSnapshot(),
-    snapshotChanged = !objectIs(
-      (currentHook || hook).memoizedState,
-      nextSnapshot
-    );
-  snapshotChanged &&
-    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
-  hook = hook.queue;
-  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
-    subscribe
-  ]);
-  if (
-    hook.getSnapshot !== getSnapshot ||
-    snapshotChanged ||
-    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
-  ) {
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
-      void 0,
-      null
-    );
-    subscribe = workInProgressRoot;
-    if (null === subscribe) throw Error(formatProdErrorMessage(349));
-    includesBlockingLane(subscribe, renderLanes$1) ||
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    var markerInstances = [];
+    root$94.incompleteTransitions.forEach(function (markerInstance) {
+      markerInstances.push(markerInstance);
+    });
+    push(markerInstanceStack, markerInstances);
   }
-  return nextSnapshot;
 }
-function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
-  fiber.flags |= 16384;
-  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
-  getSnapshot = currentlyRenderingFiber$1.updateQueue;
-  null === getSnapshot
-    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
-      (getSnapshot.stores = [fiber]))
-    : ((renderedSnapshot = getSnapshot.stores),
-      null === renderedSnapshot
-        ? (getSnapshot.stores = [fiber])
-        : renderedSnapshot.push(fiber));
+function pushMarkerInstance(workInProgress, markerInstance) {
+  enableTransitionTracing &&
+    (null === markerInstanceStack.current
+      ? push(markerInstanceStack, [markerInstance])
+      : push(
+          markerInstanceStack,
+          markerInstanceStack.current.concat(markerInstance)
+        ));
 }
-function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
-  inst.value = nextSnapshot;
-  inst.getSnapshot = getSnapshot;
-  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
+  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
+  didReceiveUpdate = !1;
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  workInProgress.child =
+    null === current
+      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
+      : reconcileChildFibers(
+          workInProgress,
+          current.child,
+          nextChildren,
+          renderLanes
+        );
 }
-function subscribeToStore(fiber, inst, subscribe) {
-  return subscribe(function () {
-    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
-  });
+function updateForwardRef(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  Component = Component.render;
+  var ref = workInProgress.ref;
+  prepareToReadContext(workInProgress, renderLanes);
+  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+  nextProps = renderWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    ref,
+    renderLanes
+  );
+  Component = checkDidRenderIdHook();
+  enableSchedulingProfiler && markComponentRenderStopped();
+  if (null !== current && !didReceiveUpdate)
+    return (
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+    );
+  isHydrating && Component && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, nextProps, renderLanes);
+  return workInProgress.child;
 }
-function checkIfSnapshotChanged(inst) {
-  var latestGetSnapshot = inst.getSnapshot;
-  inst = inst.value;
-  try {
-    var nextValue = latestGetSnapshot();
-    return !objectIs(inst, nextValue);
-  } catch (error) {
-    return !0;
+function updateMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null === current) {
+    var type = Component.type;
+    if (
+      "function" === typeof type &&
+      !shouldConstruct(type) &&
+      void 0 === type.defaultProps &&
+      null === Component.compare &&
+      void 0 === Component.defaultProps
+    )
+      return (
+        (workInProgress.tag = 15),
+        (workInProgress.type = type),
+        updateSimpleMemoComponent(
+          current,
+          workInProgress,
+          type,
+          nextProps,
+          renderLanes
+        )
+      );
+    current = createFiberFromTypeAndProps(
+      Component.type,
+      null,
+      nextProps,
+      workInProgress,
+      workInProgress.mode,
+      renderLanes
+    );
+    current.ref = workInProgress.ref;
+    current.return = workInProgress;
+    return (workInProgress.child = current);
   }
+  type = current.child;
+  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+    var prevProps = type.memoizedProps;
+    Component = Component.compare;
+    Component = null !== Component ? Component : shallowEqual;
+    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+  workInProgress.flags |= 1;
+  current = createWorkInProgress(type, nextProps);
+  current.ref = workInProgress.ref;
+  current.return = workInProgress;
+  return (workInProgress.child = current);
 }
-function forceStoreRerender(fiber) {
-  var root = enqueueConcurrentRenderForLane(fiber, 2);
-  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
-}
-function mountState(initialState) {
-  var hook = mountWorkInProgressHook();
-  "function" === typeof initialState && (initialState = initialState());
-  hook.memoizedState = hook.baseState = initialState;
-  initialState = {
-    pending: null,
-    lanes: 0,
-    dispatch: null,
-    lastRenderedReducer: basicStateReducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = initialState;
-  initialState = initialState.dispatch = dispatchSetState.bind(
-    null,
-    currentlyRenderingFiber$1,
-    initialState
-  );
-  return [hook.memoizedState, initialState];
-}
-function pushEffect(tag, create, destroy, deps) {
-  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
-  create = currentlyRenderingFiber$1.updateQueue;
-  null === create
-    ? ((create = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = create),
-      (create.lastEffect = tag.next = tag))
-    : ((destroy = create.lastEffect),
-      null === destroy
-        ? (create.lastEffect = tag.next = tag)
-        : ((deps = destroy.next),
-          (destroy.next = tag),
-          (tag.next = deps),
-          (create.lastEffect = tag)));
-  return tag;
-}
-function updateRef() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = mountWorkInProgressHook();
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    1 | hookFlags,
-    create,
-    void 0,
-    void 0 === deps ? null : deps
+function updateSimpleMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null !== current) {
+    var prevProps = current.memoizedProps;
+    if (
+      shallowEqual(prevProps, nextProps) &&
+      current.ref === workInProgress.ref
+    )
+      if (
+        ((didReceiveUpdate = !1),
+        (workInProgress.pendingProps = nextProps = prevProps),
+        checkScheduledUpdateOrContext(current, renderLanes))
+      )
+        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
+      else
+        return (
+          (workInProgress.lanes = current.lanes),
+          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+        );
+  }
+  return updateFunctionComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    renderLanes
   );
 }
-function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var destroy = void 0;
-  if (null !== currentHook) {
-    var prevEffect = currentHook.memoizedState;
-    destroy = prevEffect.destroy;
-    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
-      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
-      return;
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    nextChildren = nextProps.children,
+    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
+    prevState = null !== current ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+  if (
+    "hidden" === nextProps.mode ||
+    "unstable-defer-without-hiding" === nextProps.mode ||
+    nextIsDetached
+  ) {
+    if (0 !== (workInProgress.flags & 128)) {
+      nextChildren =
+        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+      if (null !== current) {
+        prevState = workInProgress.child = current.child;
+        for (nextProps = 0; null !== prevState; )
+          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
+            (prevState = prevState.sibling);
+        workInProgress.childLanes = nextProps & ~nextChildren;
+      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes
+      );
     }
-  }
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
+    if (0 === (workInProgress.mode & 1))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current && pushTransition(workInProgress, null, null),
+        reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else if (0 !== (renderLanes & 1073741824))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current &&
+          pushTransition(
+            workInProgress,
+            null !== prevState ? prevState.cachePool : null,
+            null
+          ),
+        null !== prevState
+          ? pushHiddenContext(workInProgress, prevState)
+          : reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else
+      return (
+        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
+        deferHiddenOffscreenComponent(
+          current,
+          workInProgress,
+          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
+          renderLanes
+        )
+      );
+  } else if (null !== prevState) {
+    nextProps = prevState.cachePool;
+    nextIsDetached = null;
+    if (enableTransitionTracing) {
+      var instance = workInProgress.stateNode;
+      null !== instance &&
+        null != instance._transitions &&
+        (nextIsDetached = Array.from(instance._transitions));
+    }
+    pushTransition(workInProgress, nextProps, nextIsDetached);
+    pushHiddenContext(workInProgress, prevState);
+    reuseSuspenseHandlerOnStack();
+    workInProgress.memoizedState = null;
+  } else
+    null !== current && pushTransition(workInProgress, null, null),
+      reuseHiddenContextOnStack(),
+      reuseSuspenseHandlerOnStack();
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
-function mountEffect(create, deps) {
-  mountEffectImpl(8390656, 8, create, deps);
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
+  var JSCompiler_inline_result = peekCacheFromPool();
+  JSCompiler_inline_result =
+    null === JSCompiler_inline_result
+      ? null
+      : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
+  workInProgress.memoizedState = {
+    baseLanes: nextBaseLanes,
+    cachePool: JSCompiler_inline_result
+  };
+  null !== current && pushTransition(workInProgress, null, null);
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+  enableLazyContextPropagation &&
+    null !== current &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
+  return null;
 }
-function updateEffect(create, deps) {
-  updateEffectImpl(2048, 8, create, deps);
+function markRef$1(current, workInProgress) {
+  var ref = workInProgress.ref;
+  if (
+    (null === current && null !== ref) ||
+    (null !== current && current.ref !== ref)
+  )
+    (workInProgress.flags |= 512), (workInProgress.flags |= 2097152);
 }
-function useEffectEventImpl(payload) {
-  currentlyRenderingFiber$1.flags |= 4;
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
-  if (null === componentUpdateQueue)
-    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
-      (componentUpdateQueue.events = [payload]);
-  else {
-    var events = componentUpdateQueue.events;
-    null === events
-      ? (componentUpdateQueue.events = [payload])
-      : events.push(payload);
-  }
-}
-function updateEvent(callback) {
-  var ref = updateWorkInProgressHook().memoizedState;
-  useEffectEventImpl({ ref: ref, nextImpl: callback });
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
-}
-function updateInsertionEffect(create, deps) {
-  return updateEffectImpl(4, 2, create, deps);
-}
-function updateLayoutEffect(create, deps) {
-  return updateEffectImpl(4, 4, create, deps);
-}
-function imperativeHandleEffect(create, ref) {
-  if ("function" === typeof ref)
-    return (
-      (create = create()),
-      ref(create),
-      function () {
-        ref(null);
-      }
-    );
-  if (null !== ref && void 0 !== ref)
+function updateFunctionComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  var context = isContextProvider(Component)
+    ? previousContext
+    : contextStackCursor.current;
+  context = getMaskedContext(workInProgress, context);
+  prepareToReadContext(workInProgress, renderLanes);
+  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+  Component = renderWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    context,
+    renderLanes
+  );
+  nextProps = checkDidRenderIdHook();
+  enableSchedulingProfiler && markComponentRenderStopped();
+  if (null !== current && !didReceiveUpdate)
     return (
-      (create = create()),
-      (ref.current = create),
-      function () {
-        ref.current = null;
-      }
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
     );
+  isHydrating && nextProps && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, Component, renderLanes);
+  return workInProgress.child;
 }
-function updateImperativeHandle(ref, create, deps) {
-  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
-}
-function mountDebugValue() {}
-function updateCallback(callback, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  hook.memoizedState = [callback, deps];
-  return callback;
-}
-function updateMemo(nextCreate, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-  nextCreate = nextCreate();
-  hook.memoizedState = [nextCreate, deps];
-  return nextCreate;
-}
-function updateDeferredValueImpl(hook, prevValue, value) {
-  if (0 === (renderLanes$1 & 42))
+function replayFunctionComponent(
+  current,
+  workInProgress,
+  nextProps,
+  Component,
+  renderLanes
+) {
+  var context = isContextProvider(Component)
+    ? previousContext
+    : contextStackCursor.current;
+  context = getMaskedContext(workInProgress, context);
+  prepareToReadContext(workInProgress, renderLanes);
+  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+  nextProps = renderWithHooksAgain(
+    workInProgress,
+    Component,
+    nextProps,
+    context
+  );
+  finishRenderingHooks(current);
+  Component = checkDidRenderIdHook();
+  enableSchedulingProfiler && markComponentRenderStopped();
+  if (null !== current && !didReceiveUpdate)
     return (
-      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
-      (hook.memoizedState = value)
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
     );
-  objectIs(value, prevValue) ||
-    ((value = claimNextTransitionLane()),
-    (currentlyRenderingFiber$1.lanes |= value),
-    (workInProgressRootSkippedLanes |= value),
-    (hook.baseState = !0));
-  return prevValue;
-}
-function startTransition(setPending, callback, options) {
-  var previousPriority = currentUpdatePriority;
-  currentUpdatePriority =
-    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
-  setPending(!0);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
-  enableTransitionTracing &&
-    void 0 !== options &&
-    void 0 !== options.name &&
-    ((ReactCurrentBatchConfig$2.transition.name = options.name),
-    (ReactCurrentBatchConfig$2.transition.startTime = now$1()));
-  try {
-    setPending(!1), callback();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$2.transition = prevTransition);
-  }
-}
-function updateId() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function updateRefresh() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function refreshCache(fiber, seedKey, seedValue) {
-  for (var provider = fiber.return; null !== provider; ) {
-    switch (provider.tag) {
-      case 24:
-      case 3:
-        var lane = requestUpdateLane(provider);
-        fiber = createUpdate(lane);
-        var root$96 = enqueueUpdate(provider, fiber, lane);
-        if (null !== root$96) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root$96, provider, lane, eventTime);
-          entangleTransitions(root$96, provider, lane);
-        }
-        provider = createCache();
-        null !== seedKey &&
-          void 0 !== seedKey &&
-          null !== root$96 &&
-          provider.data.set(seedKey, seedValue);
-        fiber.payload = { cache: provider };
-        return;
-    }
-    provider = provider.return;
-  }
-}
-function dispatchReducerAction(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber);
-  action = {
-    lane: lane,
-    action: action,
-    hasEagerState: !1,
-    eagerState: null,
-    next: null
-  };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
-  else if (
-    (enqueueUpdate$1(fiber, queue, action, lane),
-    (action = getRootForUpdatedFiber(fiber)),
-    null !== action)
-  ) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
-    entangleTransitionUpdate(action, queue, lane);
-  }
-  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
-}
-function dispatchSetState(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber),
-    update = {
-      lane: lane,
-      action: action,
-      hasEagerState: !1,
-      eagerState: null,
-      next: null
-    };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
-  else {
-    var alternate = fiber.alternate;
-    if (
-      0 === fiber.lanes &&
-      (null === alternate || 0 === alternate.lanes) &&
-      ((alternate = queue.lastRenderedReducer), null !== alternate)
-    )
-      try {
-        var currentState = queue.lastRenderedState,
-          eagerState = alternate(currentState, action);
-        update.hasEagerState = !0;
-        update.eagerState = eagerState;
-        if (objectIs(eagerState, currentState)) {
-          enqueueUpdate$1(fiber, queue, update, 0);
-          null === workInProgressRoot && finishQueueingConcurrentUpdates();
-          return;
-        }
-      } catch (error) {
-      } finally {
-      }
-    enqueueUpdate$1(fiber, queue, update, lane);
-    action = getRootForUpdatedFiber(fiber);
-    null !== action &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(action, fiber, lane, update),
-      entangleTransitionUpdate(action, queue, lane));
-  }
-  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
-}
-function isRenderPhaseUpdate(fiber) {
-  var alternate = fiber.alternate;
-  return (
-    fiber === currentlyRenderingFiber$1 ||
-    (null !== alternate && alternate === currentlyRenderingFiber$1)
-  );
-}
-function enqueueRenderPhaseUpdate(queue, update) {
-  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
-    !0;
-  var pending = queue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  queue.pending = update;
+  isHydrating && Component && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, nextProps, renderLanes);
+  return workInProgress.child;
 }
-function entangleTransitionUpdate(root, queue, lane) {
-  if (0 !== (lane & 8388480)) {
-    var queueLanes = queue.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    queue.lanes = lane;
-    markRootEntangled(root, lane);
+function updateClassComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (isContextProvider(Component)) {
+    var hasContext = !0;
+    pushContextProvider(workInProgress);
+  } else hasContext = !1;
+  prepareToReadContext(workInProgress, renderLanes);
+  if (null === workInProgress.stateNode)
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+      constructClassInstance(workInProgress, Component, nextProps),
+      mountClassInstance(workInProgress, Component, nextProps, renderLanes),
+      (nextProps = !0);
+  else if (null === current) {
+    var instance = workInProgress.stateNode,
+      oldProps = workInProgress.memoizedProps;
+    instance.props = oldProps;
+    var oldContext = instance.context,
+      contextType = Component.contextType;
+    "object" === typeof contextType && null !== contextType
+      ? (contextType = readContext(contextType))
+      : ((contextType = isContextProvider(Component)
+          ? previousContext
+          : contextStackCursor.current),
+        (contextType = getMaskedContext(workInProgress, contextType)));
+    var getDerivedStateFromProps = Component.getDerivedStateFromProps,
+      hasNewLifecycles =
+        "function" === typeof getDerivedStateFromProps ||
+        "function" === typeof instance.getSnapshotBeforeUpdate;
+    hasNewLifecycles ||
+      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
+        "function" !== typeof instance.componentWillReceiveProps) ||
+      ((oldProps !== nextProps || oldContext !== contextType) &&
+        callComponentWillReceiveProps(
+          workInProgress,
+          instance,
+          nextProps,
+          contextType
+        ));
+    hasForceUpdate = !1;
+    var oldState = workInProgress.memoizedState;
+    instance.state = oldState;
+    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+    oldContext = workInProgress.memoizedState;
+    oldProps !== nextProps ||
+    oldState !== oldContext ||
+    didPerformWorkStackCursor.current ||
+    hasForceUpdate
+      ? ("function" === typeof getDerivedStateFromProps &&
+          (applyDerivedStateFromProps(
+            workInProgress,
+            Component,
+            getDerivedStateFromProps,
+            nextProps
+          ),
+          (oldContext = workInProgress.memoizedState)),
+        (oldProps =
+          hasForceUpdate ||
+          checkShouldComponentUpdate(
+            workInProgress,
+            Component,
+            oldProps,
+            nextProps,
+            oldState,
+            oldContext,
+            contextType
+          ))
+          ? (hasNewLifecycles ||
+              ("function" !== typeof instance.UNSAFE_componentWillMount &&
+                "function" !== typeof instance.componentWillMount) ||
+              ("function" === typeof instance.componentWillMount &&
+                instance.componentWillMount(),
+              "function" === typeof instance.UNSAFE_componentWillMount &&
+                instance.UNSAFE_componentWillMount()),
+            "function" === typeof instance.componentDidMount &&
+              (workInProgress.flags |= 4194308))
+          : ("function" === typeof instance.componentDidMount &&
+              (workInProgress.flags |= 4194308),
+            (workInProgress.memoizedProps = nextProps),
+            (workInProgress.memoizedState = oldContext)),
+        (instance.props = nextProps),
+        (instance.state = oldContext),
+        (instance.context = contextType),
+        (nextProps = oldProps))
+      : ("function" === typeof instance.componentDidMount &&
+          (workInProgress.flags |= 4194308),
+        (nextProps = !1));
+  } else {
+    instance = workInProgress.stateNode;
+    cloneUpdateQueue(current, workInProgress);
+    oldProps = workInProgress.memoizedProps;
+    contextType =
+      workInProgress.type === workInProgress.elementType
+        ? oldProps
+        : resolveDefaultProps(workInProgress.type, oldProps);
+    instance.props = contextType;
+    hasNewLifecycles = workInProgress.pendingProps;
+    oldState = instance.context;
+    oldContext = Component.contextType;
+    "object" === typeof oldContext && null !== oldContext
+      ? (oldContext = readContext(oldContext))
+      : ((oldContext = isContextProvider(Component)
+          ? previousContext
+          : contextStackCursor.current),
+        (oldContext = getMaskedContext(workInProgress, oldContext)));
+    var getDerivedStateFromProps$jscomp$0 = Component.getDerivedStateFromProps;
+    (getDerivedStateFromProps =
+      "function" === typeof getDerivedStateFromProps$jscomp$0 ||
+      "function" === typeof instance.getSnapshotBeforeUpdate) ||
+      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
+        "function" !== typeof instance.componentWillReceiveProps) ||
+      ((oldProps !== hasNewLifecycles || oldState !== oldContext) &&
+        callComponentWillReceiveProps(
+          workInProgress,
+          instance,
+          nextProps,
+          oldContext
+        ));
+    hasForceUpdate = !1;
+    oldState = workInProgress.memoizedState;
+    instance.state = oldState;
+    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+    var newState = workInProgress.memoizedState;
+    oldProps !== hasNewLifecycles ||
+    oldState !== newState ||
+    didPerformWorkStackCursor.current ||
+    hasForceUpdate ||
+    (enableLazyContextPropagation &&
+      null !== current &&
+      null !== current.dependencies &&
+      checkIfContextChanged(current.dependencies))
+      ? ("function" === typeof getDerivedStateFromProps$jscomp$0 &&
+          (applyDerivedStateFromProps(
+            workInProgress,
+            Component,
+            getDerivedStateFromProps$jscomp$0,
+            nextProps
+          ),
+          (newState = workInProgress.memoizedState)),
+        (contextType =
+          hasForceUpdate ||
+          checkShouldComponentUpdate(
+            workInProgress,
+            Component,
+            contextType,
+            nextProps,
+            oldState,
+            newState,
+            oldContext
+          ) ||
+          (enableLazyContextPropagation &&
+            null !== current &&
+            null !== current.dependencies &&
+            checkIfContextChanged(current.dependencies)))
+          ? (getDerivedStateFromProps ||
+              ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
+                "function" !== typeof instance.componentWillUpdate) ||
+              ("function" === typeof instance.componentWillUpdate &&
+                instance.componentWillUpdate(nextProps, newState, oldContext),
+              "function" === typeof instance.UNSAFE_componentWillUpdate &&
+                instance.UNSAFE_componentWillUpdate(
+                  nextProps,
+                  newState,
+                  oldContext
+                )),
+            "function" === typeof instance.componentDidUpdate &&
+              (workInProgress.flags |= 4),
+            "function" === typeof instance.getSnapshotBeforeUpdate &&
+              (workInProgress.flags |= 1024))
+          : ("function" !== typeof instance.componentDidUpdate ||
+              (oldProps === current.memoizedProps &&
+                oldState === current.memoizedState) ||
+              (workInProgress.flags |= 4),
+            "function" !== typeof instance.getSnapshotBeforeUpdate ||
+              (oldProps === current.memoizedProps &&
+                oldState === current.memoizedState) ||
+              (workInProgress.flags |= 1024),
+            (workInProgress.memoizedProps = nextProps),
+            (workInProgress.memoizedState = newState)),
+        (instance.props = nextProps),
+        (instance.state = newState),
+        (instance.context = oldContext),
+        (nextProps = contextType))
+      : ("function" !== typeof instance.componentDidUpdate ||
+          (oldProps === current.memoizedProps &&
+            oldState === current.memoizedState) ||
+          (workInProgress.flags |= 4),
+        "function" !== typeof instance.getSnapshotBeforeUpdate ||
+          (oldProps === current.memoizedProps &&
+            oldState === current.memoizedState) ||
+          (workInProgress.flags |= 1024),
+        (nextProps = !1));
   }
+  return finishClassComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    hasContext,
+    renderLanes
+  );
 }
-var ContextOnlyDispatcher = {
-  readContext: readContext,
-  useCallback: throwInvalidHookError,
-  useContext: throwInvalidHookError,
-  useEffect: throwInvalidHookError,
-  useImperativeHandle: throwInvalidHookError,
-  useInsertionEffect: throwInvalidHookError,
-  useLayoutEffect: throwInvalidHookError,
-  useMemo: throwInvalidHookError,
-  useReducer: throwInvalidHookError,
-  useRef: throwInvalidHookError,
-  useState: throwInvalidHookError,
-  useDebugValue: throwInvalidHookError,
-  useDeferredValue: throwInvalidHookError,
-  useTransition: throwInvalidHookError,
-  useMutableSource: throwInvalidHookError,
-  useSyncExternalStore: throwInvalidHookError,
-  useId: throwInvalidHookError
-};
-ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
-ContextOnlyDispatcher.use = throwInvalidHookError;
-ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
-ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
-var HooksDispatcherOnMount = {
-  readContext: readContext,
-  useCallback: function (callback, deps) {
-    mountWorkInProgressHook().memoizedState = [
-      callback,
-      void 0 === deps ? null : deps
-    ];
-    return callback;
-  },
-  useContext: readContext,
-  useEffect: mountEffect,
-  useImperativeHandle: function (ref, create, deps) {
-    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-    mountEffectImpl(
-      4194308,
-      4,
-      imperativeHandleEffect.bind(null, create, ref),
-      deps
-    );
-  },
-  useLayoutEffect: function (create, deps) {
-    return mountEffectImpl(4194308, 4, create, deps);
-  },
-  useInsertionEffect: function (create, deps) {
-    mountEffectImpl(4, 2, create, deps);
-  },
-  useMemo: function (nextCreate, deps) {
-    var hook = mountWorkInProgressHook();
-    deps = void 0 === deps ? null : deps;
-    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-    nextCreate = nextCreate();
-    hook.memoizedState = [nextCreate, deps];
-    return nextCreate;
-  },
-  useReducer: function (reducer, initialArg, init) {
-    var hook = mountWorkInProgressHook();
-    initialArg = void 0 !== init ? init(initialArg) : initialArg;
-    hook.memoizedState = hook.baseState = initialArg;
-    reducer = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: reducer,
-      lastRenderedState: initialArg
-    };
-    hook.queue = reducer;
-    reducer = reducer.dispatch = dispatchReducerAction.bind(
-      null,
-      currentlyRenderingFiber$1,
-      reducer
-    );
-    return [hook.memoizedState, reducer];
-  },
-  useRef: function (initialValue) {
-    var hook = mountWorkInProgressHook();
-    if (enableUseRefAccessWarning)
-      return (
-        (initialValue = { current: initialValue }),
-        (hook.memoizedState = initialValue)
-      );
-    initialValue = { current: initialValue };
-    return (hook.memoizedState = initialValue);
-  },
-  useState: mountState,
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    return (mountWorkInProgressHook().memoizedState = value);
-  },
-  useTransition: function () {
-    var _mountState = mountState(!1),
-      isPending = _mountState[0];
-    _mountState = startTransition.bind(null, _mountState[1]);
-    mountWorkInProgressHook().memoizedState = _mountState;
-    return [isPending, _mountState];
-  },
-  useMutableSource: function (source, getSnapshot, subscribe) {
-    var hook = mountWorkInProgressHook();
-    hook.memoizedState = {
-      refs: { getSnapshot: getSnapshot, setSnapshot: null },
-      source: source,
-      subscribe: subscribe
-    };
-    return useMutableSource(hook, source, getSnapshot, subscribe);
-  },
-  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-    var fiber = currentlyRenderingFiber$1,
-      hook = mountWorkInProgressHook();
-    if (isHydrating) {
-      if (void 0 === getServerSnapshot)
-        throw Error(formatProdErrorMessage(407));
-      getServerSnapshot = getServerSnapshot();
-    } else {
-      getServerSnapshot = getSnapshot();
-      var root$92 = workInProgressRoot;
-      if (null === root$92) throw Error(formatProdErrorMessage(349));
-      includesBlockingLane(root$92, renderLanes$1) ||
-        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
-    }
-    hook.memoizedState = getServerSnapshot;
-    root$92 = { value: getServerSnapshot, getSnapshot: getSnapshot };
-    hook.queue = root$92;
-    mountEffect(subscribeToStore.bind(null, fiber, root$92, subscribe), [
-      subscribe
-    ]);
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(
-        null,
-        fiber,
-        root$92,
-        getServerSnapshot,
-        getSnapshot
-      ),
-      void 0,
-      null
+function finishClassComponent(
+  current,
+  workInProgress,
+  Component,
+  shouldUpdate,
+  hasContext,
+  renderLanes
+) {
+  markRef$1(current, workInProgress);
+  var didCaptureError = 0 !== (workInProgress.flags & 128);
+  if (!shouldUpdate && !didCaptureError)
+    return (
+      hasContext && invalidateContextProvider(workInProgress, Component, !1),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
     );
-    return getServerSnapshot;
-  },
-  useId: function () {
-    var hook = mountWorkInProgressHook(),
-      identifierPrefix = workInProgressRoot.identifierPrefix;
-    if (isHydrating) {
-      var JSCompiler_inline_result = treeContextOverflow;
-      var idWithLeadingBit = treeContextId;
-      JSCompiler_inline_result =
-        (
-          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
-        ).toString(32) + JSCompiler_inline_result;
-      identifierPrefix =
-        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
-      JSCompiler_inline_result = localIdCounter++;
-      0 < JSCompiler_inline_result &&
-        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
-      identifierPrefix += ":";
-    } else
-      (JSCompiler_inline_result = globalClientIdCounter++),
-        (identifierPrefix =
-          ":" +
-          identifierPrefix +
-          "r" +
-          JSCompiler_inline_result.toString(32) +
-          ":");
-    return (hook.memoizedState = identifierPrefix);
-  },
-  useCacheRefresh: function () {
-    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
-      null,
-      currentlyRenderingFiber$1
-    ));
-  }
-};
-HooksDispatcherOnMount.use = use;
-HooksDispatcherOnMount.useMemoCache = useMemoCache;
-HooksDispatcherOnMount.useEffectEvent = function (callback) {
-  var hook = mountWorkInProgressHook(),
-    ref = { impl: callback };
-  hook.memoizedState = ref;
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
-};
-var HooksDispatcherOnUpdate = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: updateReducer,
-  useRef: updateRef,
-  useState: function () {
-    return updateReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = updateReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
-HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
-HooksDispatcherOnUpdate.use = use;
-HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
-var HooksDispatcherOnRerender = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: rerenderReducer,
-  useRef: updateRef,
-  useState: function () {
-    return rerenderReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return null === currentHook
-      ? (hook.memoizedState = value)
-      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = rerenderReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
-HooksDispatcherOnRerender.use = use;
-HooksDispatcherOnRerender.useMemoCache = useMemoCache;
-HooksDispatcherOnRerender.useEffectEvent = updateEvent;
-var now = Scheduler.unstable_now,
-  commitTime = 0,
-  layoutEffectStartTime = -1,
-  profilerStartTime = -1,
-  passiveEffectStartTime = -1,
-  currentUpdateIsNested = !1,
-  nestedUpdateScheduled = !1;
-function startProfilerTimer(fiber) {
-  profilerStartTime = now();
-  0 > fiber.actualStartTime && (fiber.actualStartTime = now());
-}
-function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
-  if (0 <= profilerStartTime) {
-    var elapsedTime = now() - profilerStartTime;
-    fiber.actualDuration += elapsedTime;
-    overrideBaseTime && (fiber.selfBaseDuration = elapsedTime);
+  shouldUpdate = workInProgress.stateNode;
+  ReactCurrentOwner$1.current = workInProgress;
+  if (
+    didCaptureError &&
+    "function" !== typeof Component.getDerivedStateFromError
+  ) {
+    var nextChildren = null;
     profilerStartTime = -1;
-  }
+  } else
+    enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
+      (nextChildren = shouldUpdate.render()),
+      enableSchedulingProfiler && markComponentRenderStopped();
+  workInProgress.flags |= 1;
+  null !== current && didCaptureError
+    ? ((didCaptureError = nextChildren),
+      (workInProgress.child = reconcileChildFibers(
+        workInProgress,
+        current.child,
+        null,
+        renderLanes
+      )),
+      (workInProgress.child = reconcileChildFibers(
+        workInProgress,
+        null,
+        didCaptureError,
+        renderLanes
+      )))
+    : reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  workInProgress.memoizedState = shouldUpdate.state;
+  hasContext && invalidateContextProvider(workInProgress, Component, !0);
+  return workInProgress.child;
 }
-function recordLayoutEffectDuration(fiber) {
-  if (0 <= layoutEffectStartTime) {
-    var elapsedTime = now() - layoutEffectStartTime;
-    layoutEffectStartTime = -1;
-    for (fiber = fiber.return; null !== fiber; ) {
-      switch (fiber.tag) {
-        case 3:
-          fiber.stateNode.effectDuration += elapsedTime;
-          return;
-        case 12:
-          fiber.stateNode.effectDuration += elapsedTime;
-          return;
-      }
-      fiber = fiber.return;
-    }
-  }
-}
-function recordPassiveEffectDuration(fiber) {
-  if (0 <= passiveEffectStartTime) {
-    var elapsedTime = now() - passiveEffectStartTime;
-    passiveEffectStartTime = -1;
-    for (fiber = fiber.return; null !== fiber; ) {
-      switch (fiber.tag) {
-        case 3:
-          fiber = fiber.stateNode;
-          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
-          return;
-        case 12:
-          fiber = fiber.stateNode;
-          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
-          return;
-      }
-      fiber = fiber.return;
-    }
-  }
-}
-function startLayoutEffectTimer() {
-  layoutEffectStartTime = now();
-}
-function transferActualDuration(fiber) {
-  for (var child = fiber.child; child; )
-    (fiber.actualDuration += child.actualDuration), (child = child.sibling);
-}
-function resolveDefaultProps(Component, baseProps) {
-  if (Component && Component.defaultProps) {
-    baseProps = assign({}, baseProps);
-    Component = Component.defaultProps;
-    for (var propName in Component)
-      void 0 === baseProps[propName] &&
-        (baseProps[propName] = Component[propName]);
-    return baseProps;
-  }
-  return baseProps;
-}
-function applyDerivedStateFromProps(
-  workInProgress,
-  ctor,
-  getDerivedStateFromProps,
-  nextProps
-) {
-  ctor = workInProgress.memoizedState;
-  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
-  getDerivedStateFromProps =
-    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
-      ? ctor
-      : assign({}, ctor, getDerivedStateFromProps);
-  workInProgress.memoizedState = getDerivedStateFromProps;
-  0 === workInProgress.lanes &&
-    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
-}
-var classComponentUpdater = {
-  isMounted: function (component) {
-    return (component = component._reactInternals)
-      ? getNearestMountedFiber(component) === component
-      : !1;
-  },
-  enqueueSetState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
-  },
-  enqueueReplaceState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 1;
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
-  },
-  enqueueForceUpdate: function (inst, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 2;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    callback = enqueueUpdate(inst, update, lane);
-    null !== callback &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(callback, inst, lane, update),
-      entangleTransitions(callback, inst, lane));
-    enableSchedulingProfiler &&
-      enableSchedulingProfiler &&
-      null !== injectedProfilingHooks &&
-      "function" === typeof injectedProfilingHooks.markForceUpdateScheduled &&
-      injectedProfilingHooks.markForceUpdateScheduled(inst, lane);
-  }
-};
-function checkShouldComponentUpdate(
-  workInProgress,
-  ctor,
-  oldProps,
-  newProps,
-  oldState,
-  newState,
-  nextContext
-) {
-  workInProgress = workInProgress.stateNode;
-  return "function" === typeof workInProgress.shouldComponentUpdate
-    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
-    : ctor.prototype && ctor.prototype.isPureReactComponent
-    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
-    : !0;
-}
-function constructClassInstance(workInProgress, ctor, props) {
-  var isLegacyContextConsumer = !1,
-    unmaskedContext = emptyContextObject;
-  var context = ctor.contextType;
-  "object" === typeof context && null !== context
-    ? (context = readContext(context))
-    : ((unmaskedContext = isContextProvider(ctor)
-        ? previousContext
-        : contextStackCursor.current),
-      (isLegacyContextConsumer = ctor.contextTypes),
-      (context = (isLegacyContextConsumer =
-        null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer)
-        ? getMaskedContext(workInProgress, unmaskedContext)
-        : emptyContextObject));
-  ctor = new ctor(props, context);
-  workInProgress.memoizedState =
-    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
-  ctor.updater = classComponentUpdater;
-  workInProgress.stateNode = ctor;
-  ctor._reactInternals = workInProgress;
-  isLegacyContextConsumer &&
-    ((workInProgress = workInProgress.stateNode),
-    (workInProgress.__reactInternalMemoizedUnmaskedChildContext =
-      unmaskedContext),
-    (workInProgress.__reactInternalMemoizedMaskedChildContext = context));
-  return ctor;
+function pushHostRootContext(workInProgress) {
+  var root = workInProgress.stateNode;
+  root.pendingContext
+    ? pushTopLevelContextObject(
+        workInProgress,
+        root.pendingContext,
+        root.pendingContext !== root.context
+      )
+    : root.context &&
+      pushTopLevelContextObject(workInProgress, root.context, !1);
+  pushHostContainer(workInProgress, root.containerInfo);
 }
-function callComponentWillReceiveProps(
+function mountHostRootWithoutHydrating(
+  current,
   workInProgress,
-  instance,
-  newProps,
-  nextContext
+  nextChildren,
+  renderLanes,
+  recoverableError
 ) {
-  workInProgress = instance.state;
-  "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, nextContext);
-  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
-  instance.state !== workInProgress &&
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
-}
-function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  var instance = workInProgress.stateNode;
-  instance.props = newProps;
-  instance.state = workInProgress.memoizedState;
-  instance.refs = {};
-  initializeUpdateQueue(workInProgress);
-  var contextType = ctor.contextType;
-  "object" === typeof contextType && null !== contextType
-    ? (instance.context = readContext(contextType))
-    : ((contextType = isContextProvider(ctor)
-        ? previousContext
-        : contextStackCursor.current),
-      (instance.context = getMaskedContext(workInProgress, contextType)));
-  instance.state = workInProgress.memoizedState;
-  contextType = ctor.getDerivedStateFromProps;
-  "function" === typeof contextType &&
-    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof ctor.getDerivedStateFromProps ||
-    "function" === typeof instance.getSnapshotBeforeUpdate ||
-    ("function" !== typeof instance.UNSAFE_componentWillMount &&
-      "function" !== typeof instance.componentWillMount) ||
-    ((ctor = instance.state),
-    "function" === typeof instance.componentWillMount &&
-      instance.componentWillMount(),
-    "function" === typeof instance.UNSAFE_componentWillMount &&
-      instance.UNSAFE_componentWillMount(),
-    ctor !== instance.state &&
-      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
-    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof instance.componentDidMount &&
-    (workInProgress.flags |= 4194308);
-}
-function createCapturedValueAtFiber(value, source) {
-  try {
-    var info = "",
-      node = source;
-    do (info += describeFiber(node)), (node = node.return);
-    while (node);
-    var JSCompiler_inline_result = info;
-  } catch (x) {
-    JSCompiler_inline_result =
-      "\nError generating stack: " + x.message + "\n" + x.stack;
-  }
-  return {
-    value: value,
-    source: source,
-    stack: JSCompiler_inline_result,
-    digest: null
-  };
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= 256;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
-function createCapturedValue(value, digest, stack) {
-  return {
-    value: value,
-    source: null,
-    stack: null != stack ? stack : null,
-    digest: null != digest ? digest : null
-  };
+var SUSPENDED_MARKER = { dehydrated: null, treeContext: null, retryLane: 0 };
+function mountSuspenseOffscreenState(renderLanes) {
+  return { baseLanes: renderLanes, cachePool: getSuspendedCache() };
 }
-var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
-if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
-  throw Error(formatProdErrorMessage(320));
-function logCapturedError(boundary, errorInfo) {
-  try {
-    !1 !==
-      ReactFiberErrorDialogWWW.showErrorDialog({
-        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
-        error: errorInfo.value,
-        errorBoundary:
-          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
-      }) && console.error(errorInfo.value);
-  } catch (e$103) {
-    setTimeout(function () {
-      throw e$103;
-    });
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    showFallback = !1,
+    didSuspend = 0 !== (workInProgress.flags & 128),
+    JSCompiler_temp;
+  (JSCompiler_temp = didSuspend) ||
+    (JSCompiler_temp =
+      null !== current && null === current.memoizedState
+        ? !1
+        : 0 !== (suspenseStackCursor.current & 2));
+  JSCompiler_temp && ((showFallback = !0), (workInProgress.flags &= -129));
+  if (null === current) {
+    if (isHydrating) {
+      showFallback
+        ? pushPrimaryTreeSuspenseHandler(workInProgress)
+        : reuseSuspenseHandlerOnStack();
+      isHydrating &&
+        (((current = nextHydratableInstance),
+        rootOrSingletonContext && advanceToFirstAttemptableSuspenseInstance(),
+        (didSuspend = nextHydratableInstance),
+        didSuspend)
+          ? tryHydrateSuspense(workInProgress, didSuspend) ||
+            (shouldClientRenderOnMismatch(workInProgress) &&
+              throwOnHydrationMismatch(),
+            (nextHydratableInstance = getNextHydratable(
+              didSuspend.nextSibling
+            )),
+            (JSCompiler_temp = hydrationParentFiber),
+            rootOrSingletonContext &&
+              advanceToFirstAttemptableSuspenseInstance(),
+            nextHydratableInstance &&
+            tryHydrateSuspense(workInProgress, nextHydratableInstance)
+              ? deleteHydratableInstance(JSCompiler_temp, didSuspend)
+              : (insertNonHydratedInstance(
+                  hydrationParentFiber,
+                  workInProgress
+                ),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = current)))
+          : (shouldClientRenderOnMismatch(workInProgress) &&
+              throwOnHydrationMismatch(),
+            insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+            (isHydrating = !1),
+            (hydrationParentFiber = workInProgress),
+            (nextHydratableInstance = current)));
+      current = workInProgress.memoizedState;
+      if (
+        null !== current &&
+        ((current = current.dehydrated), null !== current)
+      )
+        return (
+          0 === (workInProgress.mode & 1)
+            ? (workInProgress.lanes = 2)
+            : "$!" === current.data
+            ? (workInProgress.lanes = 16)
+            : (workInProgress.lanes = 1073741824),
+          null
+        );
+      popSuspenseHandler(workInProgress);
+    }
+    current = nextProps.children;
+    didSuspend = nextProps.fallback;
+    if (showFallback)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (current = mountSuspenseFallbackChildren(
+          workInProgress,
+          current,
+          didSuspend,
+          renderLanes
+        )),
+        (nextProps = workInProgress.child),
+        (nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes)),
+        (workInProgress.memoizedState = SUSPENDED_MARKER),
+        enableTransitionTracing &&
+          ((workInProgress = enableTransitionTracing
+            ? transitionStack.current
+            : null),
+          null !== workInProgress &&
+            ((renderLanes = enableTransitionTracing
+              ? markerInstanceStack.current
+              : null),
+            (showFallback = nextProps.updateQueue),
+            null === showFallback
+              ? (nextProps.updateQueue = {
+                  transitions: workInProgress,
+                  markerInstances: renderLanes,
+                  wakeables: null
+                })
+              : ((showFallback.transitions = workInProgress),
+                (showFallback.markerInstances = renderLanes)))),
+        current
+      );
+    if ("number" === typeof nextProps.unstable_expectedLoadTime)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (current = mountSuspenseFallbackChildren(
+          workInProgress,
+          current,
+          didSuspend,
+          renderLanes
+        )),
+        (workInProgress.child.memoizedState =
+          mountSuspenseOffscreenState(renderLanes)),
+        (workInProgress.memoizedState = SUSPENDED_MARKER),
+        (workInProgress.lanes = 8388608),
+        current
+      );
+    pushPrimaryTreeSuspenseHandler(workInProgress);
+    return mountSuspensePrimaryChildren(workInProgress, current);
   }
-}
-function createRootErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  lane.payload = { element: null };
-  var error = errorInfo.value;
-  lane.callback = function () {
-    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
-    logCapturedError(fiber, errorInfo);
-  };
-  return lane;
-}
-function createClassErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
-  if ("function" === typeof getDerivedStateFromError) {
-    var error = errorInfo.value;
-    lane.payload = function () {
-      return getDerivedStateFromError(error);
-    };
-    lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-    };
+  JSCompiler_temp = current.memoizedState;
+  if (null !== JSCompiler_temp) {
+    var dehydrated$101 = JSCompiler_temp.dehydrated;
+    if (null !== dehydrated$101)
+      return updateDehydratedSuspenseComponent(
+        current,
+        workInProgress,
+        didSuspend,
+        nextProps,
+        dehydrated$101,
+        JSCompiler_temp,
+        renderLanes
+      );
   }
-  var inst = fiber.stateNode;
-  null !== inst &&
-    "function" === typeof inst.componentDidCatch &&
-    (lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-      "function" !== typeof getDerivedStateFromError &&
-        (null === legacyErrorBoundariesThatAlreadyFailed
-          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
-          : legacyErrorBoundariesThatAlreadyFailed.add(this));
-      var stack = errorInfo.stack;
-      this.componentDidCatch(errorInfo.value, {
-        componentStack: null !== stack ? stack : ""
-      });
-    });
-  return lane;
+  if (showFallback) {
+    reuseSuspenseHandlerOnStack();
+    showFallback = nextProps.fallback;
+    didSuspend = workInProgress.mode;
+    JSCompiler_temp = current.child;
+    dehydrated$101 = JSCompiler_temp.sibling;
+    var primaryChildProps = { mode: "hidden", children: nextProps.children };
+    0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
+      ? ((nextProps = workInProgress.child),
+        (nextProps.childLanes = 0),
+        (nextProps.pendingProps = primaryChildProps),
+        workInProgress.mode & 2 &&
+          ((nextProps.actualDuration = 0),
+          (nextProps.actualStartTime = -1),
+          (nextProps.selfBaseDuration = JSCompiler_temp.selfBaseDuration),
+          (nextProps.treeBaseDuration = JSCompiler_temp.treeBaseDuration)),
+        (workInProgress.deletions = null))
+      : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
+        (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
+    null !== dehydrated$101
+      ? (showFallback = createWorkInProgress(dehydrated$101, showFallback))
+      : ((showFallback = createFiberFromFragment(
+          showFallback,
+          didSuspend,
+          renderLanes,
+          null
+        )),
+        (showFallback.flags |= 2));
+    showFallback.return = workInProgress;
+    nextProps.return = workInProgress;
+    nextProps.sibling = showFallback;
+    workInProgress.child = nextProps;
+    nextProps = showFallback;
+    showFallback = workInProgress.child;
+    didSuspend = current.child.memoizedState;
+    null === didSuspend
+      ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
+      : ((JSCompiler_temp = didSuspend.cachePool),
+        null !== JSCompiler_temp
+          ? ((dehydrated$101 = CacheContext._currentValue),
+            (JSCompiler_temp =
+              JSCompiler_temp.parent !== dehydrated$101
+                ? { parent: dehydrated$101, pool: dehydrated$101 }
+                : JSCompiler_temp))
+          : (JSCompiler_temp = getSuspendedCache()),
+        (didSuspend = {
+          baseLanes: didSuspend.baseLanes | renderLanes,
+          cachePool: JSCompiler_temp
+        }));
+    showFallback.memoizedState = didSuspend;
+    enableTransitionTracing &&
+      ((didSuspend = enableTransitionTracing ? transitionStack.current : null),
+      null !== didSuspend &&
+        ((JSCompiler_temp = enableTransitionTracing
+          ? markerInstanceStack.current
+          : null),
+        (dehydrated$101 = showFallback.updateQueue),
+        (primaryChildProps = current.updateQueue),
+        null === dehydrated$101
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables: null
+            })
+          : dehydrated$101 === primaryChildProps
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables:
+                null !== primaryChildProps ? primaryChildProps.wakeables : null
+            })
+          : ((dehydrated$101.transitions = didSuspend),
+            (dehydrated$101.markerInstances = JSCompiler_temp))));
+    showFallback.childLanes = current.childLanes & ~renderLanes;
+    workInProgress.memoizedState = SUSPENDED_MARKER;
+    return nextProps;
+  }
+  pushPrimaryTreeSuspenseHandler(workInProgress);
+  showFallback = current.child;
+  current = showFallback.sibling;
+  nextProps = createWorkInProgress(showFallback, {
+    mode: "visible",
+    children: nextProps.children
+  });
+  0 === (workInProgress.mode & 1) && (nextProps.lanes = renderLanes);
+  nextProps.return = workInProgress;
+  nextProps.sibling = null;
+  null !== current &&
+    ((renderLanes = workInProgress.deletions),
+    null === renderLanes
+      ? ((workInProgress.deletions = [current]), (workInProgress.flags |= 16))
+      : renderLanes.push(current));
+  workInProgress.child = nextProps;
+  workInProgress.memoizedState = null;
+  return nextProps;
 }
-function markSuspenseBoundaryShouldCapture(
-  suspenseBoundary,
-  returnFiber,
-  sourceFiber,
-  root,
-  rootRenderLanes
-) {
-  if (0 === (suspenseBoundary.mode & 1))
-    return (
-      suspenseBoundary === returnFiber
-        ? (suspenseBoundary.flags |= 65536)
-        : ((suspenseBoundary.flags |= 128),
-          (sourceFiber.flags |= 131072),
-          (sourceFiber.flags &= -52805),
-          1 === sourceFiber.tag &&
-            (null === sourceFiber.alternate
-              ? (sourceFiber.tag = 17)
-              : ((returnFiber = createUpdate(2)),
-                (returnFiber.tag = 2),
-                enqueueUpdate(sourceFiber, returnFiber, 2))),
-          (sourceFiber.lanes |= 2)),
-      suspenseBoundary
-    );
-  suspenseBoundary.flags |= 65536;
-  suspenseBoundary.lanes = rootRenderLanes;
-  return suspenseBoundary;
-}
-function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
-  if (enableTransitionTracing && null !== pendingTransitions) {
-    var transitionStart = pendingTransitions.transitionStart,
-      onTransitionStart = callbacks.onTransitionStart;
-    null !== transitionStart &&
-      null != onTransitionStart &&
-      transitionStart.forEach(function (transition) {
-        return onTransitionStart(transition.name, transition.startTime);
-      });
-    transitionStart = pendingTransitions.markerProgress;
-    var onMarkerProgress = callbacks.onMarkerProgress;
-    null != onMarkerProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (markerInstance, markerName) {
-        if (null !== markerInstance.transitions) {
-          var pending =
-            null !== markerInstance.pendingBoundaries
-              ? Array.from(markerInstance.pendingBoundaries.values())
-              : [];
-          markerInstance.transitions.forEach(function (transition) {
-            onMarkerProgress(
-              transition.name,
-              markerName,
-              transition.startTime,
-              endTime,
-              pending
-            );
-          });
-        }
-      });
-    transitionStart = pendingTransitions.markerComplete;
-    var onMarkerComplete = callbacks.onMarkerComplete;
-    null !== transitionStart &&
-      null != onMarkerComplete &&
-      transitionStart.forEach(function (transitions, markerName) {
-        transitions.forEach(function (transition) {
-          onMarkerComplete(
-            transition.name,
-            markerName,
-            transition.startTime,
-            endTime
-          );
-        });
-      });
-    transitionStart = pendingTransitions.markerIncomplete;
-    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
-    null != onMarkerIncomplete &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (_ref, markerName) {
-        var aborts = _ref.aborts;
-        _ref.transitions.forEach(function (transition) {
-          var filteredAborts = [];
-          aborts.forEach(function (abort) {
-            switch (abort.reason) {
-              case "marker":
-                filteredAborts.push({
-                  type: "marker",
-                  name: abort.name,
-                  endTime: endTime
-                });
-                break;
-              case "suspense":
-                filteredAborts.push({
-                  type: "suspense",
-                  name: abort.name,
-                  endTime: endTime
-                });
-            }
-          });
-          0 < filteredAborts.length &&
-            onMarkerIncomplete(
-              transition.name,
-              markerName,
-              transition.startTime,
-              filteredAborts
-            );
-        });
-      });
-    transitionStart = pendingTransitions.transitionProgress;
-    var onTransitionProgress = callbacks.onTransitionProgress;
-    null != onTransitionProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (pending, transition) {
-        onTransitionProgress(
-          transition.name,
-          transition.startTime,
-          endTime,
-          Array.from(pending.values())
-        );
-      });
-    pendingTransitions = pendingTransitions.transitionComplete;
-    var onTransitionComplete = callbacks.onTransitionComplete;
-    null !== pendingTransitions &&
-      null != onTransitionComplete &&
-      pendingTransitions.forEach(function (transition) {
-        return onTransitionComplete(
-          transition.name,
-          transition.startTime,
-          endTime
-        );
-      });
-  }
-}
-var markerInstanceStack = createCursor(null);
-function pushRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    var transitions = workInProgressTransitions,
-      root$109 = workInProgress.stateNode;
-    null !== transitions &&
-      transitions.forEach(function (transition) {
-        if (!root$109.incompleteTransitions.has(transition)) {
-          var markerInstance = {
-            tag: 0,
-            transitions: new Set([transition]),
-            pendingBoundaries: null,
-            aborts: null,
-            name: null
-          };
-          root$109.incompleteTransitions.set(transition, markerInstance);
-        }
-      });
-    var markerInstances = [];
-    root$109.incompleteTransitions.forEach(function (markerInstance) {
-      markerInstances.push(markerInstance);
-    });
-    push(markerInstanceStack, markerInstances);
-  }
-}
-function pushMarkerInstance(workInProgress, markerInstance) {
-  enableTransitionTracing &&
-    (null === markerInstanceStack.current
-      ? push(markerInstanceStack, [markerInstance])
-      : push(
-          markerInstanceStack,
-          markerInstanceStack.current.concat(markerInstance)
-        ));
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
+  primaryChildren = createFiberFromOffscreen(
+    { mode: "visible", children: primaryChildren },
+    workInProgress.mode,
+    0,
+    null
+  );
+  primaryChildren.return = workInProgress;
+  return (workInProgress.child = primaryChildren);
 }
-var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
-  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
-  didReceiveUpdate = !1;
-function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
-  workInProgress.child =
-    null === current
-      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
-      : reconcileChildFibers(
-          workInProgress,
-          current.child,
-          nextChildren,
-          renderLanes
-        );
+function mountSuspenseFallbackChildren(
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode,
+    progressedPrimaryFragment = workInProgress.child;
+  primaryChildren = { mode: "hidden", children: primaryChildren };
+  0 === (mode & 1) && null !== progressedPrimaryFragment
+    ? ((progressedPrimaryFragment.childLanes = 0),
+      (progressedPrimaryFragment.pendingProps = primaryChildren),
+      workInProgress.mode & 2 &&
+        ((progressedPrimaryFragment.actualDuration = 0),
+        (progressedPrimaryFragment.actualStartTime = -1),
+        (progressedPrimaryFragment.selfBaseDuration = 0),
+        (progressedPrimaryFragment.treeBaseDuration = 0)))
+    : (progressedPrimaryFragment = createFiberFromOffscreen(
+        primaryChildren,
+        mode,
+        0,
+        null
+      ));
+  fallbackChildren = createFiberFromFragment(
+    fallbackChildren,
+    mode,
+    renderLanes,
+    null
+  );
+  progressedPrimaryFragment.return = workInProgress;
+  fallbackChildren.return = workInProgress;
+  progressedPrimaryFragment.sibling = fallbackChildren;
+  workInProgress.child = progressedPrimaryFragment;
+  return fallbackChildren;
 }
-function updateForwardRef(
+function retrySuspenseComponentWithoutHydrating(
   current,
   workInProgress,
-  Component,
-  nextProps,
-  renderLanes
+  renderLanes,
+  recoverableError
 ) {
-  Component = Component.render;
-  var ref = workInProgress.ref;
-  prepareToReadContext(workInProgress, renderLanes);
-  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-  nextProps = renderWithHooks(
-    current,
+  null !== recoverableError && queueHydrationError(recoverableError);
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  current = mountSuspensePrimaryChildren(
     workInProgress,
-    Component,
-    nextProps,
-    ref,
-    renderLanes
+    workInProgress.pendingProps.children
   );
-  Component = checkDidRenderIdHook();
-  enableSchedulingProfiler && markComponentRenderStopped();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && Component && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, nextProps, renderLanes);
-  return workInProgress.child;
+  current.flags |= 2;
+  workInProgress.memoizedState = null;
+  return current;
 }
-function updateMemoComponent(
+function updateDehydratedSuspenseComponent(
   current,
   workInProgress,
-  Component,
+  didSuspend,
   nextProps,
+  suspenseInstance,
+  suspenseState,
   renderLanes
 ) {
-  if (null === current) {
-    var type = Component.type;
-    if (
-      "function" === typeof type &&
-      !shouldConstruct(type) &&
-      void 0 === type.defaultProps &&
-      null === Component.compare &&
-      void 0 === Component.defaultProps
-    )
+  if (didSuspend) {
+    if (workInProgress.flags & 256)
       return (
-        (workInProgress.tag = 15),
-        (workInProgress.type = type),
-        updateSimpleMemoComponent(
+        pushPrimaryTreeSuspenseHandler(workInProgress),
+        (workInProgress.flags &= -257),
+        (suspenseState = createCapturedValue(
+          Error(formatProdErrorMessage(422))
+        )),
+        retrySuspenseComponentWithoutHydrating(
           current,
           workInProgress,
-          type,
-          nextProps,
-          renderLanes
+          renderLanes,
+          suspenseState
         )
       );
-    current = createFiberFromTypeAndProps(
-      Component.type,
-      null,
-      nextProps,
-      workInProgress,
-      workInProgress.mode,
-      renderLanes
+    if (null !== workInProgress.memoizedState)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (workInProgress.child = current.child),
+        (workInProgress.flags |= 128),
+        null
+      );
+    reuseSuspenseHandlerOnStack();
+    suspenseState = nextProps.fallback;
+    suspenseInstance = workInProgress.mode;
+    nextProps = createFiberFromOffscreen(
+      { mode: "visible", children: nextProps.children },
+      suspenseInstance,
+      0,
+      null
     );
-    current.ref = workInProgress.ref;
-    current.return = workInProgress;
-    return (workInProgress.child = current);
+    suspenseState = createFiberFromFragment(
+      suspenseState,
+      suspenseInstance,
+      renderLanes,
+      null
+    );
+    suspenseState.flags |= 2;
+    nextProps.return = workInProgress;
+    suspenseState.return = workInProgress;
+    nextProps.sibling = suspenseState;
+    workInProgress.child = nextProps;
+    0 !== (workInProgress.mode & 1) &&
+      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+    workInProgress.child.memoizedState =
+      mountSuspenseOffscreenState(renderLanes);
+    workInProgress.memoizedState = SUSPENDED_MARKER;
+    return suspenseState;
   }
-  type = current.child;
-  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
-    var prevProps = type.memoizedProps;
-    Component = Component.compare;
-    Component = null !== Component ? Component : shallowEqual;
-    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  pushPrimaryTreeSuspenseHandler(workInProgress);
+  if (0 === (workInProgress.mode & 1))
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      null
+    );
+  if ("$!" === suspenseInstance.data) {
+    suspenseState =
+      suspenseInstance.nextSibling && suspenseInstance.nextSibling.dataset;
+    if (suspenseState) var digest = suspenseState.dgst;
+    suspenseState = digest;
+    nextProps = Error(formatProdErrorMessage(419));
+    nextProps.digest = suspenseState;
+    suspenseState = createCapturedValue(nextProps, suspenseState, void 0);
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      suspenseState
+    );
   }
-  workInProgress.flags |= 1;
-  current = createWorkInProgress(type, nextProps);
-  current.ref = workInProgress.ref;
-  current.return = workInProgress;
-  return (workInProgress.child = current);
-}
-function updateSimpleMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (null !== current) {
-    var prevProps = current.memoizedProps;
-    if (
-      shallowEqual(prevProps, nextProps) &&
-      current.ref === workInProgress.ref
-    )
+  enableLazyContextPropagation &&
+    !didReceiveUpdate &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !1);
+  digest = 0 !== (renderLanes & current.childLanes);
+  if (didReceiveUpdate || digest) {
+    nextProps = workInProgressRoot;
+    if (null !== nextProps) {
+      suspenseInstance = renderLanes & -renderLanes;
+      if (enableUnifiedSyncLane && 0 !== (suspenseInstance & 42))
+        suspenseInstance = 1;
+      else
+        switch (suspenseInstance) {
+          case 2:
+            suspenseInstance = 1;
+            break;
+          case 8:
+            suspenseInstance = 4;
+            break;
+          case 32:
+            suspenseInstance = 16;
+            break;
+          case 128:
+          case 256:
+          case 512:
+          case 1024:
+          case 2048:
+          case 4096:
+          case 8192:
+          case 16384:
+          case 32768:
+          case 65536:
+          case 131072:
+          case 262144:
+          case 524288:
+          case 1048576:
+          case 2097152:
+          case 4194304:
+          case 8388608:
+          case 16777216:
+          case 33554432:
+          case 67108864:
+            suspenseInstance = 64;
+            break;
+          case 536870912:
+            suspenseInstance = 268435456;
+            break;
+          default:
+            suspenseInstance = 0;
+        }
+      suspenseInstance =
+        0 !== (suspenseInstance & (nextProps.suspendedLanes | renderLanes))
+          ? 0
+          : suspenseInstance;
       if (
-        ((didReceiveUpdate = !1),
-        (workInProgress.pendingProps = nextProps = prevProps),
-        checkScheduledUpdateOrContext(current, renderLanes))
+        0 !== suspenseInstance &&
+        suspenseInstance !== suspenseState.retryLane
       )
-        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
-      else
-        return (
-          (workInProgress.lanes = current.lanes),
-          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+        throw (
+          ((suspenseState.retryLane = suspenseInstance),
+          enqueueConcurrentRenderForLane(current, suspenseInstance),
+          scheduleUpdateOnFiber(nextProps, current, suspenseInstance, -1),
+          SelectiveHydrationException)
         );
+    }
+    renderDidSuspendDelayIfPossible();
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      null
+    );
   }
-  return updateFunctionComponent(
-    current,
+  if ("$?" === suspenseInstance.data)
+    return (
+      (workInProgress.flags |= 128),
+      (workInProgress.child = current.child),
+      (workInProgress = retryDehydratedSuspenseBoundary.bind(null, current)),
+      (suspenseInstance._reactRetry = workInProgress),
+      null
+    );
+  current = suspenseState.treeContext;
+  nextHydratableInstance = getNextHydratable(suspenseInstance.nextSibling);
+  hydrationParentFiber = workInProgress;
+  isHydrating = !0;
+  hydrationErrors = null;
+  rootOrSingletonContext = !1;
+  null !== current &&
+    ((idStack[idStackIndex++] = treeContextId),
+    (idStack[idStackIndex++] = treeContextOverflow),
+    (idStack[idStackIndex++] = treeContextProvider),
+    (treeContextId = current.id),
+    (treeContextOverflow = current.overflow),
+    (treeContextProvider = workInProgress));
+  workInProgress = mountSuspensePrimaryChildren(
     workInProgress,
-    Component,
-    nextProps,
-    renderLanes
+    nextProps.children
   );
+  workInProgress.flags |= 4096;
+  return workInProgress;
 }
-function updateOffscreenComponent(current, workInProgress, renderLanes) {
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes |= renderLanes;
+  var alternate = fiber.alternate;
+  null !== alternate && (alternate.lanes |= renderLanes);
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
+function initSuspenseListRenderState(
+  workInProgress,
+  isBackwards,
+  tail,
+  lastContentRow,
+  tailMode
+) {
+  var renderState = workInProgress.memoizedState;
+  null === renderState
+    ? (workInProgress.memoizedState = {
+        isBackwards: isBackwards,
+        rendering: null,
+        renderingStartTime: 0,
+        last: lastContentRow,
+        tail: tail,
+        tailMode: tailMode
+      })
+    : ((renderState.isBackwards = isBackwards),
+      (renderState.rendering = null),
+      (renderState.renderingStartTime = 0),
+      (renderState.last = lastContentRow),
+      (renderState.tail = tail),
+      (renderState.tailMode = tailMode));
+}
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
   var nextProps = workInProgress.pendingProps,
-    nextChildren = nextProps.children,
-    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
-    prevState = null !== current ? current.memoizedState : null;
-  markRef$1(current, workInProgress);
-  if (
-    "hidden" === nextProps.mode ||
-    "unstable-defer-without-hiding" === nextProps.mode ||
-    nextIsDetached
-  ) {
-    if (0 !== (workInProgress.flags & 128)) {
-      nextChildren =
-        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
-      if (null !== current) {
-        prevState = workInProgress.child = current.child;
-        for (nextProps = 0; null !== prevState; )
-          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
-            (prevState = prevState.sibling);
-        workInProgress.childLanes = nextProps & ~nextChildren;
-      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes
-      );
-    }
-    if (0 === (workInProgress.mode & 1))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current && pushTransition(workInProgress, null, null),
-        reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else if (0 !== (renderLanes & 1073741824))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current &&
-          pushTransition(
-            workInProgress,
-            null !== prevState ? prevState.cachePool : null,
-            null
-          ),
-        null !== prevState
-          ? pushHiddenContext(workInProgress, prevState)
-          : reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else
-      return (
-        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
-        deferHiddenOffscreenComponent(
-          current,
+    revealOrder = nextProps.revealOrder,
+    tailMode = nextProps.tail;
+  reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
+  nextProps = suspenseStackCursor.current;
+  if (0 !== (nextProps & 2))
+    (nextProps = (nextProps & 1) | 2), (workInProgress.flags |= 128);
+  else {
+    if (null !== current && 0 !== (current.flags & 128))
+      a: for (current = workInProgress.child; null !== current; ) {
+        if (13 === current.tag)
+          null !== current.memoizedState &&
+            scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
+        else if (19 === current.tag)
+          scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
+        else if (null !== current.child) {
+          current.child.return = current;
+          current = current.child;
+          continue;
+        }
+        if (current === workInProgress) break a;
+        for (; null === current.sibling; ) {
+          if (null === current.return || current.return === workInProgress)
+            break a;
+          current = current.return;
+        }
+        current.sibling.return = current.return;
+        current = current.sibling;
+      }
+    nextProps &= 1;
+  }
+  push(suspenseStackCursor, nextProps);
+  if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;
+  else
+    switch (revealOrder) {
+      case "forwards":
+        renderLanes = workInProgress.child;
+        for (revealOrder = null; null !== renderLanes; )
+          (current = renderLanes.alternate),
+            null !== current &&
+              null === findFirstSuspended(current) &&
+              (revealOrder = renderLanes),
+            (renderLanes = renderLanes.sibling);
+        renderLanes = revealOrder;
+        null === renderLanes
+          ? ((revealOrder = workInProgress.child),
+            (workInProgress.child = null))
+          : ((revealOrder = renderLanes.sibling), (renderLanes.sibling = null));
+        initSuspenseListRenderState(
           workInProgress,
-          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
-          renderLanes
-        )
-      );
-  } else if (null !== prevState) {
-    nextProps = prevState.cachePool;
-    nextIsDetached = null;
-    if (enableTransitionTracing) {
-      var instance = workInProgress.stateNode;
-      null !== instance &&
-        null != instance._transitions &&
-        (nextIsDetached = Array.from(instance._transitions));
+          !1,
+          revealOrder,
+          renderLanes,
+          tailMode
+        );
+        break;
+      case "backwards":
+        renderLanes = null;
+        revealOrder = workInProgress.child;
+        for (workInProgress.child = null; null !== revealOrder; ) {
+          current = revealOrder.alternate;
+          if (null !== current && null === findFirstSuspended(current)) {
+            workInProgress.child = revealOrder;
+            break;
+          }
+          current = revealOrder.sibling;
+          revealOrder.sibling = renderLanes;
+          renderLanes = revealOrder;
+          revealOrder = current;
+        }
+        initSuspenseListRenderState(
+          workInProgress,
+          !0,
+          renderLanes,
+          null,
+          tailMode
+        );
+        break;
+      case "together":
+        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+        break;
+      default:
+        workInProgress.memoizedState = null;
     }
-    pushTransition(workInProgress, nextProps, nextIsDetached);
-    pushHiddenContext(workInProgress, prevState);
-    reuseSuspenseHandlerOnStack();
-    workInProgress.memoizedState = null;
-  } else
-    null !== current && pushTransition(workInProgress, null, null),
-      reuseHiddenContextOnStack(),
-      reuseSuspenseHandlerOnStack();
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
   return workInProgress.child;
 }
-function deferHiddenOffscreenComponent(
-  current,
-  workInProgress,
-  nextBaseLanes,
-  renderLanes
-) {
-  var JSCompiler_inline_result = peekCacheFromPool();
-  JSCompiler_inline_result =
-    null === JSCompiler_inline_result
-      ? null
-      : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
-  workInProgress.memoizedState = {
-    baseLanes: nextBaseLanes,
-    cachePool: JSCompiler_inline_result
-  };
-  null !== current && pushTransition(workInProgress, null, null);
-  reuseHiddenContextOnStack();
-  pushOffscreenSuspenseHandler(workInProgress);
-  enableLazyContextPropagation &&
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  0 === (workInProgress.mode & 1) &&
     null !== current &&
-    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
-  return null;
-}
-function markRef$1(current, workInProgress) {
-  var ref = workInProgress.ref;
-  if (
-    (null === current && null !== ref) ||
-    (null !== current && current.ref !== ref)
-  )
-    (workInProgress.flags |= 512), (workInProgress.flags |= 2097152);
+    ((current.alternate = null),
+    (workInProgress.alternate = null),
+    (workInProgress.flags |= 2));
 }
-function updateFunctionComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  var context = isContextProvider(Component)
-    ? previousContext
-    : contextStackCursor.current;
-  context = getMaskedContext(workInProgress, context);
-  prepareToReadContext(workInProgress, renderLanes);
-  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-  Component = renderWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    context,
-    renderLanes
-  );
-  nextProps = checkDidRenderIdHook();
-  enableSchedulingProfiler && markComponentRenderStopped();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && nextProps && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, Component, renderLanes);
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  null !== current && (workInProgress.dependencies = current.dependencies);
+  profilerStartTime = -1;
+  workInProgressRootSkippedLanes |= workInProgress.lanes;
+  if (0 === (renderLanes & workInProgress.childLanes))
+    if (enableLazyContextPropagation && null !== current) {
+      if (
+        (propagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+          !1
+        ),
+        0 === (renderLanes & workInProgress.childLanes))
+      )
+        return null;
+    } else return null;
+  if (null !== current && workInProgress.child !== current.child)
+    throw Error(formatProdErrorMessage(153));
+  if (null !== workInProgress.child) {
+    current = workInProgress.child;
+    renderLanes = createWorkInProgress(current, current.pendingProps);
+    workInProgress.child = renderLanes;
+    for (renderLanes.return = workInProgress; null !== current.sibling; )
+      (current = current.sibling),
+        (renderLanes = renderLanes.sibling =
+          createWorkInProgress(current, current.pendingProps)),
+        (renderLanes.return = workInProgress);
+    renderLanes.sibling = null;
+  }
   return workInProgress.child;
 }
-function replayFunctionComponent(
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  return 0 !== (current.lanes & renderLanes) ||
+    (enableLazyContextPropagation &&
+      ((current = current.dependencies),
+      null !== current && checkIfContextChanged(current)))
+    ? !0
+    : !1;
+}
+function attemptEarlyBailoutIfNoScheduledUpdate(
   current,
   workInProgress,
-  nextProps,
-  Component,
   renderLanes
 ) {
-  var context = isContextProvider(Component)
-    ? previousContext
-    : contextStackCursor.current;
-  context = getMaskedContext(workInProgress, context);
-  prepareToReadContext(workInProgress, renderLanes);
-  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-  nextProps = renderWithHooksAgain(
-    workInProgress,
-    Component,
-    nextProps,
-    context
-  );
-  finishRenderingHooks(current);
-  Component = checkDidRenderIdHook();
-  enableSchedulingProfiler && markComponentRenderStopped();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && Component && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, nextProps, renderLanes);
-  return workInProgress.child;
-}
-function updateClassComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (isContextProvider(Component)) {
-    var hasContext = !0;
-    pushContextProvider(workInProgress);
-  } else hasContext = !1;
-  prepareToReadContext(workInProgress, renderLanes);
-  if (null === workInProgress.stateNode)
-    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-      constructClassInstance(workInProgress, Component, nextProps),
-      mountClassInstance(workInProgress, Component, nextProps, renderLanes),
-      (nextProps = !0);
-  else if (null === current) {
-    var instance = workInProgress.stateNode,
-      oldProps = workInProgress.memoizedProps;
-    instance.props = oldProps;
-    var oldContext = instance.context,
-      contextType = Component.contextType;
-    "object" === typeof contextType && null !== contextType
-      ? (contextType = readContext(contextType))
-      : ((contextType = isContextProvider(Component)
-          ? previousContext
-          : contextStackCursor.current),
-        (contextType = getMaskedContext(workInProgress, contextType)));
-    var getDerivedStateFromProps = Component.getDerivedStateFromProps,
-      hasNewLifecycles =
-        "function" === typeof getDerivedStateFromProps ||
-        "function" === typeof instance.getSnapshotBeforeUpdate;
-    hasNewLifecycles ||
-      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
-        "function" !== typeof instance.componentWillReceiveProps) ||
-      ((oldProps !== nextProps || oldContext !== contextType) &&
-        callComponentWillReceiveProps(
+  switch (workInProgress.tag) {
+    case 3:
+      pushHostRootContext(workInProgress);
+      enableTransitionTracing &&
+        push(transitionStack, workInProgressTransitions);
+      enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      resetHydrationState();
+      break;
+    case 27:
+    case 5:
+      pushHostContext(workInProgress);
+      break;
+    case 1:
+      isContextProvider(workInProgress.type) &&
+        pushContextProvider(workInProgress);
+      break;
+    case 4:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+    case 10:
+      pushProvider(
+        workInProgress,
+        workInProgress.type._context,
+        workInProgress.memoizedProps.value
+      );
+      break;
+    case 12:
+      0 !== (renderLanes & workInProgress.childLanes) &&
+        (workInProgress.flags |= 4);
+      var stateNode = workInProgress.stateNode;
+      stateNode.effectDuration = 0;
+      stateNode.passiveEffectDuration = 0;
+      break;
+    case 13:
+      stateNode = workInProgress.memoizedState;
+      if (null !== stateNode) {
+        if (null !== stateNode.dehydrated)
+          return (
+            pushPrimaryTreeSuspenseHandler(workInProgress),
+            (workInProgress.flags |= 128),
+            null
+          );
+        if (0 !== (renderLanes & workInProgress.child.childLanes))
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+        current = bailoutOnAlreadyFinishedWork(
+          current,
           workInProgress,
-          instance,
-          nextProps,
-          contextType
-        ));
-    hasForceUpdate = !1;
-    var oldState = workInProgress.memoizedState;
-    instance.state = oldState;
-    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
-    oldContext = workInProgress.memoizedState;
-    oldProps !== nextProps ||
-    oldState !== oldContext ||
-    didPerformWorkStackCursor.current ||
-    hasForceUpdate
-      ? ("function" === typeof getDerivedStateFromProps &&
-          (applyDerivedStateFromProps(
-            workInProgress,
-            Component,
-            getDerivedStateFromProps,
-            nextProps
-          ),
-          (oldContext = workInProgress.memoizedState)),
-        (oldProps =
-          hasForceUpdate ||
-          checkShouldComponentUpdate(
-            workInProgress,
-            Component,
-            oldProps,
-            nextProps,
-            oldState,
-            oldContext,
-            contextType
-          ))
-          ? (hasNewLifecycles ||
-              ("function" !== typeof instance.UNSAFE_componentWillMount &&
-                "function" !== typeof instance.componentWillMount) ||
-              ("function" === typeof instance.componentWillMount &&
-                instance.componentWillMount(),
-              "function" === typeof instance.UNSAFE_componentWillMount &&
-                instance.UNSAFE_componentWillMount()),
-            "function" === typeof instance.componentDidMount &&
-              (workInProgress.flags |= 4194308))
-          : ("function" === typeof instance.componentDidMount &&
-              (workInProgress.flags |= 4194308),
-            (workInProgress.memoizedProps = nextProps),
-            (workInProgress.memoizedState = oldContext)),
-        (instance.props = nextProps),
-        (instance.state = oldContext),
-        (instance.context = contextType),
-        (nextProps = oldProps))
-      : ("function" === typeof instance.componentDidMount &&
-          (workInProgress.flags |= 4194308),
-        (nextProps = !1));
-  } else {
-    instance = workInProgress.stateNode;
-    cloneUpdateQueue(current, workInProgress);
-    oldProps = workInProgress.memoizedProps;
-    contextType =
-      workInProgress.type === workInProgress.elementType
-        ? oldProps
-        : resolveDefaultProps(workInProgress.type, oldProps);
-    instance.props = contextType;
-    hasNewLifecycles = workInProgress.pendingProps;
-    oldState = instance.context;
-    oldContext = Component.contextType;
-    "object" === typeof oldContext && null !== oldContext
-      ? (oldContext = readContext(oldContext))
-      : ((oldContext = isContextProvider(Component)
-          ? previousContext
-          : contextStackCursor.current),
-        (oldContext = getMaskedContext(workInProgress, oldContext)));
-    var getDerivedStateFromProps$jscomp$0 = Component.getDerivedStateFromProps;
-    (getDerivedStateFromProps =
-      "function" === typeof getDerivedStateFromProps$jscomp$0 ||
-      "function" === typeof instance.getSnapshotBeforeUpdate) ||
-      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
-        "function" !== typeof instance.componentWillReceiveProps) ||
-      ((oldProps !== hasNewLifecycles || oldState !== oldContext) &&
-        callComponentWillReceiveProps(
+          renderLanes
+        );
+        return null !== current ? current.sibling : null;
+      }
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      break;
+    case 19:
+      var didSuspendBefore = 0 !== (current.flags & 128);
+      stateNode = 0 !== (renderLanes & workInProgress.childLanes);
+      enableLazyContextPropagation &&
+        !stateNode &&
+        (propagateParentContextChanges(
+          current,
           workInProgress,
-          instance,
-          nextProps,
-          oldContext
-        ));
-    hasForceUpdate = !1;
-    oldState = workInProgress.memoizedState;
-    instance.state = oldState;
-    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
-    var newState = workInProgress.memoizedState;
-    oldProps !== hasNewLifecycles ||
-    oldState !== newState ||
-    didPerformWorkStackCursor.current ||
-    hasForceUpdate ||
-    (enableLazyContextPropagation &&
-      null !== current &&
-      null !== current.dependencies &&
-      checkIfContextChanged(current.dependencies))
-      ? ("function" === typeof getDerivedStateFromProps$jscomp$0 &&
-          (applyDerivedStateFromProps(
-            workInProgress,
-            Component,
-            getDerivedStateFromProps$jscomp$0,
-            nextProps
-          ),
-          (newState = workInProgress.memoizedState)),
-        (contextType =
-          hasForceUpdate ||
-          checkShouldComponentUpdate(
+          renderLanes,
+          !1
+        ),
+        (stateNode = 0 !== (renderLanes & workInProgress.childLanes)));
+      if (didSuspendBefore) {
+        if (stateNode)
+          return updateSuspenseListComponent(
+            current,
             workInProgress,
-            Component,
-            contextType,
-            nextProps,
-            oldState,
-            newState,
-            oldContext
-          ) ||
-          (enableLazyContextPropagation &&
-            null !== current &&
-            null !== current.dependencies &&
-            checkIfContextChanged(current.dependencies)))
-          ? (getDerivedStateFromProps ||
-              ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
-                "function" !== typeof instance.componentWillUpdate) ||
-              ("function" === typeof instance.componentWillUpdate &&
-                instance.componentWillUpdate(nextProps, newState, oldContext),
-              "function" === typeof instance.UNSAFE_componentWillUpdate &&
-                instance.UNSAFE_componentWillUpdate(
-                  nextProps,
-                  newState,
-                  oldContext
-                )),
-            "function" === typeof instance.componentDidUpdate &&
-              (workInProgress.flags |= 4),
-            "function" === typeof instance.getSnapshotBeforeUpdate &&
-              (workInProgress.flags |= 1024))
-          : ("function" !== typeof instance.componentDidUpdate ||
-              (oldProps === current.memoizedProps &&
-                oldState === current.memoizedState) ||
-              (workInProgress.flags |= 4),
-            "function" !== typeof instance.getSnapshotBeforeUpdate ||
-              (oldProps === current.memoizedProps &&
-                oldState === current.memoizedState) ||
-              (workInProgress.flags |= 1024),
-            (workInProgress.memoizedProps = nextProps),
-            (workInProgress.memoizedState = newState)),
-        (instance.props = nextProps),
-        (instance.state = newState),
-        (instance.context = oldContext),
-        (nextProps = contextType))
-      : ("function" !== typeof instance.componentDidUpdate ||
-          (oldProps === current.memoizedProps &&
-            oldState === current.memoizedState) ||
-          (workInProgress.flags |= 4),
-        "function" !== typeof instance.getSnapshotBeforeUpdate ||
-          (oldProps === current.memoizedProps &&
-            oldState === current.memoizedState) ||
-          (workInProgress.flags |= 1024),
-        (nextProps = !1));
+            renderLanes
+          );
+        workInProgress.flags |= 128;
+      }
+      didSuspendBefore = workInProgress.memoizedState;
+      null !== didSuspendBefore &&
+        ((didSuspendBefore.rendering = null),
+        (didSuspendBefore.tail = null),
+        (didSuspendBefore.lastEffect = null));
+      push(suspenseStackCursor, suspenseStackCursor.current);
+      if (stateNode) break;
+      else return null;
+    case 22:
+    case 23:
+      return (
+        (workInProgress.lanes = 0),
+        updateOffscreenComponent(current, workInProgress, renderLanes)
+      );
+    case 24:
+      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        ((stateNode = workInProgress.stateNode),
+        null !== stateNode && pushMarkerInstance(workInProgress, stateNode));
   }
-  return finishClassComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    hasContext,
-    renderLanes
-  );
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
 }
-function finishClassComponent(
-  current,
-  workInProgress,
-  Component,
-  shouldUpdate,
-  hasContext,
-  renderLanes
-) {
-  markRef$1(current, workInProgress);
-  var didCaptureError = 0 !== (workInProgress.flags & 128);
-  if (!shouldUpdate && !didCaptureError)
-    return (
-      hasContext && invalidateContextProvider(workInProgress, Component, !1),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  shouldUpdate = workInProgress.stateNode;
-  ReactCurrentOwner$1.current = workInProgress;
-  if (
-    didCaptureError &&
-    "function" !== typeof Component.getDerivedStateFromError
-  ) {
-    var nextChildren = null;
-    profilerStartTime = -1;
-  } else
-    enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
-      (nextChildren = shouldUpdate.render()),
-      enableSchedulingProfiler && markComponentRenderStopped();
-  workInProgress.flags |= 1;
-  null !== current && didCaptureError
-    ? ((didCaptureError = nextChildren),
-      (workInProgress.child = reconcileChildFibers(
-        workInProgress,
-        current.child,
-        null,
-        renderLanes
-      )),
-      (workInProgress.child = reconcileChildFibers(
-        workInProgress,
-        null,
-        didCaptureError,
-        renderLanes
-      )))
-    : reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  workInProgress.memoizedState = shouldUpdate.state;
-  hasContext && invalidateContextProvider(workInProgress, Component, !0);
-  return workInProgress.child;
+var valueCursor = createCursor(null),
+  currentlyRenderingFiber = null,
+  lastContextDependency = null,
+  lastFullyObservedContext = null;
+function resetContextDependencies() {
+  lastFullyObservedContext =
+    lastContextDependency =
+    currentlyRenderingFiber =
+      null;
 }
-function pushHostRootContext(workInProgress) {
-  var root = workInProgress.stateNode;
-  root.pendingContext
-    ? pushTopLevelContextObject(
-        workInProgress,
-        root.pendingContext,
-        root.pendingContext !== root.context
-      )
-    : root.context &&
-      pushTopLevelContextObject(workInProgress, root.context, !1);
-  pushHostContainer(workInProgress, root.containerInfo);
+function pushProvider(providerFiber, context, nextValue) {
+  push(valueCursor, context._currentValue);
+  context._currentValue = nextValue;
 }
-function mountHostRootWithoutHydrating(
-  current,
+function popProvider(context) {
+  var currentValue = valueCursor.current;
+  context._currentValue =
+    currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED
+      ? context._defaultValue
+      : currentValue;
+  pop(valueCursor);
+}
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  for (; null !== parent; ) {
+    var alternate = parent.alternate;
+    (parent.childLanes & renderLanes) !== renderLanes
+      ? ((parent.childLanes |= renderLanes),
+        null !== alternate && (alternate.childLanes |= renderLanes))
+      : null !== alternate &&
+        (alternate.childLanes & renderLanes) !== renderLanes &&
+        (alternate.childLanes |= renderLanes);
+    if (parent === propagationRoot) break;
+    parent = parent.return;
+  }
+}
+function propagateContextChange(workInProgress, context, renderLanes) {
+  if (enableLazyContextPropagation)
+    propagateContextChanges(workInProgress, [context], renderLanes, !0);
+  else if (!enableLazyContextPropagation) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber; ) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        for (var dependency = list.firstContext; null !== dependency; ) {
+          if (dependency.context === context) {
+            if (1 === fiber.tag) {
+              dependency = createUpdate(renderLanes & -renderLanes);
+              dependency.tag = 2;
+              var updateQueue = fiber.updateQueue;
+              if (null !== updateQueue) {
+                updateQueue = updateQueue.shared;
+                var pending = updateQueue.pending;
+                null === pending
+                  ? (dependency.next = dependency)
+                  : ((dependency.next = pending.next),
+                    (pending.next = dependency));
+                updateQueue.pending = dependency;
+              }
+            }
+            fiber.lanes |= renderLanes;
+            dependency = fiber.alternate;
+            null !== dependency && (dependency.lanes |= renderLanes);
+            scheduleContextWorkOnParentPath(
+              fiber.return,
+              renderLanes,
+              workInProgress
+            );
+            list.lanes |= renderLanes;
+            break;
+          }
+          dependency = dependency.next;
+        }
+      } else if (10 === fiber.tag)
+        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+      else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = fiber.sibling;
+      } else 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 propagateContextChanges(
   workInProgress,
-  nextChildren,
+  contexts,
   renderLanes,
-  recoverableError
+  forcePropagateEntireTree
 ) {
-  resetHydrationState();
-  queueHydrationError(recoverableError);
-  workInProgress.flags |= 256;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
-var SUSPENDED_MARKER = { dehydrated: null, treeContext: null, retryLane: 0 };
-function mountSuspenseOffscreenState(renderLanes) {
-  return { baseLanes: renderLanes, cachePool: getSuspendedCache() };
-}
-function updateSuspenseComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    showFallback = !1,
-    didSuspend = 0 !== (workInProgress.flags & 128),
-    JSCompiler_temp;
-  (JSCompiler_temp = didSuspend) ||
-    (JSCompiler_temp =
-      null !== current && null === current.memoizedState
-        ? !1
-        : 0 !== (suspenseStackCursor.current & 2));
-  JSCompiler_temp && ((showFallback = !0), (workInProgress.flags &= -129));
-  if (null === current) {
-    if (isHydrating) {
-      showFallback
-        ? pushPrimaryTreeSuspenseHandler(workInProgress)
-        : reuseSuspenseHandlerOnStack();
-      isHydrating &&
-        (((current = nextHydratableInstance),
-        rootOrSingletonContext && advanceToFirstAttemptableSuspenseInstance(),
-        (didSuspend = nextHydratableInstance),
-        didSuspend)
-          ? tryHydrateSuspense(workInProgress, didSuspend) ||
-            (shouldClientRenderOnMismatch(workInProgress) &&
-              throwOnHydrationMismatch(),
-            (nextHydratableInstance = getNextHydratable(
-              didSuspend.nextSibling
-            )),
-            (JSCompiler_temp = hydrationParentFiber),
-            rootOrSingletonContext &&
-              advanceToFirstAttemptableSuspenseInstance(),
-            nextHydratableInstance &&
-            tryHydrateSuspense(workInProgress, nextHydratableInstance)
-              ? deleteHydratableInstance(JSCompiler_temp, didSuspend)
-              : (insertNonHydratedInstance(
-                  hydrationParentFiber,
-                  workInProgress
-                ),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = current)))
-          : (shouldClientRenderOnMismatch(workInProgress) &&
-              throwOnHydrationMismatch(),
-            insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-            (isHydrating = !1),
-            (hydrationParentFiber = workInProgress),
-            (nextHydratableInstance = current)));
-      current = workInProgress.memoizedState;
-      if (
-        null !== current &&
-        ((current = current.dehydrated), null !== current)
-      )
-        return (
-          0 === (workInProgress.mode & 1)
-            ? (workInProgress.lanes = 2)
-            : "$!" === current.data
-            ? (workInProgress.lanes = 16)
-            : (workInProgress.lanes = 1073741824),
-          null
-        );
-      popSuspenseHandler(workInProgress);
+  if (enableLazyContextPropagation) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber; ) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        list = list.firstContext;
+        a: for (; null !== list; ) {
+          var dependency = list;
+          list = fiber;
+          for (var i = 0; i < contexts.length; i++)
+            if (dependency.context === contexts[i]) {
+              list.lanes |= renderLanes;
+              dependency = list.alternate;
+              null !== dependency && (dependency.lanes |= renderLanes);
+              scheduleContextWorkOnParentPath(
+                list.return,
+                renderLanes,
+                workInProgress
+              );
+              forcePropagateEntireTree || (nextFiber = null);
+              break a;
+            }
+          list = dependency.next;
+        }
+      } else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = null;
+      } else 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;
     }
-    current = nextProps.children;
-    didSuspend = nextProps.fallback;
-    if (showFallback)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (current = mountSuspenseFallbackChildren(
-          workInProgress,
-          current,
-          didSuspend,
-          renderLanes
-        )),
-        (nextProps = workInProgress.child),
-        (nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes)),
-        (workInProgress.memoizedState = SUSPENDED_MARKER),
-        enableTransitionTracing &&
-          ((workInProgress = enableTransitionTracing
-            ? transitionStack.current
-            : null),
-          null !== workInProgress &&
-            ((renderLanes = enableTransitionTracing
-              ? markerInstanceStack.current
-              : null),
-            (showFallback = nextProps.updateQueue),
-            null === showFallback
-              ? (nextProps.updateQueue = {
-                  transitions: workInProgress,
-                  markerInstances: renderLanes,
-                  wakeables: null
-                })
-              : ((showFallback.transitions = workInProgress),
-                (showFallback.markerInstances = renderLanes)))),
-        current
-      );
-    if ("number" === typeof nextProps.unstable_expectedLoadTime)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (current = mountSuspenseFallbackChildren(
-          workInProgress,
-          current,
-          didSuspend,
-          renderLanes
-        )),
-        (workInProgress.child.memoizedState =
-          mountSuspenseOffscreenState(renderLanes)),
-        (workInProgress.memoizedState = SUSPENDED_MARKER),
-        (workInProgress.lanes = 8388608),
-        current
-      );
-    pushPrimaryTreeSuspenseHandler(workInProgress);
-    return mountSuspensePrimaryChildren(workInProgress, current);
   }
-  JSCompiler_temp = current.memoizedState;
-  if (null !== JSCompiler_temp) {
-    var dehydrated$116 = JSCompiler_temp.dehydrated;
-    if (null !== dehydrated$116)
-      return updateDehydratedSuspenseComponent(
-        current,
+}
+function propagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (enableLazyContextPropagation) {
+    current = null;
+    for (
+      var parent = workInProgress, isInsidePropagationBailout = !1;
+      null !== parent;
+
+    ) {
+      if (!isInsidePropagationBailout)
+        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
+        else if (0 !== (parent.flags & 262144)) break;
+      if (10 === parent.tag) {
+        var currentParent = parent.alternate;
+        if (null === currentParent) throw Error(formatProdErrorMessage(387));
+        currentParent = currentParent.memoizedProps;
+        if (null !== currentParent) {
+          var context = parent.type._context;
+          objectIs(parent.pendingProps.value, currentParent.value) ||
+            (null !== current ? current.push(context) : (current = [context]));
+        }
+      }
+      parent = parent.return;
+    }
+    null !== current &&
+      propagateContextChanges(
         workInProgress,
-        didSuspend,
-        nextProps,
-        dehydrated$116,
-        JSCompiler_temp,
-        renderLanes
+        current,
+        renderLanes,
+        forcePropagateEntireTree
       );
+    workInProgress.flags |= 262144;
   }
-  if (showFallback) {
-    reuseSuspenseHandlerOnStack();
-    showFallback = nextProps.fallback;
-    didSuspend = workInProgress.mode;
-    JSCompiler_temp = current.child;
-    dehydrated$116 = JSCompiler_temp.sibling;
-    var primaryChildProps = { mode: "hidden", children: nextProps.children };
-    0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
-      ? ((nextProps = workInProgress.child),
-        (nextProps.childLanes = 0),
-        (nextProps.pendingProps = primaryChildProps),
-        workInProgress.mode & 2 &&
-          ((nextProps.actualDuration = 0),
-          (nextProps.actualStartTime = -1),
-          (nextProps.selfBaseDuration = JSCompiler_temp.selfBaseDuration),
-          (nextProps.treeBaseDuration = JSCompiler_temp.treeBaseDuration)),
-        (workInProgress.deletions = null))
-      : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
-        (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
-    null !== dehydrated$116
-      ? (showFallback = createWorkInProgress(dehydrated$116, showFallback))
-      : ((showFallback = createFiberFromFragment(
-          showFallback,
-          didSuspend,
-          renderLanes,
-          null
-        )),
-        (showFallback.flags |= 2));
-    showFallback.return = workInProgress;
-    nextProps.return = workInProgress;
-    nextProps.sibling = showFallback;
-    workInProgress.child = nextProps;
-    nextProps = showFallback;
-    showFallback = workInProgress.child;
-    didSuspend = current.child.memoizedState;
-    null === didSuspend
-      ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
-      : ((JSCompiler_temp = didSuspend.cachePool),
-        null !== JSCompiler_temp
-          ? ((dehydrated$116 = CacheContext._currentValue),
-            (JSCompiler_temp =
-              JSCompiler_temp.parent !== dehydrated$116
-                ? { parent: dehydrated$116, pool: dehydrated$116 }
-                : JSCompiler_temp))
-          : (JSCompiler_temp = getSuspendedCache()),
-        (didSuspend = {
-          baseLanes: didSuspend.baseLanes | renderLanes,
-          cachePool: JSCompiler_temp
-        }));
-    showFallback.memoizedState = didSuspend;
-    enableTransitionTracing &&
-      ((didSuspend = enableTransitionTracing ? transitionStack.current : null),
-      null !== didSuspend &&
-        ((JSCompiler_temp = enableTransitionTracing
-          ? markerInstanceStack.current
-          : null),
-        (dehydrated$116 = showFallback.updateQueue),
-        (primaryChildProps = current.updateQueue),
-        null === dehydrated$116
-          ? (showFallback.updateQueue = {
-              transitions: didSuspend,
-              markerInstances: JSCompiler_temp,
-              wakeables: null
-            })
-          : dehydrated$116 === primaryChildProps
-          ? (showFallback.updateQueue = {
-              transitions: didSuspend,
-              markerInstances: JSCompiler_temp,
-              wakeables:
-                null !== primaryChildProps ? primaryChildProps.wakeables : null
-            })
-          : ((dehydrated$116.transitions = didSuspend),
-            (dehydrated$116.markerInstances = JSCompiler_temp))));
-    showFallback.childLanes = current.childLanes & ~renderLanes;
-    workInProgress.memoizedState = SUSPENDED_MARKER;
-    return nextProps;
-  }
-  pushPrimaryTreeSuspenseHandler(workInProgress);
-  showFallback = current.child;
-  current = showFallback.sibling;
-  nextProps = createWorkInProgress(showFallback, {
-    mode: "visible",
-    children: nextProps.children
-  });
-  0 === (workInProgress.mode & 1) && (nextProps.lanes = renderLanes);
-  nextProps.return = workInProgress;
-  nextProps.sibling = null;
-  null !== current &&
-    ((renderLanes = workInProgress.deletions),
-    null === renderLanes
-      ? ((workInProgress.deletions = [current]), (workInProgress.flags |= 16))
-      : renderLanes.push(current));
-  workInProgress.child = nextProps;
-  workInProgress.memoizedState = null;
-  return nextProps;
 }
-function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
-  primaryChildren = createFiberFromOffscreen(
-    { mode: "visible", children: primaryChildren },
-    workInProgress.mode,
-    0,
-    null
-  );
-  primaryChildren.return = workInProgress;
-  return (workInProgress.child = primaryChildren);
+function checkIfContextChanged(currentDependencies) {
+  if (!enableLazyContextPropagation) return !1;
+  for (
+    currentDependencies = currentDependencies.firstContext;
+    null !== currentDependencies;
+
+  ) {
+    if (
+      !objectIs(
+        currentDependencies.context._currentValue,
+        currentDependencies.memoizedValue
+      )
+    )
+      return !0;
+    currentDependencies = currentDependencies.next;
+  }
+  return !1;
 }
-function mountSuspenseFallbackChildren(
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
+function prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastFullyObservedContext = lastContextDependency = null;
+  workInProgress = workInProgress.dependencies;
+  null !== workInProgress &&
+    (enableLazyContextPropagation
+      ? (workInProgress.firstContext = null)
+      : null !== workInProgress.firstContext &&
+        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
+        (workInProgress.firstContext = null)));
+}
+function readContext(context) {
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  null === currentlyRenderingFiber &&
+    prepareToReadContext(consumer, renderLanes);
+  return readContextForConsumer(consumer, context);
+}
+function readContextForConsumer(consumer, context) {
+  var value = context._currentValue;
+  if (lastFullyObservedContext !== context)
+    if (
+      ((context = { context: context, memoizedValue: value, next: null }),
+      null === lastContextDependency)
+    ) {
+      if (null === consumer) throw Error(formatProdErrorMessage(308));
+      lastContextDependency = context;
+      consumer.dependencies = { lanes: 0, firstContext: context };
+      enableLazyContextPropagation && (consumer.flags |= 524288);
+    } else lastContextDependency = lastContextDependency.next = context;
+  return value;
+}
+var AbortControllerLocal =
+    "undefined" !== typeof AbortController
+      ? AbortController
+      : function () {
+          var listeners = [],
+            signal = (this.signal = {
+              aborted: !1,
+              addEventListener: function (type, listener) {
+                listeners.push(listener);
+              }
+            });
+          this.abort = function () {
+            signal.aborted = !0;
+            listeners.forEach(function (listener) {
+              return listener();
+            });
+          };
+        },
+  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+  NormalPriority = Scheduler.unstable_NormalPriority,
+  CacheContext = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    Consumer: null,
+    Provider: null,
+    _currentValue: null,
+    _currentValue2: null,
+    _threadCount: 0,
+    _defaultValue: null,
+    _globalName: null
+  };
+function createCache() {
+  return {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+}
+function releaseCache(cache) {
+  cache.refCount--;
+  0 === cache.refCount &&
+    scheduleCallback$1(NormalPriority, function () {
+      cache.controller.abort();
+    });
+}
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
+  resumedCache = createCursor(null),
+  transitionStack = createCursor(null);
+function peekCacheFromPool() {
+  var cacheResumedFromPreviousRender = resumedCache.current;
+  return null !== cacheResumedFromPreviousRender
+    ? cacheResumedFromPreviousRender
+    : workInProgressRoot.pooledCache;
+}
+function pushTransition(
+  offscreenWorkInProgress,
+  prevCachePool,
+  newTransitions
 ) {
-  var mode = workInProgress.mode,
-    progressedPrimaryFragment = workInProgress.child;
-  primaryChildren = { mode: "hidden", children: primaryChildren };
-  0 === (mode & 1) && null !== progressedPrimaryFragment
-    ? ((progressedPrimaryFragment.childLanes = 0),
-      (progressedPrimaryFragment.pendingProps = primaryChildren),
-      workInProgress.mode & 2 &&
-        ((progressedPrimaryFragment.actualDuration = 0),
-        (progressedPrimaryFragment.actualStartTime = -1),
-        (progressedPrimaryFragment.selfBaseDuration = 0),
-        (progressedPrimaryFragment.treeBaseDuration = 0)))
-    : (progressedPrimaryFragment = createFiberFromOffscreen(
-        primaryChildren,
-        mode,
-        0,
-        null
-      ));
-  fallbackChildren = createFiberFromFragment(
-    fallbackChildren,
-    mode,
-    renderLanes,
-    null
-  );
-  progressedPrimaryFragment.return = workInProgress;
-  fallbackChildren.return = workInProgress;
-  progressedPrimaryFragment.sibling = fallbackChildren;
-  workInProgress.child = progressedPrimaryFragment;
-  return fallbackChildren;
+  null === prevCachePool
+    ? push(resumedCache, resumedCache.current)
+    : push(resumedCache, prevCachePool.pool);
+  enableTransitionTracing &&
+    (null === transitionStack.current
+      ? push(transitionStack, newTransitions)
+      : null === newTransitions
+      ? push(transitionStack, transitionStack.current)
+      : push(transitionStack, transitionStack.current.concat(newTransitions)));
 }
-function retrySuspenseComponentWithoutHydrating(
-  current,
-  workInProgress,
-  renderLanes,
-  recoverableError
+function popTransition(workInProgress, current) {
+  null !== current &&
+    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
+}
+function getSuspendedCache() {
+  var cacheFromPool = peekCacheFromPool();
+  return null === cacheFromPool
+    ? null
+    : { parent: CacheContext._currentValue, pool: cacheFromPool };
+}
+var emptyObject = {};
+function collectScopedNodesFromChildren(
+  startingChild,
+  fn$jscomp$0,
+  scopedNodes$jscomp$0
 ) {
-  null !== recoverableError && queueHydrationError(recoverableError);
-  reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-  current = mountSuspensePrimaryChildren(
-    workInProgress,
-    workInProgress.pendingProps.children
-  );
-  current.flags |= 2;
-  workInProgress.memoizedState = null;
-  return current;
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      fn = fn$jscomp$0,
+      scopedNodes = scopedNodes$jscomp$0;
+    if (5 === node.tag) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        instance = node.stateNode;
+      null !== instance &&
+        !0 === fn(type, memoizedProps || emptyObject, instance) &&
+        scopedNodes.push(instance);
+    }
+    type = node.child;
+    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
+    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
+    startingChild = startingChild.sibling;
+  }
 }
-function updateDehydratedSuspenseComponent(
-  current,
-  workInProgress,
-  didSuspend,
-  nextProps,
-  suspenseInstance,
-  suspenseState,
-  renderLanes
+function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
+  for (; null !== startingChild; ) {
+    a: {
+      var JSCompiler_inline_result = startingChild;
+      var fn = fn$jscomp$0;
+      if (5 === JSCompiler_inline_result.tag) {
+        var type = JSCompiler_inline_result.type,
+          memoizedProps = JSCompiler_inline_result.memoizedProps,
+          instance = JSCompiler_inline_result.stateNode;
+        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
+          JSCompiler_inline_result = instance;
+          break a;
+        }
+      }
+      type = JSCompiler_inline_result.child;
+      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
+        (type = JSCompiler_inline_result.child.sibling.child);
+      JSCompiler_inline_result =
+        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
+    }
+    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
+    startingChild = startingChild.sibling;
+  }
+  return null;
+}
+function collectNearestChildContextValues(
+  startingChild,
+  context$jscomp$0,
+  childContextValues$jscomp$0
 ) {
-  if (didSuspend) {
-    if (workInProgress.flags & 256)
-      return (
-        pushPrimaryTreeSuspenseHandler(workInProgress),
-        (workInProgress.flags &= -257),
-        (suspenseState = createCapturedValue(
-          Error(formatProdErrorMessage(422))
-        )),
-        retrySuspenseComponentWithoutHydrating(
-          current,
-          workInProgress,
-          renderLanes,
-          suspenseState
-        )
-      );
-    if (null !== workInProgress.memoizedState)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (workInProgress.child = current.child),
-        (workInProgress.flags |= 128),
-        null
-      );
-    reuseSuspenseHandlerOnStack();
-    suspenseState = nextProps.fallback;
-    suspenseInstance = workInProgress.mode;
-    nextProps = createFiberFromOffscreen(
-      { mode: "visible", children: nextProps.children },
-      suspenseInstance,
-      0,
-      null
-    );
-    suspenseState = createFiberFromFragment(
-      suspenseState,
-      suspenseInstance,
-      renderLanes,
-      null
-    );
-    suspenseState.flags |= 2;
-    nextProps.return = workInProgress;
-    suspenseState.return = workInProgress;
-    nextProps.sibling = suspenseState;
-    workInProgress.child = nextProps;
-    0 !== (workInProgress.mode & 1) &&
-      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-    workInProgress.child.memoizedState =
-      mountSuspenseOffscreenState(renderLanes);
-    workInProgress.memoizedState = SUSPENDED_MARKER;
-    return suspenseState;
-  }
-  pushPrimaryTreeSuspenseHandler(workInProgress);
-  if (0 === (workInProgress.mode & 1))
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      null
-    );
-  if ("$!" === suspenseInstance.data) {
-    suspenseState =
-      suspenseInstance.nextSibling && suspenseInstance.nextSibling.dataset;
-    if (suspenseState) var digest = suspenseState.dgst;
-    suspenseState = digest;
-    nextProps = Error(formatProdErrorMessage(419));
-    nextProps.digest = suspenseState;
-    suspenseState = createCapturedValue(nextProps, suspenseState, void 0);
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      suspenseState
-    );
-  }
-  enableLazyContextPropagation &&
-    !didReceiveUpdate &&
-    propagateParentContextChanges(current, workInProgress, renderLanes, !1);
-  digest = 0 !== (renderLanes & current.childLanes);
-  if (didReceiveUpdate || digest) {
-    nextProps = workInProgressRoot;
-    if (null !== nextProps) {
-      suspenseInstance = renderLanes & -renderLanes;
-      if (enableUnifiedSyncLane && 0 !== (suspenseInstance & 42))
-        suspenseInstance = 1;
-      else
-        switch (suspenseInstance) {
-          case 2:
-            suspenseInstance = 1;
-            break;
-          case 8:
-            suspenseInstance = 4;
-            break;
-          case 32:
-            suspenseInstance = 16;
-            break;
-          case 128:
-          case 256:
-          case 512:
-          case 1024:
-          case 2048:
-          case 4096:
-          case 8192:
-          case 16384:
-          case 32768:
-          case 65536:
-          case 131072:
-          case 262144:
-          case 524288:
-          case 1048576:
-          case 2097152:
-          case 4194304:
-          case 8388608:
-          case 16777216:
-          case 33554432:
-          case 67108864:
-            suspenseInstance = 64;
-            break;
-          case 536870912:
-            suspenseInstance = 268435456;
-            break;
-          default:
-            suspenseInstance = 0;
-        }
-      suspenseInstance =
-        0 !== (suspenseInstance & (nextProps.suspendedLanes | renderLanes))
-          ? 0
-          : suspenseInstance;
-      if (
-        0 !== suspenseInstance &&
-        suspenseInstance !== suspenseState.retryLane
-      )
-        throw (
-          ((suspenseState.retryLane = suspenseInstance),
-          enqueueConcurrentRenderForLane(current, suspenseInstance),
-          scheduleUpdateOnFiber(nextProps, current, suspenseInstance, -1),
-          SelectiveHydrationException)
-        );
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      context = context$jscomp$0,
+      childContextValues = childContextValues$jscomp$0;
+    if (10 === node.tag && node.type._context === context)
+      childContextValues.push(node.memoizedProps.value);
+    else {
+      var child = node.child;
+      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
+      null !== child &&
+        collectNearestChildContextValues(child, context, childContextValues);
     }
-    renderDidSuspendDelayIfPossible();
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      null
-    );
+    startingChild = startingChild.sibling;
   }
-  if ("$?" === suspenseInstance.data)
-    return (
-      (workInProgress.flags |= 128),
-      (workInProgress.child = current.child),
-      (workInProgress = retryDehydratedSuspenseBoundary.bind(null, current)),
-      (suspenseInstance._reactRetry = workInProgress),
-      null
-    );
-  current = suspenseState.treeContext;
-  nextHydratableInstance = getNextHydratable(suspenseInstance.nextSibling);
-  hydrationParentFiber = workInProgress;
-  isHydrating = !0;
-  hydrationErrors = null;
-  rootOrSingletonContext = !1;
-  null !== current &&
-    ((idStack[idStackIndex++] = treeContextId),
-    (idStack[idStackIndex++] = treeContextOverflow),
-    (idStack[idStackIndex++] = treeContextProvider),
-    (treeContextId = current.id),
-    (treeContextOverflow = current.overflow),
-    (treeContextProvider = workInProgress));
-  workInProgress = mountSuspensePrimaryChildren(
-    workInProgress,
-    nextProps.children
-  );
-  workInProgress.flags |= 4096;
-  return workInProgress;
 }
-function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
-  fiber.lanes |= renderLanes;
-  var alternate = fiber.alternate;
-  null !== alternate && (alternate.lanes |= renderLanes);
-  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  var scopedNodes = [];
+  null !== currentFiber &&
+    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
+  return 0 === scopedNodes.length ? null : scopedNodes;
 }
-function initSuspenseListRenderState(
-  workInProgress,
-  isBackwards,
-  tail,
-  lastContentRow,
-  tailMode
-) {
-  var renderState = workInProgress.memoizedState;
-  null === renderState
-    ? (workInProgress.memoizedState = {
-        isBackwards: isBackwards,
-        rendering: null,
-        renderingStartTime: 0,
-        last: lastContentRow,
-        tail: tail,
-        tailMode: tailMode
-      })
-    : ((renderState.isBackwards = isBackwards),
-      (renderState.rendering = null),
-      (renderState.renderingStartTime = 0),
-      (renderState.last = lastContentRow),
-      (renderState.tail = tail),
-      (renderState.tailMode = tailMode));
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  return null !== currentFiber
+    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
+    : null;
 }
-function updateSuspenseListComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    revealOrder = nextProps.revealOrder,
-    tailMode = nextProps.tail;
-  reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
-  nextProps = suspenseStackCursor.current;
-  if (0 !== (nextProps & 2))
-    (nextProps = (nextProps & 1) | 2), (workInProgress.flags |= 128);
-  else {
-    if (null !== current && 0 !== (current.flags & 128))
-      a: for (current = workInProgress.child; null !== current; ) {
-        if (13 === current.tag)
-          null !== current.memoizedState &&
-            scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
-        else if (19 === current.tag)
-          scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
-        else if (null !== current.child) {
-          current.child.return = current;
-          current = current.child;
-          continue;
-        }
-        if (current === workInProgress) break a;
-        for (; null === current.sibling; ) {
-          if (null === current.return || current.return === workInProgress)
-            break a;
-          current = current.return;
-        }
-        current.sibling.return = current.return;
-        current = current.sibling;
-      }
-    nextProps &= 1;
-  }
-  push(suspenseStackCursor, nextProps);
-  if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;
-  else
-    switch (revealOrder) {
-      case "forwards":
-        renderLanes = workInProgress.child;
-        for (revealOrder = null; null !== renderLanes; )
-          (current = renderLanes.alternate),
-            null !== current &&
-              null === findFirstSuspended(current) &&
-              (revealOrder = renderLanes),
-            (renderLanes = renderLanes.sibling);
-        renderLanes = revealOrder;
-        null === renderLanes
-          ? ((revealOrder = workInProgress.child),
-            (workInProgress.child = null))
-          : ((revealOrder = renderLanes.sibling), (renderLanes.sibling = null));
-        initSuspenseListRenderState(
-          workInProgress,
-          !1,
-          revealOrder,
-          renderLanes,
-          tailMode
-        );
+function containsNode(node) {
+  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
+    if (21 === node.tag && node.stateNode === this) return !0;
+    node = node.return;
+  }
+  return !1;
+}
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return [];
+  currentFiber = currentFiber.child;
+  var childContextValues = [];
+  null !== currentFiber &&
+    collectNearestChildContextValues(currentFiber, context, childContextValues);
+  return childContextValues;
+}
+function markUpdate(workInProgress) {
+  workInProgress.flags |= 4;
+}
+function markRef(workInProgress) {
+  workInProgress.flags |= 2097664;
+}
+function updateHostComponent(current, workInProgress, type, newProps) {
+  var oldProps = current.memoizedProps;
+  if (oldProps !== newProps) {
+    current = workInProgress.stateNode;
+    var updatePayload = null;
+    switch (type) {
+      case "input":
+        oldProps = getHostProps$2(current, oldProps);
+        newProps = getHostProps$2(current, newProps);
+        updatePayload = [];
         break;
-      case "backwards":
-        renderLanes = null;
-        revealOrder = workInProgress.child;
-        for (workInProgress.child = null; null !== revealOrder; ) {
-          current = revealOrder.alternate;
-          if (null !== current && null === findFirstSuspended(current)) {
-            workInProgress.child = revealOrder;
-            break;
-          }
-          current = revealOrder.sibling;
-          revealOrder.sibling = renderLanes;
-          renderLanes = revealOrder;
-          revealOrder = current;
-        }
-        initSuspenseListRenderState(
-          workInProgress,
-          !0,
-          renderLanes,
-          null,
-          tailMode
-        );
+      case "select":
+        oldProps = assign({}, oldProps, { value: void 0 });
+        newProps = assign({}, newProps, { value: void 0 });
+        updatePayload = [];
         break;
-      case "together":
-        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+      case "textarea":
+        oldProps = getHostProps(current, oldProps);
+        newProps = getHostProps(current, newProps);
+        updatePayload = [];
         break;
       default:
-        workInProgress.memoizedState = null;
+        "function" !== typeof oldProps.onClick &&
+          "function" === typeof newProps.onClick &&
+          (current.onclick = noop$1);
     }
-  return workInProgress.child;
-}
-function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
-  0 === (workInProgress.mode & 1) &&
-    null !== current &&
-    ((current.alternate = null),
-    (workInProgress.alternate = null),
-    (workInProgress.flags |= 2));
-}
-function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
-  null !== current && (workInProgress.dependencies = current.dependencies);
-  profilerStartTime = -1;
-  workInProgressRootSkippedLanes |= workInProgress.lanes;
-  if (0 === (renderLanes & workInProgress.childLanes))
-    if (enableLazyContextPropagation && null !== current) {
+    assertValidProps(type, newProps);
+    var styleName;
+    type = null;
+    for (JSCompiler_inline_result in oldProps)
       if (
-        (propagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes,
-          !1
-        ),
-        0 === (renderLanes & workInProgress.childLanes))
+        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
+        null != oldProps[JSCompiler_inline_result]
       )
-        return null;
-    } else return null;
-  if (null !== current && workInProgress.child !== current.child)
-    throw Error(formatProdErrorMessage(153));
-  if (null !== workInProgress.child) {
-    current = workInProgress.child;
-    renderLanes = createWorkInProgress(current, current.pendingProps);
-    workInProgress.child = renderLanes;
-    for (renderLanes.return = workInProgress; null !== current.sibling; )
-      (current = current.sibling),
-        (renderLanes = renderLanes.sibling =
-          createWorkInProgress(current, current.pendingProps)),
-        (renderLanes.return = workInProgress);
-    renderLanes.sibling = null;
+        if ("style" === JSCompiler_inline_result) {
+          var lastStyle = oldProps[JSCompiler_inline_result];
+          for (styleName in lastStyle)
+            lastStyle.hasOwnProperty(styleName) &&
+              (type || (type = {}), (type[styleName] = ""));
+        } else
+          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
+            "children" !== JSCompiler_inline_result &&
+            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+            "suppressHydrationWarning" !== JSCompiler_inline_result &&
+            "autoFocus" !== JSCompiler_inline_result &&
+            (registrationNameDependencies.hasOwnProperty(
+              JSCompiler_inline_result
+            )
+              ? updatePayload || (updatePayload = [])
+              : (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  null
+                ));
+    for (JSCompiler_inline_result in newProps) {
+      var nextProp = newProps[JSCompiler_inline_result];
+      lastStyle =
+        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
+      if (
+        newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        nextProp !== lastStyle &&
+        (null != nextProp || null != lastStyle)
+      )
+        if ("style" === JSCompiler_inline_result)
+          if (lastStyle) {
+            for (styleName in lastStyle)
+              !lastStyle.hasOwnProperty(styleName) ||
+                (nextProp && nextProp.hasOwnProperty(styleName)) ||
+                (type || (type = {}), (type[styleName] = ""));
+            for (styleName in nextProp)
+              nextProp.hasOwnProperty(styleName) &&
+                lastStyle[styleName] !== nextProp[styleName] &&
+                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+          } else
+            type ||
+              (updatePayload || (updatePayload = []),
+              updatePayload.push(JSCompiler_inline_result, type)),
+              (type = nextProp);
+        else
+          "dangerouslySetInnerHTML" === JSCompiler_inline_result
+            ? ((nextProp = nextProp ? nextProp.__html : void 0),
+              (lastStyle = lastStyle ? lastStyle.__html : void 0),
+              null != nextProp &&
+                lastStyle !== nextProp &&
+                (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  nextProp
+                ))
+            : "children" === JSCompiler_inline_result
+            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
+              (updatePayload = updatePayload || []).push(
+                JSCompiler_inline_result,
+                "" + nextProp
+              )
+            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+              "suppressHydrationWarning" !== JSCompiler_inline_result &&
+              (registrationNameDependencies.hasOwnProperty(
+                JSCompiler_inline_result
+              )
+                ? (null != nextProp &&
+                    "onScroll" === JSCompiler_inline_result &&
+                    listenToNonDelegatedEvent("scroll", current),
+                  updatePayload ||
+                    lastStyle === nextProp ||
+                    (updatePayload = []))
+                : (updatePayload = updatePayload || []).push(
+                    JSCompiler_inline_result,
+                    nextProp
+                  ));
+    }
+    type && (updatePayload = updatePayload || []).push("style", type);
+    var JSCompiler_inline_result = updatePayload;
+    (workInProgress.updateQueue = JSCompiler_inline_result) &&
+      markUpdate(workInProgress);
   }
-  return workInProgress.child;
 }
-function checkScheduledUpdateOrContext(current, renderLanes) {
-  return 0 !== (current.lanes & renderLanes) ||
-    (enableLazyContextPropagation &&
-      ((current = current.dependencies),
-      null !== current && checkIfContextChanged(current)))
-    ? !0
-    : !1;
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (!isHydrating)
+    switch (renderState.tailMode) {
+      case "hidden":
+        hasRenderedATailFallback = renderState.tail;
+        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
+          null !== hasRenderedATailFallback.alternate &&
+            (lastTailNode = hasRenderedATailFallback),
+            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
+        null === lastTailNode
+          ? (renderState.tail = null)
+          : (lastTailNode.sibling = null);
+        break;
+      case "collapsed":
+        lastTailNode = renderState.tail;
+        for (var lastTailNode$133 = null; null !== lastTailNode; )
+          null !== lastTailNode.alternate && (lastTailNode$133 = lastTailNode),
+            (lastTailNode = lastTailNode.sibling);
+        null === lastTailNode$133
+          ? hasRenderedATailFallback || null === renderState.tail
+            ? (renderState.tail = null)
+            : (renderState.tail.sibling = null)
+          : (lastTailNode$133.sibling = null);
+    }
 }
-function attemptEarlyBailoutIfNoScheduledUpdate(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  switch (workInProgress.tag) {
-    case 3:
-      pushHostRootContext(workInProgress);
-      enableTransitionTracing &&
-        push(transitionStack, workInProgressTransitions);
-      enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
-      resetHydrationState();
-      break;
-    case 27:
-    case 5:
-      pushHostContext(workInProgress);
-      break;
-    case 1:
-      isContextProvider(workInProgress.type) &&
-        pushContextProvider(workInProgress);
-      break;
-    case 4:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      break;
-    case 10:
-      pushProvider(
-        workInProgress,
-        workInProgress.type._context,
-        workInProgress.memoizedProps.value
-      );
-      break;
+function bubbleProperties(completedWork) {
+  var didBailout =
+      null !== completedWork.alternate &&
+      completedWork.alternate.child === completedWork.child,
+    newChildLanes = 0,
+    subtreeFlags = 0;
+  if (didBailout)
+    if (0 !== (completedWork.mode & 2)) {
+      for (
+        var treeBaseDuration$135 = completedWork.selfBaseDuration,
+          child$136 = completedWork.child;
+        null !== child$136;
+
+      )
+        (newChildLanes |= child$136.lanes | child$136.childLanes),
+          (subtreeFlags |= child$136.subtreeFlags & 14680064),
+          (subtreeFlags |= child$136.flags & 14680064),
+          (treeBaseDuration$135 += child$136.treeBaseDuration),
+          (child$136 = child$136.sibling);
+      completedWork.treeBaseDuration = treeBaseDuration$135;
+    } else
+      for (
+        treeBaseDuration$135 = completedWork.child;
+        null !== treeBaseDuration$135;
+
+      )
+        (newChildLanes |=
+          treeBaseDuration$135.lanes | treeBaseDuration$135.childLanes),
+          (subtreeFlags |= treeBaseDuration$135.subtreeFlags & 14680064),
+          (subtreeFlags |= treeBaseDuration$135.flags & 14680064),
+          (treeBaseDuration$135.return = completedWork),
+          (treeBaseDuration$135 = treeBaseDuration$135.sibling);
+  else if (0 !== (completedWork.mode & 2)) {
+    treeBaseDuration$135 = completedWork.actualDuration;
+    child$136 = completedWork.selfBaseDuration;
+    for (var child = completedWork.child; null !== child; )
+      (newChildLanes |= child.lanes | child.childLanes),
+        (subtreeFlags |= child.subtreeFlags),
+        (subtreeFlags |= child.flags),
+        (treeBaseDuration$135 += child.actualDuration),
+        (child$136 += child.treeBaseDuration),
+        (child = child.sibling);
+    completedWork.actualDuration = treeBaseDuration$135;
+    completedWork.treeBaseDuration = child$136;
+  } else
+    for (
+      treeBaseDuration$135 = completedWork.child;
+      null !== treeBaseDuration$135;
+
+    )
+      (newChildLanes |=
+        treeBaseDuration$135.lanes | treeBaseDuration$135.childLanes),
+        (subtreeFlags |= treeBaseDuration$135.subtreeFlags),
+        (subtreeFlags |= treeBaseDuration$135.flags),
+        (treeBaseDuration$135.return = completedWork),
+        (treeBaseDuration$135 = treeBaseDuration$135.sibling);
+  completedWork.subtreeFlags |= subtreeFlags;
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps;
+  popTreeContext(workInProgress);
+  switch (workInProgress.tag) {
+    case 2:
+    case 16:
+    case 15:
+    case 0:
+    case 11:
+    case 7:
+    case 8:
     case 12:
-      0 !== (renderLanes & workInProgress.childLanes) &&
-        (workInProgress.flags |= 4);
-      var stateNode = workInProgress.stateNode;
-      stateNode.effectDuration = 0;
-      stateNode.passiveEffectDuration = 0;
-      break;
-    case 13:
-      stateNode = workInProgress.memoizedState;
-      if (null !== stateNode) {
-        if (null !== stateNode.dehydrated)
-          return (
-            pushPrimaryTreeSuspenseHandler(workInProgress),
-            (workInProgress.flags |= 128),
-            null
-          );
-        if (0 !== (renderLanes & workInProgress.child.childLanes))
-          return updateSuspenseComponent(current, workInProgress, renderLanes);
-        pushPrimaryTreeSuspenseHandler(workInProgress);
-        current = bailoutOnAlreadyFinishedWork(
-          current,
-          workInProgress,
-          renderLanes
-        );
-        return null !== current ? current.sibling : null;
-      }
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      break;
-    case 19:
-      var didSuspendBefore = 0 !== (current.flags & 128);
-      stateNode = 0 !== (renderLanes & workInProgress.childLanes);
-      enableLazyContextPropagation &&
-        !stateNode &&
-        (propagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes,
-          !1
-        ),
-        (stateNode = 0 !== (renderLanes & workInProgress.childLanes)));
-      if (didSuspendBefore) {
-        if (stateNode)
-          return updateSuspenseListComponent(
-            current,
-            workInProgress,
-            renderLanes
-          );
-        workInProgress.flags |= 128;
-      }
-      didSuspendBefore = workInProgress.memoizedState;
-      null !== didSuspendBefore &&
-        ((didSuspendBefore.rendering = null),
-        (didSuspendBefore.tail = null),
-        (didSuspendBefore.lastEffect = null));
-      push(suspenseStackCursor, suspenseStackCursor.current);
-      if (stateNode) break;
-      else return null;
-    case 22:
-    case 23:
+    case 9:
+    case 14:
+      return bubbleProperties(workInProgress), null;
+    case 1:
       return (
-        (workInProgress.lanes = 0),
-        updateOffscreenComponent(current, workInProgress, renderLanes)
+        isContextProvider(workInProgress.type) && popContext(),
+        bubbleProperties(workInProgress),
+        null
       );
-    case 24:
-      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
-      break;
-    case 25:
+    case 3:
+      renderLanes = workInProgress.stateNode;
       enableTransitionTracing &&
-        ((stateNode = workInProgress.stateNode),
-        null !== stateNode && pushMarkerInstance(workInProgress, stateNode));
-  }
-  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-}
-var valueCursor = createCursor(null),
-  currentlyRenderingFiber = null,
-  lastContextDependency = null,
-  lastFullyObservedContext = null;
-function resetContextDependencies() {
-  lastFullyObservedContext =
-    lastContextDependency =
-    currentlyRenderingFiber =
-      null;
-}
-function pushProvider(providerFiber, context, nextValue) {
-  push(valueCursor, context._currentValue);
-  context._currentValue = nextValue;
-}
-function popProvider(context) {
-  var currentValue = valueCursor.current;
-  context._currentValue =
-    currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED
-      ? context._defaultValue
-      : currentValue;
-  pop(valueCursor);
-}
-function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
-  for (; null !== parent; ) {
-    var alternate = parent.alternate;
-    (parent.childLanes & renderLanes) !== renderLanes
-      ? ((parent.childLanes |= renderLanes),
-        null !== alternate && (alternate.childLanes |= renderLanes))
-      : null !== alternate &&
-        (alternate.childLanes & renderLanes) !== renderLanes &&
-        (alternate.childLanes |= renderLanes);
-    if (parent === propagationRoot) break;
-    parent = parent.return;
-  }
-}
-function propagateContextChange(workInProgress, context, renderLanes) {
-  if (enableLazyContextPropagation)
-    propagateContextChanges(workInProgress, [context], renderLanes, !0);
-  else if (!enableLazyContextPropagation) {
-    var fiber = workInProgress.child;
-    null !== fiber && (fiber.return = workInProgress);
-    for (; null !== fiber; ) {
-      var list = fiber.dependencies;
-      if (null !== list) {
-        var nextFiber = fiber.child;
-        for (var dependency = list.firstContext; null !== dependency; ) {
-          if (dependency.context === context) {
-            if (1 === fiber.tag) {
-              dependency = createUpdate(renderLanes & -renderLanes);
-              dependency.tag = 2;
-              var updateQueue = fiber.updateQueue;
-              if (null !== updateQueue) {
-                updateQueue = updateQueue.shared;
-                var pending = updateQueue.pending;
-                null === pending
-                  ? (dependency.next = dependency)
-                  : ((dependency.next = pending.next),
-                    (pending.next = dependency));
-                updateQueue.pending = dependency;
-              }
-            }
-            fiber.lanes |= renderLanes;
-            dependency = fiber.alternate;
-            null !== dependency && (dependency.lanes |= renderLanes);
-            scheduleContextWorkOnParentPath(
-              fiber.return,
-              renderLanes,
-              workInProgress
-            );
-            list.lanes |= renderLanes;
-            break;
-          }
-          dependency = dependency.next;
-        }
-      } else if (10 === fiber.tag)
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-      else if (18 === fiber.tag) {
-        nextFiber = fiber.return;
-        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
-        nextFiber.lanes |= renderLanes;
-        list = nextFiber.alternate;
-        null !== list && (list.lanes |= renderLanes);
-        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
-        nextFiber = fiber.sibling;
-      } else 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 propagateContextChanges(
-  workInProgress,
-  contexts,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (enableLazyContextPropagation) {
-    var fiber = workInProgress.child;
-    null !== fiber && (fiber.return = workInProgress);
-    for (; null !== fiber; ) {
-      var list = fiber.dependencies;
-      if (null !== list) {
-        var nextFiber = fiber.child;
-        list = list.firstContext;
-        a: for (; null !== list; ) {
-          var dependency = list;
-          list = fiber;
-          for (var i = 0; i < contexts.length; i++)
-            if (dependency.context === contexts[i]) {
-              list.lanes |= renderLanes;
-              dependency = list.alternate;
-              null !== dependency && (dependency.lanes |= renderLanes);
-              scheduleContextWorkOnParentPath(
-                list.return,
-                renderLanes,
-                workInProgress
-              );
-              forcePropagateEntireTree || (nextFiber = null);
-              break a;
-            }
-          list = dependency.next;
+        null !== workInProgressTransitions &&
+        (workInProgress.flags |= 2048);
+      newProps = null;
+      null !== current && (newProps = current.memoizedState.cache);
+      workInProgress.memoizedState.cache !== newProps &&
+        (workInProgress.flags |= 2048);
+      popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
+      popHostContainer();
+      pop(didPerformWorkStackCursor);
+      pop(contextStackCursor);
+      resetWorkInProgressVersions();
+      renderLanes.pendingContext &&
+        ((renderLanes.context = renderLanes.pendingContext),
+        (renderLanes.pendingContext = null));
+      if (null === current || null === current.child)
+        popHydrationState(workInProgress)
+          ? markUpdate(workInProgress)
+          : null === current ||
+            (current.memoizedState.isDehydrated &&
+              0 === (workInProgress.flags & 256)) ||
+            ((workInProgress.flags |= 1024),
+            null !== hydrationErrors &&
+              (queueRecoverableErrors(hydrationErrors),
+              (hydrationErrors = null)));
+      bubbleProperties(workInProgress);
+      enableTransitionTracing &&
+        0 !== (workInProgress.subtreeFlags & 8192) &&
+        (workInProgress.flags |= 2048);
+      return null;
+    case 26:
+      return (
+        (current ? current.ref : null) !== workInProgress.ref &&
+          markRef(workInProgress),
+        null === current ||
+        current.memoizedState !== workInProgress.memoizedState
+          ? markUpdate(workInProgress)
+          : null === workInProgress.memoizedState &&
+            updateHostComponent(
+              current,
+              workInProgress,
+              workInProgress.type,
+              workInProgress.pendingProps
+            ),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 27:
+      popHostContext(workInProgress);
+      renderLanes = rootInstanceStackCursor.current;
+      var type = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, type, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
         }
-      } else if (18 === fiber.tag) {
-        nextFiber = fiber.return;
-        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
-        nextFiber.lanes |= renderLanes;
-        list = nextFiber.alternate;
-        null !== list && (list.lanes |= renderLanes);
-        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
-        nextFiber = null;
-      } else nextFiber = fiber.child;
-      if (null !== nextFiber) nextFiber.return = fiber;
-      else
-        for (nextFiber = fiber; null !== nextFiber; ) {
-          if (nextFiber === workInProgress) {
-            nextFiber = null;
-            break;
+        current = contextStackCursor$1.current;
+        popHydrationState(workInProgress)
+          ? prepareToHydrateHostInstance(workInProgress, current)
+          : ((workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              renderLanes
+            )),
+            markUpdate(workInProgress));
+        null !== workInProgress.ref && markRef(workInProgress);
+      }
+      bubbleProperties(workInProgress);
+      return null;
+    case 5:
+      popHostContext(workInProgress);
+      renderLanes = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, renderLanes, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor$1.current;
+        if (popHydrationState(workInProgress))
+          prepareToHydrateHostInstance(workInProgress, current) &&
+            markUpdate(workInProgress);
+        else {
+          type = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          );
+          switch (current) {
+            case "http://www.w3.org/2000/svg":
+            case "http://www.w3.org/1998/Math/MathML":
+              current = type.createElementNS(current, renderLanes);
+              break;
+            default:
+              switch (renderLanes) {
+                case "svg":
+                  current = type.createElementNS(
+                    "http://www.w3.org/2000/svg",
+                    renderLanes
+                  );
+                  break;
+                case "math":
+                  current = type.createElementNS(
+                    "http://www.w3.org/1998/Math/MathML",
+                    renderLanes
+                  );
+                  break;
+                case "script":
+                  current = type.createElement("div");
+                  current.innerHTML = "<script>\x3c/script>";
+                  current = current.removeChild(current.firstChild);
+                  break;
+                case "select":
+                  current =
+                    "string" === typeof newProps.is
+                      ? type.createElement("select", { is: newProps.is })
+                      : type.createElement("select");
+                  newProps.multiple
+                    ? (current.multiple = !0)
+                    : newProps.size && (current.size = newProps.size);
+                  break;
+                default:
+                  current = createHTMLElement(renderLanes, newProps, type);
+              }
           }
-          fiber = nextFiber.sibling;
-          if (null !== fiber) {
-            fiber.return = nextFiber.return;
-            nextFiber = fiber;
-            break;
+          current[internalInstanceKey] = workInProgress;
+          current[internalPropsKey] = newProps;
+          a: for (type = workInProgress.child; null !== type; ) {
+            if (5 === type.tag || 6 === type.tag)
+              current.appendChild(type.stateNode);
+            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
+              type.child.return = type;
+              type = type.child;
+              continue;
+            }
+            if (type === workInProgress) break a;
+            for (; null === type.sibling; ) {
+              if (null === type.return || type.return === workInProgress)
+                break a;
+              type = type.return;
+            }
+            type.sibling.return = type.return;
+            type = type.sibling;
           }
-          nextFiber = nextFiber.return;
-        }
-      fiber = nextFiber;
-    }
-  }
-}
-function propagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (enableLazyContextPropagation) {
-    current = null;
-    for (
-      var parent = workInProgress, isInsidePropagationBailout = !1;
-      null !== parent;
-
-    ) {
-      if (!isInsidePropagationBailout)
-        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
-        else if (0 !== (parent.flags & 262144)) break;
-      if (10 === parent.tag) {
-        var currentParent = parent.alternate;
-        if (null === currentParent) throw Error(formatProdErrorMessage(387));
-        currentParent = currentParent.memoizedProps;
-        if (null !== currentParent) {
-          var context = parent.type._context;
-          objectIs(parent.pendingProps.value, currentParent.value) ||
-            (null !== current ? current.push(context) : (current = [context]));
+          workInProgress.stateNode = current;
+          a: switch (
+            (setInitialProperties(current, renderLanes, newProps), renderLanes)
+          ) {
+            case "button":
+            case "input":
+            case "select":
+            case "textarea":
+              current = !!newProps.autoFocus;
+              break a;
+            case "img":
+              current = !0;
+              break a;
+            default:
+              current = !1;
+          }
+          current && markUpdate(workInProgress);
         }
+        null !== workInProgress.ref && markRef(workInProgress);
       }
-      parent = parent.return;
-    }
-    null !== current &&
-      propagateContextChanges(
-        workInProgress,
-        current,
-        renderLanes,
-        forcePropagateEntireTree
-      );
-    workInProgress.flags |= 262144;
-  }
-}
-function checkIfContextChanged(currentDependencies) {
-  if (!enableLazyContextPropagation) return !1;
-  for (
-    currentDependencies = currentDependencies.firstContext;
-    null !== currentDependencies;
-
-  ) {
-    if (
-      !objectIs(
-        currentDependencies.context._currentValue,
-        currentDependencies.memoizedValue
-      )
-    )
-      return !0;
-    currentDependencies = currentDependencies.next;
-  }
-  return !1;
-}
-function prepareToReadContext(workInProgress, renderLanes) {
-  currentlyRenderingFiber = workInProgress;
-  lastFullyObservedContext = lastContextDependency = null;
-  workInProgress = workInProgress.dependencies;
-  null !== workInProgress &&
-    (enableLazyContextPropagation
-      ? (workInProgress.firstContext = null)
-      : null !== workInProgress.firstContext &&
-        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
-        (workInProgress.firstContext = null)));
-}
-function readContext(context) {
-  return readContextForConsumer(currentlyRenderingFiber, context);
-}
-function readContextDuringReconcilation(consumer, context, renderLanes) {
-  null === currentlyRenderingFiber &&
-    prepareToReadContext(consumer, renderLanes);
-  return readContextForConsumer(consumer, context);
-}
-function readContextForConsumer(consumer, context) {
-  var value = context._currentValue;
-  if (lastFullyObservedContext !== context)
-    if (
-      ((context = { context: context, memoizedValue: value, next: null }),
-      null === lastContextDependency)
-    ) {
-      if (null === consumer) throw Error(formatProdErrorMessage(308));
-      lastContextDependency = context;
-      consumer.dependencies = { lanes: 0, firstContext: context };
-      enableLazyContextPropagation && (consumer.flags |= 524288);
-    } else lastContextDependency = lastContextDependency.next = context;
-  return value;
-}
-var AbortControllerLocal =
-    "undefined" !== typeof AbortController
-      ? AbortController
-      : function () {
-          var listeners = [],
-            signal = (this.signal = {
-              aborted: !1,
-              addEventListener: function (type, listener) {
-                listeners.push(listener);
+      bubbleProperties(workInProgress);
+      return null;
+    case 6:
+      if (current && null != workInProgress.stateNode)
+        current.memoizedProps !== newProps && markUpdate(workInProgress);
+      else {
+        if ("string" !== typeof newProps && null === workInProgress.stateNode)
+          throw Error(formatProdErrorMessage(166));
+        current = rootInstanceStackCursor.current;
+        if (popHydrationState(workInProgress)) {
+          newProps = workInProgress.stateNode;
+          current = workInProgress.memoizedProps;
+          newProps[internalInstanceKey] = workInProgress;
+          if ((renderLanes = newProps.nodeValue !== current))
+            if (((type = hydrationParentFiber), null !== type))
+              switch (type.tag) {
+                case 3:
+                  newProps = newProps.nodeValue;
+                  normalizeMarkupForTextOrAttribute(current);
+                  normalizeMarkupForTextOrAttribute(newProps);
+                  break;
+                case 27:
+                case 5:
+                  !0 !== type.memoizedProps.suppressHydrationWarning &&
+                    ((newProps = newProps.nodeValue),
+                    normalizeMarkupForTextOrAttribute(current),
+                    normalizeMarkupForTextOrAttribute(newProps));
               }
-            });
-          this.abort = function () {
-            signal.aborted = !0;
-            listeners.forEach(function (listener) {
-              return listener();
-            });
-          };
-        },
-  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
-  NormalPriority = Scheduler.unstable_NormalPriority,
-  CacheContext = {
-    $$typeof: REACT_CONTEXT_TYPE,
-    Consumer: null,
-    Provider: null,
-    _currentValue: null,
-    _currentValue2: null,
-    _threadCount: 0,
-    _defaultValue: null,
-    _globalName: null
-  };
-function createCache() {
-  return {
-    controller: new AbortControllerLocal(),
-    data: new Map(),
-    refCount: 0
-  };
-}
-function releaseCache(cache) {
-  cache.refCount--;
-  0 === cache.refCount &&
-    scheduleCallback$1(NormalPriority, function () {
-      cache.controller.abort();
-    });
-}
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
-  resumedCache = createCursor(null),
-  transitionStack = createCursor(null);
-function peekCacheFromPool() {
-  var cacheResumedFromPreviousRender = resumedCache.current;
-  return null !== cacheResumedFromPreviousRender
-    ? cacheResumedFromPreviousRender
-    : workInProgressRoot.pooledCache;
-}
-function pushTransition(
-  offscreenWorkInProgress,
-  prevCachePool,
-  newTransitions
-) {
-  null === prevCachePool
-    ? push(resumedCache, resumedCache.current)
-    : push(resumedCache, prevCachePool.pool);
-  enableTransitionTracing &&
-    (null === transitionStack.current
-      ? push(transitionStack, newTransitions)
-      : null === newTransitions
-      ? push(transitionStack, transitionStack.current)
-      : push(transitionStack, transitionStack.current.concat(newTransitions)));
-}
-function popTransition(workInProgress, current) {
-  null !== current &&
-    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
-}
-function getSuspendedCache() {
-  var cacheFromPool = peekCacheFromPool();
-  return null === cacheFromPool
-    ? null
-    : { parent: CacheContext._currentValue, pool: cacheFromPool };
-}
-var emptyObject = {};
-function collectScopedNodesFromChildren(
-  startingChild,
-  fn$jscomp$0,
-  scopedNodes$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      fn = fn$jscomp$0,
-      scopedNodes = scopedNodes$jscomp$0;
-    if (5 === node.tag) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        instance = node.stateNode;
-      null !== instance &&
-        !0 === fn(type, memoizedProps || emptyObject, instance) &&
-        scopedNodes.push(instance);
-    }
-    type = node.child;
-    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
-    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
-    startingChild = startingChild.sibling;
-  }
-}
-function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
-  for (; null !== startingChild; ) {
-    a: {
-      var JSCompiler_inline_result = startingChild;
-      var fn = fn$jscomp$0;
-      if (5 === JSCompiler_inline_result.tag) {
-        var type = JSCompiler_inline_result.type,
-          memoizedProps = JSCompiler_inline_result.memoizedProps,
-          instance = JSCompiler_inline_result.stateNode;
-        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
-          JSCompiler_inline_result = instance;
-          break a;
-        }
+          renderLanes && markUpdate(workInProgress);
+        } else
+          (current =
+            getOwnerDocumentFromRootContainer(current).createTextNode(
+              newProps
+            )),
+            (current[internalInstanceKey] = workInProgress),
+            (workInProgress.stateNode = current);
       }
-      type = JSCompiler_inline_result.child;
-      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
-        (type = JSCompiler_inline_result.child.sibling.child);
-      JSCompiler_inline_result =
-        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
-    }
-    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
-    startingChild = startingChild.sibling;
-  }
-  return null;
-}
-function collectNearestChildContextValues(
-  startingChild,
-  context$jscomp$0,
-  childContextValues$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      context = context$jscomp$0,
-      childContextValues = childContextValues$jscomp$0;
-    if (10 === node.tag && node.type._context === context)
-      childContextValues.push(node.memoizedProps.value);
-    else {
-      var child = node.child;
-      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
-      null !== child &&
-        collectNearestChildContextValues(child, context, childContextValues);
-    }
-    startingChild = startingChild.sibling;
-  }
-}
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  var scopedNodes = [];
-  null !== currentFiber &&
-    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
-  return 0 === scopedNodes.length ? null : scopedNodes;
-}
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  return null !== currentFiber
-    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
-    : null;
-}
-function containsNode(node) {
-  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
-    if (21 === node.tag && node.stateNode === this) return !0;
-    node = node.return;
-  }
-  return !1;
-}
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return [];
-  currentFiber = currentFiber.child;
-  var childContextValues = [];
-  null !== currentFiber &&
-    collectNearestChildContextValues(currentFiber, context, childContextValues);
-  return childContextValues;
-}
-function markUpdate(workInProgress) {
-  workInProgress.flags |= 4;
-}
-function markRef(workInProgress) {
-  workInProgress.flags |= 2097664;
-}
-function updateHostComponent(current, workInProgress, type, newProps) {
-  var oldProps = current.memoizedProps;
-  if (oldProps !== newProps) {
-    current = workInProgress.stateNode;
-    var updatePayload = null;
-    switch (type) {
-      case "input":
-        oldProps = getHostProps$2(current, oldProps);
-        newProps = getHostProps$2(current, newProps);
-        updatePayload = [];
-        break;
-      case "select":
-        oldProps = assign({}, oldProps, { value: void 0 });
-        newProps = assign({}, newProps, { value: void 0 });
-        updatePayload = [];
-        break;
-      case "textarea":
-        oldProps = getHostProps(current, oldProps);
-        newProps = getHostProps(current, newProps);
-        updatePayload = [];
-        break;
-      default:
-        "function" !== typeof oldProps.onClick &&
-          "function" === typeof newProps.onClick &&
-          (current.onclick = noop$1);
-    }
-    assertValidProps(type, newProps);
-    var styleName;
-    type = null;
-    for (JSCompiler_inline_result in oldProps)
+      bubbleProperties(workInProgress);
+      return null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      newProps = workInProgress.memoizedState;
       if (
-        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
-        null != oldProps[JSCompiler_inline_result]
-      )
-        if ("style" === JSCompiler_inline_result) {
-          var lastStyle = oldProps[JSCompiler_inline_result];
-          for (styleName in lastStyle)
-            lastStyle.hasOwnProperty(styleName) &&
-              (type || (type = {}), (type[styleName] = ""));
+        null === current ||
+        (null !== current.memoizedState &&
+          null !== current.memoizedState.dehydrated)
+      ) {
+        if (
+          isHydrating &&
+          null !== nextHydratableInstance &&
+          0 !== (workInProgress.mode & 1) &&
+          0 === (workInProgress.flags & 128)
+        )
+          warnIfUnhydratedTailNodes(),
+            resetHydrationState(),
+            (workInProgress.flags |= 98560),
+            (type = !1);
+        else if (
+          ((type = popHydrationState(workInProgress)),
+          null !== newProps && null !== newProps.dehydrated)
+        ) {
+          if (null === current) {
+            if (!type) throw Error(formatProdErrorMessage(318));
+            type = workInProgress.memoizedState;
+            type = null !== type ? type.dehydrated : null;
+            if (!type) throw Error(formatProdErrorMessage(317));
+            type[internalInstanceKey] = workInProgress;
+            bubbleProperties(workInProgress);
+            0 !== (workInProgress.mode & 2) &&
+              null !== newProps &&
+              ((type = workInProgress.child),
+              null !== type &&
+                (workInProgress.treeBaseDuration -= type.treeBaseDuration));
+          } else
+            resetHydrationState(),
+              0 === (workInProgress.flags & 128) &&
+                (workInProgress.memoizedState = null),
+              (workInProgress.flags |= 4),
+              bubbleProperties(workInProgress),
+              0 !== (workInProgress.mode & 2) &&
+                null !== newProps &&
+                ((type = workInProgress.child),
+                null !== type &&
+                  (workInProgress.treeBaseDuration -= type.treeBaseDuration));
+          type = !1;
         } else
-          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
-            "children" !== JSCompiler_inline_result &&
-            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-            "suppressHydrationWarning" !== JSCompiler_inline_result &&
-            "autoFocus" !== JSCompiler_inline_result &&
-            (registrationNameDependencies.hasOwnProperty(
-              JSCompiler_inline_result
+          null !== hydrationErrors &&
+            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
+            (type = !0);
+        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
+      }
+      if (0 !== (workInProgress.flags & 128))
+        return (
+          (workInProgress.lanes = renderLanes),
+          0 !== (workInProgress.mode & 2) &&
+            transferActualDuration(workInProgress),
+          workInProgress
+        );
+      renderLanes = null !== newProps;
+      current = null !== current && null !== current.memoizedState;
+      if (renderLanes) {
+        newProps = workInProgress.child;
+        type = null;
+        null !== newProps.alternate &&
+          null !== newProps.alternate.memoizedState &&
+          null !== newProps.alternate.memoizedState.cachePool &&
+          (type = newProps.alternate.memoizedState.cachePool.pool);
+        var cache$149 = null;
+        null !== newProps.memoizedState &&
+          null !== newProps.memoizedState.cachePool &&
+          (cache$149 = newProps.memoizedState.cachePool.pool);
+        cache$149 !== type && (newProps.flags |= 2048);
+      }
+      renderLanes !== current &&
+        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
+        renderLanes && (workInProgress.child.flags |= 8192));
+      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
+      null !== workInProgress.updateQueue &&
+        null != workInProgress.memoizedProps.suspenseCallback &&
+        (workInProgress.flags |= 4);
+      bubbleProperties(workInProgress);
+      0 !== (workInProgress.mode & 2) &&
+        renderLanes &&
+        ((current = workInProgress.child),
+        null !== current &&
+          (workInProgress.treeBaseDuration -= current.treeBaseDuration));
+      return null;
+    case 4:
+      return (
+        popHostContainer(),
+        null === current &&
+          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 10:
+      return (
+        popProvider(workInProgress.type._context),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 17:
+      return (
+        isContextProvider(workInProgress.type) && popContext(),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 19:
+      pop(suspenseStackCursor);
+      type = workInProgress.memoizedState;
+      if (null === type) return bubbleProperties(workInProgress), null;
+      newProps = 0 !== (workInProgress.flags & 128);
+      cache$149 = type.rendering;
+      if (null === cache$149)
+        if (newProps) cutOffTailIfNeeded(type, !1);
+        else {
+          if (
+            0 !== workInProgressRootExitStatus ||
+            (null !== current && 0 !== (current.flags & 128))
+          )
+            for (current = workInProgress.child; null !== current; ) {
+              cache$149 = findFirstSuspended(current);
+              if (null !== cache$149) {
+                workInProgress.flags |= 128;
+                cutOffTailIfNeeded(type, !1);
+                current = cache$149.updateQueue;
+                null !== current &&
+                  ((workInProgress.updateQueue = current),
+                  (workInProgress.flags |= 4));
+                workInProgress.subtreeFlags = 0;
+                current = renderLanes;
+                for (renderLanes = workInProgress.child; null !== renderLanes; )
+                  resetWorkInProgress(renderLanes, current),
+                    (renderLanes = renderLanes.sibling);
+                push(
+                  suspenseStackCursor,
+                  (suspenseStackCursor.current & 1) | 2
+                );
+                return workInProgress.child;
+              }
+              current = current.sibling;
+            }
+          null !== type.tail &&
+            now$1() > workInProgressRootRenderTargetTime &&
+            ((workInProgress.flags |= 128),
+            (newProps = !0),
+            cutOffTailIfNeeded(type, !1),
+            (workInProgress.lanes = 8388608));
+        }
+      else {
+        if (!newProps)
+          if (((current = findFirstSuspended(cache$149)), null !== current)) {
+            if (
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              (current = current.updateQueue),
+              null !== current &&
+                ((workInProgress.updateQueue = current),
+                (workInProgress.flags |= 4)),
+              cutOffTailIfNeeded(type, !0),
+              null === type.tail &&
+                "hidden" === type.tailMode &&
+                !cache$149.alternate &&
+                !isHydrating)
             )
-              ? updatePayload || (updatePayload = [])
-              : (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  null
-                ));
-    for (JSCompiler_inline_result in newProps) {
-      var nextProp = newProps[JSCompiler_inline_result];
-      lastStyle =
-        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
-      if (
-        newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        nextProp !== lastStyle &&
-        (null != nextProp || null != lastStyle)
-      )
-        if ("style" === JSCompiler_inline_result)
-          if (lastStyle) {
-            for (styleName in lastStyle)
-              !lastStyle.hasOwnProperty(styleName) ||
-                (nextProp && nextProp.hasOwnProperty(styleName)) ||
-                (type || (type = {}), (type[styleName] = ""));
-            for (styleName in nextProp)
-              nextProp.hasOwnProperty(styleName) &&
-                lastStyle[styleName] !== nextProp[styleName] &&
-                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+              return bubbleProperties(workInProgress), null;
           } else
-            type ||
-              (updatePayload || (updatePayload = []),
-              updatePayload.push(JSCompiler_inline_result, type)),
-              (type = nextProp);
-        else
-          "dangerouslySetInnerHTML" === JSCompiler_inline_result
-            ? ((nextProp = nextProp ? nextProp.__html : void 0),
-              (lastStyle = lastStyle ? lastStyle.__html : void 0),
-              null != nextProp &&
-                lastStyle !== nextProp &&
-                (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  nextProp
-                ))
-            : "children" === JSCompiler_inline_result
-            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
-              (updatePayload = updatePayload || []).push(
-                JSCompiler_inline_result,
-                "" + nextProp
-              )
-            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-              "suppressHydrationWarning" !== JSCompiler_inline_result &&
-              (registrationNameDependencies.hasOwnProperty(
-                JSCompiler_inline_result
-              )
-                ? (null != nextProp &&
-                    "onScroll" === JSCompiler_inline_result &&
-                    listenToNonDelegatedEvent("scroll", current),
-                  updatePayload ||
-                    lastStyle === nextProp ||
-                    (updatePayload = []))
-                : (updatePayload = updatePayload || []).push(
-                    JSCompiler_inline_result,
-                    nextProp
-                  ));
-    }
-    type && (updatePayload = updatePayload || []).push("style", type);
-    var JSCompiler_inline_result = updatePayload;
-    (workInProgress.updateQueue = JSCompiler_inline_result) &&
-      markUpdate(workInProgress);
+            2 * now$1() - type.renderingStartTime >
+              workInProgressRootRenderTargetTime &&
+              1073741824 !== renderLanes &&
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              cutOffTailIfNeeded(type, !1),
+              (workInProgress.lanes = 8388608));
+        type.isBackwards
+          ? ((cache$149.sibling = workInProgress.child),
+            (workInProgress.child = cache$149))
+          : ((current = type.last),
+            null !== current
+              ? (current.sibling = cache$149)
+              : (workInProgress.child = cache$149),
+            (type.last = cache$149));
+      }
+      if (null !== type.tail)
+        return (
+          (workInProgress = type.tail),
+          (type.rendering = workInProgress),
+          (type.tail = workInProgress.sibling),
+          (type.renderingStartTime = now$1()),
+          (workInProgress.sibling = null),
+          (current = suspenseStackCursor.current),
+          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
+          workInProgress
+        );
+      bubbleProperties(workInProgress);
+      return null;
+    case 21:
+      return (
+        null === current
+          ? ((current = {
+              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+              containsNode: containsNode,
+              getChildContextValues: getChildContextValues
+            }),
+            (workInProgress.stateNode = current),
+            (current[internalInstanceKey] = workInProgress),
+            null !== workInProgress.ref &&
+              (markRef(workInProgress), markUpdate(workInProgress)))
+          : (null !== workInProgress.ref && markUpdate(workInProgress),
+            current.ref !== workInProgress.ref && markRef(workInProgress)),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        (newProps = null !== workInProgress.memoizedState),
+        23 !== workInProgress.tag &&
+          (null !== current
+            ? (null !== current.memoizedState) !== newProps &&
+              (workInProgress.flags |= 8192)
+            : newProps && (workInProgress.flags |= 8192)),
+        newProps && 0 !== (workInProgress.mode & 1)
+          ? 0 !== (renderLanes & 1073741824) &&
+            0 === (workInProgress.flags & 128) &&
+            (bubbleProperties(workInProgress),
+            23 !== workInProgress.tag &&
+              workInProgress.subtreeFlags & 6 &&
+              (workInProgress.flags |= 8192))
+          : bubbleProperties(workInProgress),
+        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
+        (renderLanes = null),
+        null !== current &&
+          null !== current.memoizedState &&
+          null !== current.memoizedState.cachePool &&
+          (renderLanes = current.memoizedState.cachePool.pool),
+        (newProps = null),
+        null !== workInProgress.memoizedState &&
+          null !== workInProgress.memoizedState.cachePool &&
+          (newProps = workInProgress.memoizedState.cachePool.pool),
+        newProps !== renderLanes && (workInProgress.flags |= 2048),
+        popTransition(workInProgress, current),
+        null
+      );
+    case 24:
+      return (
+        (renderLanes = null),
+        null !== current && (renderLanes = current.memoizedState.cache),
+        workInProgress.memoizedState.cache !== renderLanes &&
+          (workInProgress.flags |= 2048),
+        popProvider(CacheContext),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 25:
+      return (
+        enableTransitionTracing &&
+          (null !== workInProgress.stateNode &&
+            enableTransitionTracing &&
+            pop(markerInstanceStack),
+          bubbleProperties(workInProgress)),
+        null
+      );
   }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (!isHydrating)
-    switch (renderState.tailMode) {
-      case "hidden":
-        hasRenderedATailFallback = renderState.tail;
-        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
-          null !== hasRenderedATailFallback.alternate &&
-            (lastTailNode = hasRenderedATailFallback),
-            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
-        null === lastTailNode
-          ? (renderState.tail = null)
-          : (lastTailNode.sibling = null);
-        break;
-      case "collapsed":
-        lastTailNode = renderState.tail;
-        for (var lastTailNode$148 = null; null !== lastTailNode; )
-          null !== lastTailNode.alternate && (lastTailNode$148 = lastTailNode),
-            (lastTailNode = lastTailNode.sibling);
-        null === lastTailNode$148
-          ? hasRenderedATailFallback || null === renderState.tail
-            ? (renderState.tail = null)
-            : (renderState.tail.sibling = null)
-          : (lastTailNode$148.sibling = null);
-    }
-}
-function bubbleProperties(completedWork) {
-  var didBailout =
-      null !== completedWork.alternate &&
-      completedWork.alternate.child === completedWork.child,
-    newChildLanes = 0,
-    subtreeFlags = 0;
-  if (didBailout)
-    if (0 !== (completedWork.mode & 2)) {
-      for (
-        var treeBaseDuration$150 = completedWork.selfBaseDuration,
-          child$151 = completedWork.child;
-        null !== child$151;
-
-      )
-        (newChildLanes |= child$151.lanes | child$151.childLanes),
-          (subtreeFlags |= child$151.subtreeFlags & 14680064),
-          (subtreeFlags |= child$151.flags & 14680064),
-          (treeBaseDuration$150 += child$151.treeBaseDuration),
-          (child$151 = child$151.sibling);
-      completedWork.treeBaseDuration = treeBaseDuration$150;
-    } else
-      for (
-        treeBaseDuration$150 = completedWork.child;
-        null !== treeBaseDuration$150;
-
-      )
-        (newChildLanes |=
-          treeBaseDuration$150.lanes | treeBaseDuration$150.childLanes),
-          (subtreeFlags |= treeBaseDuration$150.subtreeFlags & 14680064),
-          (subtreeFlags |= treeBaseDuration$150.flags & 14680064),
-          (treeBaseDuration$150.return = completedWork),
-          (treeBaseDuration$150 = treeBaseDuration$150.sibling);
-  else if (0 !== (completedWork.mode & 2)) {
-    treeBaseDuration$150 = completedWork.actualDuration;
-    child$151 = completedWork.selfBaseDuration;
-    for (var child = completedWork.child; null !== child; )
-      (newChildLanes |= child.lanes | child.childLanes),
-        (subtreeFlags |= child.subtreeFlags),
-        (subtreeFlags |= child.flags),
-        (treeBaseDuration$150 += child.actualDuration),
-        (child$151 += child.treeBaseDuration),
-        (child = child.sibling);
-    completedWork.actualDuration = treeBaseDuration$150;
-    completedWork.treeBaseDuration = child$151;
-  } else
-    for (
-      treeBaseDuration$150 = completedWork.child;
-      null !== treeBaseDuration$150;
-
-    )
-      (newChildLanes |=
-        treeBaseDuration$150.lanes | treeBaseDuration$150.childLanes),
-        (subtreeFlags |= treeBaseDuration$150.subtreeFlags),
-        (subtreeFlags |= treeBaseDuration$150.flags),
-        (treeBaseDuration$150.return = completedWork),
-        (treeBaseDuration$150 = treeBaseDuration$150.sibling);
-  completedWork.subtreeFlags |= subtreeFlags;
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
-}
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps;
+function unwindWork(current, workInProgress) {
   popTreeContext(workInProgress);
   switch (workInProgress.tag) {
-    case 2:
-    case 16:
-    case 15:
-    case 0:
-    case 11:
-    case 7:
-    case 8:
-    case 12:
-    case 9:
-    case 14:
-      return bubbleProperties(workInProgress), null;
     case 1:
       return (
         isContextProvider(workInProgress.type) && popContext(),
-        bubbleProperties(workInProgress),
-        null
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128),
+            0 !== (workInProgress.mode & 2) &&
+              transferActualDuration(workInProgress),
+            workInProgress)
+          : null
       );
     case 3:
-      renderLanes = workInProgress.stateNode;
-      enableTransitionTracing &&
-        null !== workInProgressTransitions &&
-        (workInProgress.flags |= 2048);
-      newProps = null;
-      null !== current && (newProps = current.memoizedState.cache);
-      workInProgress.memoizedState.cache !== newProps &&
-        (workInProgress.flags |= 2048);
-      popProvider(CacheContext);
-      enableTransitionTracing &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
-      enableTransitionTracing && pop(transitionStack);
-      popHostContainer();
-      pop(didPerformWorkStackCursor);
-      pop(contextStackCursor);
-      resetWorkInProgressVersions();
-      renderLanes.pendingContext &&
-        ((renderLanes.context = renderLanes.pendingContext),
-        (renderLanes.pendingContext = null));
-      if (null === current || null === current.child)
-        popHydrationState(workInProgress)
-          ? markUpdate(workInProgress)
-          : null === current ||
-            (current.memoizedState.isDehydrated &&
-              0 === (workInProgress.flags & 256)) ||
-            ((workInProgress.flags |= 1024),
-            null !== hydrationErrors &&
-              (queueRecoverableErrors(hydrationErrors),
-              (hydrationErrors = null)));
-      bubbleProperties(workInProgress);
-      enableTransitionTracing &&
-        0 !== (workInProgress.subtreeFlags & 8192) &&
-        (workInProgress.flags |= 2048);
-      return null;
-    case 26:
       return (
-        (current ? current.ref : null) !== workInProgress.ref &&
-          markRef(workInProgress),
-        null === current ||
-        current.memoizedState !== workInProgress.memoizedState
-          ? markUpdate(workInProgress)
-          : null === workInProgress.memoizedState &&
-            updateHostComponent(
-              current,
-              workInProgress,
-              workInProgress.type,
-              workInProgress.pendingProps
-            ),
-        bubbleProperties(workInProgress),
-        null
+        popProvider(CacheContext),
+        enableTransitionTracing &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        enableTransitionTracing && pop(transitionStack),
+        popHostContainer(),
+        pop(didPerformWorkStackCursor),
+        pop(contextStackCursor),
+        resetWorkInProgressVersions(),
+        (current = workInProgress.flags),
+        0 !== (current & 65536) && 0 === (current & 128)
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
       );
+    case 26:
     case 27:
-      popHostContext(workInProgress);
-      renderLanes = rootInstanceStackCursor.current;
-      var type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, type, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor$1.current;
-        popHydrationState(workInProgress)
-          ? prepareToHydrateHostInstance(workInProgress, current)
-          : ((workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              renderLanes
-            )),
-            markUpdate(workInProgress));
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
     case 5:
-      popHostContext(workInProgress);
-      renderLanes = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, renderLanes, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor$1.current;
-        if (popHydrationState(workInProgress))
-          prepareToHydrateHostInstance(workInProgress, current) &&
-            markUpdate(workInProgress);
-        else {
-          type = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
-          );
-          switch (current) {
-            case "http://www.w3.org/2000/svg":
-            case "http://www.w3.org/1998/Math/MathML":
-              current = type.createElementNS(current, renderLanes);
-              break;
-            default:
-              switch (renderLanes) {
-                case "svg":
-                  current = type.createElementNS(
-                    "http://www.w3.org/2000/svg",
-                    renderLanes
-                  );
-                  break;
-                case "math":
-                  current = type.createElementNS(
-                    "http://www.w3.org/1998/Math/MathML",
-                    renderLanes
-                  );
-                  break;
-                case "script":
-                  current = type.createElement("div");
-                  current.innerHTML = "<script>\x3c/script>";
-                  current = current.removeChild(current.firstChild);
-                  break;
-                case "select":
-                  current =
-                    "string" === typeof newProps.is
-                      ? type.createElement("select", { is: newProps.is })
-                      : type.createElement("select");
-                  newProps.multiple
-                    ? (current.multiple = !0)
-                    : newProps.size && (current.size = newProps.size);
-                  break;
-                default:
-                  current = createHTMLElement(renderLanes, newProps, type);
-              }
-          }
-          current[internalInstanceKey] = workInProgress;
-          current[internalPropsKey] = newProps;
-          a: for (type = workInProgress.child; null !== type; ) {
-            if (5 === type.tag || 6 === type.tag)
-              current.appendChild(type.stateNode);
-            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
-              type.child.return = type;
-              type = type.child;
-              continue;
-            }
-            if (type === workInProgress) break a;
-            for (; null === type.sibling; ) {
-              if (null === type.return || type.return === workInProgress)
-                break a;
-              type = type.return;
-            }
-            type.sibling.return = type.return;
-            type = type.sibling;
-          }
-          workInProgress.stateNode = current;
-          a: switch (
-            (setInitialProperties(current, renderLanes, newProps), renderLanes)
-          ) {
-            case "button":
-            case "input":
-            case "select":
-            case "textarea":
-              current = !!newProps.autoFocus;
-              break a;
-            case "img":
-              current = !0;
-              break a;
-            default:
-              current = !1;
-          }
-          current && markUpdate(workInProgress);
-        }
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        current.memoizedProps !== newProps && markUpdate(workInProgress);
-      else {
-        if ("string" !== typeof newProps && null === workInProgress.stateNode)
-          throw Error(formatProdErrorMessage(166));
-        current = rootInstanceStackCursor.current;
-        if (popHydrationState(workInProgress)) {
-          newProps = workInProgress.stateNode;
-          current = workInProgress.memoizedProps;
-          newProps[internalInstanceKey] = workInProgress;
-          if ((renderLanes = newProps.nodeValue !== current))
-            if (((type = hydrationParentFiber), null !== type))
-              switch (type.tag) {
-                case 3:
-                  newProps = newProps.nodeValue;
-                  normalizeMarkupForTextOrAttribute(current);
-                  normalizeMarkupForTextOrAttribute(newProps);
-                  break;
-                case 27:
-                case 5:
-                  !0 !== type.memoizedProps.suppressHydrationWarning &&
-                    ((newProps = newProps.nodeValue),
-                    normalizeMarkupForTextOrAttribute(current),
-                    normalizeMarkupForTextOrAttribute(newProps));
-              }
-          renderLanes && markUpdate(workInProgress);
-        } else
-          (current =
-            getOwnerDocumentFromRootContainer(current).createTextNode(
-              newProps
-            )),
-            (current[internalInstanceKey] = workInProgress),
-            (workInProgress.stateNode = current);
-      }
-      bubbleProperties(workInProgress);
-      return null;
+      return popHostContext(workInProgress), null;
     case 13:
       popSuspenseHandler(workInProgress);
-      newProps = workInProgress.memoizedState;
-      if (
-        null === current ||
-        (null !== current.memoizedState &&
-          null !== current.memoizedState.dehydrated)
-      ) {
-        if (
-          isHydrating &&
-          null !== nextHydratableInstance &&
-          0 !== (workInProgress.mode & 1) &&
-          0 === (workInProgress.flags & 128)
-        )
-          warnIfUnhydratedTailNodes(),
-            resetHydrationState(),
-            (workInProgress.flags |= 98560),
-            (type = !1);
-        else if (
-          ((type = popHydrationState(workInProgress)),
-          null !== newProps && null !== newProps.dehydrated)
-        ) {
-          if (null === current) {
-            if (!type) throw Error(formatProdErrorMessage(318));
-            type = workInProgress.memoizedState;
-            type = null !== type ? type.dehydrated : null;
-            if (!type) throw Error(formatProdErrorMessage(317));
-            type[internalInstanceKey] = workInProgress;
-            bubbleProperties(workInProgress);
-            0 !== (workInProgress.mode & 2) &&
-              null !== newProps &&
-              ((type = workInProgress.child),
-              null !== type &&
-                (workInProgress.treeBaseDuration -= type.treeBaseDuration));
-          } else
-            resetHydrationState(),
-              0 === (workInProgress.flags & 128) &&
-                (workInProgress.memoizedState = null),
-              (workInProgress.flags |= 4),
-              bubbleProperties(workInProgress),
-              0 !== (workInProgress.mode & 2) &&
-                null !== newProps &&
-                ((type = workInProgress.child),
-                null !== type &&
-                  (workInProgress.treeBaseDuration -= type.treeBaseDuration));
-          type = !1;
-        } else
-          null !== hydrationErrors &&
-            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
-            (type = !0);
-        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
+      current = workInProgress.memoizedState;
+      if (null !== current && null !== current.dehydrated) {
+        if (null === workInProgress.alternate)
+          throw Error(formatProdErrorMessage(340));
+        resetHydrationState();
       }
-      if (0 !== (workInProgress.flags & 128))
-        return (
-          (workInProgress.lanes = renderLanes),
+      current = workInProgress.flags;
+      return current & 65536
+        ? ((workInProgress.flags = (current & -65537) | 128),
           0 !== (workInProgress.mode & 2) &&
             transferActualDuration(workInProgress),
-          workInProgress
-        );
-      renderLanes = null !== newProps;
-      current = null !== current && null !== current.memoizedState;
-      if (renderLanes) {
-        newProps = workInProgress.child;
-        type = null;
-        null !== newProps.alternate &&
-          null !== newProps.alternate.memoizedState &&
-          null !== newProps.alternate.memoizedState.cachePool &&
-          (type = newProps.alternate.memoizedState.cachePool.pool);
-        var cache$164 = null;
-        null !== newProps.memoizedState &&
-          null !== newProps.memoizedState.cachePool &&
-          (cache$164 = newProps.memoizedState.cachePool.pool);
-        cache$164 !== type && (newProps.flags |= 2048);
-      }
-      renderLanes !== current &&
-        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
-        renderLanes && (workInProgress.child.flags |= 8192));
-      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
-      null !== workInProgress.updateQueue &&
-        null != workInProgress.memoizedProps.suspenseCallback &&
-        (workInProgress.flags |= 4);
-      bubbleProperties(workInProgress);
-      0 !== (workInProgress.mode & 2) &&
-        renderLanes &&
-        ((current = workInProgress.child),
-        null !== current &&
-          (workInProgress.treeBaseDuration -= current.treeBaseDuration));
-      return null;
+          workInProgress)
+        : null;
+    case 19:
+      return pop(suspenseStackCursor), null;
     case 4:
-      return (
-        popHostContainer(),
-        null === current &&
-          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
-        bubbleProperties(workInProgress),
-        null
-      );
+      return popHostContainer(), null;
     case 10:
-      return (
-        popProvider(workInProgress.type._context),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 17:
-      return (
-        isContextProvider(workInProgress.type) && popContext(),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 19:
-      pop(suspenseStackCursor);
-      type = workInProgress.memoizedState;
-      if (null === type) return bubbleProperties(workInProgress), null;
-      newProps = 0 !== (workInProgress.flags & 128);
-      cache$164 = type.rendering;
-      if (null === cache$164)
-        if (newProps) cutOffTailIfNeeded(type, !1);
-        else {
-          if (
-            0 !== workInProgressRootExitStatus ||
-            (null !== current && 0 !== (current.flags & 128))
-          )
-            for (current = workInProgress.child; null !== current; ) {
-              cache$164 = findFirstSuspended(current);
-              if (null !== cache$164) {
-                workInProgress.flags |= 128;
-                cutOffTailIfNeeded(type, !1);
-                current = cache$164.updateQueue;
-                null !== current &&
-                  ((workInProgress.updateQueue = current),
-                  (workInProgress.flags |= 4));
-                workInProgress.subtreeFlags = 0;
-                current = renderLanes;
-                for (renderLanes = workInProgress.child; null !== renderLanes; )
-                  resetWorkInProgress(renderLanes, current),
-                    (renderLanes = renderLanes.sibling);
-                push(
-                  suspenseStackCursor,
-                  (suspenseStackCursor.current & 1) | 2
-                );
-                return workInProgress.child;
-              }
-              current = current.sibling;
-            }
-          null !== type.tail &&
-            now$1() > workInProgressRootRenderTargetTime &&
-            ((workInProgress.flags |= 128),
-            (newProps = !0),
-            cutOffTailIfNeeded(type, !1),
-            (workInProgress.lanes = 8388608));
-        }
-      else {
-        if (!newProps)
-          if (((current = findFirstSuspended(cache$164)), null !== current)) {
-            if (
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              (current = current.updateQueue),
-              null !== current &&
-                ((workInProgress.updateQueue = current),
-                (workInProgress.flags |= 4)),
-              cutOffTailIfNeeded(type, !0),
-              null === type.tail &&
-                "hidden" === type.tailMode &&
-                !cache$164.alternate &&
-                !isHydrating)
-            )
-              return bubbleProperties(workInProgress), null;
-          } else
-            2 * now$1() - type.renderingStartTime >
-              workInProgressRootRenderTargetTime &&
-              1073741824 !== renderLanes &&
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              cutOffTailIfNeeded(type, !1),
-              (workInProgress.lanes = 8388608));
-        type.isBackwards
-          ? ((cache$164.sibling = workInProgress.child),
-            (workInProgress.child = cache$164))
-          : ((current = type.last),
-            null !== current
-              ? (current.sibling = cache$164)
-              : (workInProgress.child = cache$164),
-            (type.last = cache$164));
-      }
-      if (null !== type.tail)
-        return (
-          (workInProgress = type.tail),
-          (type.rendering = workInProgress),
-          (type.tail = workInProgress.sibling),
-          (type.renderingStartTime = now$1()),
-          (workInProgress.sibling = null),
-          (current = suspenseStackCursor.current),
-          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
-          workInProgress
-        );
-      bubbleProperties(workInProgress);
-      return null;
-    case 21:
-      return (
-        null === current
-          ? ((current = {
-              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-              containsNode: containsNode,
-              getChildContextValues: getChildContextValues
-            }),
-            (workInProgress.stateNode = current),
-            (current[internalInstanceKey] = workInProgress),
-            null !== workInProgress.ref &&
-              (markRef(workInProgress), markUpdate(workInProgress)))
-          : (null !== workInProgress.ref && markUpdate(workInProgress),
-            current.ref !== workInProgress.ref && markRef(workInProgress)),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        (newProps = null !== workInProgress.memoizedState),
-        23 !== workInProgress.tag &&
-          (null !== current
-            ? (null !== current.memoizedState) !== newProps &&
-              (workInProgress.flags |= 8192)
-            : newProps && (workInProgress.flags |= 8192)),
-        newProps && 0 !== (workInProgress.mode & 1)
-          ? 0 !== (renderLanes & 1073741824) &&
-            0 === (workInProgress.flags & 128) &&
-            (bubbleProperties(workInProgress),
-            23 !== workInProgress.tag &&
-              workInProgress.subtreeFlags & 6 &&
-              (workInProgress.flags |= 8192))
-          : bubbleProperties(workInProgress),
-        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
-        (renderLanes = null),
-        null !== current &&
-          null !== current.memoizedState &&
-          null !== current.memoizedState.cachePool &&
-          (renderLanes = current.memoizedState.cachePool.pool),
-        (newProps = null),
-        null !== workInProgress.memoizedState &&
-          null !== workInProgress.memoizedState.cachePool &&
-          (newProps = workInProgress.memoizedState.cachePool.pool),
-        newProps !== renderLanes && (workInProgress.flags |= 2048),
-        popTransition(workInProgress, current),
-        null
-      );
-    case 24:
-      return (
-        (renderLanes = null),
-        null !== current && (renderLanes = current.memoizedState.cache),
-        workInProgress.memoizedState.cache !== renderLanes &&
-          (workInProgress.flags |= 2048),
-        popProvider(CacheContext),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 25:
-      return (
-        enableTransitionTracing &&
-          (null !== workInProgress.stateNode &&
-            enableTransitionTracing &&
-            pop(markerInstanceStack),
-          bubbleProperties(workInProgress)),
-        null
-      );
-  }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
-}
-function unwindWork(current, workInProgress) {
-  popTreeContext(workInProgress);
-  switch (workInProgress.tag) {
-    case 1:
-      return (
-        isContextProvider(workInProgress.type) && popContext(),
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128),
-            0 !== (workInProgress.mode & 2) &&
-              transferActualDuration(workInProgress),
-            workInProgress)
-          : null
-      );
-    case 3:
-      return (
-        popProvider(CacheContext),
-        enableTransitionTracing &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        enableTransitionTracing && pop(transitionStack),
-        popHostContainer(),
-        pop(didPerformWorkStackCursor),
-        pop(contextStackCursor),
-        resetWorkInProgressVersions(),
-        (current = workInProgress.flags),
-        0 !== (current & 65536) && 0 === (current & 128)
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 26:
-    case 27:
-    case 5:
-      return popHostContext(workInProgress), null;
-    case 13:
-      popSuspenseHandler(workInProgress);
-      current = workInProgress.memoizedState;
-      if (null !== current && null !== current.dehydrated) {
-        if (null === workInProgress.alternate)
-          throw Error(formatProdErrorMessage(340));
-        resetHydrationState();
-      }
-      current = workInProgress.flags;
-      return current & 65536
-        ? ((workInProgress.flags = (current & -65537) | 128),
-          0 !== (workInProgress.mode & 2) &&
-            transferActualDuration(workInProgress),
-          workInProgress)
-        : null;
-    case 19:
-      return pop(suspenseStackCursor), null;
-    case 4:
-      return popHostContainer(), null;
-    case 10:
-      return popProvider(workInProgress.type._context), null;
-    case 22:
-    case 23:
+      return popProvider(workInProgress.type._context), null;
+    case 22:
+    case 23:
       return (
         popSuspenseHandler(workInProgress),
         popHiddenContext(),
@@ -10964,29 +8763,71 @@ function unwindInterruptedWork(current, interruptedWork) {
         pop(markerInstanceStack);
   }
 }
-var offscreenSubtreeIsHidden = !1,
-  offscreenSubtreeWasHidden = !1,
-  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
-  nextEffect = null,
-  inProgressLanes = null,
-  inProgressRoot = null;
-function shouldProfile(current) {
-  return 0 !== (current.mode & 2) && 0 !== (executionContext & 4);
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
+if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
+  throw Error(formatProdErrorMessage(255));
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
 }
-function callComponentWillUnmountWithTimer(current, instance) {
-  instance.props = current.memoizedProps;
-  instance.state = current.memoizedState;
-  if (shouldProfile(current))
-    try {
-      startLayoutEffectTimer(), instance.componentWillUnmount();
-    } finally {
-      recordLayoutEffectDuration(current);
+var hasError = !1,
+  caughtError = null,
+  hasRethrowError = !1,
+  rethrowError = null,
+  reporter = {
+    onError: function (error) {
+      hasError = !0;
+      caughtError = error;
     }
-  else instance.componentWillUnmount();
+  };
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = !1;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
 }
-function safelyAttachRef(current, nearestMountedAncestor) {
-  try {
-    var ref = current.ref;
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
+) {
+  invokeGuardedCallback.apply(this, arguments);
+  if (hasError) {
+    if (hasError) {
+      var error = caughtError;
+      hasError = !1;
+      caughtError = null;
+    } else throw Error(formatProdErrorMessage(198));
+    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
+  }
+}
+var offscreenSubtreeIsHidden = !1,
+  offscreenSubtreeWasHidden = !1,
+  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+  nextEffect = null,
+  inProgressLanes = null,
+  inProgressRoot = null;
+function shouldProfile(current) {
+  return 0 !== (current.mode & 2) && 0 !== (executionContext & 4);
+}
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+  if (shouldProfile(current))
+    try {
+      startLayoutEffectTimer(), instance.componentWillUnmount();
+    } finally {
+      recordLayoutEffectDuration(current);
+    }
+  else instance.componentWillUnmount();
+}
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    var ref = current.ref;
     if (null !== ref) {
       var instance = current.stateNode;
       switch (current.tag) {
@@ -11042,8 +8883,8 @@ function safelyDetachRef(current, nearestMountedAncestor) {
             recordLayoutEffectDuration(current);
           }
         else ref(null);
-      } catch (error$180) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error$180);
+      } catch (error$165) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$165);
       }
     else ref.current = null;
 }
@@ -11341,11 +9182,11 @@ function commitPassiveEffectDurations(finishedRoot, finishedWork) {
         var _finishedWork$memoize = finishedWork.memoizedProps,
           id = _finishedWork$memoize.id;
         _finishedWork$memoize = _finishedWork$memoize.onPostCommit;
-        var commitTime$182 = commitTime,
+        var commitTime$167 = commitTime,
           phase = null === finishedWork.alternate ? "mount" : "update";
         currentUpdateIsNested && (phase = "nested-update");
         "function" === typeof _finishedWork$memoize &&
-          _finishedWork$memoize(id, phase, finishedRoot, commitTime$182);
+          _finishedWork$memoize(id, phase, finishedRoot, commitTime$167);
         finishedWork = finishedWork.return;
         a: for (; null !== finishedWork; ) {
           switch (finishedWork.tag) {
@@ -11372,8 +9213,8 @@ function commitHookLayoutEffects(finishedWork, hookFlags) {
   } else
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error$184) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error$184);
+    } catch (error$169) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error$169);
     }
 }
 function commitClassCallbacks(finishedWork) {
@@ -11472,11 +9313,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
           } else
             try {
               finishedRoot.componentDidMount();
-            } catch (error$185) {
+            } catch (error$170) {
               captureCommitPhaseError(
                 finishedWork,
                 finishedWork.return,
-                error$185
+                error$170
               );
             }
         else {
@@ -11493,11 +9334,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
                   current,
                   finishedRoot.__reactInternalSnapshotBeforeUpdate
                 );
-            } catch (error$186) {
+            } catch (error$171) {
               captureCommitPhaseError(
                 finishedWork,
                 finishedWork.return,
-                error$186
+                error$171
               );
             }
             recordLayoutEffectDuration(finishedWork);
@@ -11508,11 +9349,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
                 current,
                 finishedRoot.__reactInternalSnapshotBeforeUpdate
               );
-            } catch (error$187) {
+            } catch (error$172) {
               captureCommitPhaseError(
                 finishedWork,
                 finishedWork.return,
-                error$187
+                error$172
               );
             }
         }
@@ -12211,22 +10052,22 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
           try {
             startLayoutEffectTimer(),
               commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-          } catch (error$202) {
+          } catch (error$187) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$202
+              error$187
             );
           }
           recordLayoutEffectDuration(finishedWork);
         } else
           try {
             commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-          } catch (error$203) {
+          } catch (error$188) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$203
+              error$188
             );
           }
       }
@@ -12405,11 +10246,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               newProps
             );
             domElement[internalPropsKey] = newProps;
-          } catch (error$204) {
+          } catch (error$189) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$204
+              error$189
             );
           }
       break;
@@ -12445,8 +10286,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         root = finishedWork.stateNode;
         try {
           setTextContent(root, "");
-        } catch (error$205) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$205);
+        } catch (error$190) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$190);
         }
       }
       if (
@@ -12463,8 +10304,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         try {
           updateProperties(flags, maybeNodes, hoistableRoot, current, root),
             (flags[internalPropsKey] = root);
-        } catch (error$208) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$208);
+        } catch (error$193) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$193);
         }
       break;
     case 6:
@@ -12477,8 +10318,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         flags = finishedWork.memoizedProps;
         try {
           current.nodeValue = flags;
-        } catch (error$209) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$209);
+        } catch (error$194) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$194);
         }
       }
       break;
@@ -12492,8 +10333,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
       if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
         try {
           retryIfBlockedOn(root.containerInfo);
-        } catch (error$210) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$210);
+        } catch (error$195) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$195);
         }
       break;
     case 4:
@@ -12523,8 +10364,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               null !== wakeables && suspenseCallback(new Set(wakeables));
             }
           }
-        } catch (error$212) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$212);
+        } catch (error$197) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$197);
         }
         current = finishedWork.updateQueue;
         null !== current &&
@@ -12602,11 +10443,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
             if (null === current)
               try {
                 root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
-              } catch (error$192) {
+              } catch (error$177) {
                 captureCommitPhaseError(
                   finishedWork,
                   finishedWork.return,
-                  error$192
+                  error$177
                 );
               }
           } else if (
@@ -12681,21 +10522,21 @@ function commitReconciliationEffects(finishedWork) {
             insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
             break;
           case 5:
-            var parent$193 = JSCompiler_inline_result.stateNode;
+            var parent$178 = JSCompiler_inline_result.stateNode;
             JSCompiler_inline_result.flags & 32 &&
-              (setTextContent(parent$193, ""),
+              (setTextContent(parent$178, ""),
               (JSCompiler_inline_result.flags &= -33));
-            var before$194 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before$194, parent$193);
+            var before$179 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before$179, parent$178);
             break;
           case 3:
           case 4:
-            var parent$195 = JSCompiler_inline_result.stateNode.containerInfo,
-              before$196 = getHostSibling(finishedWork);
+            var parent$180 = JSCompiler_inline_result.stateNode.containerInfo,
+              before$181 = getHostSibling(finishedWork);
             insertOrAppendPlacementNodeIntoContainer(
               finishedWork,
-              before$196,
-              parent$195
+              before$181,
+              parent$180
             );
             break;
           default:
@@ -12887,8 +10728,8 @@ function commitHookPassiveMountEffects(finishedWork, hookFlags) {
   } else
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error$218) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error$218);
+    } catch (error$203) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error$203);
     }
 }
 function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
@@ -13187,9 +11028,9 @@ function recursivelyTraverseReconnectPassiveEffects(
           );
         break;
       case 22:
-        var instance$223 = finishedWork.stateNode;
+        var instance$208 = finishedWork.stateNode;
         null !== finishedWork.memoizedState
-          ? instance$223._visibility & 4
+          ? instance$208._visibility & 4
             ? recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -13202,7 +11043,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork
               )
-            : ((instance$223._visibility |= 4),
+            : ((instance$208._visibility |= 4),
               recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -13210,7 +11051,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 committedTransitions,
                 includeWorkInProgressEffects
               ))
-          : ((instance$223._visibility |= 4),
+          : ((instance$208._visibility |= 4),
             recursivelyTraverseReconnectPassiveEffects(
               finishedRoot,
               finishedWork,
@@ -13223,7 +11064,7 @@ function recursivelyTraverseReconnectPassiveEffects(
           commitOffscreenPassiveMountEffects(
             finishedWork.alternate,
             finishedWork,
-            instance$223
+            instance$208
           );
         break;
       case 24:
@@ -13532,7 +11373,7 @@ var ceil = Math.ceil,
   ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
   ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
   ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
   executionContext = 0,
   workInProgressRoot = null,
   workInProgress = null,
@@ -13614,2610 +11455,4839 @@ function addTransitionProgressCallbackToPendingTransition(
       boundaries
     ));
 }
-function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now$1() + 500;
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now$1() + 500;
+}
+var hasUncaughtError = !1,
+  firstUncaughtError = null,
+  legacyErrorBoundariesThatAlreadyFailed = null,
+  rootCommittingMutationOrLayoutEffects = null,
+  rootDoesHavePassiveEffects = !1,
+  rootWithPendingPassiveEffects = null,
+  pendingPassiveEffectsLanes = 0,
+  pendingPassiveProfilerEffects = [],
+  pendingPassiveEffectsRemainingLanes = 0,
+  pendingPassiveTransitions = null,
+  nestedUpdateCount = 0,
+  rootWithNestedUpdates = null,
+  currentEventTime = -1,
+  currentEventTransitionLane = 0;
+function requestEventTime() {
+  return 0 !== (executionContext & 6)
+    ? now$1()
+    : -1 !== currentEventTime
+    ? currentEventTime
+    : (currentEventTime = now$1());
+}
+function requestUpdateLane(fiber) {
+  if (0 === (fiber.mode & 1)) return 2;
+  if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    0 !== (executionContext & 2) &&
+    0 !== workInProgressRootRenderLanes
+  )
+    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
+  if (null !== ReactCurrentBatchConfig$2.transition)
+    return (
+      0 === currentEventTransitionLane &&
+        (currentEventTransitionLane = claimNextTransitionLane()),
+      currentEventTransitionLane
+    );
+  fiber = currentUpdatePriority;
+  if (0 !== fiber) return fiber;
+  fiber = window.event;
+  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
+  return fiber;
+}
+function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+  2 === workInProgressSuspendedReason &&
+    root === workInProgressRoot &&
+    (prepareFreshStack(root, 0),
+    markRootSuspended(root, workInProgressRootRenderLanes));
+  markRootUpdated(root, lane, eventTime);
+  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
+    isDevToolsPresent && addFiberToLanesMap(root, fiber, lane);
+    if (
+      enableProfilerNestedUpdateScheduledHook &&
+      0 !== (executionContext & 4) &&
+      root === rootCommittingMutationOrLayoutEffects &&
+      fiber.mode & 2
+    )
+      for (var current = fiber; null !== current; ) {
+        if (12 === current.tag) {
+          var _current$memoizedProp = current.memoizedProps,
+            id = _current$memoizedProp.id;
+          _current$memoizedProp = _current$memoizedProp.onNestedUpdateScheduled;
+          "function" === typeof _current$memoizedProp &&
+            _current$memoizedProp(id);
+        }
+        current = current.return;
+      }
+    if (
+      enableTransitionTracing &&
+      ((current = ReactCurrentBatchConfig$1.transition),
+      null !== current &&
+        null != current.name &&
+        (-1 === current.startTime && (current.startTime = now$1()),
+        enableTransitionTracing))
+    ) {
+      id = root.transitionLanes;
+      _current$memoizedProp = 31 - clz32(lane);
+      var transitions = id[_current$memoizedProp];
+      null === transitions && (transitions = new Set());
+      transitions.add(current);
+      id[_current$memoizedProp] = transitions;
+    }
+    if (root === workInProgressRoot) {
+      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
+        workInProgressRootInterleavedUpdatedLanes |= lane;
+      4 === workInProgressRootExitStatus &&
+        markRootSuspended(root, workInProgressRootRenderLanes);
+    }
+    ensureRootIsScheduled(root, eventTime);
+    2 === lane &&
+      0 === executionContext &&
+      0 === (fiber.mode & 1) &&
+      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
+  }
+}
+function ensureRootIsScheduled(root, currentTime) {
+  var existingCallbackNode = root.callbackNode;
+  markStarvedLanesAsExpired(root, currentTime);
+  var nextLanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+  );
+  if (0 === nextLanes)
+    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
+      (root.callbackNode = null),
+      (root.callbackPriority = 0);
+  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
+    (root.callbackPriority = 0), (root.callbackNode = null);
+  else if (
+    ((currentTime = nextLanes & -nextLanes),
+    root.callbackPriority !== currentTime)
+  ) {
+    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
+    if (0 !== (currentTime & 3))
+      0 === root.tag
+        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
+        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
+        scheduleMicrotask(function () {
+          0 === (executionContext & 6) && flushSyncCallbacks();
+        }),
+        (existingCallbackNode = null);
+    else {
+      switch (lanesToEventPriority(nextLanes)) {
+        case 2:
+          existingCallbackNode = ImmediatePriority;
+          break;
+        case 8:
+          existingCallbackNode = UserBlockingPriority;
+          break;
+        case 32:
+          existingCallbackNode = NormalPriority$1;
+          break;
+        case 536870912:
+          existingCallbackNode = IdlePriority;
+          break;
+        default:
+          existingCallbackNode = NormalPriority$1;
+      }
+      existingCallbackNode = scheduleCallback(
+        existingCallbackNode,
+        performConcurrentWorkOnRoot.bind(null, root)
+      );
+    }
+    root.callbackPriority = currentTime;
+    root.callbackNode = existingCallbackNode;
+  }
+}
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  nestedUpdateScheduled = currentUpdateIsNested = !1;
+  currentEventTime = -1;
+  currentEventTransitionLane = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var originalCallbackNode = root.callbackNode;
+  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
+    return null;
+  var lanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+  );
+  if (0 === lanes) return null;
+  didTimeout =
+    includesBlockingLane(root, lanes) ||
+    0 !== (lanes & root.expiredLanes) ||
+    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
+      ? renderRootSync(root, lanes)
+      : renderRootConcurrent(root, lanes);
+  if (0 !== didTimeout) {
+    if (2 === didTimeout) {
+      var originallyAttemptedLanes = lanes,
+        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+          root,
+          originallyAttemptedLanes
+        );
+      0 !== errorRetryLanes &&
+        ((lanes = errorRetryLanes),
+        (didTimeout = recoverFromConcurrentError(
+          root,
+          originallyAttemptedLanes,
+          errorRetryLanes
+        )));
+    }
+    if (1 === didTimeout)
+      throw (
+        ((originalCallbackNode = workInProgressRootFatalError),
+        prepareFreshStack(root, 0),
+        markRootSuspended(root, lanes),
+        ensureRootIsScheduled(root, now$1()),
+        originalCallbackNode)
+      );
+    if (6 === didTimeout) markRootSuspended(root, lanes);
+    else {
+      errorRetryLanes = !includesBlockingLane(root, lanes);
+      originallyAttemptedLanes = root.current.alternate;
+      if (
+        errorRetryLanes &&
+        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
+      ) {
+        didTimeout = renderRootSync(root, lanes);
+        if (2 === didTimeout) {
+          errorRetryLanes = lanes;
+          var errorRetryLanes$217 = getLanesToRetrySynchronouslyOnError(
+            root,
+            errorRetryLanes
+          );
+          0 !== errorRetryLanes$217 &&
+            ((lanes = errorRetryLanes$217),
+            (didTimeout = recoverFromConcurrentError(
+              root,
+              errorRetryLanes,
+              errorRetryLanes$217
+            )));
+        }
+        if (1 === didTimeout)
+          throw (
+            ((originalCallbackNode = workInProgressRootFatalError),
+            prepareFreshStack(root, 0),
+            markRootSuspended(root, lanes),
+            ensureRootIsScheduled(root, now$1()),
+            originalCallbackNode)
+          );
+      }
+      root.finishedWork = originallyAttemptedLanes;
+      root.finishedLanes = lanes;
+      switch (didTimeout) {
+        case 0:
+        case 1:
+          throw Error(formatProdErrorMessage(345));
+        case 2:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 3:
+          markRootSuspended(root, lanes);
+          if (
+            (lanes & 125829120) === lanes &&
+            ((lanes = globalMostRecentFallbackTime + 500 - now$1()), 10 < lanes)
+          ) {
+            if (0 !== getNextLanes(root, 0)) break;
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
+            );
+            break;
+          }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 4:
+          markRootSuspended(root, lanes);
+          if ((lanes & 8388480) === lanes) break;
+          didTimeout = root.eventTimes;
+          for (originallyAttemptedLanes = -1; 0 < lanes; )
+            (errorRetryLanes$217 = 31 - clz32(lanes)),
+              (errorRetryLanes = 1 << errorRetryLanes$217),
+              (errorRetryLanes$217 = didTimeout[errorRetryLanes$217]),
+              errorRetryLanes$217 > originallyAttemptedLanes &&
+                (originallyAttemptedLanes = errorRetryLanes$217),
+              (lanes &= ~errorRetryLanes);
+          lanes = originallyAttemptedLanes;
+          lanes = now$1() - lanes;
+          lanes =
+            (120 > lanes
+              ? 120
+              : 480 > lanes
+              ? 480
+              : 1080 > lanes
+              ? 1080
+              : 1920 > lanes
+              ? 1920
+              : 3e3 > lanes
+              ? 3e3
+              : 4320 > lanes
+              ? 4320
+              : 1960 * ceil(lanes / 1960)) - lanes;
+          if (10 < lanes) {
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
+            );
+            break;
+          }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 5:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        default:
+          throw Error(formatProdErrorMessage(329));
+      }
+    }
+  }
+  ensureRootIsScheduled(root, now$1());
+  return root.callbackNode === originalCallbackNode
+    ? performConcurrentWorkOnRoot.bind(null, root)
+    : null;
+}
+function recoverFromConcurrentError(
+  root,
+  originallyAttemptedLanes,
+  errorRetryLanes
+) {
+  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
+    wasRootDehydrated = root.current.memoizedState.isDehydrated;
+  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
+  errorRetryLanes = renderRootSync(root, errorRetryLanes);
+  if (2 !== errorRetryLanes) {
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
+      return (
+        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
+        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
+        4
+      );
+    root = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
+    null !== root && queueRecoverableErrors(root);
+  }
+  return errorRetryLanes;
+}
+function queueRecoverableErrors(errors) {
+  null === workInProgressRootRecoverableErrors
+    ? (workInProgressRootRecoverableErrors = errors)
+    : workInProgressRootRecoverableErrors.push.apply(
+        workInProgressRootRecoverableErrors,
+        errors
+      );
+}
+function isRenderConsistentWithExternalStores(finishedWork) {
+  for (var node = finishedWork; ; ) {
+    if (node.flags & 16384) {
+      var updateQueue = node.updateQueue;
+      if (
+        null !== updateQueue &&
+        ((updateQueue = updateQueue.stores), null !== updateQueue)
+      )
+        for (var i = 0; i < updateQueue.length; i++) {
+          var check = updateQueue[i],
+            getSnapshot = check.getSnapshot;
+          check = check.value;
+          try {
+            if (!objectIs(getSnapshot(), check)) return !1;
+          } catch (error) {
+            return !1;
+          }
+        }
+    }
+    updateQueue = node.child;
+    if (node.subtreeFlags & 16384 && null !== updateQueue)
+      (updateQueue.return = node), (node = updateQueue);
+    else {
+      if (node === finishedWork) break;
+      for (; null === node.sibling; ) {
+        if (null === node.return || node.return === finishedWork) return !0;
+        node = node.return;
+      }
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+  return !0;
+}
+function markRootSuspended(root, suspendedLanes) {
+  suspendedLanes &= ~workInProgressRootPingedLanes;
+  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes;
+  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
+    var index$14 = 31 - clz32(suspendedLanes),
+      lane = 1 << index$14;
+    root[index$14] = -1;
+    suspendedLanes &= ~lane;
+  }
+}
+function performSyncWorkOnRoot(root) {
+  currentUpdateIsNested = nestedUpdateScheduled;
+  nestedUpdateScheduled = !1;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  flushPassiveEffects();
+  var lanes = getNextLanes(root, 0);
+  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now$1()), null;
+  var exitStatus = renderRootSync(root, lanes);
+  if (0 !== root.tag && 2 === exitStatus) {
+    var originallyAttemptedLanes = lanes,
+      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+        root,
+        originallyAttemptedLanes
+      );
+    0 !== errorRetryLanes &&
+      ((lanes = errorRetryLanes),
+      (exitStatus = recoverFromConcurrentError(
+        root,
+        originallyAttemptedLanes,
+        errorRetryLanes
+      )));
+  }
+  if (1 === exitStatus)
+    throw (
+      ((exitStatus = workInProgressRootFatalError),
+      prepareFreshStack(root, 0),
+      markRootSuspended(root, lanes),
+      ensureRootIsScheduled(root, now$1()),
+      exitStatus)
+    );
+  if (6 === exitStatus)
+    return (
+      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now$1()), null
+    );
+  root.finishedWork = root.current.alternate;
+  root.finishedLanes = lanes;
+  commitRoot(
+    root,
+    workInProgressRootRecoverableErrors,
+    workInProgressTransitions
+  );
+  ensureRootIsScheduled(root, now$1());
+  return null;
+}
+function batchedUpdates$1(fn, a) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  try {
+    return fn(a);
+  } finally {
+    (executionContext = prevExecutionContext),
+      0 === executionContext &&
+        (resetRenderTimer(),
+        includesLegacySyncCallbacks && flushSyncCallbacks());
+  }
+}
+function flushSync$1(fn) {
+  null !== rootWithPendingPassiveEffects &&
+    0 === rootWithPendingPassiveEffects.tag &&
+    0 === (executionContext & 6) &&
+    flushPassiveEffects();
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
+    previousPriority = currentUpdatePriority;
+  try {
+    if (
+      ((ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      fn)
+    )
+      return fn();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (executionContext = prevExecutionContext),
+      0 === (executionContext & 6) && flushSyncCallbacks();
+  }
+}
+function resetWorkInProgressStack() {
+  if (null !== workInProgress) {
+    if (0 === workInProgressSuspendedReason)
+      var interruptedWork = workInProgress.return;
+    else
+      resetContextDependencies(),
+        resetHooksOnUnwind(),
+        (thenableState$1 = null),
+        (thenableIndexCounter$1 = 0),
+        (interruptedWork = workInProgress);
+    for (; null !== interruptedWork; )
+      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
+        (interruptedWork = interruptedWork.return);
+    workInProgress = null;
+  }
+}
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  var timeoutHandle = root.timeoutHandle;
+  -1 !== timeoutHandle &&
+    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  workInProgress = root = createWorkInProgress(root.current, null);
+  workInProgressRootRenderLanes = renderLanes = lanes;
+  workInProgressSuspendedReason = 0;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = !1;
+  workInProgressRootExitStatus = 0;
+  workInProgressRootFatalError = null;
+  workInProgressRootPingedLanes =
+    workInProgressRootInterleavedUpdatedLanes =
+    workInProgressRootSkippedLanes =
+      0;
+  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
+    null;
+  finishQueueingConcurrentUpdates();
+  return root;
+}
+function handleThrow(root, thrownValue) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  ReactCurrentOwner.current = null;
+  if (thrownValue === SuspenseException) {
+    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
+    thrownValue = suspendedThenable;
+    suspendedThenable = null;
+    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
+      ? 2
+      : 3;
+  } else
+    workInProgressSuspendedReason =
+      thrownValue === SelectiveHydrationException
+        ? 6
+        : null !== thrownValue &&
+          "object" === typeof thrownValue &&
+          "function" === typeof thrownValue.then
+        ? 4
+        : 1;
+  workInProgressThrownValue = thrownValue;
+  root = workInProgress;
+  if (null === root)
+    (workInProgressRootExitStatus = 1),
+      (workInProgressRootFatalError = thrownValue);
+  else if (
+    (root.mode & 2 && stopProfilerTimerIfRunningAndRecordDelta(root, !0),
+    enableSchedulingProfiler)
+  )
+    switch ((markComponentRenderStopped(), workInProgressSuspendedReason)) {
+      case 1:
+        enableSchedulingProfiler &&
+          null !== injectedProfilingHooks &&
+          "function" === typeof injectedProfilingHooks.markComponentErrored &&
+          injectedProfilingHooks.markComponentErrored(
+            root,
+            thrownValue,
+            workInProgressRootRenderLanes
+          );
+        break;
+      case 2:
+      case 3:
+      case 4:
+      case 5:
+        enableSchedulingProfiler &&
+          null !== injectedProfilingHooks &&
+          "function" === typeof injectedProfilingHooks.markComponentSuspended &&
+          injectedProfilingHooks.markComponentSuspended(
+            root,
+            thrownValue,
+            workInProgressRootRenderLanes
+          );
+    }
+}
+function shouldAttemptToSuspendUntilDataResolves() {
+  if (
+    0 !== (workInProgressRootSkippedLanes & 268435455) ||
+    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
+  )
+    return !1;
+  if (
+    (workInProgressRootRenderLanes & 8388480) ===
+    workInProgressRootRenderLanes
+  )
+    return null === shellBoundary;
+  var handler = suspenseHandlerStackCursor.current;
+  return null !== handler &&
+    (workInProgressRootRenderLanes & 125829120) ===
+      workInProgressRootRenderLanes
+    ? handler === shellBoundary
+    : !1;
+}
+function pushDispatcher(container) {
+  container = getHoistableRoot(container);
+  lastCurrentDocument = container.ownerDocument || container;
+  previousDispatcher = Dispatcher$1.current;
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  container = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+  return null === container ? ContextOnlyDispatcher : container;
+}
+function pushCacheDispatcher() {
+  var prevCacheDispatcher = ReactCurrentCache.current;
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  return prevCacheDispatcher;
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = 4;
+  null === workInProgressRoot ||
+    (0 === (workInProgressRootSkippedLanes & 268435455) &&
+      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+}
+function renderRootSync(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    if (isDevToolsPresent) {
+      var memoizedUpdaters = root.memoizedUpdaters;
+      0 < memoizedUpdaters.size &&
+        (restorePendingUpdaters(root, workInProgressRootRenderLanes),
+        memoizedUpdaters.clear());
+      movePendingFibersToMemoized(root, lanes);
+    }
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    prepareFreshStack(root, lanes);
+  }
+  enableSchedulingProfiler && markRenderStarted(lanes);
+  a: do
+    try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress)
+        switch (
+          ((lanes = workInProgress),
+          (memoizedUpdaters = workInProgressThrownValue),
+          workInProgressSuspendedReason)
+        ) {
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            (workInProgressSuspendedReason = 0),
+              (workInProgressThrownValue = null),
+              unwindSuspendedUnitOfWork(lanes, memoizedUpdaters);
+        }
+      workLoopSync();
+      break;
+    } catch (thrownValue$220) {
+      handleThrow(root, thrownValue$220);
+    }
+  while (1);
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
+  enableSchedulingProfiler && markRenderStopped();
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+}
+function workLoopSync() {
+  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+}
+function renderRootConcurrent(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    if (isDevToolsPresent) {
+      var memoizedUpdaters = root.memoizedUpdaters;
+      0 < memoizedUpdaters.size &&
+        (restorePendingUpdaters(root, workInProgressRootRenderLanes),
+        memoizedUpdaters.clear());
+      movePendingFibersToMemoized(root, lanes);
+    }
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
+  enableSchedulingProfiler && markRenderStarted(lanes);
+  a: do
+    try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress)
+        switch (
+          ((lanes = workInProgress),
+          (memoizedUpdaters = workInProgressThrownValue),
+          workInProgressSuspendedReason)
+        ) {
+          case 1:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, memoizedUpdaters);
+            break;
+          case 2:
+            if (isThenableResolved(memoizedUpdaters)) {
+              workInProgressSuspendedReason = 0;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
+            }
+            lanes = function () {
+              2 === workInProgressSuspendedReason &&
+                workInProgressRoot === root &&
+                (workInProgressSuspendedReason = 5);
+              ensureRootIsScheduled(root, now$1());
+            };
+            memoizedUpdaters.then(lanes, lanes);
+            break a;
+          case 3:
+            workInProgressSuspendedReason = 5;
+            break a;
+          case 5:
+            isThenableResolved(memoizedUpdaters)
+              ? ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                replaySuspendedUnitOfWork(lanes))
+              : ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                unwindSuspendedUnitOfWork(lanes, memoizedUpdaters));
+            break;
+          case 4:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, memoizedUpdaters);
+            break;
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            throw Error(formatProdErrorMessage(462));
+        }
+      workLoopConcurrent();
+      break;
+    } catch (thrownValue$222) {
+      handleThrow(root, thrownValue$222);
+    }
+  while (1);
+  resetContextDependencies();
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  executionContext = prevExecutionContext;
+  if (null !== workInProgress)
+    return (
+      enableSchedulingProfiler &&
+        enableSchedulingProfiler &&
+        null !== injectedProfilingHooks &&
+        "function" === typeof injectedProfilingHooks.markRenderYielded &&
+        injectedProfilingHooks.markRenderYielded(),
+      0
+    );
+  enableSchedulingProfiler && markRenderStopped();
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+}
+function workLoopConcurrent() {
+  for (; null !== workInProgress && !shouldYield(); )
+    performUnitOfWork(workInProgress);
+}
+function performUnitOfWork(unitOfWork) {
+  var current = unitOfWork.alternate;
+  0 !== (unitOfWork.mode & 2)
+    ? (startProfilerTimer(unitOfWork),
+      (current = beginWork(current, unitOfWork, renderLanes)),
+      stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, !0))
+    : (current = beginWork(current, unitOfWork, renderLanes));
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === current
+    ? completeUnitOfWork(unitOfWork)
+    : (workInProgress = current);
+  ReactCurrentOwner.current = null;
+}
+function replaySuspendedUnitOfWork(unitOfWork) {
+  var current = unitOfWork.alternate,
+    isProfilingMode = 0 !== (unitOfWork.mode & 2);
+  isProfilingMode && startProfilerTimer(unitOfWork);
+  switch (unitOfWork.tag) {
+    case 2:
+      unitOfWork.tag = 0;
+    case 0:
+    case 11:
+      var Component = unitOfWork.type,
+        unresolvedProps = unitOfWork.pendingProps;
+      unresolvedProps =
+        unitOfWork.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unresolvedProps,
+        Component,
+        workInProgressRootRenderLanes
+      );
+      break;
+    case 15:
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unitOfWork.pendingProps,
+        unitOfWork.type,
+        workInProgressRootRenderLanes
+      );
+      break;
+    default:
+      unwindInterruptedWork(current, unitOfWork),
+        (unitOfWork = workInProgress =
+          resetWorkInProgress(unitOfWork, renderLanes)),
+        (current = beginWork(current, unitOfWork, renderLanes));
+  }
+  isProfilingMode && stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, !0);
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === current
+    ? completeUnitOfWork(unitOfWork)
+    : (workInProgress = current);
+  ReactCurrentOwner.current = null;
+}
+function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
+  resetContextDependencies();
+  resetHooksOnUnwind();
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+  var returnFiber = unitOfWork.return;
+  if (null === returnFiber || null === workInProgressRoot)
+    (workInProgressRootExitStatus = 1),
+      (workInProgressRootFatalError = thrownValue),
+      (workInProgress = null);
+  else {
+    try {
+      a: {
+        var root = workInProgressRoot,
+          value = thrownValue;
+        thrownValue = workInProgressRootRenderLanes;
+        unitOfWork.flags |= 32768;
+        isDevToolsPresent && restorePendingUpdaters(root, thrownValue);
+        if (
+          null !== value &&
+          "object" === typeof value &&
+          "function" === typeof value.then
+        ) {
+          var wakeable = value;
+          if (enableLazyContextPropagation) {
+            var currentSourceFiber = unitOfWork.alternate;
+            null !== currentSourceFiber &&
+              propagateParentContextChanges(
+                currentSourceFiber,
+                unitOfWork,
+                thrownValue,
+                !0
+              );
+          }
+          var tag = unitOfWork.tag;
+          if (
+            0 === (unitOfWork.mode & 1) &&
+            (0 === tag || 11 === tag || 15 === tag)
+          ) {
+            var currentSource = unitOfWork.alternate;
+            currentSource
+              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
+                (unitOfWork.memoizedState = currentSource.memoizedState),
+                (unitOfWork.lanes = currentSource.lanes))
+              : ((unitOfWork.updateQueue = null),
+                (unitOfWork.memoizedState = null));
+          }
+          var suspenseBoundary = suspenseHandlerStackCursor.current;
+          if (null !== suspenseBoundary) {
+            switch (suspenseBoundary.tag) {
+              case 13:
+                unitOfWork.mode & 1 &&
+                  (null === shellBoundary
+                    ? renderDidSuspendDelayIfPossible()
+                    : null === suspenseBoundary.alternate &&
+                      0 === workInProgressRootExitStatus &&
+                      (workInProgressRootExitStatus = 3));
+                suspenseBoundary.flags &= -257;
+                markSuspenseBoundaryShouldCapture(
+                  suspenseBoundary,
+                  returnFiber,
+                  unitOfWork,
+                  root,
+                  thrownValue
+                );
+                var wakeables = suspenseBoundary.updateQueue;
+                null === wakeables
+                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
+                  : wakeables.add(wakeable);
+                break;
+              case 22:
+                if (suspenseBoundary.mode & 1) {
+                  suspenseBoundary.flags |= 65536;
+                  var offscreenQueue = suspenseBoundary.updateQueue;
+                  if (null === offscreenQueue) {
+                    var newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      wakeables: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    var wakeables$89 = offscreenQueue.wakeables;
+                    null === wakeables$89
+                      ? (offscreenQueue.wakeables = new Set([wakeable]))
+                      : wakeables$89.add(wakeable);
+                  }
+                  break;
+                }
+              default:
+                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
+            }
+            suspenseBoundary.mode & 1 &&
+              attachPingListener(root, wakeable, thrownValue);
+            break a;
+          } else if (1 === root.tag) {
+            attachPingListener(root, wakeable, thrownValue);
+            renderDidSuspendDelayIfPossible();
+            break a;
+          } else value = Error(formatProdErrorMessage(426));
+        } else if (
+          isHydrating &&
+          unitOfWork.mode & 1 &&
+          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
+        ) {
+          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
+          markSuspenseBoundaryShouldCapture(
+            wakeable,
+            returnFiber,
+            unitOfWork,
+            root,
+            thrownValue
+          );
+          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
+          break a;
+        }
+        root = value = createCapturedValueAtFiber(value, unitOfWork);
+        4 !== workInProgressRootExitStatus &&
+          (workInProgressRootExitStatus = 2);
+        null === workInProgressRootConcurrentErrors
+          ? (workInProgressRootConcurrentErrors = [root])
+          : workInProgressRootConcurrentErrors.push(root);
+        root = returnFiber;
+        do {
+          switch (root.tag) {
+            case 3:
+              var errorInfo = value;
+              root.flags |= 65536;
+              thrownValue &= -thrownValue;
+              root.lanes |= thrownValue;
+              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
+              enqueueCapturedUpdate(root, update);
+              break a;
+            case 1:
+              currentSourceFiber = value;
+              var ctor = root.type,
+                instance = root.stateNode;
+              if (
+                0 === (root.flags & 128) &&
+                ("function" === typeof ctor.getDerivedStateFromError ||
+                  (null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
+              ) {
+                root.flags |= 65536;
+                update = thrownValue & -thrownValue;
+                root.lanes |= update;
+                errorInfo = createClassErrorUpdate(
+                  root,
+                  currentSourceFiber,
+                  update
+                );
+                enqueueCapturedUpdate(root, errorInfo);
+                break a;
+              }
+          }
+          root = root.return;
+        } while (null !== root);
+      }
+    } catch (error) {
+      throw ((workInProgress = returnFiber), error);
+    }
+    completeUnitOfWork(unitOfWork);
+  }
+}
+function completeUnitOfWork(unitOfWork) {
+  var completedWork = unitOfWork;
+  do {
+    var current = completedWork.alternate;
+    unitOfWork = completedWork.return;
+    if (0 === (completedWork.flags & 32768)) {
+      if (
+        (0 === (completedWork.mode & 2)
+          ? (current = completeWork(current, completedWork, renderLanes))
+          : (startProfilerTimer(completedWork),
+            (current = completeWork(current, completedWork, renderLanes)),
+            stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1)),
+        null !== current)
+      ) {
+        workInProgress = current;
+        return;
+      }
+    } else {
+      current = unwindWork(current, completedWork);
+      if (null !== current) {
+        current.flags &= 16383;
+        workInProgress = current;
+        return;
+      }
+      if (0 !== (completedWork.mode & 2)) {
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1);
+        current = completedWork.actualDuration;
+        for (var child = completedWork.child; null !== child; )
+          (current += child.actualDuration), (child = child.sibling);
+        completedWork.actualDuration = current;
+      }
+      if (null !== unitOfWork)
+        (unitOfWork.flags |= 32768),
+          (unitOfWork.subtreeFlags = 0),
+          (unitOfWork.deletions = null);
+      else {
+        workInProgressRootExitStatus = 6;
+        workInProgress = null;
+        return;
+      }
+    }
+    completedWork = completedWork.sibling;
+    if (null !== completedWork) {
+      workInProgress = completedWork;
+      return;
+    }
+    workInProgress = completedWork = unitOfWork;
+  } while (null !== completedWork);
+  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+}
+function commitRoot(root, recoverableErrors, transitions) {
+  var previousUpdateLanePriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig$1.transition;
+  try {
+    (ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      commitRootImpl(
+        root,
+        recoverableErrors,
+        transitions,
+        previousUpdateLanePriority
+      );
+  } finally {
+    (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (currentUpdatePriority = previousUpdateLanePriority);
+  }
+  return null;
+}
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
+) {
+  do flushPassiveEffects();
+  while (null !== rootWithPendingPassiveEffects);
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var finishedWork = root.finishedWork,
+    lanes = root.finishedLanes;
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markCommitStarted &&
+    injectedProfilingHooks.markCommitStarted(lanes);
+  if (null === finishedWork)
+    return enableSchedulingProfiler && markCommitStopped(), null;
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
+  root.callbackNode = null;
+  root.callbackPriority = 0;
+  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
+  remainingLanes |= concurrentlyUpdatedLanes;
+  markRootFinished(root, remainingLanes);
+  root === workInProgressRoot &&
+    ((workInProgress = workInProgressRoot = null),
+    (workInProgressRootRenderLanes = 0));
+  (0 === (finishedWork.subtreeFlags & 10256) &&
+    0 === (finishedWork.flags & 10256)) ||
+    rootDoesHavePassiveEffects ||
+    ((rootDoesHavePassiveEffects = !0),
+    (pendingPassiveEffectsRemainingLanes = remainingLanes),
+    (pendingPassiveTransitions = transitions),
+    scheduleCallback(NormalPriority$1, function () {
+      flushPassiveEffects();
+      return null;
+    }));
+  transitions = 0 !== (finishedWork.flags & 15990);
+  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
+    transitions = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    var prevExecutionContext = executionContext;
+    executionContext |= 4;
+    ReactCurrentOwner.current = null;
+    var shouldFireAfterActiveInstanceBlur$225 = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
+    commitTime = now();
+    enableProfilerNestedUpdateScheduledHook &&
+      (rootCommittingMutationOrLayoutEffects = root);
+    commitMutationEffects(root, finishedWork, lanes);
+    shouldFireAfterActiveInstanceBlur$225 &&
+      ((_enabled = !0),
+      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
+      (_enabled = !1));
+    restoreSelection(selectionInformation);
+    _enabled = !!eventsEnabled;
+    selectionInformation = eventsEnabled = null;
+    root.current = finishedWork;
+    enableSchedulingProfiler &&
+      enableSchedulingProfiler &&
+      null !== injectedProfilingHooks &&
+      "function" === typeof injectedProfilingHooks.markLayoutEffectsStarted &&
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    commitLayoutEffects(finishedWork, root, lanes);
+    enableSchedulingProfiler &&
+      enableSchedulingProfiler &&
+      null !== injectedProfilingHooks &&
+      "function" === typeof injectedProfilingHooks.markLayoutEffectsStopped &&
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    enableProfilerNestedUpdateScheduledHook &&
+      (rootCommittingMutationOrLayoutEffects = null);
+    requestPaint();
+    executionContext = prevExecutionContext;
+    currentUpdatePriority = previousPriority;
+    ReactCurrentBatchConfig$1.transition = transitions;
+  } else (root.current = finishedWork), (commitTime = now());
+  rootDoesHavePassiveEffects
+    ? ((rootDoesHavePassiveEffects = !1),
+      (rootWithPendingPassiveEffects = root),
+      (pendingPassiveEffectsLanes = lanes))
+    : releaseRootPooledCache(root, remainingLanes);
+  remainingLanes = root.pendingLanes;
+  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  isDevToolsPresent && root.memoizedUpdaters.clear();
+  ensureRootIsScheduled(root, now$1());
+  if (null !== recoverableErrors)
+    for (
+      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
+      finishedWork < recoverableErrors.length;
+      finishedWork++
+    )
+      (lanes = recoverableErrors[finishedWork]),
+        (remainingLanes = {
+          digest: lanes.digest,
+          componentStack: lanes.stack
+        }),
+        renderPriorityLevel(lanes.value, remainingLanes);
+  if (hasUncaughtError)
+    throw (
+      ((hasUncaughtError = !1),
+      (root = firstUncaughtError),
+      (firstUncaughtError = null),
+      root)
+    );
+  0 !== (pendingPassiveEffectsLanes & 3) &&
+    0 !== root.tag &&
+    flushPassiveEffects();
+  remainingLanes = root.pendingLanes;
+  0 !== (remainingLanes & 3)
+    ? ((nestedUpdateScheduled = !0),
+      root === rootWithNestedUpdates
+        ? nestedUpdateCount++
+        : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root)))
+    : (nestedUpdateCount = 0);
+  flushSyncCallbacks();
+  enableSchedulingProfiler && markCommitStopped();
+  if (enableTransitionTracing) {
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    null !== prevRootTransitionCallbacks &&
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+        null !== prevPendingTransitionCallbacks
+          ? ((currentPendingTransitionCallbacks = null),
+            scheduleCallback(IdlePriority, function () {
+              processTransitionCallbacks(
+                prevPendingTransitionCallbacks,
+                endTime,
+                prevRootTransitionCallbacks
+              );
+            }))
+          : (currentEndTime = endTime);
+      });
+  }
+  return null;
+}
+function releaseRootPooledCache(root, remainingLanes) {
+  0 === (root.pooledCacheLanes &= remainingLanes) &&
+    ((remainingLanes = root.pooledCache),
+    null != remainingLanes &&
+      ((root.pooledCache = null), releaseCache(remainingLanes)));
+}
+function flushPassiveEffects() {
+  if (null !== rootWithPendingPassiveEffects) {
+    var root$226 = rootWithPendingPassiveEffects,
+      remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = 0;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    renderPriority = 32 > renderPriority ? 32 : renderPriority;
+    var prevTransition = ReactCurrentBatchConfig$1.transition,
+      previousPriority = currentUpdatePriority;
+    try {
+      return (
+        (ReactCurrentBatchConfig$1.transition = null),
+        (currentUpdatePriority = renderPriority),
+        flushPassiveEffectsImpl()
+      );
+    } finally {
+      (currentUpdatePriority = previousPriority),
+        (ReactCurrentBatchConfig$1.transition = prevTransition),
+        releaseRootPooledCache(root$226, remainingLanes);
+    }
+  }
+  return !1;
+}
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  pendingPassiveProfilerEffects.push(fiber);
+  rootDoesHavePassiveEffects ||
+    ((rootDoesHavePassiveEffects = !0),
+    scheduleCallback(NormalPriority$1, function () {
+      flushPassiveEffects();
+      return null;
+    }));
+}
+function flushPassiveEffectsImpl() {
+  if (null === rootWithPendingPassiveEffects) return !1;
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects,
+    lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null;
+  pendingPassiveEffectsLanes = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markPassiveEffectsStarted &&
+    injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+  var prevExecutionContext = executionContext;
+  executionContext |= 4;
+  commitPassiveUnmountOnFiber(root.current);
+  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
+  transitions = pendingPassiveProfilerEffects;
+  pendingPassiveProfilerEffects = [];
+  for (lanes = 0; lanes < transitions.length; lanes++)
+    commitPassiveEffectDurations(root, transitions[lanes]);
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markPassiveEffectsStopped &&
+    injectedProfilingHooks.markPassiveEffectsStopped();
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
+      prevRootTransitionCallbacks = root.transitionCallbacks,
+      prevEndTime = currentEndTime;
+    null !== prevPendingTransitionCallbacks &&
+      null !== prevRootTransitionCallbacks &&
+      null !== prevEndTime &&
+      ((currentEndTime = currentPendingTransitionCallbacks = null),
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
+        );
+      }));
+  }
+  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {}
+  root = root.current.stateNode;
+  root.effectDuration = 0;
+  root.passiveEffectDuration = 0;
+  return !0;
+}
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
+  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+  sourceFiber = requestEventTime();
+  null !== rootFiber &&
+    (markRootUpdated(rootFiber, 2, sourceFiber),
+    ensureRootIsScheduled(rootFiber, sourceFiber));
+}
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+  if (3 === sourceFiber.tag)
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+  else
+    for (
+      nearestMountedAncestor = skipUnmountedBoundaries
+        ? nearestMountedAncestor
+        : sourceFiber.return;
+      null !== nearestMountedAncestor;
+
+    ) {
+      if (3 === nearestMountedAncestor.tag) {
+        captureCommitPhaseErrorOnRoot(
+          nearestMountedAncestor,
+          sourceFiber,
+          error
+        );
+        break;
+      } else if (1 === nearestMountedAncestor.tag) {
+        var instance = nearestMountedAncestor.stateNode;
+        if (
+          "function" ===
+            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
+          ("function" === typeof instance.componentDidCatch &&
+            (null === legacyErrorBoundariesThatAlreadyFailed ||
+              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
+        ) {
+          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+          sourceFiber = createClassErrorUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
+          );
+          nearestMountedAncestor = enqueueUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
+          );
+          sourceFiber = requestEventTime();
+          null !== nearestMountedAncestor &&
+            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
+            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
+          break;
+        }
+      }
+      nearestMountedAncestor = nearestMountedAncestor.return;
+    }
+}
+function attachPingListener(root, wakeable, lanes) {
+  var pingCache = root.pingCache;
+  if (null === pingCache) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    var threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else
+    (threadIDs = pingCache.get(wakeable)),
+      void 0 === threadIDs &&
+        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
+  threadIDs.has(lanes) ||
+    ((workInProgressRootDidAttachPingListener = !0),
+    threadIDs.add(lanes),
+    (pingCache = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
+    isDevToolsPresent && restorePendingUpdaters(root, lanes),
+    wakeable.then(pingCache, pingCache));
+}
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
+  null !== pingCache && pingCache.delete(wakeable);
+  wakeable = requestEventTime();
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+  workInProgressRoot === root &&
+    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
+    (4 === workInProgressRootExitStatus ||
+    (3 === workInProgressRootExitStatus &&
+      (workInProgressRootRenderLanes & 125829120) ===
+        workInProgressRootRenderLanes &&
+      500 > now$1() - globalMostRecentFallbackTime)
+      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
+      : (workInProgressRootPingedLanes |= pingedLanes));
+  ensureRootIsScheduled(root, wakeable);
+}
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  0 === retryLane &&
+    (0 === (boundaryFiber.mode & 1)
+      ? (retryLane = 2)
+      : ((retryLane = nextRetryLane),
+        (nextRetryLane <<= 1),
+        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
+  var eventTime = requestEventTime();
+  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+  null !== boundaryFiber &&
+    (markRootUpdated(boundaryFiber, retryLane, eventTime),
+    ensureRootIsScheduled(boundaryFiber, eventTime));
+}
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState,
+    retryLane = 0;
+  null !== suspenseState && (retryLane = suspenseState.retryLane);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = 0;
+  switch (boundaryFiber.tag) {
+    case 13:
+      var retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
+      null !== suspenseState && (retryLane = suspenseState.retryLane);
+      break;
+    case 19:
+      retryCache = boundaryFiber.stateNode;
+      break;
+    case 22:
+      retryCache = boundaryFiber.stateNode._retryCache;
+      break;
+    default:
+      throw Error(formatProdErrorMessage(314));
+  }
+  null !== retryCache && retryCache.delete(wakeable);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+var beginWork;
+beginWork = function (current, workInProgress, renderLanes) {
+  if (null !== current)
+    if (
+      current.memoizedProps !== workInProgress.pendingProps ||
+      didPerformWorkStackCursor.current
+    )
+      didReceiveUpdate = !0;
+    else {
+      if (
+        !checkScheduledUpdateOrContext(current, renderLanes) &&
+        0 === (workInProgress.flags & 128)
+      )
+        return (
+          (didReceiveUpdate = !1),
+          attemptEarlyBailoutIfNoScheduledUpdate(
+            current,
+            workInProgress,
+            renderLanes
+          )
+        );
+      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+    }
+  else
+    (didReceiveUpdate = !1),
+      isHydrating &&
+        0 !== (workInProgress.flags & 1048576) &&
+        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
+  workInProgress.lanes = 0;
+  switch (workInProgress.tag) {
+    case 2:
+      var Component = workInProgress.type;
+      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+      current = workInProgress.pendingProps;
+      var context = getMaskedContext(
+        workInProgress,
+        contextStackCursor.current
+      );
+      prepareToReadContext(workInProgress, renderLanes);
+      enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+      current = renderWithHooks(
+        null,
+        workInProgress,
+        Component,
+        current,
+        context,
+        renderLanes
+      );
+      Component = checkDidRenderIdHook();
+      enableSchedulingProfiler && markComponentRenderStopped();
+      workInProgress.flags |= 1;
+      workInProgress.tag = 0;
+      isHydrating && Component && pushMaterializedTreeId(workInProgress);
+      reconcileChildren(null, workInProgress, current, renderLanes);
+      workInProgress = workInProgress.child;
+      return workInProgress;
+    case 16:
+      Component = workInProgress.elementType;
+      a: {
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+        current = workInProgress.pendingProps;
+        context = Component._init;
+        Component = context(Component._payload);
+        workInProgress.type = Component;
+        context = workInProgress.tag = resolveLazyComponentTag(Component);
+        current = resolveDefaultProps(Component, current);
+        switch (context) {
+          case 0:
+            workInProgress = updateFunctionComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 1:
+            workInProgress = updateClassComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 11:
+            workInProgress = updateForwardRef(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 14:
+            workInProgress = updateMemoComponent(
+              null,
+              workInProgress,
+              Component,
+              resolveDefaultProps(Component.type, current),
+              renderLanes
+            );
+            break a;
+        }
+        throw Error(formatProdErrorMessage(306, Component, ""));
+      }
+      return workInProgress;
+    case 0:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        updateFunctionComponent(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
+    case 1:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        updateClassComponent(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
+    case 3:
+      a: {
+        pushHostRootContext(workInProgress);
+        if (null === current) throw Error(formatProdErrorMessage(387));
+        Component = workInProgress.pendingProps;
+        var prevState = workInProgress.memoizedState;
+        context = prevState.element;
+        cloneUpdateQueue(current, workInProgress);
+        processUpdateQueue(workInProgress, Component, null, renderLanes);
+        var nextState = workInProgress.memoizedState,
+          root = workInProgress.stateNode;
+        enableTransitionTracing &&
+          push(transitionStack, workInProgressTransitions);
+        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+        Component = nextState.cache;
+        pushProvider(workInProgress, CacheContext, Component);
+        Component !== prevState.cache &&
+          propagateContextChange(workInProgress, CacheContext, renderLanes);
+        Component = nextState.element;
+        if (prevState.isDehydrated)
+          if (
+            ((prevState = {
+              element: Component,
+              isDehydrated: !1,
+              cache: nextState.cache
+            }),
+            (workInProgress.updateQueue.baseState = prevState),
+            (workInProgress.memoizedState = prevState),
+            workInProgress.flags & 256)
+          ) {
+            context = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(423)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              context
+            );
+            break a;
+          } else if (Component !== context) {
+            context = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(424)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              context
+            );
+            break a;
+          } else {
+            nextHydratableInstance = getNextHydratable(
+              workInProgress.stateNode.containerInfo.firstChild
+            );
+            hydrationParentFiber = workInProgress;
+            isHydrating = !0;
+            hydrationErrors = null;
+            rootOrSingletonContext = !0;
+            current = root.mutableSourceEagerHydrationData;
+            if (null != current)
+              for (context = 0; context < current.length; context += 2)
+                (prevState = current[context]),
+                  (prevState._workInProgressVersionPrimary =
+                    current[context + 1]),
+                  workInProgressSources.push(prevState);
+            renderLanes = mountChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            );
+            for (workInProgress.child = renderLanes; renderLanes; )
+              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
+                (renderLanes = renderLanes.sibling);
+          }
+        else {
+          resetHydrationState();
+          if (Component === context) {
+            workInProgress = bailoutOnAlreadyFinishedWork(
+              current,
+              workInProgress,
+              renderLanes
+            );
+            break a;
+          }
+          reconcileChildren(current, workInProgress, Component, renderLanes);
+        }
+        workInProgress = workInProgress.child;
+      }
+      return workInProgress;
+    case 26:
+      return (
+        markRef$1(current, workInProgress),
+        (renderLanes = workInProgress.memoizedState =
+          getResource(
+            workInProgress.type,
+            null === current ? null : current.memoizedProps,
+            workInProgress.pendingProps
+          )),
+        null !== current ||
+          isHydrating ||
+          null !== renderLanes ||
+          ((renderLanes = workInProgress.type),
+          (current = workInProgress.pendingProps),
+          (Component = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          )),
+          (Component = createHTMLElement(renderLanes, current, Component)),
+          (Component[internalInstanceKey] = workInProgress),
+          (Component[internalPropsKey] = current),
+          setInitialProperties(Component, renderLanes, current),
+          markNodeAsHoistable(Component),
+          (workInProgress.stateNode = Component)),
+        null
+      );
+    case 27:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          ((Component = workInProgress.stateNode =
+            resolveSingletonInstance(
+              workInProgress.type,
+              workInProgress.pendingProps,
+              rootInstanceStackCursor.current
+            )),
+          (hydrationParentFiber = workInProgress),
+          (rootOrSingletonContext = !0),
+          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
+        (Component = workInProgress.pendingProps.children),
+        null !== current || isHydrating
+          ? reconcileChildren(current, workInProgress, Component, renderLanes)
+          : (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            )),
+        markRef$1(current, workInProgress),
+        workInProgress.child
+      );
+    case 5:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          (((Component = workInProgress.pendingProps),
+          "script" === workInProgress.type
+            ? ((context = Component.onLoad),
+              (prevState = Component.onError),
+              (Component = !(Component.async && (context || prevState))))
+            : (Component = !0),
+          Component)
+            ? ((Component = nextHydratableInstance),
+              rootOrSingletonContext &&
+                advanceToFirstAttemptableInstance(workInProgress),
+              (context = nextHydratableInstance),
+              context)
+              ? tryHydrateInstance(workInProgress, context) ||
+                (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                (nextHydratableInstance = getNextHydratable(
+                  context.nextSibling
+                )),
+                (prevState = hydrationParentFiber),
+                rootOrSingletonContext &&
+                  advanceToFirstAttemptableInstance(workInProgress),
+                nextHydratableInstance &&
+                tryHydrateInstance(workInProgress, nextHydratableInstance)
+                  ? deleteHydratableInstance(prevState, context)
+                  : (insertNonHydratedInstance(
+                      hydrationParentFiber,
+                      workInProgress
+                    ),
+                    (isHydrating = !1),
+                    (hydrationParentFiber = workInProgress),
+                    (nextHydratableInstance = Component)))
+              : (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = Component))
+            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress))),
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (prevState = null !== current ? current.memoizedProps : null),
+        (root = context.children),
+        shouldSetTextContent(Component, context)
+          ? (root = null)
+          : null !== prevState &&
+            shouldSetTextContent(Component, prevState) &&
+            (workInProgress.flags |= 32),
+        markRef$1(current, workInProgress),
+        reconcileChildren(current, workInProgress, root, renderLanes),
+        workInProgress.child
+      );
+    case 6:
+      return (
+        null === current &&
+          isHydrating &&
+          (((renderLanes = "" !== workInProgress.pendingProps),
+          (current = nextHydratableInstance),
+          rootOrSingletonContext &&
+            renderLanes &&
+            advanceToFirstAttemptableTextInstance(),
+          (Component = nextHydratableInstance),
+          Component && renderLanes)
+            ? tryHydrateText(workInProgress, Component) ||
+              (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              (nextHydratableInstance = getNextHydratable(
+                Component.nextSibling
+              )),
+              (context = hydrationParentFiber),
+              rootOrSingletonContext &&
+                renderLanes &&
+                advanceToFirstAttemptableTextInstance(),
+              nextHydratableInstance &&
+              tryHydrateText(workInProgress, nextHydratableInstance)
+                ? deleteHydratableInstance(context, Component)
+                : (insertNonHydratedInstance(
+                    hydrationParentFiber,
+                    workInProgress
+                  ),
+                  (isHydrating = !1),
+                  (hydrationParentFiber = workInProgress),
+                  (nextHydratableInstance = current)))
+            : (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress),
+              (nextHydratableInstance = current))),
+        null
+      );
+    case 13:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+    case 4:
+      return (
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        ),
+        (Component = workInProgress.pendingProps),
+        null === current
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            ))
+          : reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 11:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        updateForwardRef(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
+    case 7:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 8:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 12:
+      return (
+        (workInProgress.flags |= 4),
+        (Component = workInProgress.stateNode),
+        (Component.effectDuration = 0),
+        (Component.passiveEffectDuration = 0),
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 10:
+      a: {
+        Component = workInProgress.type._context;
+        context = workInProgress.pendingProps;
+        prevState = workInProgress.memoizedProps;
+        root = context.value;
+        pushProvider(workInProgress, Component, root);
+        if (!enableLazyContextPropagation && null !== prevState)
+          if (objectIs(prevState.value, root)) {
+            if (
+              prevState.children === context.children &&
+              !didPerformWorkStackCursor.current
+            ) {
+              workInProgress = bailoutOnAlreadyFinishedWork(
+                current,
+                workInProgress,
+                renderLanes
+              );
+              break a;
+            }
+          } else propagateContextChange(workInProgress, Component, renderLanes);
+        reconcileChildren(
+          current,
+          workInProgress,
+          context.children,
+          renderLanes
+        );
+        workInProgress = workInProgress.child;
+      }
+      return workInProgress;
+    case 9:
+      return (
+        (context = workInProgress.type),
+        (Component = workInProgress.pendingProps.children),
+        prepareToReadContext(workInProgress, renderLanes),
+        (context = readContext(context)),
+        enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
+        (Component = Component(context)),
+        enableSchedulingProfiler && markComponentRenderStopped(),
+        (workInProgress.flags |= 1),
+        reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 14:
+      return (
+        (Component = workInProgress.type),
+        (context = resolveDefaultProps(Component, workInProgress.pendingProps)),
+        (context = resolveDefaultProps(Component.type, context)),
+        updateMemoComponent(
+          current,
+          workInProgress,
+          Component,
+          context,
+          renderLanes
+        )
+      );
+    case 15:
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        workInProgress.pendingProps,
+        renderLanes
+      );
+    case 17:
+      return (
+        (Component = workInProgress.type),
+        (context = workInProgress.pendingProps),
+        (context =
+          workInProgress.elementType === Component
+            ? context
+            : resolveDefaultProps(Component, context)),
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+        (workInProgress.tag = 1),
+        isContextProvider(Component)
+          ? ((current = !0), pushContextProvider(workInProgress))
+          : (current = !1),
+        prepareToReadContext(workInProgress, renderLanes),
+        constructClassInstance(workInProgress, Component, context),
+        mountClassInstance(workInProgress, Component, context, renderLanes),
+        finishClassComponent(
+          null,
+          workInProgress,
+          Component,
+          !0,
+          current,
+          renderLanes
+        )
+      );
+    case 19:
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    case 21:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 22:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 23:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 24:
+      return (
+        prepareToReadContext(workInProgress, renderLanes),
+        (Component = readContext(CacheContext)),
+        null === current
+          ? ((context = peekCacheFromPool()),
+            null === context &&
+              ((context = workInProgressRoot),
+              (prevState = createCache()),
+              (context.pooledCache = prevState),
+              prevState.refCount++,
+              null !== prevState && (context.pooledCacheLanes |= renderLanes),
+              (context = prevState)),
+            (workInProgress.memoizedState = {
+              parent: Component,
+              cache: context
+            }),
+            initializeUpdateQueue(workInProgress),
+            pushProvider(workInProgress, CacheContext, context))
+          : (0 !== (current.lanes & renderLanes) &&
+              (cloneUpdateQueue(current, workInProgress),
+              processUpdateQueue(workInProgress, null, null, renderLanes)),
+            (context = current.memoizedState),
+            (prevState = workInProgress.memoizedState),
+            context.parent !== Component
+              ? ((context = { parent: Component, cache: Component }),
+                (workInProgress.memoizedState = context),
+                0 === workInProgress.lanes &&
+                  (workInProgress.memoizedState =
+                    workInProgress.updateQueue.baseState =
+                      context),
+                pushProvider(workInProgress, CacheContext, Component))
+              : ((Component = prevState.cache),
+                pushProvider(workInProgress, CacheContext, Component),
+                Component !== context.cache &&
+                  propagateContextChange(
+                    workInProgress,
+                    CacheContext,
+                    renderLanes
+                  ))),
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 25:
+      if (enableTransitionTracing)
+        return (
+          enableTransitionTracing
+            ? (null === current &&
+                ((Component = enableTransitionTracing
+                  ? transitionStack.current
+                  : null),
+                null !== Component &&
+                  ((Component = {
+                    tag: 1,
+                    transitions: new Set(Component),
+                    pendingBoundaries: null,
+                    name: workInProgress.pendingProps.name,
+                    aborts: null
+                  }),
+                  (workInProgress.stateNode = Component),
+                  (workInProgress.flags |= 2048))),
+              (Component = workInProgress.stateNode),
+              null !== Component &&
+                pushMarkerInstance(workInProgress, Component),
+              reconcileChildren(
+                current,
+                workInProgress,
+                workInProgress.pendingProps.children,
+                renderLanes
+              ),
+              (workInProgress = workInProgress.child))
+            : (workInProgress = null),
+          workInProgress
+        );
+  }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+};
+function restorePendingUpdaters(root, lanes) {
+  isDevToolsPresent &&
+    root.memoizedUpdaters.forEach(function (schedulingFiber) {
+      addFiberToLanesMap(root, schedulingFiber, lanes);
+    });
+}
+function scheduleCallback(priorityLevel, callback) {
+  return scheduleCallback$2(priorityLevel, callback);
 }
-var hasUncaughtError = !1,
-  firstUncaughtError = null,
-  legacyErrorBoundariesThatAlreadyFailed = null,
-  rootCommittingMutationOrLayoutEffects = null,
-  rootDoesHavePassiveEffects = !1,
-  rootWithPendingPassiveEffects = null,
-  pendingPassiveEffectsLanes = 0,
-  pendingPassiveProfilerEffects = [],
-  pendingPassiveEffectsRemainingLanes = 0,
-  pendingPassiveTransitions = null,
-  nestedUpdateCount = 0,
-  rootWithNestedUpdates = null,
-  currentEventTime = -1,
-  currentEventTransitionLane = 0;
-function requestEventTime() {
-  return 0 !== (executionContext & 6)
-    ? now$1()
-    : -1 !== currentEventTime
-    ? currentEventTime
-    : (currentEventTime = now$1());
+function FiberNode(tag, pendingProps, key, mode) {
+  this.tag = tag;
+  this.key = key;
+  this.sibling =
+    this.child =
+    this.return =
+    this.stateNode =
+    this.type =
+    this.elementType =
+      null;
+  this.index = 0;
+  this.refCleanup = this.ref = null;
+  this.pendingProps = pendingProps;
+  this.dependencies =
+    this.memoizedState =
+    this.updateQueue =
+    this.memoizedProps =
+      null;
+  this.mode = mode;
+  this.subtreeFlags = this.flags = 0;
+  this.deletions = null;
+  this.childLanes = this.lanes = 0;
+  this.alternate = null;
+  this.actualDuration = 0;
+  this.actualStartTime = -1;
+  this.treeBaseDuration = this.selfBaseDuration = 0;
 }
-function requestUpdateLane(fiber) {
-  if (0 === (fiber.mode & 1)) return 2;
-  if (
-    !deferRenderPhaseUpdateToNextBatch &&
-    0 !== (executionContext & 2) &&
-    0 !== workInProgressRootRenderLanes
-  )
-    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
-  if (null !== ReactCurrentBatchConfig$1.transition)
-    return (
-      0 === currentEventTransitionLane &&
-        (currentEventTransitionLane = claimNextTransitionLane()),
-      currentEventTransitionLane
-    );
-  fiber = currentUpdatePriority;
-  if (0 !== fiber) return fiber;
-  fiber = window.event;
-  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
-  return fiber;
+function createFiber(tag, pendingProps, key, mode) {
+  return new FiberNode(tag, pendingProps, key, mode);
 }
-function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
-  2 === workInProgressSuspendedReason &&
-    root === workInProgressRoot &&
-    (prepareFreshStack(root, 0),
-    markRootSuspended(root, workInProgressRootRenderLanes));
-  markRootUpdated(root, lane, eventTime);
-  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
-    isDevToolsPresent && addFiberToLanesMap(root, fiber, lane);
-    if (
-      enableProfilerNestedUpdateScheduledHook &&
-      0 !== (executionContext & 4) &&
-      root === rootCommittingMutationOrLayoutEffects &&
-      fiber.mode & 2
-    )
-      for (var current = fiber; null !== current; ) {
-        if (12 === current.tag) {
-          var _current$memoizedProp = current.memoizedProps,
-            id = _current$memoizedProp.id;
-          _current$memoizedProp = _current$memoizedProp.onNestedUpdateScheduled;
-          "function" === typeof _current$memoizedProp &&
-            _current$memoizedProp(id);
-        }
-        current = current.return;
-      }
-    if (
-      enableTransitionTracing &&
-      ((current = ReactCurrentBatchConfig.transition),
-      null !== current &&
-        null != current.name &&
-        (-1 === current.startTime && (current.startTime = now$1()),
-        enableTransitionTracing))
-    ) {
-      id = root.transitionLanes;
-      _current$memoizedProp = 31 - clz32(lane);
-      var transitions = id[_current$memoizedProp];
-      null === transitions && (transitions = new Set());
-      transitions.add(current);
-      id[_current$memoizedProp] = transitions;
-    }
-    if (root === workInProgressRoot) {
-      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
-        workInProgressRootInterleavedUpdatedLanes |= lane;
-      4 === workInProgressRootExitStatus &&
-        markRootSuspended(root, workInProgressRootRenderLanes);
-    }
-    ensureRootIsScheduled(root, eventTime);
-    2 === lane &&
-      0 === executionContext &&
-      0 === (fiber.mode & 1) &&
-      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
-  }
+function shouldConstruct(Component) {
+  Component = Component.prototype;
+  return !(!Component || !Component.isReactComponent);
 }
-function ensureRootIsScheduled(root, currentTime) {
-  var existingCallbackNode = root.callbackNode;
-  markStarvedLanesAsExpired(root, currentTime);
-  var nextLanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
-  );
-  if (0 === nextLanes)
-    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
-      (root.callbackNode = null),
-      (root.callbackPriority = 0);
-  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
-    (root.callbackPriority = 0), (root.callbackNode = null);
-  else if (
-    ((currentTime = nextLanes & -nextLanes),
-    root.callbackPriority !== currentTime)
-  ) {
-    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
-    if (0 !== (currentTime & 3))
-      0 === root.tag
-        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
-        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
-        scheduleMicrotask(function () {
-          0 === (executionContext & 6) && flushSyncCallbacks();
-        }),
-        (existingCallbackNode = null);
-    else {
-      switch (lanesToEventPriority(nextLanes)) {
-        case 2:
-          existingCallbackNode = ImmediatePriority;
-          break;
-        case 8:
-          existingCallbackNode = UserBlockingPriority;
-          break;
-        case 32:
-          existingCallbackNode = NormalPriority$1;
-          break;
-        case 536870912:
-          existingCallbackNode = IdlePriority;
-          break;
-        default:
-          existingCallbackNode = NormalPriority$1;
-      }
-      existingCallbackNode = scheduleCallback(
-        existingCallbackNode,
-        performConcurrentWorkOnRoot.bind(null, root)
-      );
-    }
-    root.callbackPriority = currentTime;
-    root.callbackNode = existingCallbackNode;
+function resolveLazyComponentTag(Component) {
+  if ("function" === typeof Component)
+    return shouldConstruct(Component) ? 1 : 0;
+  if (void 0 !== Component && null !== Component) {
+    Component = Component.$$typeof;
+    if (Component === REACT_FORWARD_REF_TYPE) return 11;
+    if (Component === REACT_MEMO_TYPE) return 14;
   }
+  return 2;
+}
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
+  null === workInProgress
+    ? ((workInProgress = createFiber(
+        current.tag,
+        pendingProps,
+        current.key,
+        current.mode
+      )),
+      (workInProgress.elementType = current.elementType),
+      (workInProgress.type = current.type),
+      (workInProgress.stateNode = current.stateNode),
+      (workInProgress.alternate = current),
+      (current.alternate = workInProgress))
+    : ((workInProgress.pendingProps = pendingProps),
+      (workInProgress.type = current.type),
+      (workInProgress.flags = 0),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null),
+      (workInProgress.actualDuration = 0),
+      (workInProgress.actualStartTime = -1));
+  workInProgress.flags = current.flags & 14680064;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue;
+  pendingProps = current.dependencies;
+  workInProgress.dependencies =
+    null === pendingProps
+      ? null
+      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+  workInProgress.selfBaseDuration = current.selfBaseDuration;
+  workInProgress.treeBaseDuration = current.treeBaseDuration;
+  return workInProgress;
+}
+function resetWorkInProgress(workInProgress, renderLanes) {
+  workInProgress.flags &= 14680066;
+  var current = workInProgress.alternate;
+  null === current
+    ? ((workInProgress.childLanes = 0),
+      (workInProgress.lanes = renderLanes),
+      (workInProgress.child = null),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.memoizedProps = null),
+      (workInProgress.memoizedState = null),
+      (workInProgress.updateQueue = null),
+      (workInProgress.dependencies = null),
+      (workInProgress.stateNode = null),
+      (workInProgress.selfBaseDuration = 0),
+      (workInProgress.treeBaseDuration = 0))
+    : ((workInProgress.childLanes = current.childLanes),
+      (workInProgress.lanes = current.lanes),
+      (workInProgress.child = current.child),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null),
+      (workInProgress.memoizedProps = current.memoizedProps),
+      (workInProgress.memoizedState = current.memoizedState),
+      (workInProgress.updateQueue = current.updateQueue),
+      (workInProgress.type = current.type),
+      (renderLanes = current.dependencies),
+      (workInProgress.dependencies =
+        null === renderLanes
+          ? null
+          : {
+              lanes: renderLanes.lanes,
+              firstContext: renderLanes.firstContext
+            }),
+      (workInProgress.selfBaseDuration = current.selfBaseDuration),
+      (workInProgress.treeBaseDuration = current.treeBaseDuration));
+  return workInProgress;
 }
-function performConcurrentWorkOnRoot(root, didTimeout) {
-  nestedUpdateScheduled = currentUpdateIsNested = !1;
-  currentEventTime = -1;
-  currentEventTransitionLane = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var originalCallbackNode = root.callbackNode;
-  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
-    return null;
-  var lanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
-  );
-  if (0 === lanes) return null;
-  didTimeout =
-    includesBlockingLane(root, lanes) ||
-    0 !== (lanes & root.expiredLanes) ||
-    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
-      ? renderRootSync(root, lanes)
-      : renderRootConcurrent(root, lanes);
-  if (0 !== didTimeout) {
-    if (2 === didTimeout) {
-      var originallyAttemptedLanes = lanes,
-        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-          root,
-          originallyAttemptedLanes
+function createFiberFromTypeAndProps(
+  type,
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
+) {
+  var fiberTag = 2;
+  owner = type;
+  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
+  else if ("string" === typeof type)
+    fiberTag = isHostHoistableType(
+      type,
+      pendingProps,
+      contextStackCursor$1.current
+    )
+      ? 26
+      : "html" === type || "head" === type || "body" === type
+      ? 27
+      : 5;
+  else
+    a: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = 8;
+        mode |= 8;
+        0 !== (mode & 1) && (mode |= 16);
+        break;
+      case REACT_PROFILER_TYPE:
+        return (
+          (type = createFiber(12, pendingProps, key, mode | 2)),
+          (type.elementType = REACT_PROFILER_TYPE),
+          (type.lanes = lanes),
+          (type.stateNode = { effectDuration: 0, passiveEffectDuration: 0 }),
+          type
         );
-      0 !== errorRetryLanes &&
-        ((lanes = errorRetryLanes),
-        (didTimeout = recoverFromConcurrentError(
-          root,
-          originallyAttemptedLanes,
-          errorRetryLanes
-        )));
-    }
-    if (1 === didTimeout)
-      throw (
-        ((originalCallbackNode = workInProgressRootFatalError),
-        prepareFreshStack(root, 0),
-        markRootSuspended(root, lanes),
-        ensureRootIsScheduled(root, now$1()),
-        originalCallbackNode)
-      );
-    if (6 === didTimeout) markRootSuspended(root, lanes);
-    else {
-      errorRetryLanes = !includesBlockingLane(root, lanes);
-      originallyAttemptedLanes = root.current.alternate;
-      if (
-        errorRetryLanes &&
-        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
-      ) {
-        didTimeout = renderRootSync(root, lanes);
-        if (2 === didTimeout) {
-          errorRetryLanes = lanes;
-          var errorRetryLanes$232 = getLanesToRetrySynchronouslyOnError(
-            root,
-            errorRetryLanes
-          );
-          0 !== errorRetryLanes$232 &&
-            ((lanes = errorRetryLanes$232),
-            (didTimeout = recoverFromConcurrentError(
-              root,
-              errorRetryLanes,
-              errorRetryLanes$232
-            )));
-        }
-        if (1 === didTimeout)
-          throw (
-            ((originalCallbackNode = workInProgressRootFatalError),
-            prepareFreshStack(root, 0),
-            markRootSuspended(root, lanes),
-            ensureRootIsScheduled(root, now$1()),
-            originalCallbackNode)
-          );
-      }
-      root.finishedWork = originallyAttemptedLanes;
-      root.finishedLanes = lanes;
-      switch (didTimeout) {
-        case 0:
-        case 1:
-          throw Error(formatProdErrorMessage(345));
-        case 2:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 3:
-          markRootSuspended(root, lanes);
-          if (
-            (lanes & 125829120) === lanes &&
-            ((lanes = globalMostRecentFallbackTime + 500 - now$1()), 10 < lanes)
-          ) {
-            if (0 !== getNextLanes(root, 0)) break;
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
-          }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 4:
-          markRootSuspended(root, lanes);
-          if ((lanes & 8388480) === lanes) break;
-          didTimeout = root.eventTimes;
-          for (originallyAttemptedLanes = -1; 0 < lanes; )
-            (errorRetryLanes$232 = 31 - clz32(lanes)),
-              (errorRetryLanes = 1 << errorRetryLanes$232),
-              (errorRetryLanes$232 = didTimeout[errorRetryLanes$232]),
-              errorRetryLanes$232 > originallyAttemptedLanes &&
-                (originallyAttemptedLanes = errorRetryLanes$232),
-              (lanes &= ~errorRetryLanes);
-          lanes = originallyAttemptedLanes;
-          lanes = now$1() - lanes;
-          lanes =
-            (120 > lanes
-              ? 120
-              : 480 > lanes
-              ? 480
-              : 1080 > lanes
-              ? 1080
-              : 1920 > lanes
-              ? 1920
-              : 3e3 > lanes
-              ? 3e3
-              : 4320 > lanes
-              ? 4320
-              : 1960 * ceil(lanes / 1960)) - lanes;
-          if (10 < lanes) {
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
-          }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 5:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
+      case REACT_SUSPENSE_TYPE:
+        return (
+          (type = createFiber(13, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_SUSPENSE_LIST_TYPE:
+        return (
+          (type = createFiber(19, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+      case REACT_LEGACY_HIDDEN_TYPE:
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      case REACT_SCOPE_TYPE:
+        return (
+          (pendingProps = createFiber(21, pendingProps, key, mode)),
+          (pendingProps.type = type),
+          (pendingProps.elementType = type),
+          (pendingProps.lanes = lanes),
+          pendingProps
+        );
+      case REACT_CACHE_TYPE:
+        return (
+          (type = createFiber(24, pendingProps, key, mode)),
+          (type.elementType = REACT_CACHE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing)
+          return (
+            (type = createFiber(25, pendingProps, key, mode)),
+            (type.elementType = REACT_TRACING_MARKER_TYPE),
+            (type.lanes = lanes),
+            (type.stateNode = {
+              tag: 1,
+              transitions: null,
+              pendingBoundaries: null,
+              aborts: null,
+              name: pendingProps.name
+            }),
+            type
           );
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = 8;
+          mode |= 4;
           break;
-        default:
-          throw Error(formatProdErrorMessage(329));
-      }
+        }
+      default:
+        if ("object" === typeof type && null !== type)
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = 10;
+              break a;
+            case REACT_CONTEXT_TYPE:
+              fiberTag = 9;
+              break a;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = 11;
+              break a;
+            case REACT_MEMO_TYPE:
+              fiberTag = 14;
+              break a;
+            case REACT_LAZY_TYPE:
+              fiberTag = 16;
+              owner = null;
+              break a;
+          }
+        throw Error(
+          formatProdErrorMessage(130, null == type ? type : typeof type, "")
+        );
     }
-  }
-  ensureRootIsScheduled(root, now$1());
-  return root.callbackNode === originalCallbackNode
-    ? performConcurrentWorkOnRoot.bind(null, root)
-    : null;
-}
-function recoverFromConcurrentError(
-  root,
-  originallyAttemptedLanes,
-  errorRetryLanes
-) {
-  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
-    wasRootDehydrated = root.current.memoizedState.isDehydrated;
-  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
-  errorRetryLanes = renderRootSync(root, errorRetryLanes);
-  if (2 !== errorRetryLanes) {
-    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
-      return (
-        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
-        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
-        4
-      );
-    root = workInProgressRootRecoverableErrors;
-    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
-    null !== root && queueRecoverableErrors(root);
-  }
-  return errorRetryLanes;
+  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
+  pendingProps.elementType = type;
+  pendingProps.type = owner;
+  pendingProps.lanes = lanes;
+  return pendingProps;
 }
-function queueRecoverableErrors(errors) {
-  null === workInProgressRootRecoverableErrors
-    ? (workInProgressRootRecoverableErrors = errors)
-    : workInProgressRootRecoverableErrors.push.apply(
-        workInProgressRootRecoverableErrors,
-        errors
-      );
+function createFiberFromFragment(elements, mode, lanes, key) {
+  elements = createFiber(7, elements, key, mode);
+  elements.lanes = lanes;
+  return elements;
 }
-function isRenderConsistentWithExternalStores(finishedWork) {
-  for (var node = finishedWork; ; ) {
-    if (node.flags & 16384) {
-      var updateQueue = node.updateQueue;
-      if (
-        null !== updateQueue &&
-        ((updateQueue = updateQueue.stores), null !== updateQueue)
-      )
-        for (var i = 0; i < updateQueue.length; i++) {
-          var check = updateQueue[i],
-            getSnapshot = check.getSnapshot;
-          check = check.value;
-          try {
-            if (!objectIs(getSnapshot(), check)) return !1;
-          } catch (error) {
-            return !1;
-          }
-        }
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(22, pendingProps, key, mode);
+  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
+  pendingProps.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
     }
-    updateQueue = node.child;
-    if (node.subtreeFlags & 16384 && null !== updateQueue)
-      (updateQueue.return = node), (node = updateQueue);
-    else {
-      if (node === finishedWork) break;
-      for (; null === node.sibling; ) {
-        if (null === node.return || node.return === finishedWork) return !0;
-        node = node.return;
-      }
-      node.sibling.return = node.return;
-      node = node.sibling;
+  };
+  pendingProps.stateNode = primaryChildInstance;
+  return pendingProps;
+}
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(23, pendingProps, key, mode);
+  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  pendingProps.lanes = lanes;
+  var instance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
     }
-  }
-  return !0;
+  };
+  pendingProps.stateNode = instance;
+  return pendingProps;
 }
-function markRootSuspended(root, suspendedLanes) {
-  suspendedLanes &= ~workInProgressRootPingedLanes;
-  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
-  root.suspendedLanes |= suspendedLanes;
-  root.pingedLanes &= ~suspendedLanes;
-  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
-    var index$14 = 31 - clz32(suspendedLanes),
-      lane = 1 << index$14;
-    root[index$14] = -1;
-    suspendedLanes &= ~lane;
-  }
+function createFiberFromText(content, mode, lanes) {
+  content = createFiber(6, content, null, mode);
+  content.lanes = lanes;
+  return content;
 }
-function performSyncWorkOnRoot(root) {
-  currentUpdateIsNested = nestedUpdateScheduled;
-  nestedUpdateScheduled = !1;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  flushPassiveEffects();
-  var lanes = getNextLanes(root, 0);
-  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now$1()), null;
-  var exitStatus = renderRootSync(root, lanes);
-  if (0 !== root.tag && 2 === exitStatus) {
-    var originallyAttemptedLanes = lanes,
-      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-        root,
-        originallyAttemptedLanes
-      );
-    0 !== errorRetryLanes &&
-      ((lanes = errorRetryLanes),
-      (exitStatus = recoverFromConcurrentError(
-        root,
-        originallyAttemptedLanes,
-        errorRetryLanes
-      )));
-  }
-  if (1 === exitStatus)
-    throw (
-      ((exitStatus = workInProgressRootFatalError),
-      prepareFreshStack(root, 0),
-      markRootSuspended(root, lanes),
-      ensureRootIsScheduled(root, now$1()),
-      exitStatus)
-    );
-  if (6 === exitStatus)
-    return (
-      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now$1()), null
-    );
-  root.finishedWork = root.current.alternate;
-  root.finishedLanes = lanes;
-  commitRoot(
-    root,
-    workInProgressRootRecoverableErrors,
-    workInProgressTransitions
+function createFiberFromPortal(portal, mode, lanes) {
+  mode = createFiber(
+    4,
+    null !== portal.children ? portal.children : [],
+    portal.key,
+    mode
+  );
+  mode.lanes = lanes;
+  mode.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    implementation: portal.implementation
+  };
+  return mode;
+}
+function FiberRootNode(
+  containerInfo,
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
+) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.finishedWork =
+    this.pingCache =
+    this.current =
+    this.pendingChildren =
+      null;
+  this.timeoutHandle = -1;
+  this.callbackNode = this.pendingContext = this.context = null;
+  this.callbackPriority = 0;
+  this.eventTimes = createLaneMap(0);
+  this.expirationTimes = createLaneMap(-1);
+  this.entangledLanes =
+    this.errorRecoveryDisabledLanes =
+    this.finishedLanes =
+    this.mutableReadLanes =
+    this.expiredLanes =
+    this.pingedLanes =
+    this.suspendedLanes =
+    this.pendingLanes =
+      0;
+  this.entanglements = createLaneMap(0);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+  this.pooledCache = null;
+  this.pooledCacheLanes = 0;
+  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
+  this.incompleteTransitions = new Map();
+  if (enableTransitionTracing)
+    for (
+      this.transitionCallbacks = null,
+        containerInfo = this.transitionLanes = [],
+        tag = 0;
+      31 > tag;
+      tag++
+    )
+      containerInfo.push(null);
+  this.passiveEffectDuration = this.effectDuration = 0;
+  this.memoizedUpdaters = new Set();
+  containerInfo = this.pendingUpdatersLaneMap = [];
+  for (tag = 0; 31 > tag; tag++) containerInfo.push(new Set());
+}
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  containerInfo = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
   );
-  ensureRootIsScheduled(root, now$1());
-  return null;
+  containerInfo.hydrationCallbacks = hydrationCallbacks;
+  enableTransitionTracing &&
+    (containerInfo.transitionCallbacks = transitionCallbacks);
+  1 === tag
+    ? ((tag = 1),
+      !0 === isStrictMode && (tag |= 24),
+      concurrentUpdatesByDefaultOverride && (tag |= 32))
+    : (tag = 0);
+  isDevToolsPresent && (tag |= 2);
+  isStrictMode = createFiber(3, null, null, tag);
+  containerInfo.current = isStrictMode;
+  isStrictMode.stateNode = containerInfo;
+  concurrentUpdatesByDefaultOverride = createCache();
+  concurrentUpdatesByDefaultOverride.refCount++;
+  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
+  concurrentUpdatesByDefaultOverride.refCount++;
+  isStrictMode.memoizedState = {
+    element: initialChildren,
+    isDehydrated: hydrate,
+    cache: concurrentUpdatesByDefaultOverride
+  };
+  initializeUpdateQueue(isStrictMode);
+  return containerInfo;
 }
-function batchedUpdates(fn, a) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
-  try {
-    return fn(a);
-  } finally {
-    (executionContext = prevExecutionContext),
-      0 === executionContext &&
-        (resetRenderTimer(),
-        includesLegacySyncCallbacks && flushSyncCallbacks());
-  }
+function createPortal$1(children, containerInfo, implementation) {
+  var key =
+    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+  return {
+    $$typeof: REACT_PORTAL_TYPE,
+    key: null == key ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
 }
-function flushSync$1(fn) {
-  null !== rootWithPendingPassiveEffects &&
-    0 === rootWithPendingPassiveEffects.tag &&
-    0 === (executionContext & 6) &&
-    flushPassiveEffects();
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
-    previousPriority = currentUpdatePriority;
-  try {
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) return emptyContextObject;
+  parentComponent = parentComponent._reactInternals;
+  a: {
     if (
-      ((ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      fn)
+      getNearestMountedFiber(parentComponent) !== parentComponent ||
+      1 !== parentComponent.tag
     )
-      return fn();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
-      (executionContext = prevExecutionContext),
-      0 === (executionContext & 6) && flushSyncCallbacks();
+      throw Error(formatProdErrorMessage(170));
+    var JSCompiler_inline_result = parentComponent;
+    do {
+      switch (JSCompiler_inline_result.tag) {
+        case 3:
+          JSCompiler_inline_result = JSCompiler_inline_result.stateNode.context;
+          break a;
+        case 1:
+          if (isContextProvider(JSCompiler_inline_result.type)) {
+            JSCompiler_inline_result =
+              JSCompiler_inline_result.stateNode
+                .__reactInternalMemoizedMergedChildContext;
+            break a;
+          }
+      }
+      JSCompiler_inline_result = JSCompiler_inline_result.return;
+    } while (null !== JSCompiler_inline_result);
+    throw Error(formatProdErrorMessage(171));
   }
-}
-function resetWorkInProgressStack() {
-  if (null !== workInProgress) {
-    if (0 === workInProgressSuspendedReason)
-      var interruptedWork = workInProgress.return;
-    else
-      resetContextDependencies(),
-        resetHooksOnUnwind(),
-        (thenableState$1 = null),
-        (thenableIndexCounter$1 = 0),
-        (interruptedWork = workInProgress);
-    for (; null !== interruptedWork; )
-      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
-        (interruptedWork = interruptedWork.return);
-    workInProgress = null;
+  if (1 === parentComponent.tag) {
+    var Component = parentComponent.type;
+    if (isContextProvider(Component))
+      return processChildContext(
+        parentComponent,
+        Component,
+        JSCompiler_inline_result
+      );
   }
+  return JSCompiler_inline_result;
 }
-function prepareFreshStack(root, lanes) {
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  var timeoutHandle = root.timeoutHandle;
-  -1 !== timeoutHandle &&
-    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
-  resetWorkInProgressStack();
-  workInProgressRoot = root;
-  workInProgress = root = createWorkInProgress(root.current, null);
-  workInProgressRootRenderLanes = renderLanes = lanes;
-  workInProgressSuspendedReason = 0;
-  workInProgressThrownValue = null;
-  workInProgressRootDidAttachPingListener = !1;
-  workInProgressRootExitStatus = 0;
-  workInProgressRootFatalError = null;
-  workInProgressRootPingedLanes =
-    workInProgressRootInterleavedUpdatedLanes =
-    workInProgressRootSkippedLanes =
-      0;
-  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
-    null;
-  finishQueueingConcurrentUpdates();
-  return root;
+function createHydrationContainer(
+  initialChildren,
+  callback,
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  initialChildren = createFiberRoot(
+    containerInfo,
+    tag,
+    !0,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
+  );
+  initialChildren.context = getContextForSubtree(null);
+  containerInfo = initialChildren.current;
+  tag = requestUpdateLane(containerInfo);
+  hydrationCallbacks = createUpdate(tag);
+  hydrationCallbacks.callback =
+    void 0 !== callback && null !== callback ? callback : null;
+  callback = requestEventTime();
+  enqueueUpdate(containerInfo, hydrationCallbacks, tag);
+  initialChildren.current.lanes = tag;
+  markRootUpdated(initialChildren, tag, callback);
+  ensureRootIsScheduled(initialChildren, callback);
+  return initialChildren;
 }
-function handleThrow(root, thrownValue) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  ReactCurrentOwner.current = null;
-  if (thrownValue === SuspenseException) {
-    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
-    thrownValue = suspendedThenable;
-    suspendedThenable = null;
-    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
-      ? 2
-      : 3;
-  } else
-    workInProgressSuspendedReason =
-      thrownValue === SelectiveHydrationException
-        ? 6
-        : null !== thrownValue &&
-          "object" === typeof thrownValue &&
-          "function" === typeof thrownValue.then
-        ? 4
-        : 1;
-  workInProgressThrownValue = thrownValue;
-  root = workInProgress;
-  if (null === root)
-    (workInProgressRootExitStatus = 1),
-      (workInProgressRootFatalError = thrownValue);
-  else if (
-    (root.mode & 2 && stopProfilerTimerIfRunningAndRecordDelta(root, !0),
-    enableSchedulingProfiler)
-  )
-    switch ((markComponentRenderStopped(), workInProgressSuspendedReason)) {
-      case 1:
-        enableSchedulingProfiler &&
-          null !== injectedProfilingHooks &&
-          "function" === typeof injectedProfilingHooks.markComponentErrored &&
-          injectedProfilingHooks.markComponentErrored(
-            root,
-            thrownValue,
-            workInProgressRootRenderLanes
-          );
-        break;
-      case 2:
-      case 3:
-      case 4:
-      case 5:
-        enableSchedulingProfiler &&
-          null !== injectedProfilingHooks &&
-          "function" === typeof injectedProfilingHooks.markComponentSuspended &&
-          injectedProfilingHooks.markComponentSuspended(
-            root,
-            thrownValue,
-            workInProgressRootRenderLanes
-          );
-    }
+function updateContainer(element, container, parentComponent, callback) {
+  var current = container.current,
+    lane = requestUpdateLane(current);
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markRenderScheduled &&
+    injectedProfilingHooks.markRenderScheduled(lane);
+  parentComponent = getContextForSubtree(parentComponent);
+  null === container.context
+    ? (container.context = parentComponent)
+    : (container.pendingContext = parentComponent);
+  container = createUpdate(lane);
+  container.payload = { element: element };
+  callback = void 0 === callback ? null : callback;
+  null !== callback && (container.callback = callback);
+  element = enqueueUpdate(current, container, lane);
+  null !== element &&
+    ((callback = requestEventTime()),
+    scheduleUpdateOnFiber(element, current, lane, callback),
+    entangleTransitions(element, current, lane));
+  return lane;
 }
-function shouldAttemptToSuspendUntilDataResolves() {
-  if (
-    0 !== (workInProgressRootSkippedLanes & 268435455) ||
-    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
-  )
-    return !1;
-  if (
-    (workInProgressRootRenderLanes & 8388480) ===
-    workInProgressRootRenderLanes
-  )
-    return null === shellBoundary;
-  var handler = suspenseHandlerStackCursor.current;
-  return null !== handler &&
-    (workInProgressRootRenderLanes & 125829120) ===
-      workInProgressRootRenderLanes
-    ? handler === shellBoundary
-    : !1;
+function getPublicRootInstance(container) {
+  container = container.current;
+  if (!container.child) return null;
+  switch (container.child.tag) {
+    case 27:
+    case 5:
+      return container.child.stateNode;
+    default:
+      return container.child.stateNode;
+  }
 }
-function pushDispatcher(container) {
-  container = getHoistableRoot(container);
-  lastCurrentDocument = container.ownerDocument || container;
-  previousDispatcher = Dispatcher$1.current;
-  Dispatcher$1.current = ReactDOMClientDispatcher;
-  container = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
-  return null === container ? ContextOnlyDispatcher : container;
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case 3:
+      var root$229 = fiber.stateNode;
+      if (root$229.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$229.pendingLanes);
+        0 !== lanes &&
+          (markRootEntangled(root$229, lanes | 2),
+          ensureRootIsScheduled(root$229, now$1()),
+          0 === (executionContext & 6) &&
+            (resetRenderTimer(), flushSyncCallbacks()));
+      }
+      break;
+    case 13:
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, 2);
+        if (null !== root) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
+        }
+      }),
+        markRetryLaneIfNotHydrated(fiber, 2);
+  }
 }
-function pushCacheDispatcher() {
-  var prevCacheDispatcher = ReactCurrentCache.current;
-  ReactCurrentCache.current = DefaultCacheDispatcher;
-  return prevCacheDispatcher;
+function markRetryLaneImpl(fiber, retryLane) {
+  fiber = fiber.memoizedState;
+  if (null !== fiber && null !== fiber.dehydrated) {
+    var a = fiber.retryLane;
+    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+  }
 }
-function renderDidSuspendDelayIfPossible() {
-  workInProgressRootExitStatus = 4;
-  null === workInProgressRoot ||
-    (0 === (workInProgressRootSkippedLanes & 268435455) &&
-      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
-    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
 }
-function renderRootSync(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    if (isDevToolsPresent) {
-      var memoizedUpdaters = root.memoizedUpdaters;
-      0 < memoizedUpdaters.size &&
-        (restorePendingUpdaters(root, workInProgressRootRenderLanes),
-        memoizedUpdaters.clear());
-      movePendingFibersToMemoized(root, lanes);
+function attemptContinuousHydration(fiber) {
+  if (13 === fiber.tag) {
+    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
+    if (null !== root) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
     }
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    prepareFreshStack(root, lanes);
+    markRetryLaneIfNotHydrated(fiber, 134217728);
   }
-  enableSchedulingProfiler && markRenderStarted(lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress)
-        switch (
-          ((lanes = workInProgress),
-          (memoizedUpdaters = workInProgressThrownValue),
-          workInProgressSuspendedReason)
-        ) {
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            (workInProgressSuspendedReason = 0),
-              (workInProgressThrownValue = null),
-              unwindSuspendedUnitOfWork(lanes, memoizedUpdaters);
-        }
-      workLoopSync();
-      break;
-    } catch (thrownValue$235) {
-      handleThrow(root, thrownValue$235);
-    }
-  while (1);
-  resetContextDependencies();
-  executionContext = prevExecutionContext;
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
-  enableSchedulingProfiler && markRenderStopped();
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
 }
-function workLoopSync() {
-  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+function emptyFindFiberByHostInstance() {
+  return null;
 }
-function renderRootConcurrent(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    if (isDevToolsPresent) {
-      var memoizedUpdaters = root.memoizedUpdaters;
-      0 < memoizedUpdaters.size &&
-        (restorePendingUpdaters(root, workInProgressRootRenderLanes),
-        memoizedUpdaters.clear());
-      movePendingFibersToMemoized(root, lanes);
-    }
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    resetRenderTimer();
-    prepareFreshStack(root, lanes);
+var isInsideEventHandler = !1;
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) return fn(a, b);
+  isInsideEventHandler = !0;
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    if (
+      ((isInsideEventHandler = !1),
+      null !== restoreTarget || null !== restoreQueue)
+    )
+      flushSync$1(), restoreStateIfNeeded();
   }
-  enableSchedulingProfiler && markRenderStarted(lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress)
-        switch (
-          ((lanes = workInProgress),
-          (memoizedUpdaters = workInProgressThrownValue),
-          workInProgressSuspendedReason)
-        ) {
-          case 1:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, memoizedUpdaters);
-            break;
-          case 2:
-            if (isThenableResolved(memoizedUpdaters)) {
-              workInProgressSuspendedReason = 0;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(lanes);
-              break;
-            }
-            lanes = function () {
-              2 === workInProgressSuspendedReason &&
-                workInProgressRoot === root &&
-                (workInProgressSuspendedReason = 5);
-              ensureRootIsScheduled(root, now$1());
-            };
-            memoizedUpdaters.then(lanes, lanes);
-            break a;
-          case 3:
-            workInProgressSuspendedReason = 5;
-            break a;
-          case 5:
-            isThenableResolved(memoizedUpdaters)
-              ? ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                replaySuspendedUnitOfWork(lanes))
-              : ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                unwindSuspendedUnitOfWork(lanes, memoizedUpdaters));
-            break;
-          case 4:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, memoizedUpdaters);
-            break;
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            throw Error(formatProdErrorMessage(462));
-        }
-      workLoopConcurrent();
-      break;
-    } catch (thrownValue$237) {
-      handleThrow(root, thrownValue$237);
-    }
-  while (1);
-  resetContextDependencies();
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  executionContext = prevExecutionContext;
-  if (null !== workInProgress)
-    return (
-      enableSchedulingProfiler &&
-        enableSchedulingProfiler &&
-        null !== injectedProfilingHooks &&
-        "function" === typeof injectedProfilingHooks.markRenderYielded &&
-        injectedProfilingHooks.markRenderYielded(),
-      0
+}
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
+  if (null === stateNode) return null;
+  var props = getFiberCurrentPropsFromNode(stateNode);
+  if (null === props) return null;
+  stateNode = props[registrationName];
+  a: switch (registrationName) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      (props = !props.disabled) ||
+        ((inst = inst.type),
+        (props = !(
+          "button" === inst ||
+          "input" === inst ||
+          "select" === inst ||
+          "textarea" === inst
+        )));
+      inst = !props;
+      break a;
+    default:
+      inst = !1;
+  }
+  if (inst) return null;
+  if (stateNode && "function" !== typeof stateNode)
+    throw Error(
+      formatProdErrorMessage(231, registrationName, typeof stateNode)
     );
-  enableSchedulingProfiler && markRenderStopped();
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
+  return stateNode;
 }
-function workLoopConcurrent() {
-  for (; null !== workInProgress && !shouldYield(); )
-    performUnitOfWork(workInProgress);
+var passiveBrowserEventsSupported = !1;
+if (canUseDOM)
+  try {
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = !0;
+      }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = !1;
+  }
+var EventListenerWWW = require("EventListener"),
+  root = null,
+  startText = null,
+  fallbackText = null;
+function getData() {
+  if (fallbackText) return fallbackText;
+  var start,
+    startValue = startText,
+    startLength = startValue.length,
+    end,
+    endValue = "value" in root ? root.value : root.textContent,
+    endLength = endValue.length;
+  for (
+    start = 0;
+    start < startLength && startValue[start] === endValue[start];
+    start++
+  );
+  var minEnd = startLength - start;
+  for (
+    end = 1;
+    end <= minEnd &&
+    startValue[startLength - end] === endValue[endLength - end];
+    end++
+  );
+  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
 }
-function performUnitOfWork(unitOfWork) {
-  var current = unitOfWork.alternate;
-  0 !== (unitOfWork.mode & 2)
-    ? (startProfilerTimer(unitOfWork),
-      (current = beginWork(current, unitOfWork, renderLanes)),
-      stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, !0))
-    : (current = beginWork(current, unitOfWork, renderLanes));
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === current
-    ? completeUnitOfWork(unitOfWork)
-    : (workInProgress = current);
-  ReactCurrentOwner.current = null;
+function getEventCharCode(nativeEvent) {
+  var keyCode = nativeEvent.keyCode;
+  "charCode" in nativeEvent
+    ? ((nativeEvent = nativeEvent.charCode),
+      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
+    : (nativeEvent = keyCode);
+  10 === nativeEvent && (nativeEvent = 13);
+  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
+}
+function functionThatReturnsTrue() {
+  return !0;
+}
+function functionThatReturnsFalse() {
+  return !1;
+}
+function createSyntheticEvent(Interface) {
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  ) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+    for (var propName in Interface)
+      Interface.hasOwnProperty(propName) &&
+        ((reactName = Interface[propName]),
+        (this[propName] = reactName
+          ? reactName(nativeEvent)
+          : nativeEvent[propName]));
+    this.isDefaultPrevented = (
+      null != nativeEvent.defaultPrevented
+        ? nativeEvent.defaultPrevented
+        : !1 === nativeEvent.returnValue
+    )
+      ? functionThatReturnsTrue
+      : functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  }
+  assign(SyntheticBaseEvent.prototype, {
+    preventDefault: function () {
+      this.defaultPrevented = !0;
+      var event = this.nativeEvent;
+      event &&
+        (event.preventDefault
+          ? event.preventDefault()
+          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
+        (this.isDefaultPrevented = functionThatReturnsTrue));
+    },
+    stopPropagation: function () {
+      var event = this.nativeEvent;
+      event &&
+        (event.stopPropagation
+          ? event.stopPropagation()
+          : "unknown" !== typeof event.cancelBubble &&
+            (event.cancelBubble = !0),
+        (this.isPropagationStopped = functionThatReturnsTrue));
+    },
+    persist: function () {},
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+var EventInterface = {
+    eventPhase: 0,
+    bubbles: 0,
+    cancelable: 0,
+    timeStamp: function (event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: 0,
+    isTrusted: 0
+  },
+  SyntheticEvent = createSyntheticEvent(EventInterface),
+  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
+  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
+  lastMovementX,
+  lastMovementY,
+  lastMouseEvent,
+  MouseEventInterface = assign({}, UIEventInterface, {
+    screenX: 0,
+    screenY: 0,
+    clientX: 0,
+    clientY: 0,
+    pageX: 0,
+    pageY: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    getModifierState: getEventModifierState,
+    button: 0,
+    buttons: 0,
+    relatedTarget: function (event) {
+      return void 0 === event.relatedTarget
+        ? event.fromElement === event.srcElement
+          ? event.toElement
+          : event.fromElement
+        : event.relatedTarget;
+    },
+    movementX: function (event) {
+      if ("movementX" in event) return event.movementX;
+      event !== lastMouseEvent &&
+        (lastMouseEvent && "mousemove" === event.type
+          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
+            (lastMovementY = event.screenY - lastMouseEvent.screenY))
+          : (lastMovementY = lastMovementX = 0),
+        (lastMouseEvent = event));
+      return lastMovementX;
+    },
+    movementY: function (event) {
+      return "movementY" in event ? event.movementY : lastMovementY;
+    }
+  }),
+  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
+  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
+  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
+  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
+  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
+  AnimationEventInterface = assign({}, EventInterface, {
+    animationName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
+  ClipboardEventInterface = assign({}, EventInterface, {
+    clipboardData: function (event) {
+      return "clipboardData" in event
+        ? event.clipboardData
+        : window.clipboardData;
+    }
+  }),
+  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
+  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
+  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
+  normalizeKey = {
+    Esc: "Escape",
+    Spacebar: " ",
+    Left: "ArrowLeft",
+    Up: "ArrowUp",
+    Right: "ArrowRight",
+    Down: "ArrowDown",
+    Del: "Delete",
+    Win: "OS",
+    Menu: "ContextMenu",
+    Apps: "ContextMenu",
+    Scroll: "ScrollLock",
+    MozPrintableKey: "Unidentified"
+  },
+  translateToKey = {
+    8: "Backspace",
+    9: "Tab",
+    12: "Clear",
+    13: "Enter",
+    16: "Shift",
+    17: "Control",
+    18: "Alt",
+    19: "Pause",
+    20: "CapsLock",
+    27: "Escape",
+    32: " ",
+    33: "PageUp",
+    34: "PageDown",
+    35: "End",
+    36: "Home",
+    37: "ArrowLeft",
+    38: "ArrowUp",
+    39: "ArrowRight",
+    40: "ArrowDown",
+    45: "Insert",
+    46: "Delete",
+    112: "F1",
+    113: "F2",
+    114: "F3",
+    115: "F4",
+    116: "F5",
+    117: "F6",
+    118: "F7",
+    119: "F8",
+    120: "F9",
+    121: "F10",
+    122: "F11",
+    123: "F12",
+    144: "NumLock",
+    145: "ScrollLock",
+    224: "Meta"
+  },
+  modifierKeyToProp = {
+    Alt: "altKey",
+    Control: "ctrlKey",
+    Meta: "metaKey",
+    Shift: "shiftKey"
+  };
+function modifierStateGetter(keyArg) {
+  var nativeEvent = this.nativeEvent;
+  return nativeEvent.getModifierState
+    ? nativeEvent.getModifierState(keyArg)
+    : (keyArg = modifierKeyToProp[keyArg])
+    ? !!nativeEvent[keyArg]
+    : !1;
 }
-function replaySuspendedUnitOfWork(unitOfWork) {
-  var current = unitOfWork.alternate,
-    isProfilingMode = 0 !== (unitOfWork.mode & 2);
-  isProfilingMode && startProfilerTimer(unitOfWork);
-  switch (unitOfWork.tag) {
-    case 2:
-      unitOfWork.tag = 0;
-    case 0:
-    case 11:
-      var Component = unitOfWork.type,
-        unresolvedProps = unitOfWork.pendingProps;
-      unresolvedProps =
-        unitOfWork.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unresolvedProps,
-        Component,
-        workInProgressRootRenderLanes
-      );
-      break;
-    case 15:
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unitOfWork.pendingProps,
-        unitOfWork.type,
-        workInProgressRootRenderLanes
-      );
-      break;
-    default:
-      unwindInterruptedWork(current, unitOfWork),
-        (unitOfWork = workInProgress =
-          resetWorkInProgress(unitOfWork, renderLanes)),
-        (current = beginWork(current, unitOfWork, renderLanes));
-  }
-  isProfilingMode && stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, !0);
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === current
-    ? completeUnitOfWork(unitOfWork)
-    : (workInProgress = current);
-  ReactCurrentOwner.current = null;
+function getEventModifierState() {
+  return modifierStateGetter;
 }
-function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
-  resetContextDependencies();
-  resetHooksOnUnwind();
-  thenableState$1 = null;
-  thenableIndexCounter$1 = 0;
-  var returnFiber = unitOfWork.return;
-  if (null === returnFiber || null === workInProgressRoot)
-    (workInProgressRootExitStatus = 1),
-      (workInProgressRootFatalError = thrownValue),
-      (workInProgress = null);
-  else {
-    try {
-      a: {
-        var root = workInProgressRoot,
-          value = thrownValue;
-        thrownValue = workInProgressRootRenderLanes;
-        unitOfWork.flags |= 32768;
-        isDevToolsPresent && restorePendingUpdaters(root, thrownValue);
-        if (
-          null !== value &&
-          "object" === typeof value &&
-          "function" === typeof value.then
-        ) {
-          var wakeable = value;
-          if (enableLazyContextPropagation) {
-            var currentSourceFiber = unitOfWork.alternate;
-            null !== currentSourceFiber &&
-              propagateParentContextChanges(
-                currentSourceFiber,
-                unitOfWork,
-                thrownValue,
-                !0
-              );
-          }
-          var tag = unitOfWork.tag;
-          if (
-            0 === (unitOfWork.mode & 1) &&
-            (0 === tag || 11 === tag || 15 === tag)
-          ) {
-            var currentSource = unitOfWork.alternate;
-            currentSource
-              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
-                (unitOfWork.memoizedState = currentSource.memoizedState),
-                (unitOfWork.lanes = currentSource.lanes))
-              : ((unitOfWork.updateQueue = null),
-                (unitOfWork.memoizedState = null));
-          }
-          var suspenseBoundary = suspenseHandlerStackCursor.current;
-          if (null !== suspenseBoundary) {
-            switch (suspenseBoundary.tag) {
-              case 13:
-                unitOfWork.mode & 1 &&
-                  (null === shellBoundary
-                    ? renderDidSuspendDelayIfPossible()
-                    : null === suspenseBoundary.alternate &&
-                      0 === workInProgressRootExitStatus &&
-                      (workInProgressRootExitStatus = 3));
-                suspenseBoundary.flags &= -257;
-                markSuspenseBoundaryShouldCapture(
-                  suspenseBoundary,
-                  returnFiber,
-                  unitOfWork,
-                  root,
-                  thrownValue
-                );
-                var wakeables = suspenseBoundary.updateQueue;
-                null === wakeables
-                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
-                  : wakeables.add(wakeable);
-                break;
-              case 22:
-                if (suspenseBoundary.mode & 1) {
-                  suspenseBoundary.flags |= 65536;
-                  var offscreenQueue = suspenseBoundary.updateQueue;
-                  if (null === offscreenQueue) {
-                    var newOffscreenQueue = {
-                      transitions: null,
-                      markerInstances: null,
-                      wakeables: new Set([wakeable])
-                    };
-                    suspenseBoundary.updateQueue = newOffscreenQueue;
-                  } else {
-                    var wakeables$104 = offscreenQueue.wakeables;
-                    null === wakeables$104
-                      ? (offscreenQueue.wakeables = new Set([wakeable]))
-                      : wakeables$104.add(wakeable);
-                  }
-                  break;
-                }
-              default:
-                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
-            }
-            suspenseBoundary.mode & 1 &&
-              attachPingListener(root, wakeable, thrownValue);
-            break a;
-          } else if (1 === root.tag) {
-            attachPingListener(root, wakeable, thrownValue);
-            renderDidSuspendDelayIfPossible();
-            break a;
-          } else value = Error(formatProdErrorMessage(426));
-        } else if (
-          isHydrating &&
-          unitOfWork.mode & 1 &&
-          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
-        ) {
-          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
-          markSuspenseBoundaryShouldCapture(
-            wakeable,
-            returnFiber,
-            unitOfWork,
-            root,
-            thrownValue
-          );
-          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
-          break a;
-        }
-        root = value = createCapturedValueAtFiber(value, unitOfWork);
-        4 !== workInProgressRootExitStatus &&
-          (workInProgressRootExitStatus = 2);
-        null === workInProgressRootConcurrentErrors
-          ? (workInProgressRootConcurrentErrors = [root])
-          : workInProgressRootConcurrentErrors.push(root);
-        root = returnFiber;
-        do {
-          switch (root.tag) {
-            case 3:
-              var errorInfo = value;
-              root.flags |= 65536;
-              thrownValue &= -thrownValue;
-              root.lanes |= thrownValue;
-              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
-              enqueueCapturedUpdate(root, update);
-              break a;
-            case 1:
-              currentSourceFiber = value;
-              var ctor = root.type,
-                instance = root.stateNode;
-              if (
-                0 === (root.flags & 128) &&
-                ("function" === typeof ctor.getDerivedStateFromError ||
-                  (null !== instance &&
-                    "function" === typeof instance.componentDidCatch &&
-                    (null === legacyErrorBoundariesThatAlreadyFailed ||
-                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
-              ) {
-                root.flags |= 65536;
-                update = thrownValue & -thrownValue;
-                root.lanes |= update;
-                errorInfo = createClassErrorUpdate(
-                  root,
-                  currentSourceFiber,
-                  update
-                );
-                enqueueCapturedUpdate(root, errorInfo);
-                break a;
-              }
-          }
-          root = root.return;
-        } while (null !== root);
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+    key: function (nativeEvent) {
+      if (nativeEvent.key) {
+        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+        if ("Unidentified" !== key) return key;
       }
-    } catch (error) {
-      throw ((workInProgress = returnFiber), error);
+      return "keypress" === nativeEvent.type
+        ? ((nativeEvent = getEventCharCode(nativeEvent)),
+          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
+        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
+        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
+        : "";
+    },
+    code: 0,
+    location: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    repeat: 0,
+    locale: 0,
+    getModifierState: getEventModifierState,
+    charCode: function (event) {
+      return "keypress" === event.type ? getEventCharCode(event) : 0;
+    },
+    keyCode: function (event) {
+      return "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
+    },
+    which: function (event) {
+      return "keypress" === event.type
+        ? getEventCharCode(event)
+        : "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
     }
-    completeUnitOfWork(unitOfWork);
+  }),
+  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
+  PointerEventInterface = assign({}, MouseEventInterface, {
+    pointerId: 0,
+    width: 0,
+    height: 0,
+    pressure: 0,
+    tangentialPressure: 0,
+    tiltX: 0,
+    tiltY: 0,
+    twist: 0,
+    pointerType: 0,
+    isPrimary: 0
+  }),
+  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
+  TouchEventInterface = assign({}, UIEventInterface, {
+    touches: 0,
+    targetTouches: 0,
+    changedTouches: 0,
+    altKey: 0,
+    metaKey: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    getModifierState: getEventModifierState
+  }),
+  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
+  TransitionEventInterface = assign({}, EventInterface, {
+    propertyName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
+  WheelEventInterface = assign({}, MouseEventInterface, {
+    deltaX: function (event) {
+      return "deltaX" in event
+        ? event.deltaX
+        : "wheelDeltaX" in event
+        ? -event.wheelDeltaX
+        : 0;
+    },
+    deltaY: function (event) {
+      return "deltaY" in event
+        ? event.deltaY
+        : "wheelDeltaY" in event
+        ? -event.wheelDeltaY
+        : "wheelDelta" in event
+        ? -event.wheelDelta
+        : 0;
+    },
+    deltaZ: 0,
+    deltaMode: 0
+  }),
+  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
+  END_KEYCODES = [9, 13, 27, 32],
+  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
+  documentMode = null;
+canUseDOM &&
+  "documentMode" in document &&
+  (documentMode = document.documentMode);
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
+  useFallbackCompositionData =
+    canUseDOM &&
+    (!canUseCompositionEvent ||
+      (documentMode && 8 < documentMode && 11 >= documentMode)),
+  SPACEBAR_CHAR = String.fromCharCode(32),
+  hasSpaceKeypress = !1;
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
+    case "keydown":
+      return 229 !== nativeEvent.keyCode;
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      return !0;
+    default:
+      return !1;
   }
 }
-function completeUnitOfWork(unitOfWork) {
-  var completedWork = unitOfWork;
-  do {
-    var current = completedWork.alternate;
-    unitOfWork = completedWork.return;
-    if (0 === (completedWork.flags & 32768)) {
+function getDataFromCustomEvent(nativeEvent) {
+  nativeEvent = nativeEvent.detail;
+  return "object" === typeof nativeEvent && "data" in nativeEvent
+    ? nativeEvent.data
+    : null;
+}
+var isComposing = !1;
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
+    case "keypress":
+      if (32 !== nativeEvent.which) return null;
+      hasSpaceKeypress = !0;
+      return SPACEBAR_CHAR;
+    case "textInput":
+      return (
+        (domEventName = nativeEvent.data),
+        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
+      );
+    default:
+      return null;
+  }
+}
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  if (isComposing)
+    return "compositionend" === domEventName ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+      ? ((domEventName = getData()),
+        (fallbackText = startText = root = null),
+        (isComposing = !1),
+        domEventName)
+      : null;
+  switch (domEventName) {
+    case "paste":
+      return null;
+    case "keypress":
       if (
-        (0 === (completedWork.mode & 2)
-          ? (current = completeWork(current, completedWork, renderLanes))
-          : (startProfilerTimer(completedWork),
-            (current = completeWork(current, completedWork, renderLanes)),
-            stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1)),
-        null !== current)
+        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
+        (nativeEvent.ctrlKey && nativeEvent.altKey)
       ) {
-        workInProgress = current;
-        return;
-      }
-    } else {
-      current = unwindWork(current, completedWork);
-      if (null !== current) {
-        current.flags &= 16383;
-        workInProgress = current;
-        return;
-      }
-      if (0 !== (completedWork.mode & 2)) {
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1);
-        current = completedWork.actualDuration;
-        for (var child = completedWork.child; null !== child; )
-          (current += child.actualDuration), (child = child.sibling);
-        completedWork.actualDuration = current;
-      }
-      if (null !== unitOfWork)
-        (unitOfWork.flags |= 32768),
-          (unitOfWork.subtreeFlags = 0),
-          (unitOfWork.deletions = null);
-      else {
-        workInProgressRootExitStatus = 6;
-        workInProgress = null;
-        return;
+        if (nativeEvent.char && 1 < nativeEvent.char.length)
+          return nativeEvent.char;
+        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
       }
-    }
-    completedWork = completedWork.sibling;
-    if (null !== completedWork) {
-      workInProgress = completedWork;
-      return;
-    }
-    workInProgress = completedWork = unitOfWork;
-  } while (null !== completedWork);
-  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
-}
-function commitRoot(root, recoverableErrors, transitions) {
-  var previousUpdateLanePriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig.transition;
-  try {
-    (ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      commitRootImpl(
-        root,
-        recoverableErrors,
-        transitions,
-        previousUpdateLanePriority
-      );
-  } finally {
-    (ReactCurrentBatchConfig.transition = prevTransition),
-      (currentUpdatePriority = previousUpdateLanePriority);
+      return null;
+    case "compositionend":
+      return useFallbackCompositionData && "ko" !== nativeEvent.locale
+        ? null
+        : nativeEvent.data;
+    default:
+      return null;
   }
-  return null;
 }
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
-) {
-  do flushPassiveEffects();
-  while (null !== rootWithPendingPassiveEffects);
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var finishedWork = root.finishedWork,
-    lanes = root.finishedLanes;
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markCommitStarted &&
-    injectedProfilingHooks.markCommitStarted(lanes);
-  if (null === finishedWork)
-    return enableSchedulingProfiler && markCommitStopped(), null;
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
-  root.callbackNode = null;
-  root.callbackPriority = 0;
-  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
-  remainingLanes |= concurrentlyUpdatedLanes;
-  markRootFinished(root, remainingLanes);
-  root === workInProgressRoot &&
-    ((workInProgress = workInProgressRoot = null),
-    (workInProgressRootRenderLanes = 0));
-  (0 === (finishedWork.subtreeFlags & 10256) &&
-    0 === (finishedWork.flags & 10256)) ||
-    rootDoesHavePassiveEffects ||
-    ((rootDoesHavePassiveEffects = !0),
-    (pendingPassiveEffectsRemainingLanes = remainingLanes),
-    (pendingPassiveTransitions = transitions),
-    scheduleCallback(NormalPriority$1, function () {
-      flushPassiveEffects();
-      return null;
-    }));
-  transitions = 0 !== (finishedWork.flags & 15990);
-  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
-    transitions = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    var prevExecutionContext = executionContext;
-    executionContext |= 4;
-    ReactCurrentOwner.current = null;
-    var shouldFireAfterActiveInstanceBlur$240 = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
-    commitTime = now();
-    enableProfilerNestedUpdateScheduledHook &&
-      (rootCommittingMutationOrLayoutEffects = root);
-    commitMutationEffects(root, finishedWork, lanes);
-    shouldFireAfterActiveInstanceBlur$240 &&
-      ((_enabled = !0),
-      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
-      (_enabled = !1));
-    restoreSelection(selectionInformation);
-    _enabled = !!eventsEnabled;
-    selectionInformation = eventsEnabled = null;
-    root.current = finishedWork;
-    enableSchedulingProfiler &&
-      enableSchedulingProfiler &&
-      null !== injectedProfilingHooks &&
-      "function" === typeof injectedProfilingHooks.markLayoutEffectsStarted &&
-      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
-    commitLayoutEffects(finishedWork, root, lanes);
-    enableSchedulingProfiler &&
-      enableSchedulingProfiler &&
-      null !== injectedProfilingHooks &&
-      "function" === typeof injectedProfilingHooks.markLayoutEffectsStopped &&
-      injectedProfilingHooks.markLayoutEffectsStopped();
-    enableProfilerNestedUpdateScheduledHook &&
-      (rootCommittingMutationOrLayoutEffects = null);
-    requestPaint();
-    executionContext = prevExecutionContext;
-    currentUpdatePriority = previousPriority;
-    ReactCurrentBatchConfig.transition = transitions;
-  } else (root.current = finishedWork), (commitTime = now());
-  rootDoesHavePassiveEffects
-    ? ((rootDoesHavePassiveEffects = !1),
-      (rootWithPendingPassiveEffects = root),
-      (pendingPassiveEffectsLanes = lanes))
-    : releaseRootPooledCache(root, remainingLanes);
-  remainingLanes = root.pendingLanes;
-  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
-  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
-  isDevToolsPresent && root.memoizedUpdaters.clear();
-  ensureRootIsScheduled(root, now$1());
-  if (null !== recoverableErrors)
-    for (
-      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
-      finishedWork < recoverableErrors.length;
-      finishedWork++
-    )
-      (lanes = recoverableErrors[finishedWork]),
-        (remainingLanes = {
-          digest: lanes.digest,
-          componentStack: lanes.stack
-        }),
-        renderPriorityLevel(lanes.value, remainingLanes);
-  if (hasUncaughtError)
-    throw (
-      ((hasUncaughtError = !1),
-      (root = firstUncaughtError),
-      (firstUncaughtError = null),
-      root)
+var supportedInputTypes = {
+  color: !0,
+  date: !0,
+  datetime: !0,
+  "datetime-local": !0,
+  email: !0,
+  month: !0,
+  number: !0,
+  password: !0,
+  range: !0,
+  search: !0,
+  tel: !0,
+  text: !0,
+  time: !0,
+  url: !0,
+  week: !0
+};
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return "input" === nodeName
+    ? !!supportedInputTypes[elem.type]
+    : "textarea" === nodeName
+    ? !0
+    : !1;
+}
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
+) {
+  enqueueStateRestore(target);
+  inst = accumulateTwoPhaseListeners(inst, "onChange");
+  0 < inst.length &&
+    ((nativeEvent = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    )),
+    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+}
+var activeElement$1 = null,
+  activeElementInst$1 = null;
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
+  if (updateValueIfChanged(targetNode)) return targetInst;
+}
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if ("change" === domEventName) return targetInst;
+}
+var isInputEventSupported = !1;
+if (canUseDOM) {
+  var JSCompiler_inline_result$jscomp$330;
+  if (canUseDOM) {
+    var isSupported$jscomp$inline_1650 = "oninput" in document;
+    if (!isSupported$jscomp$inline_1650) {
+      var element$jscomp$inline_1651 = document.createElement("div");
+      element$jscomp$inline_1651.setAttribute("oninput", "return;");
+      isSupported$jscomp$inline_1650 =
+        "function" === typeof element$jscomp$inline_1651.oninput;
+    }
+    JSCompiler_inline_result$jscomp$330 = isSupported$jscomp$inline_1650;
+  } else JSCompiler_inline_result$jscomp$330 = !1;
+  isInputEventSupported =
+    JSCompiler_inline_result$jscomp$330 &&
+    (!document.documentMode || 9 < document.documentMode);
+}
+function stopWatchingForValueChange() {
+  activeElement$1 &&
+    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
+    (activeElementInst$1 = activeElement$1 = null));
+}
+function handlePropertyChange(nativeEvent) {
+  if (
+    "value" === nativeEvent.propertyName &&
+    getInstIfValueChanged(activeElementInst$1)
+  ) {
+    var dispatchQueue = [];
+    createAndAccumulateChangeEvent(
+      dispatchQueue,
+      activeElementInst$1,
+      nativeEvent,
+      getEventTarget(nativeEvent)
     );
-  0 !== (pendingPassiveEffectsLanes & 3) &&
-    0 !== root.tag &&
-    flushPassiveEffects();
-  remainingLanes = root.pendingLanes;
-  0 !== (remainingLanes & 3)
-    ? ((nestedUpdateScheduled = !0),
-      root === rootWithNestedUpdates
-        ? nestedUpdateCount++
-        : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root)))
-    : (nestedUpdateCount = 0);
-  flushSyncCallbacks();
-  enableSchedulingProfiler && markCommitStopped();
-  if (enableTransitionTracing) {
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    null !== prevRootTransitionCallbacks &&
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-        null !== prevPendingTransitionCallbacks
-          ? ((currentPendingTransitionCallbacks = null),
-            scheduleCallback(IdlePriority, function () {
-              processTransitionCallbacks(
-                prevPendingTransitionCallbacks,
-                endTime,
-                prevRootTransitionCallbacks
-              );
-            }))
-          : (currentEndTime = endTime);
-      });
+    batchedUpdates(runEventInBatch, dispatchQueue);
   }
-  return null;
 }
-function releaseRootPooledCache(root, remainingLanes) {
-  0 === (root.pooledCacheLanes &= remainingLanes) &&
-    ((remainingLanes = root.pooledCache),
-    null != remainingLanes &&
-      ((root.pooledCache = null), releaseCache(remainingLanes)));
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  "focusin" === domEventName
+    ? (stopWatchingForValueChange(),
+      (activeElement$1 = target),
+      (activeElementInst$1 = targetInst),
+      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
+    : "focusout" === domEventName && stopWatchingForValueChange();
+}
+function getTargetInstForInputEventPolyfill(domEventName) {
+  if (
+    "selectionchange" === domEventName ||
+    "keyup" === domEventName ||
+    "keydown" === domEventName
+  )
+    return getInstIfValueChanged(activeElementInst$1);
+}
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
+}
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if ("input" === domEventName || "change" === domEventName)
+    return getInstIfValueChanged(targetInst);
+}
+var skipSelectionChangeEvent =
+    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
+  activeElement = null,
+  activeElementInst = null,
+  lastSelection = null,
+  mouseDown = !1;
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  var doc =
+    nativeEventTarget.window === nativeEventTarget
+      ? nativeEventTarget.document
+      : 9 === nativeEventTarget.nodeType
+      ? nativeEventTarget
+      : nativeEventTarget.ownerDocument;
+  mouseDown ||
+    null == activeElement ||
+    activeElement !== getActiveElement(doc) ||
+    ((doc = activeElement),
+    "selectionStart" in doc && hasSelectionCapabilities(doc)
+      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
+      : ((doc = (
+          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
+          window
+        ).getSelection()),
+        (doc = {
+          anchorNode: doc.anchorNode,
+          anchorOffset: doc.anchorOffset,
+          focusNode: doc.focusNode,
+          focusOffset: doc.focusOffset
+        })),
+    (lastSelection && shallowEqual(lastSelection, doc)) ||
+      ((lastSelection = doc),
+      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
+      0 < doc.length &&
+        ((nativeEvent = new SyntheticEvent(
+          "onSelect",
+          "select",
+          null,
+          nativeEvent,
+          nativeEventTarget
+        )),
+        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
+        (nativeEvent.target = activeElement))));
+}
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
+}
+var vendorPrefixes = {
+    animationend: makePrefixMap("Animation", "AnimationEnd"),
+    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+    animationstart: makePrefixMap("Animation", "AnimationStart"),
+    transitionend: makePrefixMap("Transition", "TransitionEnd")
+  },
+  prefixedEventNames = {},
+  style = {};
+canUseDOM &&
+  ((style = document.createElement("div").style),
+  "AnimationEvent" in window ||
+    (delete vendorPrefixes.animationend.animation,
+    delete vendorPrefixes.animationiteration.animation,
+    delete vendorPrefixes.animationstart.animation),
+  "TransitionEvent" in window ||
+    delete vendorPrefixes.transitionend.transition);
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
+  if (!vendorPrefixes[eventName]) return eventName;
+  var prefixMap = vendorPrefixes[eventName],
+    styleProp;
+  for (styleProp in prefixMap)
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
+  return eventName;
+}
+var ANIMATION_END = getVendorPrefixedEventName("animationend"),
+  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
+  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
+  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
+  topLevelEventsToReactNames = new Map(),
+  simpleEventPluginEvents =
+    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
+      " "
+    );
+topLevelEventsToReactNames.set("beforeblur", null);
+topLevelEventsToReactNames.set("afterblur", null);
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
+for (
+  var i$jscomp$inline_1663 = 0;
+  i$jscomp$inline_1663 < simpleEventPluginEvents.length;
+  i$jscomp$inline_1663++
+) {
+  var eventName$jscomp$inline_1664 =
+      simpleEventPluginEvents[i$jscomp$inline_1663],
+    domEventName$jscomp$inline_1665 =
+      eventName$jscomp$inline_1664.toLowerCase(),
+    capitalizedEvent$jscomp$inline_1666 =
+      eventName$jscomp$inline_1664[0].toUpperCase() +
+      eventName$jscomp$inline_1664.slice(1);
+  registerSimpleEvent(
+    domEventName$jscomp$inline_1665,
+    "on" + capitalizedEvent$jscomp$inline_1666
+  );
 }
-function flushPassiveEffects() {
-  if (null !== rootWithPendingPassiveEffects) {
-    var root$241 = rootWithPendingPassiveEffects,
-      remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = 0;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    renderPriority = 32 > renderPriority ? 32 : renderPriority;
-    var prevTransition = ReactCurrentBatchConfig.transition,
-      previousPriority = currentUpdatePriority;
-    try {
-      return (
-        (ReactCurrentBatchConfig.transition = null),
-        (currentUpdatePriority = renderPriority),
-        flushPassiveEffectsImpl()
-      );
-    } finally {
-      (currentUpdatePriority = previousPriority),
-        (ReactCurrentBatchConfig.transition = prevTransition),
-        releaseRootPooledCache(root$241, remainingLanes);
+registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+registerSimpleEvent("dblclick", "onDoubleClick");
+registerSimpleEvent("focusin", "onFocus");
+registerSimpleEvent("focusout", "onBlur");
+registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+registerTwoPhaseEvent(
+  "onChange",
+  "change click focusin focusout input keydown keyup selectionchange".split(" ")
+);
+registerTwoPhaseEvent(
+  "onSelect",
+  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
+    " "
+  )
+);
+registerTwoPhaseEvent("onBeforeInput", [
+  "compositionend",
+  "keypress",
+  "textInput",
+  "paste"
+]);
+registerTwoPhaseEvent(
+  "onCompositionEnd",
+  "compositionend focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionStart",
+  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionUpdate",
+  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
+);
+var mediaEventTypes =
+    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
+      " "
+    ),
+  nonDelegatedEvents = new Set(
+    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
+  );
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+  event.currentTarget = null;
+}
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  eventSystemFlags = 0 !== (eventSystemFlags & 4);
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event;
+    _dispatchQueue$i = _dispatchQueue$i.listeners;
+    a: {
+      var previousInstance = void 0;
+      if (eventSystemFlags)
+        for (
+          var i$jscomp$0 = _dispatchQueue$i.length - 1;
+          0 <= i$jscomp$0;
+          i$jscomp$0--
+        ) {
+          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
+        }
+      else
+        for (
+          i$jscomp$0 = 0;
+          i$jscomp$0 < _dispatchQueue$i.length;
+          i$jscomp$0++
+        ) {
+          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
+          instance = _dispatchListeners$i.instance;
+          currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
+        }
     }
   }
-  return !1;
+  if (hasRethrowError)
+    throw (
+      ((dispatchQueue = rethrowError),
+      (hasRethrowError = !1),
+      (rethrowError = null),
+      dispatchQueue)
+    );
 }
-function enqueuePendingPassiveProfilerEffect(fiber) {
-  pendingPassiveProfilerEffects.push(fiber);
-  rootDoesHavePassiveEffects ||
-    ((rootDoesHavePassiveEffects = !0),
-    scheduleCallback(NormalPriority$1, function () {
-      flushPassiveEffects();
-      return null;
-    }));
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+  var listenerSet = getEventListenerSet(targetElement),
+    listenerSetKey = domEventName + "__bubble";
+  listenerSet.has(listenerSetKey) ||
+    (addTrappedEventListener(targetElement, domEventName, 2, !1),
+    listenerSet.add(listenerSetKey));
 }
-function flushPassiveEffectsImpl() {
-  if (null === rootWithPendingPassiveEffects) return !1;
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects,
-    lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null;
-  pendingPassiveEffectsLanes = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markPassiveEffectsStarted &&
-    injectedProfilingHooks.markPassiveEffectsStarted(lanes);
-  var prevExecutionContext = executionContext;
-  executionContext |= 4;
-  commitPassiveUnmountOnFiber(root.current);
-  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
-  transitions = pendingPassiveProfilerEffects;
-  pendingPassiveProfilerEffects = [];
-  for (lanes = 0; lanes < transitions.length; lanes++)
-    commitPassiveEffectDurations(root, transitions[lanes]);
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markPassiveEffectsStopped &&
-    injectedProfilingHooks.markPassiveEffectsStopped();
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
-      prevRootTransitionCallbacks = root.transitionCallbacks,
-      prevEndTime = currentEndTime;
-    null !== prevPendingTransitionCallbacks &&
-      null !== prevRootTransitionCallbacks &&
-      null !== prevEndTime &&
-      ((currentEndTime = currentPendingTransitionCallbacks = null),
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
-        );
-      }));
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+  var eventSystemFlags = 0;
+  isCapturePhaseListener && (eventSystemFlags |= 4);
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
+}
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = !0;
+    allNativeEvents.forEach(function (domEventName) {
+      "selectionchange" !== domEventName &&
+        (nonDelegatedEvents.has(domEventName) ||
+          listenToNativeEvent(domEventName, !1, rootContainerElement),
+        listenToNativeEvent(domEventName, !0, rootContainerElement));
+    });
+    var ownerDocument =
+      9 === rootContainerElement.nodeType
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
+    null === ownerDocument ||
+      ownerDocument[listeningMarker] ||
+      ((ownerDocument[listeningMarker] = !0),
+      listenToNativeEvent("selectionchange", !1, ownerDocument));
   }
-  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
-    try {
-      injectedHook.onPostCommitFiberRoot(rendererID, root);
-    } catch (err) {}
-  root = root.current.stateNode;
-  root.effectDuration = 0;
-  root.passiveEffectDuration = 0;
-  return !0;
 }
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
-  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
-  sourceFiber = requestEventTime();
-  null !== rootFiber &&
-    (markRootUpdated(rootFiber, 2, sourceFiber),
-    ensureRootIsScheduled(rootFiber, sourceFiber));
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  eventSystemFlags = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  );
+  var isPassiveListener = void 0;
+  !passiveBrowserEventsSupported ||
+    ("touchstart" !== domEventName &&
+      "touchmove" !== domEventName &&
+      "wheel" !== domEventName) ||
+    (isPassiveListener = !0);
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = eventSystemFlags;
+    eventSystemFlags = function () {
+      unsubscribeListener.remove();
+      for (
+        var _len = arguments.length, p = Array(_len), _key = 0;
+        _key < _len;
+        _key++
+      )
+        p[_key] = arguments[_key];
+      return originalListener.apply(this, p);
+    };
+  }
+  var unsubscribeListener = isCapturePhaseListener
+    ? void 0 !== isPassiveListener
+      ? EventListenerWWW.captureWithPassiveFlag(
+          targetContainer,
+          domEventName,
+          eventSystemFlags,
+          isPassiveListener
+        )
+      : EventListenerWWW.capture(
+          targetContainer,
+          domEventName,
+          eventSystemFlags
+        )
+    : void 0 !== isPassiveListener
+    ? EventListenerWWW.bubbleWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        eventSystemFlags,
+        isPassiveListener
+      )
+    : EventListenerWWW.listen(targetContainer, domEventName, eventSystemFlags);
 }
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
-  if (3 === sourceFiber.tag)
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
-  else
-    for (
-      nearestMountedAncestor = skipUnmountedBoundaries
-        ? nearestMountedAncestor
-        : sourceFiber.return;
-      null !== nearestMountedAncestor;
-
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst$jscomp$0,
+  targetContainer
+) {
+  var ancestorInst = targetInst$jscomp$0;
+  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+    if (
+      enableLegacyFBSupport &&
+      "click" === domEventName &&
+      0 === (eventSystemFlags & 20) &&
+      nativeEvent !== currentReplayingEvent
     ) {
-      if (3 === nearestMountedAncestor.tag) {
-        captureCommitPhaseErrorOnRoot(
-          nearestMountedAncestor,
-          sourceFiber,
-          error
-        );
-        break;
-      } else if (1 === nearestMountedAncestor.tag) {
-        var instance = nearestMountedAncestor.stateNode;
-        if (
-          "function" ===
-            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
-          ("function" === typeof instance.componentDidCatch &&
-            (null === legacyErrorBoundariesThatAlreadyFailed ||
-              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
-        ) {
-          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-          sourceFiber = createClassErrorUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          nearestMountedAncestor = enqueueUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          sourceFiber = requestEventTime();
-          null !== nearestMountedAncestor &&
-            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
-            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
-          break;
+      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
+      return;
+    }
+    if (null !== targetInst$jscomp$0)
+      a: for (;;) {
+        if (null === targetInst$jscomp$0) return;
+        var nodeTag = targetInst$jscomp$0.tag;
+        if (3 === nodeTag || 4 === nodeTag) {
+          var container = targetInst$jscomp$0.stateNode.containerInfo;
+          if (
+            container === targetContainer ||
+            (8 === container.nodeType &&
+              container.parentNode === targetContainer)
+          )
+            break;
+          if (4 === nodeTag)
+            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
+              var grandTag = nodeTag.tag;
+              if (3 === grandTag || 4 === grandTag)
+                if (
+                  ((grandTag = nodeTag.stateNode.containerInfo),
+                  grandTag === targetContainer ||
+                    (8 === grandTag.nodeType &&
+                      grandTag.parentNode === targetContainer))
+                )
+                  return;
+              nodeTag = nodeTag.return;
+            }
+          for (; null !== container; ) {
+            nodeTag = getClosestInstanceFromNode(container);
+            if (null === nodeTag) return;
+            grandTag = nodeTag.tag;
+            if (
+              5 === grandTag ||
+              6 === grandTag ||
+              26 === grandTag ||
+              27 === grandTag
+            ) {
+              targetInst$jscomp$0 = ancestorInst = nodeTag;
+              continue a;
+            }
+            container = container.parentNode;
+          }
+        }
+        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+      }
+  }
+  batchedUpdates(function () {
+    var targetInst = ancestorInst,
+      nativeEventTarget = getEventTarget(nativeEvent),
+      dispatchQueue = [];
+    a: {
+      var reactName = topLevelEventsToReactNames.get(domEventName);
+      if (void 0 !== reactName) {
+        var SyntheticEventCtor = SyntheticEvent,
+          reactEventType = domEventName;
+        switch (domEventName) {
+          case "keypress":
+            if (0 === getEventCharCode(nativeEvent)) break a;
+          case "keydown":
+          case "keyup":
+            SyntheticEventCtor = SyntheticKeyboardEvent;
+            break;
+          case "focusin":
+            reactEventType = "focus";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "focusout":
+            reactEventType = "blur";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "beforeblur":
+          case "afterblur":
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "click":
+            if (2 === nativeEvent.button) break a;
+          case "auxclick":
+          case "dblclick":
+          case "mousedown":
+          case "mousemove":
+          case "mouseup":
+          case "mouseout":
+          case "mouseover":
+          case "contextmenu":
+            SyntheticEventCtor = SyntheticMouseEvent;
+            break;
+          case "drag":
+          case "dragend":
+          case "dragenter":
+          case "dragexit":
+          case "dragleave":
+          case "dragover":
+          case "dragstart":
+          case "drop":
+            SyntheticEventCtor = SyntheticDragEvent;
+            break;
+          case "touchcancel":
+          case "touchend":
+          case "touchmove":
+          case "touchstart":
+            SyntheticEventCtor = SyntheticTouchEvent;
+            break;
+          case ANIMATION_END:
+          case ANIMATION_ITERATION:
+          case ANIMATION_START:
+            SyntheticEventCtor = SyntheticAnimationEvent;
+            break;
+          case TRANSITION_END:
+            SyntheticEventCtor = SyntheticTransitionEvent;
+            break;
+          case "scroll":
+            SyntheticEventCtor = SyntheticUIEvent;
+            break;
+          case "wheel":
+            SyntheticEventCtor = SyntheticWheelEvent;
+            break;
+          case "copy":
+          case "cut":
+          case "paste":
+            SyntheticEventCtor = SyntheticClipboardEvent;
+            break;
+          case "gotpointercapture":
+          case "lostpointercapture":
+          case "pointercancel":
+          case "pointerdown":
+          case "pointermove":
+          case "pointerout":
+          case "pointerover":
+          case "pointerup":
+            SyntheticEventCtor = SyntheticPointerEvent;
         }
+        var inCapturePhase = 0 !== (eventSystemFlags & 4);
+        eventSystemFlags & 1
+          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
+              reactEventType,
+              targetContainer,
+              inCapturePhase
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })))
+          : ((inCapturePhase = accumulateSinglePhaseListeners(
+              targetInst,
+              reactName,
+              nativeEvent.type,
+              inCapturePhase,
+              !inCapturePhase && "scroll" === domEventName,
+              nativeEvent
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })));
       }
-      nearestMountedAncestor = nearestMountedAncestor.return;
-    }
-}
-function attachPingListener(root, wakeable, lanes) {
-  var pingCache = root.pingCache;
-  if (null === pingCache) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    var threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else
-    (threadIDs = pingCache.get(wakeable)),
-      void 0 === threadIDs &&
-        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
-  threadIDs.has(lanes) ||
-    ((workInProgressRootDidAttachPingListener = !0),
-    threadIDs.add(lanes),
-    (pingCache = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
-    isDevToolsPresent && restorePendingUpdaters(root, lanes),
-    wakeable.then(pingCache, pingCache));
-}
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
-  null !== pingCache && pingCache.delete(wakeable);
-  wakeable = requestEventTime();
-  root.pingedLanes |= root.suspendedLanes & pingedLanes;
-  workInProgressRoot === root &&
-    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
-    (4 === workInProgressRootExitStatus ||
-    (3 === workInProgressRootExitStatus &&
-      (workInProgressRootRenderLanes & 125829120) ===
-        workInProgressRootRenderLanes &&
-      500 > now$1() - globalMostRecentFallbackTime)
-      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
-      : (workInProgressRootPingedLanes |= pingedLanes));
-  ensureRootIsScheduled(root, wakeable);
-}
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  0 === retryLane &&
-    (0 === (boundaryFiber.mode & 1)
-      ? (retryLane = 2)
-      : ((retryLane = nextRetryLane),
-        (nextRetryLane <<= 1),
-        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
-  var eventTime = requestEventTime();
-  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
-  null !== boundaryFiber &&
-    (markRootUpdated(boundaryFiber, retryLane, eventTime),
-    ensureRootIsScheduled(boundaryFiber, eventTime));
-}
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState,
-    retryLane = 0;
-  null !== suspenseState && (retryLane = suspenseState.retryLane);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-}
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = 0;
-  switch (boundaryFiber.tag) {
-    case 13:
-      var retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
-      null !== suspenseState && (retryLane = suspenseState.retryLane);
-      break;
-    case 19:
-      retryCache = boundaryFiber.stateNode;
-      break;
-    case 22:
-      retryCache = boundaryFiber.stateNode._retryCache;
-      break;
-    default:
-      throw Error(formatProdErrorMessage(314));
-  }
-  null !== retryCache && retryCache.delete(wakeable);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-}
-var beginWork;
-beginWork = function (current, workInProgress, renderLanes) {
-  if (null !== current)
-    if (
-      current.memoizedProps !== workInProgress.pendingProps ||
-      didPerformWorkStackCursor.current
-    )
-      didReceiveUpdate = !0;
-    else {
-      if (
-        !checkScheduledUpdateOrContext(current, renderLanes) &&
-        0 === (workInProgress.flags & 128)
-      )
-        return (
-          (didReceiveUpdate = !1),
-          attemptEarlyBailoutIfNoScheduledUpdate(
-            current,
-            workInProgress,
-            renderLanes
-          )
-        );
-      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
     }
-  else
-    (didReceiveUpdate = !1),
-      isHydrating &&
-        0 !== (workInProgress.flags & 1048576) &&
-        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
-  workInProgress.lanes = 0;
-  switch (workInProgress.tag) {
-    case 2:
-      var Component = workInProgress.type;
-      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-      current = workInProgress.pendingProps;
-      var context = getMaskedContext(
-        workInProgress,
-        contextStackCursor.current
-      );
-      prepareToReadContext(workInProgress, renderLanes);
-      enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-      current = renderWithHooks(
-        null,
-        workInProgress,
-        Component,
-        current,
-        context,
-        renderLanes
-      );
-      Component = checkDidRenderIdHook();
-      enableSchedulingProfiler && markComponentRenderStopped();
-      workInProgress.flags |= 1;
-      workInProgress.tag = 0;
-      isHydrating && Component && pushMaterializedTreeId(workInProgress);
-      reconcileChildren(null, workInProgress, current, renderLanes);
-      workInProgress = workInProgress.child;
-      return workInProgress;
-    case 16:
-      Component = workInProgress.elementType;
+    if (0 === (eventSystemFlags & 7)) {
       a: {
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-        current = workInProgress.pendingProps;
-        context = Component._init;
-        Component = context(Component._payload);
-        workInProgress.type = Component;
-        context = workInProgress.tag = resolveLazyComponentTag(Component);
-        current = resolveDefaultProps(Component, current);
-        switch (context) {
-          case 0:
-            workInProgress = updateFunctionComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 1:
-            workInProgress = updateClassComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 11:
-            workInProgress = updateForwardRef(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 14:
-            workInProgress = updateMemoComponent(
-              null,
-              workInProgress,
-              Component,
-              resolveDefaultProps(Component.type, current),
-              renderLanes
+        reactName =
+          "mouseover" === domEventName || "pointerover" === domEventName;
+        SyntheticEventCtor =
+          "mouseout" === domEventName || "pointerout" === domEventName;
+        if (
+          reactName &&
+          nativeEvent !== currentReplayingEvent &&
+          (reactEventType =
+            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
+          (getClosestInstanceFromNode(reactEventType) ||
+            reactEventType[internalContainerInstanceKey])
+        )
+          break a;
+        if (SyntheticEventCtor || reactName) {
+          reactName =
+            nativeEventTarget.window === nativeEventTarget
+              ? nativeEventTarget
+              : (reactName = nativeEventTarget.ownerDocument)
+              ? reactName.defaultView || reactName.parentWindow
+              : window;
+          if (SyntheticEventCtor) {
+            if (
+              ((reactEventType =
+                nativeEvent.relatedTarget || nativeEvent.toElement),
+              (SyntheticEventCtor = targetInst),
+              (reactEventType = reactEventType
+                ? getClosestInstanceFromNode(reactEventType)
+                : null),
+              null !== reactEventType)
+            ) {
+              inCapturePhase = getNearestMountedFiber(reactEventType);
+              var tag = reactEventType.tag;
+              if (
+                reactEventType !== inCapturePhase ||
+                (5 !== tag && 27 !== tag && 6 !== tag)
+              )
+                reactEventType = null;
+            }
+          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
+          if (SyntheticEventCtor !== reactEventType) {
+            tag = SyntheticMouseEvent;
+            var leaveEventType = "onMouseLeave",
+              enterEventType = "onMouseEnter",
+              eventTypePrefix = "mouse";
+            if ("pointerout" === domEventName || "pointerover" === domEventName)
+              (tag = SyntheticPointerEvent),
+                (leaveEventType = "onPointerLeave"),
+                (enterEventType = "onPointerEnter"),
+                (eventTypePrefix = "pointer");
+            inCapturePhase =
+              null == SyntheticEventCtor
+                ? reactName
+                : getNodeFromInstance(SyntheticEventCtor);
+            var toNode =
+              null == reactEventType
+                ? reactName
+                : getNodeFromInstance(reactEventType);
+            reactName = new tag(
+              leaveEventType,
+              eventTypePrefix + "leave",
+              SyntheticEventCtor,
+              nativeEvent,
+              nativeEventTarget
             );
-            break a;
+            reactName.target = inCapturePhase;
+            reactName.relatedTarget = toNode;
+            leaveEventType = null;
+            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
+              ((tag = new tag(
+                enterEventType,
+                eventTypePrefix + "enter",
+                reactEventType,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              (tag.target = toNode),
+              (tag.relatedTarget = inCapturePhase),
+              (leaveEventType = tag));
+            inCapturePhase = leaveEventType;
+            if (SyntheticEventCtor && reactEventType)
+              b: {
+                tag = SyntheticEventCtor;
+                enterEventType = reactEventType;
+                eventTypePrefix = 0;
+                for (toNode = tag; toNode; toNode = getParent(toNode))
+                  eventTypePrefix++;
+                toNode = 0;
+                for (
+                  leaveEventType = enterEventType;
+                  leaveEventType;
+                  leaveEventType = getParent(leaveEventType)
+                )
+                  toNode++;
+                for (; 0 < eventTypePrefix - toNode; )
+                  (tag = getParent(tag)), eventTypePrefix--;
+                for (; 0 < toNode - eventTypePrefix; )
+                  (enterEventType = getParent(enterEventType)), toNode--;
+                for (; eventTypePrefix--; ) {
+                  if (
+                    tag === enterEventType ||
+                    (null !== enterEventType &&
+                      tag === enterEventType.alternate)
+                  )
+                    break b;
+                  tag = getParent(tag);
+                  enterEventType = getParent(enterEventType);
+                }
+                tag = null;
+              }
+            else tag = null;
+            null !== SyntheticEventCtor &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                reactName,
+                SyntheticEventCtor,
+                tag,
+                !1
+              );
+            null !== reactEventType &&
+              null !== inCapturePhase &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                inCapturePhase,
+                reactEventType,
+                tag,
+                !0
+              );
+          }
         }
-        throw Error(formatProdErrorMessage(306, Component, ""));
       }
-      return workInProgress;
-    case 0:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        updateFunctionComponent(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 1:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        updateClassComponent(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 3:
       a: {
-        pushHostRootContext(workInProgress);
-        if (null === current) throw Error(formatProdErrorMessage(387));
-        Component = workInProgress.pendingProps;
-        var prevState = workInProgress.memoizedState;
-        context = prevState.element;
-        cloneUpdateQueue(current, workInProgress);
-        processUpdateQueue(workInProgress, Component, null, renderLanes);
-        var nextState = workInProgress.memoizedState,
-          root = workInProgress.stateNode;
-        enableTransitionTracing &&
-          push(transitionStack, workInProgressTransitions);
-        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-        Component = nextState.cache;
-        pushProvider(workInProgress, CacheContext, Component);
-        Component !== prevState.cache &&
-          propagateContextChange(workInProgress, CacheContext, renderLanes);
-        Component = nextState.element;
-        if (prevState.isDehydrated)
-          if (
-            ((prevState = {
-              element: Component,
-              isDehydrated: !1,
-              cache: nextState.cache
-            }),
-            (workInProgress.updateQueue.baseState = prevState),
-            (workInProgress.memoizedState = prevState),
-            workInProgress.flags & 256)
-          ) {
-            context = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(423)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              context
-            );
-            break a;
-          } else if (Component !== context) {
-            context = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(424)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              context
-            );
-            break a;
-          } else {
-            nextHydratableInstance = getNextHydratable(
-              workInProgress.stateNode.containerInfo.firstChild
-            );
-            hydrationParentFiber = workInProgress;
-            isHydrating = !0;
-            hydrationErrors = null;
-            rootOrSingletonContext = !0;
-            current = root.mutableSourceEagerHydrationData;
-            if (null != current)
-              for (context = 0; context < current.length; context += 2)
-                (prevState = current[context]),
-                  (prevState._workInProgressVersionPrimary =
-                    current[context + 1]),
-                  workInProgressSources.push(prevState);
-            renderLanes = mountChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            );
-            for (workInProgress.child = renderLanes; renderLanes; )
-              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
-                (renderLanes = renderLanes.sibling);
+        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
+        SyntheticEventCtor =
+          reactName.nodeName && reactName.nodeName.toLowerCase();
+        if (
+          "select" === SyntheticEventCtor ||
+          ("input" === SyntheticEventCtor && "file" === reactName.type)
+        )
+          var getTargetInstFunc = getTargetInstForChangeEvent;
+        else if (isTextInputElement(reactName))
+          if (isInputEventSupported)
+            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+          else {
+            getTargetInstFunc = getTargetInstForInputEventPolyfill;
+            var handleEventFunc = handleEventsForInputEventPolyfill;
           }
-        else {
-          resetHydrationState();
-          if (Component === context) {
-            workInProgress = bailoutOnAlreadyFinishedWork(
-              current,
-              workInProgress,
-              renderLanes
-            );
-            break a;
+        else
+          (SyntheticEventCtor = reactName.nodeName),
+            !SyntheticEventCtor ||
+            "input" !== SyntheticEventCtor.toLowerCase() ||
+            ("checkbox" !== reactName.type && "radio" !== reactName.type)
+              ? enableCustomElementPropertySupport &&
+                targetInst &&
+                isCustomComponent(
+                  targetInst.elementType,
+                  targetInst.memoizedProps
+                ) &&
+                (getTargetInstFunc = getTargetInstForChangeEvent)
+              : (getTargetInstFunc = getTargetInstForClickEvent);
+        if (
+          getTargetInstFunc &&
+          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
+        ) {
+          createAndAccumulateChangeEvent(
+            dispatchQueue,
+            getTargetInstFunc,
+            nativeEvent,
+            nativeEventTarget
+          );
+          break a;
+        }
+        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
+        "focusout" === domEventName &&
+          (handleEventFunc = reactName._wrapperState) &&
+          handleEventFunc.controlled &&
+          "number" === reactName.type &&
+          (disableInputAttributeSyncing ||
+            setDefaultValue(reactName, "number", reactName.value));
+      }
+      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
+      switch (domEventName) {
+        case "focusin":
+          if (
+            isTextInputElement(handleEventFunc) ||
+            "true" === handleEventFunc.contentEditable
+          )
+            (activeElement = handleEventFunc),
+              (activeElementInst = targetInst),
+              (lastSelection = null);
+          break;
+        case "focusout":
+          lastSelection = activeElementInst = activeElement = null;
+          break;
+        case "mousedown":
+          mouseDown = !0;
+          break;
+        case "contextmenu":
+        case "mouseup":
+        case "dragend":
+          mouseDown = !1;
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+          break;
+        case "selectionchange":
+          if (skipSelectionChangeEvent) break;
+        case "keydown":
+        case "keyup":
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      }
+      var fallbackData;
+      if (canUseCompositionEvent)
+        b: {
+          switch (domEventName) {
+            case "compositionstart":
+              var eventType = "onCompositionStart";
+              break b;
+            case "compositionend":
+              eventType = "onCompositionEnd";
+              break b;
+            case "compositionupdate":
+              eventType = "onCompositionUpdate";
+              break b;
           }
-          reconcileChildren(current, workInProgress, Component, renderLanes);
+          eventType = void 0;
         }
-        workInProgress = workInProgress.child;
-      }
-      return workInProgress;
-    case 26:
-      return (
-        markRef$1(current, workInProgress),
-        (renderLanes = workInProgress.memoizedState =
-          getResource(
-            workInProgress.type,
-            null === current ? null : current.memoizedProps,
-            workInProgress.pendingProps
-          )),
-        null !== current ||
-          isHydrating ||
-          null !== renderLanes ||
-          ((renderLanes = workInProgress.type),
-          (current = workInProgress.pendingProps),
-          (Component = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
+      else
+        isComposing
+          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
+            (eventType = "onCompositionEnd")
+          : "keydown" === domEventName &&
+            229 === nativeEvent.keyCode &&
+            (eventType = "onCompositionStart");
+      eventType &&
+        (useFallbackCompositionData &&
+          "ko" !== nativeEvent.locale &&
+          (isComposing || "onCompositionStart" !== eventType
+            ? "onCompositionEnd" === eventType &&
+              isComposing &&
+              (fallbackData = getData())
+            : ((root = nativeEventTarget),
+              (startText = "value" in root ? root.value : root.textContent),
+              (isComposing = !0))),
+        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
+        0 < handleEventFunc.length &&
+          ((eventType = new SyntheticCompositionEvent(
+            eventType,
+            domEventName,
+            null,
+            nativeEvent,
+            nativeEventTarget
           )),
-          (Component = createHTMLElement(renderLanes, current, Component)),
-          (Component[internalInstanceKey] = workInProgress),
-          (Component[internalPropsKey] = current),
-          setInitialProperties(Component, renderLanes, current),
-          markNodeAsHoistable(Component),
-          (workInProgress.stateNode = Component)),
-        null
-      );
-    case 27:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          ((Component = workInProgress.stateNode =
-            resolveSingletonInstance(
-              workInProgress.type,
-              workInProgress.pendingProps,
-              rootInstanceStackCursor.current
-            )),
-          (hydrationParentFiber = workInProgress),
-          (rootOrSingletonContext = !0),
-          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
-        (Component = workInProgress.pendingProps.children),
-        null !== current || isHydrating
-          ? reconcileChildren(current, workInProgress, Component, renderLanes)
-          : (workInProgress.child = reconcileChildFibers(
-              workInProgress,
+          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
+          fallbackData
+            ? (eventType.data = fallbackData)
+            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
+              null !== fallbackData && (eventType.data = fallbackData))));
+      if (
+        (fallbackData = canUseTextInputEvent
+          ? getNativeBeforeInputChars(domEventName, nativeEvent)
+          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+      )
+        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
+          0 < targetInst.length &&
+            ((nativeEventTarget = new SyntheticCompositionEvent(
+              "onBeforeInput",
+              "beforeinput",
               null,
-              Component,
-              renderLanes
+              nativeEvent,
+              nativeEventTarget
             )),
-        markRef$1(current, workInProgress),
-        workInProgress.child
-      );
-    case 5:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          (((Component = workInProgress.pendingProps),
-          "script" === workInProgress.type
-            ? ((context = Component.onLoad),
-              (prevState = Component.onError),
-              (Component = !(Component.async && (context || prevState))))
-            : (Component = !0),
-          Component)
-            ? ((Component = nextHydratableInstance),
-              rootOrSingletonContext &&
-                advanceToFirstAttemptableInstance(workInProgress),
-              (context = nextHydratableInstance),
-              context)
-              ? tryHydrateInstance(workInProgress, context) ||
-                (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                (nextHydratableInstance = getNextHydratable(
-                  context.nextSibling
-                )),
-                (prevState = hydrationParentFiber),
-                rootOrSingletonContext &&
-                  advanceToFirstAttemptableInstance(workInProgress),
-                nextHydratableInstance &&
-                tryHydrateInstance(workInProgress, nextHydratableInstance)
-                  ? deleteHydratableInstance(prevState, context)
-                  : (insertNonHydratedInstance(
-                      hydrationParentFiber,
-                      workInProgress
-                    ),
-                    (isHydrating = !1),
-                    (hydrationParentFiber = workInProgress),
-                    (nextHydratableInstance = Component)))
-              : (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = Component))
-            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress))),
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (prevState = null !== current ? current.memoizedProps : null),
-        (root = context.children),
-        shouldSetTextContent(Component, context)
-          ? (root = null)
-          : null !== prevState &&
-            shouldSetTextContent(Component, prevState) &&
-            (workInProgress.flags |= 32),
-        markRef$1(current, workInProgress),
-        reconcileChildren(current, workInProgress, root, renderLanes),
-        workInProgress.child
-      );
-    case 6:
-      return (
-        null === current &&
-          isHydrating &&
-          (((renderLanes = "" !== workInProgress.pendingProps),
-          (current = nextHydratableInstance),
-          rootOrSingletonContext &&
-            renderLanes &&
-            advanceToFirstAttemptableTextInstance(),
-          (Component = nextHydratableInstance),
-          Component && renderLanes)
-            ? tryHydrateText(workInProgress, Component) ||
-              (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              (nextHydratableInstance = getNextHydratable(
-                Component.nextSibling
-              )),
-              (context = hydrationParentFiber),
-              rootOrSingletonContext &&
-                renderLanes &&
-                advanceToFirstAttemptableTextInstance(),
-              nextHydratableInstance &&
-              tryHydrateText(workInProgress, nextHydratableInstance)
-                ? deleteHydratableInstance(context, Component)
-                : (insertNonHydratedInstance(
-                    hydrationParentFiber,
-                    workInProgress
-                  ),
-                  (isHydrating = !1),
-                  (hydrationParentFiber = workInProgress),
-                  (nextHydratableInstance = current)))
-            : (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress),
-              (nextHydratableInstance = current))),
-        null
-      );
-    case 13:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
-    case 4:
-      return (
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
+            dispatchQueue.push({
+              event: nativeEventTarget,
+              listeners: targetInst
+            }),
+            (nativeEventTarget.data = fallbackData));
+    }
+    processDispatchQueue(dispatchQueue, eventSystemFlags);
+  });
+}
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  reactName = inCapturePhase
+    ? null !== reactName
+      ? reactName + "Capture"
+      : null
+    : reactName;
+  for (
+    var listeners = [], instance = targetFiber, lastHostComponent = null;
+    null !== instance;
+
+  ) {
+    var _instance = instance;
+    targetFiber = _instance.stateNode;
+    _instance = _instance.tag;
+    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
+    null === targetFiber
+      ? 21 === _instance &&
+        null !== lastHostComponent &&
+        null !== targetFiber &&
+        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }))
+      : ((lastHostComponent = targetFiber),
+        (targetFiber =
+          lastHostComponent[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }),
+        null !== reactName &&
+          ((targetFiber = getListener(instance, reactName)),
+          null != targetFiber &&
+            listeners.push(
+              createDispatchListener(instance, targetFiber, lastHostComponent)
+            )));
+    if (accumulateTargetOnly) break;
+    "beforeblur" === nativeEvent.type &&
+      ((targetFiber = nativeEvent._detachedInterceptFiber),
+      null === targetFiber ||
+        (targetFiber !== instance && targetFiber !== instance.alternate) ||
+        (listeners = []));
+    instance = instance.return;
+  }
+  return listeners;
+}
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  for (
+    var captureName = reactName + "Capture", listeners = [];
+    null !== targetFiber;
+
+  ) {
+    var _instance2 = targetFiber,
+      stateNode = _instance2.stateNode;
+    _instance2 = _instance2.tag;
+    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
+      null === stateNode ||
+      ((_instance2 = getListener(targetFiber, captureName)),
+      null != _instance2 &&
+        listeners.unshift(
+          createDispatchListener(targetFiber, _instance2, stateNode)
         ),
-        (Component = workInProgress.pendingProps),
-        null === current
-          ? (workInProgress.child = reconcileChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
+      (_instance2 = getListener(targetFiber, reactName)),
+      null != _instance2 &&
+        listeners.push(
+          createDispatchListener(targetFiber, _instance2, stateNode)
+        ));
+    targetFiber = targetFiber.return;
+  }
+  return listeners;
+}
+function getParent(inst) {
+  if (null === inst) return null;
+  do inst = inst.return;
+  while (inst && 5 !== inst.tag && 27 !== inst.tag);
+  return inst ? inst : null;
+}
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
+) {
+  for (
+    var registrationName = event._reactName, listeners = [];
+    null !== target && target !== common;
+
+  ) {
+    var _instance3 = target,
+      alternate = _instance3.alternate,
+      stateNode = _instance3.stateNode;
+    _instance3 = _instance3.tag;
+    if (null !== alternate && alternate === common) break;
+    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
+      null === stateNode ||
+      ((alternate = stateNode),
+      inCapturePhase
+        ? ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.unshift(
+              createDispatchListener(target, stateNode, alternate)
             ))
-          : reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 11:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        updateForwardRef(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 7:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 8:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 12:
+        : inCapturePhase ||
+          ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.push(
+              createDispatchListener(target, stateNode, alternate)
+            )));
+    target = target.return;
+  }
+  0 !== listeners.length &&
+    dispatchQueue.push({ event: event, listeners: listeners });
+}
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
+) {
+  var listeners = [],
+    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
+  null !== eventListeners &&
+    eventListeners.forEach(function (entry) {
+      entry.type === reactEventType &&
+        entry.capture === inCapturePhase &&
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
+        );
+    });
+  return listeners;
+}
+var hasScheduledReplayAttempt = !1,
+  queuedDiscreteEvents = [],
+  queuedFocus = null,
+  queuedDrag = null,
+  queuedMouse = null,
+  queuedPointers = new Map(),
+  queuedPointerCaptures = new Map(),
+  queuedExplicitHydrationTargets = [],
+  discreteReplayableEvents =
+    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
+      " "
+    );
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return {
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
+  };
+}
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
+    ((blockedOn = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )),
+    queuedDiscreteEvents.push(blockedOn),
+    1 === queuedDiscreteEvents.length)
+  )
+    for (; null !== blockedOn.blockedOn; ) {
+      domEventName = getInstanceFromNode(blockedOn.blockedOn);
+      if (null === domEventName) break;
+      attemptSynchronousHydration(domEventName);
+      if (null === blockedOn.blockedOn) replayUnblockedEvents();
+      else break;
+    }
+}
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
+    case "pointerover":
+    case "pointerout":
+      queuedPointers.delete(nativeEvent.pointerId);
+      break;
+    case "gotpointercapture":
+    case "lostpointercapture":
+      queuedPointerCaptures.delete(nativeEvent.pointerId);
+  }
+}
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    null === existingQueuedEvent ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
+  )
+    return (
+      (existingQueuedEvent = createQueuedReplayableEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )),
+      null !== blockedOn &&
+        ((blockedOn = getInstanceFromNode(blockedOn)),
+        null !== blockedOn && attemptContinuousHydration(blockedOn)),
+      existingQueuedEvent
+    );
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  blockedOn = existingQueuedEvent.targetContainers;
+  null !== targetContainer &&
+    -1 === blockedOn.indexOf(targetContainer) &&
+    blockedOn.push(targetContainer);
+  return existingQueuedEvent;
+}
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  switch (domEventName) {
+    case "focusin":
       return (
-        (workInProgress.flags |= 4),
-        (Component = workInProgress.stateNode),
-        (Component.effectDuration = 0),
-        (Component.passiveEffectDuration = 0),
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
+        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedFocus,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
       );
-    case 10:
-      a: {
-        Component = workInProgress.type._context;
-        context = workInProgress.pendingProps;
-        prevState = workInProgress.memoizedProps;
-        root = context.value;
-        pushProvider(workInProgress, Component, root);
-        if (!enableLazyContextPropagation && null !== prevState)
-          if (objectIs(prevState.value, root)) {
-            if (
-              prevState.children === context.children &&
-              !didPerformWorkStackCursor.current
-            ) {
-              workInProgress = bailoutOnAlreadyFinishedWork(
-                current,
-                workInProgress,
-                renderLanes
-              );
-              break a;
-            }
-          } else propagateContextChange(workInProgress, Component, renderLanes);
-        reconcileChildren(
-          current,
-          workInProgress,
-          context.children,
-          renderLanes
-        );
-        workInProgress = workInProgress.child;
-      }
-      return workInProgress;
-    case 9:
+    case "dragenter":
       return (
-        (context = workInProgress.type),
-        (Component = workInProgress.pendingProps.children),
-        prepareToReadContext(workInProgress, renderLanes),
-        (context = readContext(context)),
-        enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
-        (Component = Component(context)),
-        enableSchedulingProfiler && markComponentRenderStopped(),
-        (workInProgress.flags |= 1),
-        reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
+        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedDrag,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
       );
-    case 14:
+    case "mouseover":
       return (
-        (Component = workInProgress.type),
-        (context = resolveDefaultProps(Component, workInProgress.pendingProps)),
-        (context = resolveDefaultProps(Component.type, context)),
-        updateMemoComponent(
-          current,
-          workInProgress,
-          Component,
-          context,
-          renderLanes
-        )
-      );
-    case 15:
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
+        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedMouse,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
       );
-    case 17:
-      return (
-        (Component = workInProgress.type),
-        (context = workInProgress.pendingProps),
-        (context =
-          workInProgress.elementType === Component
-            ? context
-            : resolveDefaultProps(Component, context)),
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-        (workInProgress.tag = 1),
-        isContextProvider(Component)
-          ? ((current = !0), pushContextProvider(workInProgress))
-          : (current = !1),
-        prepareToReadContext(workInProgress, renderLanes),
-        constructClassInstance(workInProgress, Component, context),
-        mountClassInstance(workInProgress, Component, context, renderLanes),
-        finishClassComponent(
-          null,
-          workInProgress,
-          Component,
-          !0,
-          current,
-          renderLanes
+    case "pointerover":
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
         )
       );
-    case 19:
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    case 21:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 22:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 23:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 24:
+      return !0;
+    case "gotpointercapture":
       return (
-        prepareToReadContext(workInProgress, renderLanes),
-        (Component = readContext(CacheContext)),
-        null === current
-          ? ((context = peekCacheFromPool()),
-            null === context &&
-              ((context = workInProgressRoot),
-              (prevState = createCache()),
-              (context.pooledCache = prevState),
-              prevState.refCount++,
-              null !== prevState && (context.pooledCacheLanes |= renderLanes),
-              (context = prevState)),
-            (workInProgress.memoizedState = {
-              parent: Component,
-              cache: context
-            }),
-            initializeUpdateQueue(workInProgress),
-            pushProvider(workInProgress, CacheContext, context))
-          : (0 !== (current.lanes & renderLanes) &&
-              (cloneUpdateQueue(current, workInProgress),
-              processUpdateQueue(workInProgress, null, null, renderLanes)),
-            (context = current.memoizedState),
-            (prevState = workInProgress.memoizedState),
-            context.parent !== Component
-              ? ((context = { parent: Component, cache: Component }),
-                (workInProgress.memoizedState = context),
-                0 === workInProgress.lanes &&
-                  (workInProgress.memoizedState =
-                    workInProgress.updateQueue.baseState =
-                      context),
-                pushProvider(workInProgress, CacheContext, Component))
-              : ((Component = prevState.cache),
-                pushProvider(workInProgress, CacheContext, Component),
-                Component !== context.cache &&
-                  propagateContextChange(
-                    workInProgress,
-                    CacheContext,
-                    renderLanes
-                  ))),
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 25:
-      if (enableTransitionTracing)
-        return (
-          enableTransitionTracing
-            ? (null === current &&
-                ((Component = enableTransitionTracing
-                  ? transitionStack.current
-                  : null),
-                null !== Component &&
-                  ((Component = {
-                    tag: 1,
-                    transitions: new Set(Component),
-                    pendingBoundaries: null,
-                    name: workInProgress.pendingProps.name,
-                    aborts: null
-                  }),
-                  (workInProgress.stateNode = Component),
-                  (workInProgress.flags |= 2048))),
-              (Component = workInProgress.stateNode),
-              null !== Component &&
-                pushMarkerInstance(workInProgress, Component),
-              reconcileChildren(
-                current,
-                workInProgress,
-                workInProgress.pendingProps.children,
-                renderLanes
-              ),
-              (workInProgress = workInProgress.child))
-            : (workInProgress = null),
-          workInProgress
-        );
+        (pointerId = nativeEvent.pointerId),
+        queuedPointerCaptures.set(
+          pointerId,
+          accumulateOrCreateContinuousQueuedReplayableEvent(
+            queuedPointerCaptures.get(pointerId) || null,
+            blockedOn,
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          )
+        ),
+        !0
+      );
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
-};
-function restorePendingUpdaters(root, lanes) {
-  isDevToolsPresent &&
-    root.memoizedUpdaters.forEach(function (schedulingFiber) {
-      addFiberToLanesMap(root, schedulingFiber, lanes);
-    });
-}
-function scheduleCallback(priorityLevel, callback) {
-  return scheduleCallback$2(priorityLevel, callback);
-}
-function FiberNode(tag, pendingProps, key, mode) {
-  this.tag = tag;
-  this.key = key;
-  this.sibling =
-    this.child =
-    this.return =
-    this.stateNode =
-    this.type =
-    this.elementType =
-      null;
-  this.index = 0;
-  this.refCleanup = this.ref = null;
-  this.pendingProps = pendingProps;
-  this.dependencies =
-    this.memoizedState =
-    this.updateQueue =
-    this.memoizedProps =
-      null;
-  this.mode = mode;
-  this.subtreeFlags = this.flags = 0;
-  this.deletions = null;
-  this.childLanes = this.lanes = 0;
-  this.alternate = null;
-  this.actualDuration = 0;
-  this.actualStartTime = -1;
-  this.treeBaseDuration = this.selfBaseDuration = 0;
-}
-function createFiber(tag, pendingProps, key, mode) {
-  return new FiberNode(tag, pendingProps, key, mode);
-}
-function shouldConstruct(Component) {
-  Component = Component.prototype;
-  return !(!Component || !Component.isReactComponent);
+  return !1;
 }
-function resolveLazyComponentTag(Component) {
-  if ("function" === typeof Component)
-    return shouldConstruct(Component) ? 1 : 0;
-  if (void 0 !== Component && null !== Component) {
-    Component = Component.$$typeof;
-    if (Component === REACT_FORWARD_REF_TYPE) return 11;
-    if (Component === REACT_MEMO_TYPE) return 14;
+function attemptExplicitHydrationTarget(queuedTarget) {
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
+  if (null !== targetInst) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
+    if (null !== nearestMounted)
+      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
+        if (
+          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
+          null !== targetInst)
+        ) {
+          queuedTarget.blockedOn = targetInst;
+          runWithPriority(queuedTarget.priority, function () {
+            if (13 === nearestMounted.tag) {
+              var lane = requestUpdateLane(nearestMounted),
+                root = enqueueConcurrentRenderForLane(nearestMounted, lane);
+              if (null !== root) {
+                var eventTime = requestEventTime();
+                scheduleUpdateOnFiber(root, nearestMounted, lane, eventTime);
+              }
+              markRetryLaneIfNotHydrated(nearestMounted, lane);
+            }
+          });
+          return;
+        }
+      } else if (
+        3 === targetInst &&
+        nearestMounted.stateNode.current.memoizedState.isDehydrated
+      ) {
+        queuedTarget.blockedOn =
+          3 === nearestMounted.tag
+            ? nearestMounted.stateNode.containerInfo
+            : null;
+        return;
+      }
   }
-  return 2;
-}
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
-  null === workInProgress
-    ? ((workInProgress = createFiber(
-        current.tag,
-        pendingProps,
-        current.key,
-        current.mode
-      )),
-      (workInProgress.elementType = current.elementType),
-      (workInProgress.type = current.type),
-      (workInProgress.stateNode = current.stateNode),
-      (workInProgress.alternate = current),
-      (current.alternate = workInProgress))
-    : ((workInProgress.pendingProps = pendingProps),
-      (workInProgress.type = current.type),
-      (workInProgress.flags = 0),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null),
-      (workInProgress.actualDuration = 0),
-      (workInProgress.actualStartTime = -1));
-  workInProgress.flags = current.flags & 14680064;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue;
-  pendingProps = current.dependencies;
-  workInProgress.dependencies =
-    null === pendingProps
-      ? null
-      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
-  workInProgress.selfBaseDuration = current.selfBaseDuration;
-  workInProgress.treeBaseDuration = current.treeBaseDuration;
-  return workInProgress;
-}
-function resetWorkInProgress(workInProgress, renderLanes) {
-  workInProgress.flags &= 14680066;
-  var current = workInProgress.alternate;
-  null === current
-    ? ((workInProgress.childLanes = 0),
-      (workInProgress.lanes = renderLanes),
-      (workInProgress.child = null),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.memoizedProps = null),
-      (workInProgress.memoizedState = null),
-      (workInProgress.updateQueue = null),
-      (workInProgress.dependencies = null),
-      (workInProgress.stateNode = null),
-      (workInProgress.selfBaseDuration = 0),
-      (workInProgress.treeBaseDuration = 0))
-    : ((workInProgress.childLanes = current.childLanes),
-      (workInProgress.lanes = current.lanes),
-      (workInProgress.child = current.child),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null),
-      (workInProgress.memoizedProps = current.memoizedProps),
-      (workInProgress.memoizedState = current.memoizedState),
-      (workInProgress.updateQueue = current.updateQueue),
-      (workInProgress.type = current.type),
-      (renderLanes = current.dependencies),
-      (workInProgress.dependencies =
-        null === renderLanes
-          ? null
-          : {
-              lanes: renderLanes.lanes,
-              firstContext: renderLanes.firstContext
-            }),
-      (workInProgress.selfBaseDuration = current.selfBaseDuration),
-      (workInProgress.treeBaseDuration = current.treeBaseDuration));
-  return workInProgress;
+  queuedTarget.blockedOn = null;
 }
-function createFiberFromTypeAndProps(
-  type,
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = 2;
-  owner = type;
-  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
-  else if ("string" === typeof type)
-    fiberTag = isHostHoistableType(
-      type,
-      pendingProps,
-      contextStackCursor$1.current
-    )
-      ? 26
-      : "html" === type || "head" === type || "body" === type
-      ? 27
-      : 5;
-  else
-    a: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = 8;
-        mode |= 8;
-        0 !== (mode & 1) && (mode |= 16);
-        break;
-      case REACT_PROFILER_TYPE:
-        return (
-          (type = createFiber(12, pendingProps, key, mode | 2)),
-          (type.elementType = REACT_PROFILER_TYPE),
-          (type.lanes = lanes),
-          (type.stateNode = { effectDuration: 0, passiveEffectDuration: 0 }),
-          type
-        );
-      case REACT_SUSPENSE_TYPE:
-        return (
-          (type = createFiber(13, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_LIST_TYPE:
-        return (
-          (type = createFiber(19, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
-      case REACT_LEGACY_HIDDEN_TYPE:
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      case REACT_SCOPE_TYPE:
-        return (
-          (pendingProps = createFiber(21, pendingProps, key, mode)),
-          (pendingProps.type = type),
-          (pendingProps.elementType = type),
-          (pendingProps.lanes = lanes),
-          pendingProps
-        );
-      case REACT_CACHE_TYPE:
-        return (
-          (type = createFiber(24, pendingProps, key, mode)),
-          (type.elementType = REACT_CACHE_TYPE),
-          (type.lanes = lanes),
-          type
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (null !== queuedEvent.blockedOn) return !1;
+  for (
+    var targetContainers = queuedEvent.targetContainers;
+    0 < targetContainers.length;
+
+  ) {
+    var targetContainer = targetContainers[0],
+      nextBlockedOn = findInstanceBlockingEvent(
+        queuedEvent.domEventName,
+        queuedEvent.eventSystemFlags,
+        targetContainer,
+        queuedEvent.nativeEvent
+      );
+    if (null === nextBlockedOn)
+      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
+        ? ((nextBlockedOn = queuedEvent.nativeEvent),
+          (currentReplayingEvent = targetContainer =
+            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
+          nextBlockedOn.target.dispatchEvent(targetContainer))
+        : ((currentReplayingEvent = queuedEvent.nativeEvent),
+          dispatchEventForPluginEventSystem(
+            queuedEvent.domEventName,
+            queuedEvent.eventSystemFlags,
+            queuedEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          )),
+        (currentReplayingEvent = null);
+    else
+      return (
+        (targetContainers = getInstanceFromNode(nextBlockedOn)),
+        null !== targetContainers &&
+          attemptContinuousHydration(targetContainers),
+        (queuedEvent.blockedOn = nextBlockedOn),
+        !1
+      );
+    targetContainers.shift();
+  }
+  return !0;
+}
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+}
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = !1;
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
+    for (; 0 < queuedDiscreteEvents.length; ) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
+      if (null !== nextDiscreteEvent.blockedOn) {
+        nextDiscreteEvent = getInstanceFromNode(nextDiscreteEvent.blockedOn);
+        if (null !== nextDiscreteEvent && 13 === nextDiscreteEvent.tag) {
+          var root = enqueueConcurrentRenderForLane(nextDiscreteEvent, 2);
+          if (null !== root) {
+            var eventTime = requestEventTime();
+            scheduleUpdateOnFiber(root, nextDiscreteEvent, 2, eventTime);
+          }
+          markRetryLaneIfNotHydrated(nextDiscreteEvent, 2);
+        }
+        break;
+      }
+      for (root = nextDiscreteEvent.targetContainers; 0 < root.length; ) {
+        eventTime = root[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          eventTime,
+          nextDiscreteEvent.nativeEvent
         );
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing)
-          return (
-            (type = createFiber(25, pendingProps, key, mode)),
-            (type.elementType = REACT_TRACING_MARKER_TYPE),
-            (type.lanes = lanes),
-            (type.stateNode = {
-              tag: 1,
-              transitions: null,
-              pendingBoundaries: null,
-              aborts: null,
-              name: pendingProps.name
-            }),
-            type
-          );
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = 8;
-          mode |= 4;
+        if (null === nextBlockedOn)
+          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
+            dispatchEventForPluginEventSystem(
+              nextDiscreteEvent.domEventName,
+              nextDiscreteEvent.eventSystemFlags,
+              nextDiscreteEvent.nativeEvent,
+              return_targetInst,
+              eventTime
+            ),
+            (currentReplayingEvent = null);
+        else {
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
           break;
         }
-      default:
-        if ("object" === typeof type && null !== type)
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = 10;
-              break a;
-            case REACT_CONTEXT_TYPE:
-              fiberTag = 9;
-              break a;
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = 11;
-              break a;
-            case REACT_MEMO_TYPE:
-              fiberTag = 14;
-              break a;
-            case REACT_LAZY_TYPE:
-              fiberTag = 16;
-              owner = null;
-              break a;
-          }
-        throw Error(
-          formatProdErrorMessage(130, null == type ? type : typeof type, "")
-        );
+        root.shift();
+      }
+      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
     }
-  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
-  pendingProps.elementType = type;
-  pendingProps.type = owner;
-  pendingProps.lanes = lanes;
-  return pendingProps;
-}
-function createFiberFromFragment(elements, mode, lanes, key) {
-  elements = createFiber(7, elements, key, mode);
-  elements.lanes = lanes;
-  return elements;
+  null !== queuedFocus &&
+    attemptReplayContinuousQueuedEvent(queuedFocus) &&
+    (queuedFocus = null);
+  null !== queuedDrag &&
+    attemptReplayContinuousQueuedEvent(queuedDrag) &&
+    (queuedDrag = null);
+  null !== queuedMouse &&
+    attemptReplayContinuousQueuedEvent(queuedMouse) &&
+    (queuedMouse = null);
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
 }
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(22, pendingProps, key, mode);
-  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
-  pendingProps.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
-    }
-  };
-  pendingProps.stateNode = primaryChildInstance;
-  return pendingProps;
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  queuedEvent.blockedOn === unblocked &&
+    ((queuedEvent.blockedOn = null),
+    hasScheduledReplayAttempt ||
+      ((hasScheduledReplayAttempt = !0),
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      )));
 }
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(23, pendingProps, key, mode);
-  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  pendingProps.lanes = lanes;
-  var instance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
+function retryIfBlockedOn(unblocked) {
+  function unblock(queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  }
+  if (0 < queuedDiscreteEvents.length) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
     }
-  };
-  pendingProps.stateNode = instance;
-  return pendingProps;
-}
-function createFiberFromText(content, mode, lanes) {
-  content = createFiber(6, content, null, mode);
-  content.lanes = lanes;
-  return content;
-}
-function createFiberFromPortal(portal, mode, lanes) {
-  mode = createFiber(
-    4,
-    null !== portal.children ? portal.children : [],
-    portal.key,
-    mode
-  );
-  mode.lanes = lanes;
-  mode.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    implementation: portal.implementation
-  };
-  return mode;
-}
-function FiberRootNode(
-  containerInfo,
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
-) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.finishedWork =
-    this.pingCache =
-    this.current =
-    this.pendingChildren =
-      null;
-  this.timeoutHandle = -1;
-  this.callbackNode = this.pendingContext = this.context = null;
-  this.callbackPriority = 0;
-  this.eventTimes = createLaneMap(0);
-  this.expirationTimes = createLaneMap(-1);
-  this.entangledLanes =
-    this.errorRecoveryDisabledLanes =
-    this.finishedLanes =
-    this.mutableReadLanes =
-    this.expiredLanes =
-    this.pingedLanes =
-    this.suspendedLanes =
-    this.pendingLanes =
-      0;
-  this.entanglements = createLaneMap(0);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
-  this.pooledCache = null;
-  this.pooledCacheLanes = 0;
-  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
-  this.incompleteTransitions = new Map();
-  if (enableTransitionTracing)
-    for (
-      this.transitionCallbacks = null,
-        containerInfo = this.transitionLanes = [],
-        tag = 0;
-      31 > tag;
-      tag++
-    )
-      containerInfo.push(null);
-  this.passiveEffectDuration = this.effectDuration = 0;
-  this.memoizedUpdaters = new Set();
-  containerInfo = this.pendingUpdatersLaneMap = [];
-  for (tag = 0; 31 > tag; tag++) containerInfo.push(new Set());
+  }
+  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
+    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
+  for (
+    ;
+    0 < queuedExplicitHydrationTargets.length &&
+    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
+
+  )
+    attemptExplicitHydrationTarget(i),
+      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
 }
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
+  _enabled = !0;
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
 ) {
-  containerInfo = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
+  switch (getEventPriority(domEventName)) {
+    case 2:
+      var listenerWrapper = dispatchDiscreteEvent;
+      break;
+    case 8:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+    default:
+      listenerWrapper = dispatchEvent;
+  }
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
   );
-  containerInfo.hydrationCallbacks = hydrationCallbacks;
-  enableTransitionTracing &&
-    (containerInfo.transitionCallbacks = transitionCallbacks);
-  1 === tag
-    ? ((tag = 1),
-      !0 === isStrictMode && (tag |= 24),
-      concurrentUpdatesByDefaultOverride && (tag |= 32))
-    : (tag = 0);
-  isDevToolsPresent && (tag |= 2);
-  isStrictMode = createFiber(3, null, null, tag);
-  containerInfo.current = isStrictMode;
-  isStrictMode.stateNode = containerInfo;
-  concurrentUpdatesByDefaultOverride = createCache();
-  concurrentUpdatesByDefaultOverride.refCount++;
-  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
-  concurrentUpdatesByDefaultOverride.refCount++;
-  isStrictMode.memoizedState = {
-    element: initialChildren,
-    isDehydrated: hydrate,
-    cache: concurrentUpdatesByDefaultOverride
-  };
-  initializeUpdateQueue(isStrictMode);
-  return containerInfo;
 }
-function createPortal$1(children, containerInfo, implementation) {
-  var key =
-    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
-  return {
-    $$typeof: REACT_PORTAL_TYPE,
-    key: null == key ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
-  };
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 2),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
+  }
 }
-function getContextForSubtree(parentComponent) {
-  if (!parentComponent) return emptyContextObject;
-  parentComponent = parentComponent._reactInternals;
-  a: {
-    if (
-      getNearestMountedFiber(parentComponent) !== parentComponent ||
-      1 !== parentComponent.tag
-    )
-      throw Error(formatProdErrorMessage(170));
-    var JSCompiler_inline_result = parentComponent;
-    do {
-      switch (JSCompiler_inline_result.tag) {
-        case 3:
-          JSCompiler_inline_result = JSCompiler_inline_result.stateNode.context;
-          break a;
-        case 1:
-          if (isContextProvider(JSCompiler_inline_result.type)) {
-            JSCompiler_inline_result =
-              JSCompiler_inline_result.stateNode
-                .__reactInternalMemoizedMergedChildContext;
-            break a;
-          }
-      }
-      JSCompiler_inline_result = JSCompiler_inline_result.return;
-    } while (null !== JSCompiler_inline_result);
-    throw Error(formatProdErrorMessage(171));
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 8),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
   }
-  if (1 === parentComponent.tag) {
-    var Component = parentComponent.type;
-    if (isContextProvider(Component))
-      return processChildContext(
-        parentComponent,
-        Component,
-        JSCompiler_inline_result
+}
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (_enabled)
+    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+      var blockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
       );
-  }
-  return JSCompiler_inline_result;
+      if (null === blockedOn)
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          clearIfContinuousEvent(domEventName, nativeEvent);
+      else if (
+        queueIfContinuousEvent(
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
+      )
+        nativeEvent.stopPropagation();
+      else if (
+        (clearIfContinuousEvent(domEventName, nativeEvent),
+        eventSystemFlags & 4 &&
+          -1 < discreteReplayableEvents.indexOf(domEventName))
+      ) {
+        for (; null !== blockedOn; ) {
+          var fiber = getInstanceFromNode(blockedOn);
+          null !== fiber && attemptSynchronousHydration(fiber);
+          fiber = findInstanceBlockingEvent(
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          );
+          null === fiber &&
+            dispatchEventForPluginEventSystem(
+              domEventName,
+              eventSystemFlags,
+              nativeEvent,
+              return_targetInst,
+              targetContainer
+            );
+          if (fiber === blockedOn) break;
+          blockedOn = fiber;
+        }
+        null !== blockedOn && nativeEvent.stopPropagation();
+      } else
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+    } else
+      a: if (
+        (blockedOn = 0 === (eventSystemFlags & 4)) &&
+        0 < queuedDiscreteEvents.length &&
+        -1 < discreteReplayableEvents.indexOf(domEventName)
+      )
+        queueDiscreteEvent(
+          null,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        );
+      else if (
+        ((fiber = findInstanceBlockingEvent(
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        null === fiber)
+      )
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
+      else {
+        if (blockedOn) {
+          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
+            queueDiscreteEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            );
+            break a;
+          }
+          if (
+            queueIfContinuousEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            )
+          )
+            break a;
+          clearIfContinuousEvent(domEventName, nativeEvent);
+        }
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+      }
 }
-function createHydrationContainer(
-  initialChildren,
-  callback,
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+var return_targetInst = null;
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
 ) {
-  initialChildren = createFiberRoot(
-    containerInfo,
-    tag,
-    !0,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
-  );
-  initialChildren.context = getContextForSubtree(null);
-  containerInfo = initialChildren.current;
-  tag = requestUpdateLane(containerInfo);
-  hydrationCallbacks = createUpdate(tag);
-  hydrationCallbacks.callback =
-    void 0 !== callback && null !== callback ? callback : null;
-  callback = requestEventTime();
-  enqueueUpdate(containerInfo, hydrationCallbacks, tag);
-  initialChildren.current.lanes = tag;
-  markRootUpdated(initialChildren, tag, callback);
-  ensureRootIsScheduled(initialChildren, callback);
-  return initialChildren;
-}
-function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current,
-    lane = requestUpdateLane(current);
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markRenderScheduled &&
-    injectedProfilingHooks.markRenderScheduled(lane);
-  parentComponent = getContextForSubtree(parentComponent);
-  null === container.context
-    ? (container.context = parentComponent)
-    : (container.pendingContext = parentComponent);
-  container = createUpdate(lane);
-  container.payload = { element: element };
-  callback = void 0 === callback ? null : callback;
-  null !== callback && (container.callback = callback);
-  element = enqueueUpdate(current, container, lane);
-  null !== element &&
-    ((callback = requestEventTime()),
-    scheduleUpdateOnFiber(element, current, lane, callback),
-    entangleTransitions(element, current, lane));
-  return lane;
+  return_targetInst = null;
+  domEventName = getEventTarget(nativeEvent);
+  domEventName = getClosestInstanceFromNode(domEventName);
+  if (null !== domEventName)
+    if (
+      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
+      null === eventSystemFlags)
+    )
+      domEventName = null;
+    else if (
+      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
+    ) {
+      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
+      if (null !== domEventName) return domEventName;
+      domEventName = null;
+    } else if (3 === targetContainer) {
+      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
+        return 3 === eventSystemFlags.tag
+          ? eventSystemFlags.stateNode.containerInfo
+          : null;
+      domEventName = null;
+    } else eventSystemFlags !== domEventName && (domEventName = null);
+  return_targetInst = domEventName;
+  return null;
 }
-function getPublicRootInstance(container) {
-  container = container.current;
-  if (!container.child) return null;
-  switch (container.child.tag) {
-    case 27:
-    case 5:
-      return container.child.stateNode;
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange":
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate":
+    case "beforeblur":
+    case "afterblur":
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return 2;
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel":
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return 8;
+    case "message":
+      switch (getCurrentPriorityLevel()) {
+        case ImmediatePriority:
+          return 2;
+        case UserBlockingPriority:
+          return 8;
+        case NormalPriority$1:
+        case LowPriority:
+          return 32;
+        case IdlePriority:
+          return 536870912;
+        default:
+          return 32;
+      }
     default:
-      return container.child.stateNode;
-  }
-}
-function markRetryLaneImpl(fiber, retryLane) {
-  fiber = fiber.memoizedState;
-  if (null !== fiber && null !== fiber.dehydrated) {
-    var a = fiber.retryLane;
-    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+      return 32;
   }
 }
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
-}
-function emptyFindFiberByHostInstance() {
-  return null;
-}
 var Dispatcher = Internals.Dispatcher,
   defaultOnRecoverableError =
     "function" === typeof reportError
@@ -16251,7 +16321,7 @@ function ReactDOMHydrationRoot(internalRoot) {
 }
 ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
   if (target) {
-    var updatePriority = getCurrentUpdatePriority();
+    var updatePriority = currentUpdatePriority;
     target = { blockedOn: null, target: target, priority: updatePriority };
     for (
       var i = 0;
@@ -16296,11 +16366,11 @@ function legacyCreateRootFromDOMContainer(
     if ("function" === typeof callback) {
       var originalCallback = callback;
       callback = function () {
-        var instance = getPublicRootInstance(root$245);
+        var instance = getPublicRootInstance(root$244);
         originalCallback.call(instance);
       };
     }
-    var root$245 = createHydrationContainer(
+    var root$244 = createHydrationContainer(
       initialChildren,
       callback,
       container,
@@ -16312,23 +16382,23 @@ function legacyCreateRootFromDOMContainer(
       noopOnRecoverableError,
       null
     );
-    container._reactRootContainer = root$245;
-    container[internalContainerInstanceKey] = root$245.current;
+    container._reactRootContainer = root$244;
+    container[internalContainerInstanceKey] = root$244.current;
     listenToAllSupportedEvents(
       8 === container.nodeType ? container.parentNode : container
     );
     flushSync$1();
-    return root$245;
+    return root$244;
   }
   clearContainer(container);
   if ("function" === typeof callback) {
-    var originalCallback$246 = callback;
+    var originalCallback$245 = callback;
     callback = function () {
-      var instance = getPublicRootInstance(root$247);
-      originalCallback$246.call(instance);
+      var instance = getPublicRootInstance(root$246);
+      originalCallback$245.call(instance);
     };
   }
-  var root$247 = createFiberRoot(
+  var root$246 = createFiberRoot(
     container,
     0,
     !1,
@@ -16340,15 +16410,15 @@ function legacyCreateRootFromDOMContainer(
     noopOnRecoverableError,
     null
   );
-  container._reactRootContainer = root$247;
-  container[internalContainerInstanceKey] = root$247.current;
+  container._reactRootContainer = root$246;
+  container[internalContainerInstanceKey] = root$246.current;
   listenToAllSupportedEvents(
     8 === container.nodeType ? container.parentNode : container
   );
   flushSync$1(function () {
-    updateContainer(initialChildren, root$247, parentComponent, callback);
+    updateContainer(initialChildren, root$246, parentComponent, callback);
   });
-  return root$247;
+  return root$246;
 }
 function legacyRenderSubtreeIntoContainer(
   parentComponent,
@@ -16399,108 +16469,18 @@ function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
         listenerSet.add(listenerSetKey));
     } else throw Error(formatProdErrorMessage(369));
 }
-_attemptSynchronousHydration = function (fiber) {
-  switch (fiber.tag) {
-    case 3:
-      var root$244 = fiber.stateNode;
-      if (root$244.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$244.pendingLanes);
-        0 !== lanes &&
-          (markRootEntangled(root$244, lanes | 2),
-          ensureRootIsScheduled(root$244, now$1()),
-          0 === (executionContext & 6) &&
-            (resetRenderTimer(), flushSyncCallbacks()));
-      }
-      break;
-    case 13:
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        if (null !== root) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-        }
-      }),
-        markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptDiscreteHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptContinuousHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 134217728);
-  }
-};
-attemptHydrationAtCurrentPriority$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var lane = requestUpdateLane(fiber),
-      root = enqueueConcurrentRenderForLane(fiber, lane);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, lane);
-  }
-};
-getCurrentUpdatePriority = function () {
-  return currentUpdatePriority;
-};
-attemptHydrationAtPriority = runWithPriority;
-restoreImpl = function (domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, props);
-      tag = props.name;
-      if ("radio" === props.type && null != tag) {
-        for (props = domElement; props.parentNode; ) props = props.parentNode;
-        props = props.querySelectorAll(
-          "input[name=" + JSON.stringify("" + tag) + '][type="radio"]'
-        );
-        for (tag = 0; tag < props.length; tag++) {
-          var otherNode = props[tag];
-          if (otherNode !== domElement && otherNode.form === domElement.form) {
-            var otherProps = getFiberCurrentPropsFromNode(otherNode);
-            if (!otherProps) throw Error(formatProdErrorMessage(90));
-            updateValueIfChanged(otherNode);
-            updateWrapper$1(otherNode, otherProps);
-          }
-        }
-      }
-      break;
-    case "textarea":
-      updateWrapper(domElement, props);
-      break;
-    case "select":
-      (tag = props.value),
-        null != tag && updateOptions(domElement, !!props.multiple, tag, !1);
-  }
-};
-batchedUpdatesImpl = batchedUpdates;
-flushSyncImpl = flushSync$1;
 Internals.Events = [
   getInstanceFromNode,
   getNodeFromInstance,
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
-var devToolsConfig$jscomp$inline_1841 = {
+var devToolsConfig$jscomp$inline_1819 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-classic-34f1ac29",
+  version: "18.3.0-www-classic-65d9d3da",
   rendererPackageName: "react-dom"
 };
 (function (internals) {
@@ -16518,10 +16498,10 @@ var devToolsConfig$jscomp$inline_1841 = {
   } catch (err) {}
   return hook.checkDCE ? !0 : !1;
 })({
-  bundleType: devToolsConfig$jscomp$inline_1841.bundleType,
-  version: devToolsConfig$jscomp$inline_1841.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1841.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1841.rendererConfig,
+  bundleType: devToolsConfig$jscomp$inline_1819.bundleType,
+  version: devToolsConfig$jscomp$inline_1819.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1819.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1819.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -16537,14 +16517,14 @@ var devToolsConfig$jscomp$inline_1841 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1841.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1819.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-classic-34f1ac29"
+  reconcilerVersion: "18.3.0-www-classic-65d9d3da"
 });
 assign(Internals, {
   ReactBrowserEventEmitter: {
@@ -16722,7 +16702,7 @@ exports.unmountComponentAtNode = function (container) {
       !0)
     : !1;
 };
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = function (type, options) {
   function eventHandle(target, callback) {
     if ("function" !== typeof callback)
@@ -16755,15 +16735,15 @@ exports.unstable_createEventHandle = function (type, options) {
 exports.unstable_flushControlled = function (fn) {
   var prevExecutionContext = executionContext;
   executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
     previousPriority = currentUpdatePriority;
   try {
-    (ReactCurrentBatchConfig.transition = null),
+    (ReactCurrentBatchConfig$1.transition = null),
       (currentUpdatePriority = 2),
       fn();
   } finally {
     (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
       (executionContext = prevExecutionContext),
       0 === executionContext && (resetRenderTimer(), flushSyncCallbacks());
   }
@@ -16787,7 +16767,7 @@ exports.unstable_renderSubtreeIntoContainer = function (
   );
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-classic-34f1ac29";
+exports.version = "18.3.0-www-classic-65d9d3da";
 
           /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
 if (
diff --git a/compiled/facebook-www/ReactDOM-profiling.modern.js b/compiled/facebook-www/ReactDOM-profiling.modern.js
index 29d3e0e402763..5124c725cbb5d 100644
--- a/compiled/facebook-www/ReactDOM-profiling.modern.js
+++ b/compiled/facebook-www/ReactDOM-profiling.modern.js
@@ -25,8 +25,8 @@ if (
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
 "use strict";
-var Scheduler = require("scheduler"),
-  React = require("react"),
+var React = require("react"),
+  Scheduler = require("scheduler"),
   Internals = {
     usingClientEntryPoint: !1,
     Events: null,
@@ -51,6 +51,7 @@ function formatProdErrorMessage(code) {
 var dynamicFeatureFlags = require("ReactFeatureFlags"),
   disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   enableFilterEmptyStringAttributesDOM =
@@ -1129,17 +1130,46 @@ function getEventTarget(nativeEvent) {
     (nativeEvent = nativeEvent.correspondingUseElement);
   return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;
 }
-var restoreImpl = null,
-  restoreTarget = null,
+var restoreTarget = null,
   restoreQueue = null;
 function restoreStateOfTarget(target) {
-  if ((target = getInstanceFromNode$1(target))) {
-    if ("function" !== typeof restoreImpl)
-      throw Error(formatProdErrorMessage(280));
-    var stateNode = target.stateNode;
-    stateNode &&
-      ((stateNode = getFiberCurrentPropsFromNode(stateNode)),
-      restoreImpl(target.stateNode, target.type, stateNode));
+  var internalInstance = getInstanceFromNode$1(target);
+  if (internalInstance && (target = internalInstance.stateNode)) {
+    var props = getFiberCurrentPropsFromNode(target);
+    a: switch (((target = internalInstance.stateNode), internalInstance.type)) {
+      case "input":
+        updateWrapper$1(target, props);
+        internalInstance = props.name;
+        if ("radio" === props.type && null != internalInstance) {
+          for (props = target; props.parentNode; ) props = props.parentNode;
+          props = props.querySelectorAll(
+            "input[name=" +
+              JSON.stringify("" + internalInstance) +
+              '][type="radio"]'
+          );
+          for (
+            internalInstance = 0;
+            internalInstance < props.length;
+            internalInstance++
+          ) {
+            var otherNode = props[internalInstance];
+            if (otherNode !== target && otherNode.form === target.form) {
+              var otherProps = getFiberCurrentPropsFromNode(otherNode);
+              if (!otherProps) throw Error(formatProdErrorMessage(90));
+              updateValueIfChanged(otherNode);
+              updateWrapper$1(otherNode, otherProps);
+            }
+          }
+        }
+        break a;
+      case "textarea":
+        updateWrapper(target, props);
+        break a;
+      case "select":
+        (internalInstance = props.value),
+          null != internalInstance &&
+            updateOptions(target, !!props.multiple, internalInstance, !1);
+    }
   }
 }
 function enqueueStateRestore(target) {
@@ -1160,118 +1190,6 @@ function restoreStateIfNeeded() {
         restoreStateOfTarget(queuedTargets[target]);
   }
 }
-function batchedUpdatesImpl(fn, bookkeeping) {
-  return fn(bookkeeping);
-}
-function flushSyncImpl() {}
-var isInsideEventHandler = !1;
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) return fn(a, b);
-  isInsideEventHandler = !0;
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    if (
-      ((isInsideEventHandler = !1),
-      null !== restoreTarget || null !== restoreQueue)
-    )
-      flushSyncImpl(), restoreStateIfNeeded();
-  }
-}
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-  if (null === stateNode) return null;
-  var props = getFiberCurrentPropsFromNode(stateNode);
-  if (null === props) return null;
-  stateNode = props[registrationName];
-  a: switch (registrationName) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      (props = !props.disabled) ||
-        ((inst = inst.type),
-        (props = !(
-          "button" === inst ||
-          "input" === inst ||
-          "select" === inst ||
-          "textarea" === inst
-        )));
-      inst = !props;
-      break a;
-    default:
-      inst = !1;
-  }
-  if (inst) return null;
-  if (stateNode && "function" !== typeof stateNode)
-    throw Error(
-      formatProdErrorMessage(231, registrationName, typeof stateNode)
-    );
-  return stateNode;
-}
-var passiveBrowserEventsSupported = !1;
-if (canUseDOM)
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = !0;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = !1;
-  }
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
-  throw Error(formatProdErrorMessage(255));
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
-}
-var hasError = !1,
-  caughtError = null,
-  hasRethrowError = !1,
-  rethrowError = null,
-  reporter = {
-    onError: function (error) {
-      hasError = !0;
-      caughtError = error;
-    }
-  };
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = !1;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
-}
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
-  if (hasError) {
-    if (hasError) {
-      var error = caughtError;
-      hasError = !1;
-      caughtError = null;
-    } else throw Error(formatProdErrorMessage(198));
-    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
-  }
-}
 function getNearestMountedFiber(fiber) {
   var node = fiber,
     nearestMounted = fiber;
@@ -1398,114 +1316,22 @@ function doesFiberContain(parentFiber, childFiber) {
   }
   return !1;
 }
-var scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
-  cancelCallback$1 = Scheduler.unstable_cancelCallback,
-  shouldYield = Scheduler.unstable_shouldYield,
-  requestPaint = Scheduler.unstable_requestPaint,
-  now$1 = Scheduler.unstable_now,
-  getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
-  ImmediatePriority = Scheduler.unstable_ImmediatePriority,
-  UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
-  NormalPriority$1 = Scheduler.unstable_NormalPriority,
-  LowPriority = Scheduler.unstable_LowPriority,
-  IdlePriority = Scheduler.unstable_IdlePriority,
-  rendererID = null,
-  injectedHook = null,
-  injectedProfilingHooks = null,
-  isDevToolsPresent = "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__;
-function onCommitRoot(root, eventPriority) {
-  if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
-    try {
-      var didError = 128 === (root.current.flags & 128);
-      switch (eventPriority) {
-        case 2:
-          var schedulerPriority = ImmediatePriority;
-          break;
-        case 8:
-          schedulerPriority = UserBlockingPriority;
-          break;
-        case 32:
-          schedulerPriority = NormalPriority$1;
-          break;
-        case 536870912:
-          schedulerPriority = IdlePriority;
-          break;
-        default:
-          schedulerPriority = NormalPriority$1;
-      }
-      injectedHook.onCommitFiberRoot(
-        rendererID,
-        root,
-        schedulerPriority,
-        didError
-      );
-    } catch (err) {}
-}
-function injectProfilingHooks(profilingHooks) {
-  injectedProfilingHooks = profilingHooks;
-}
-function getLaneLabelMap() {
-  if (enableSchedulingProfiler) {
-    for (var map = new Map(), lane = 1, index$9 = 0; 31 > index$9; index$9++) {
-      var label = getLabelForLane(lane);
-      map.set(lane, label);
-      lane *= 2;
-    }
-    return map;
-  }
-  return null;
-}
-function markCommitStopped() {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markCommitStopped &&
-    injectedProfilingHooks.markCommitStopped();
-}
-function markComponentRenderStarted(fiber) {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markComponentRenderStarted &&
-    injectedProfilingHooks.markComponentRenderStarted(fiber);
-}
-function markComponentRenderStopped() {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markComponentRenderStopped &&
-    injectedProfilingHooks.markComponentRenderStopped();
-}
-function markComponentLayoutEffectUnmountStarted(fiber) {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" ===
-      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted &&
-    injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
-}
-function markComponentLayoutEffectUnmountStopped() {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" ===
-      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped &&
-    injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
-}
-function markRenderStarted(lanes) {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markRenderStarted &&
-    injectedProfilingHooks.markRenderStarted(lanes);
+var valueStack = [],
+  index = -1;
+function createCursor(defaultValue) {
+  return { current: defaultValue };
 }
-function markRenderStopped() {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markRenderStopped &&
-    injectedProfilingHooks.markRenderStopped();
+function pop(cursor) {
+  0 > index ||
+    ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
 }
-function markStateUpdateScheduled(fiber, lane) {
-  enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markStateUpdateScheduled &&
-    injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+function push(cursor, value) {
+  index++;
+  valueStack[index] = cursor.current;
+  cursor.current = value;
 }
-var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
+var emptyContextObject = {},
+  clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
   log = Math.log,
   LN2 = Math.LN2;
 function clz32Fallback(x) {
@@ -1678,12 +1504,12 @@ function markStarvedLanesAsExpired(root, currentTime) {
     0 < lanes;
 
   ) {
-    var index$12 = 31 - clz32(lanes),
-      lane = 1 << index$12,
-      expirationTime = expirationTimes[index$12];
+    var index$11 = 31 - clz32(lanes),
+      lane = 1 << index$11,
+      expirationTime = expirationTimes[index$11];
     if (-1 === expirationTime) {
       if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes))
-        expirationTimes[index$12] = computeExpirationTime(lane, currentTime);
+        expirationTimes[index$11] = computeExpirationTime(lane, currentTime);
     } else expirationTime <= currentTime && (root.expiredLanes |= lane);
     lanes &= ~lane;
   }
@@ -1727,19 +1553,19 @@ function markRootFinished(root, remainingLanes) {
   var eventTimes = root.eventTimes,
     expirationTimes = root.expirationTimes;
   for (root = root.hiddenUpdates; 0 < noLongerPendingLanes; ) {
-    var index$14 = 31 - clz32(noLongerPendingLanes),
-      lane = 1 << index$14;
-    remainingLanes[index$14] = 0;
-    eventTimes[index$14] = -1;
-    expirationTimes[index$14] = -1;
-    var hiddenUpdatesForLane = root[index$14];
+    var index$13 = 31 - clz32(noLongerPendingLanes),
+      lane = 1 << index$13;
+    remainingLanes[index$13] = 0;
+    eventTimes[index$13] = -1;
+    expirationTimes[index$13] = -1;
+    var hiddenUpdatesForLane = root[index$13];
     if (null !== hiddenUpdatesForLane)
       for (
-        root[index$14] = null, index$14 = 0;
-        index$14 < hiddenUpdatesForLane.length;
-        index$14++
+        root[index$13] = null, index$13 = 0;
+        index$13 < hiddenUpdatesForLane.length;
+        index$13++
       ) {
-        var update = hiddenUpdatesForLane[index$14];
+        var update = hiddenUpdatesForLane[index$13];
         null !== update && (update.lane &= -1073741825);
       }
     noLongerPendingLanes &= ~lane;
@@ -1748,19 +1574,19 @@ function markRootFinished(root, remainingLanes) {
 function markRootEntangled(root, entangledLanes) {
   var rootEntangledLanes = (root.entangledLanes |= entangledLanes);
   for (root = root.entanglements; rootEntangledLanes; ) {
-    var index$15 = 31 - clz32(rootEntangledLanes),
-      lane = 1 << index$15;
-    (lane & entangledLanes) | (root[index$15] & entangledLanes) &&
-      (root[index$15] |= entangledLanes);
+    var index$14 = 31 - clz32(rootEntangledLanes),
+      lane = 1 << index$14;
+    (lane & entangledLanes) | (root[index$14] & entangledLanes) &&
+      (root[index$14] |= entangledLanes);
     rootEntangledLanes &= ~lane;
   }
 }
 function addFiberToLanesMap(root, fiber, lanes) {
   if (isDevToolsPresent)
     for (root = root.pendingUpdatersLaneMap; 0 < lanes; ) {
-      var index$16 = 31 - clz32(lanes),
-        lane = 1 << index$16;
-      root[index$16].add(fiber);
+      var index$15 = 31 - clz32(lanes),
+        lane = 1 << index$15;
+      root[index$15].add(fiber);
       lanes &= ~lane;
     }
 }
@@ -1772,27 +1598,27 @@ function movePendingFibersToMemoized(root, lanes) {
       0 < lanes;
 
     ) {
-      var index$17 = 31 - clz32(lanes);
-      root = 1 << index$17;
-      index$17 = pendingUpdatersLaneMap[index$17];
-      0 < index$17.size &&
-        (index$17.forEach(function (fiber) {
+      var index$16 = 31 - clz32(lanes);
+      root = 1 << index$16;
+      index$16 = pendingUpdatersLaneMap[index$16];
+      0 < index$16.size &&
+        (index$16.forEach(function (fiber) {
           var alternate = fiber.alternate;
           (null !== alternate && memoizedUpdaters.has(alternate)) ||
             memoizedUpdaters.add(fiber);
         }),
-        index$17.clear());
+        index$16.clear());
       lanes &= ~root;
     }
 }
 function getTransitionsForLanes(root, lanes) {
   if (!enableTransitionTracing) return null;
   for (var transitionsForLanes = []; 0 < lanes; ) {
-    var index$19 = 31 - clz32(lanes),
-      lane = 1 << index$19;
-    index$19 = root.transitionLanes[index$19];
-    null !== index$19 &&
-      index$19.forEach(function (transition) {
+    var index$18 = 31 - clz32(lanes),
+      lane = 1 << index$18;
+    index$18 = root.transitionLanes[index$18];
+    null !== index$18 &&
+      index$18.forEach(function (transition) {
         transitionsForLanes.push(transition);
       });
     lanes &= ~lane;
@@ -1802,10 +1628,10 @@ function getTransitionsForLanes(root, lanes) {
 function clearTransitionsForLanes(root, lanes) {
   if (enableTransitionTracing)
     for (; 0 < lanes; ) {
-      var index$20 = 31 - clz32(lanes),
-        lane = 1 << index$20;
-      null !== root.transitionLanes[index$20] &&
-        (root.transitionLanes[index$20] = null);
+      var index$19 = 31 - clz32(lanes),
+        lane = 1 << index$19;
+      null !== root.transitionLanes[index$19] &&
+        (root.transitionLanes[index$19] = null);
       lanes &= ~lane;
     }
 }
@@ -1828,8268 +1654,5729 @@ function lanesToEventPriority(lanes) {
       : 8
     : 2;
 }
-var _attemptSynchronousHydration,
-  attemptDiscreteHydration$1,
-  attemptContinuousHydration$1,
-  attemptHydrationAtCurrentPriority$1,
-  getCurrentUpdatePriority,
-  attemptHydrationAtPriority,
-  hasScheduledReplayAttempt = !1,
-  queuedDiscreteEvents = [],
-  queuedFocus = null,
-  queuedDrag = null,
-  queuedMouse = null,
-  queuedPointers = new Map(),
-  queuedPointerCaptures = new Map(),
-  queuedExplicitHydrationTargets = [],
-  discreteReplayableEvents =
-    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
-      " "
-    );
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
+var scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
+  cancelCallback$1 = Scheduler.unstable_cancelCallback,
+  shouldYield = Scheduler.unstable_shouldYield,
+  requestPaint = Scheduler.unstable_requestPaint,
+  now$1 = Scheduler.unstable_now,
+  getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
+  ImmediatePriority = Scheduler.unstable_ImmediatePriority,
+  UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
+  NormalPriority$1 = Scheduler.unstable_NormalPriority,
+  LowPriority = Scheduler.unstable_LowPriority,
+  IdlePriority = Scheduler.unstable_IdlePriority,
+  rendererID = null,
+  injectedHook = null,
+  injectedProfilingHooks = null,
+  isDevToolsPresent = "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__;
+function onCommitRoot(root, eventPriority) {
+  if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
+    try {
+      var didError = 128 === (root.current.flags & 128);
+      switch (eventPriority) {
+        case 2:
+          var schedulerPriority = ImmediatePriority;
+          break;
+        case 8:
+          schedulerPriority = UserBlockingPriority;
+          break;
+        case 32:
+          schedulerPriority = NormalPriority$1;
+          break;
+        case 536870912:
+          schedulerPriority = IdlePriority;
+          break;
+        default:
+          schedulerPriority = NormalPriority$1;
+      }
+      injectedHook.onCommitFiberRoot(
+        rendererID,
+        root,
+        schedulerPriority,
+        didError
+      );
+    } catch (err) {}
 }
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
-    ((blockedOn = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )),
-    queuedDiscreteEvents.push(blockedOn),
-    1 === queuedDiscreteEvents.length)
-  )
-    for (; null !== blockedOn.blockedOn; ) {
-      domEventName = getInstanceFromNode$1(blockedOn.blockedOn);
-      if (null === domEventName) break;
-      _attemptSynchronousHydration(domEventName);
-      if (null === blockedOn.blockedOn) replayUnblockedEvents();
-      else break;
-    }
+function injectProfilingHooks(profilingHooks) {
+  injectedProfilingHooks = profilingHooks;
 }
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
-    case "pointerover":
-    case "pointerout":
-      queuedPointers.delete(nativeEvent.pointerId);
-      break;
-    case "gotpointercapture":
-    case "lostpointercapture":
-      queuedPointerCaptures.delete(nativeEvent.pointerId);
+function getLaneLabelMap() {
+  if (enableSchedulingProfiler) {
+    for (
+      var map = new Map(), lane = 1, index$20 = 0;
+      31 > index$20;
+      index$20++
+    ) {
+      var label = getLabelForLane(lane);
+      map.set(lane, label);
+      lane *= 2;
+    }
+    return map;
   }
+  return null;
 }
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    null === existingQueuedEvent ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
-  )
-    return (
-      (existingQueuedEvent = createQueuedReplayableEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )),
-      null !== blockedOn &&
-        ((blockedOn = getInstanceFromNode$1(blockedOn)),
-        null !== blockedOn && attemptContinuousHydration$1(blockedOn)),
-      existingQueuedEvent
-    );
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  blockedOn = existingQueuedEvent.targetContainers;
-  null !== targetContainer &&
-    -1 === blockedOn.indexOf(targetContainer) &&
-    blockedOn.push(targetContainer);
-  return existingQueuedEvent;
+function markCommitStopped() {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markCommitStopped &&
+    injectedProfilingHooks.markCommitStopped();
 }
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  switch (domEventName) {
-    case "focusin":
-      return (
-        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedFocus,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "dragenter":
-      return (
-        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedDrag,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "mouseover":
-      return (
-        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedMouse,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "pointerover":
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
-      );
-      return !0;
-    case "gotpointercapture":
-      return (
-        (pointerId = nativeEvent.pointerId),
-        queuedPointerCaptures.set(
-          pointerId,
-          accumulateOrCreateContinuousQueuedReplayableEvent(
-            queuedPointerCaptures.get(pointerId) || null,
-            blockedOn,
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          )
-        ),
-        !0
-      );
-  }
-  return !1;
+function markComponentRenderStarted(fiber) {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markComponentRenderStarted &&
+    injectedProfilingHooks.markComponentRenderStarted(fiber);
 }
-function attemptExplicitHydrationTarget(queuedTarget) {
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
-  if (null !== targetInst) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-    if (null !== nearestMounted)
-      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
-        if (
-          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
-          null !== targetInst)
-        ) {
-          queuedTarget.blockedOn = targetInst;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (
-        3 === targetInst &&
-        nearestMounted.stateNode.current.memoizedState.isDehydrated
-      ) {
-        queuedTarget.blockedOn =
-          3 === nearestMounted.tag
-            ? nearestMounted.stateNode.containerInfo
-            : null;
-        return;
-      }
-  }
-  queuedTarget.blockedOn = null;
+function markComponentRenderStopped() {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markComponentRenderStopped &&
+    injectedProfilingHooks.markComponentRenderStopped();
 }
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (null !== queuedEvent.blockedOn) return !1;
-  for (
-    var targetContainers = queuedEvent.targetContainers;
-    0 < targetContainers.length;
-
-  ) {
-    var targetContainer = targetContainers[0],
-      nextBlockedOn = findInstanceBlockingEvent(
-        queuedEvent.domEventName,
-        queuedEvent.eventSystemFlags,
-        targetContainer,
-        queuedEvent.nativeEvent
-      );
-    if (null === nextBlockedOn)
-      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
-        ? ((nextBlockedOn = queuedEvent.nativeEvent),
-          (currentReplayingEvent = targetContainer =
-            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
-          nextBlockedOn.target.dispatchEvent(targetContainer))
-        : ((currentReplayingEvent = queuedEvent.nativeEvent),
-          dispatchEventForPluginEventSystem(
-            queuedEvent.domEventName,
-            queuedEvent.eventSystemFlags,
-            queuedEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          )),
-        (currentReplayingEvent = null);
-    else
-      return (
-        (targetContainers = getInstanceFromNode$1(nextBlockedOn)),
-        null !== targetContainers &&
-          attemptContinuousHydration$1(targetContainers),
-        (queuedEvent.blockedOn = nextBlockedOn),
-        !1
-      );
-    targetContainers.shift();
-  }
-  return !0;
+function markComponentLayoutEffectUnmountStarted(fiber) {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" ===
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted &&
+    injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
 }
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+function markComponentLayoutEffectUnmountStopped() {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" ===
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped &&
+    injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
 }
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = !1;
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
-    for (; 0 < queuedDiscreteEvents.length; ) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
-      if (null !== nextDiscreteEvent.blockedOn) {
-        nextDiscreteEvent = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
-        null !== nextDiscreteEvent &&
-          attemptDiscreteHydration$1(nextDiscreteEvent);
-        break;
+function markRenderStarted(lanes) {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markRenderStarted &&
+    injectedProfilingHooks.markRenderStarted(lanes);
+}
+function markRenderStopped() {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markRenderStopped &&
+    injectedProfilingHooks.markRenderStopped();
+}
+function markStateUpdateScheduled(fiber, lane) {
+  enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markStateUpdateScheduled &&
+    injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+}
+function is(x, y) {
+  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+}
+var objectIs = "function" === typeof Object.is ? Object.is : is,
+  syncQueue = null,
+  includesLegacySyncCallbacks = !1,
+  isFlushingSyncQueue = !1;
+function scheduleSyncCallback(callback) {
+  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
+}
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = !0;
+  scheduleSyncCallback(callback);
+}
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && null !== syncQueue) {
+    isFlushingSyncQueue = !0;
+    var previousUpdatePriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
+      var callback = queue[i];
+      try {
+        do callback = callback(!0);
+        while (null !== callback);
+      } catch (error) {
+        null === errors ? (errors = [error]) : errors.push(error);
       }
-      for (
-        var targetContainers = nextDiscreteEvent.targetContainers;
-        0 < targetContainers.length;
-
-      ) {
-        var targetContainer = targetContainers[0],
-          nextBlockedOn = findInstanceBlockingEvent(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            targetContainer,
-            nextDiscreteEvent.nativeEvent
+    }
+    syncQueue = null;
+    includesLegacySyncCallbacks = !1;
+    currentUpdatePriority = previousUpdatePriority;
+    isFlushingSyncQueue = !1;
+    if (null !== errors) {
+      if (1 < errors.length) {
+        if ("function" === typeof AggregateError)
+          throw new AggregateError(errors);
+        for (
+          previousUpdatePriority = 1;
+          previousUpdatePriority < errors.length;
+          previousUpdatePriority++
+        )
+          scheduleCallback$2(
+            ImmediatePriority,
+            throwError.bind(null, errors[previousUpdatePriority])
           );
-        if (null === nextBlockedOn)
-          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
-            dispatchEventForPluginEventSystem(
-              nextDiscreteEvent.domEventName,
-              nextDiscreteEvent.eventSystemFlags,
-              nextDiscreteEvent.nativeEvent,
-              return_targetInst,
-              targetContainer
-            ),
-            (currentReplayingEvent = null);
-        else {
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        }
-        targetContainers.shift();
       }
-      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
-    }
-  null !== queuedFocus &&
-    attemptReplayContinuousQueuedEvent(queuedFocus) &&
-    (queuedFocus = null);
-  null !== queuedDrag &&
-    attemptReplayContinuousQueuedEvent(queuedDrag) &&
-    (queuedDrag = null);
-  null !== queuedMouse &&
-    attemptReplayContinuousQueuedEvent(queuedMouse) &&
-    (queuedMouse = null);
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
-}
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  queuedEvent.blockedOn === unblocked &&
-    ((queuedEvent.blockedOn = null),
-    hasScheduledReplayAttempt ||
-      ((hasScheduledReplayAttempt = !0),
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      )));
-}
-function retryIfBlockedOn(unblocked) {
-  function unblock(queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
-  }
-  if (0 < queuedDiscreteEvents.length) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
+      throw errors[0];
     }
   }
-  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
-  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
-  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
-    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
-  for (
-    ;
-    0 < queuedExplicitHydrationTargets.length &&
-    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
-
-  )
-    attemptExplicitHydrationTarget(i),
-      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
-}
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
-  _enabled = !0;
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  switch (getEventPriority(domEventName)) {
-    case 2:
-      var listenerWrapper = dispatchDiscreteEvent;
-      break;
-    case 8:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
-    default:
-      listenerWrapper = dispatchEvent;
-  }
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
+  return null;
 }
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 2),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
-  }
+function throwError(error) {
+  throw error;
 }
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 8),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
-  }
+var forkStack = [],
+  forkStackIndex = 0,
+  treeForkProvider = null,
+  treeForkCount = 0,
+  idStack = [],
+  idStackIndex = 0,
+  treeContextProvider = null,
+  treeContextId = 1,
+  treeContextOverflow = "";
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
 }
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (_enabled)
-    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-      var blockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
-      if (null === blockedOn)
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          clearIfContinuousEvent(domEventName, nativeEvent);
-      else if (
-        queueIfContinuousEvent(
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
-      )
-        nativeEvent.stopPropagation();
-      else if (
-        (clearIfContinuousEvent(domEventName, nativeEvent),
-        eventSystemFlags & 4 &&
-          -1 < discreteReplayableEvents.indexOf(domEventName))
-      ) {
-        for (; null !== blockedOn; ) {
-          var fiber = getInstanceFromNode$1(blockedOn);
-          null !== fiber && _attemptSynchronousHydration(fiber);
-          fiber = findInstanceBlockingEvent(
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          );
-          null === fiber &&
-            dispatchEventForPluginEventSystem(
-              domEventName,
-              eventSystemFlags,
-              nativeEvent,
-              return_targetInst,
-              targetContainer
-            );
-          if (fiber === blockedOn) break;
-          blockedOn = fiber;
-        }
-        null !== blockedOn && nativeEvent.stopPropagation();
-      } else
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-    } else
-      a: if (
-        (blockedOn = 0 === (eventSystemFlags & 4)) &&
-        0 < queuedDiscreteEvents.length &&
-        -1 < discreteReplayableEvents.indexOf(domEventName)
-      )
-        queueDiscreteEvent(
-          null,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        );
-      else if (
-        ((fiber = findInstanceBlockingEvent(
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        null === fiber)
-      )
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
-      else {
-        if (blockedOn) {
-          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
-            queueDiscreteEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            );
-            break a;
-          }
-          if (
-            queueIfContinuousEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            )
-          )
-            break a;
-          clearIfContinuousEvent(domEventName, nativeEvent);
-        }
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-      }
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  workInProgress = treeContextOverflow;
+  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
+  baseIdWithLeadingBit &= ~(1 << baseLength);
+  index += 1;
+  var length = 32 - clz32(totalChildren) + baseLength;
+  if (30 < length) {
+    var numberOfOverflowBits = baseLength - (baseLength % 5);
+    length = (
+      baseIdWithLeadingBit &
+      ((1 << numberOfOverflowBits) - 1)
+    ).toString(32);
+    baseIdWithLeadingBit >>= numberOfOverflowBits;
+    baseLength -= numberOfOverflowBits;
+    treeContextId =
+      (1 << (32 - clz32(totalChildren) + baseLength)) |
+      (index << baseLength) |
+      baseIdWithLeadingBit;
+    treeContextOverflow = length + workInProgress;
+  } else
+    (treeContextId =
+      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
+      (treeContextOverflow = workInProgress);
 }
-var return_targetInst = null;
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return_targetInst = null;
-  domEventName = getEventTarget(nativeEvent);
-  domEventName = getClosestInstanceFromNode(domEventName);
-  if (null !== domEventName)
-    if (
-      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
-      null === eventSystemFlags)
-    )
-      domEventName = null;
-    else if (
-      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
-    ) {
-      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
-      if (null !== domEventName) return domEventName;
-      domEventName = null;
-    } else if (3 === targetContainer) {
-      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
-        return 3 === eventSystemFlags.tag
-          ? eventSystemFlags.stateNode.containerInfo
-          : null;
-      domEventName = null;
-    } else eventSystemFlags !== domEventName && (domEventName = null);
-  return_targetInst = domEventName;
-  return null;
+function pushMaterializedTreeId(workInProgress) {
+  null !== workInProgress.return &&
+    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
 }
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange":
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate":
-    case "beforeblur":
-    case "afterblur":
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return 2;
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel":
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return 8;
-    case "message":
-      switch (getCurrentPriorityLevel()) {
-        case ImmediatePriority:
-          return 2;
-        case UserBlockingPriority:
-          return 8;
-        case NormalPriority$1:
-        case LowPriority:
-          return 32;
-        case IdlePriority:
-          return 536870912;
-        default:
-          return 32;
-      }
+function popTreeContext(workInProgress) {
+  for (; workInProgress === treeForkProvider; )
+    (treeForkProvider = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null),
+      (treeForkCount = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null);
+  for (; workInProgress === treeContextProvider; )
+    (treeContextProvider = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextOverflow = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextId = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null);
+}
+var contextStackCursor = createCursor(null),
+  contextFiberStackCursor = createCursor(null),
+  rootInstanceStackCursor = createCursor(null);
+function pushHostContainer(fiber, nextRootInstance) {
+  push(rootInstanceStackCursor, nextRootInstance);
+  push(contextFiberStackCursor, fiber);
+  push(contextStackCursor, null);
+  fiber = nextRootInstance.nodeType;
+  switch (fiber) {
+    case 9:
+    case 11:
+      nextRootInstance = (nextRootInstance = nextRootInstance.documentElement)
+        ? nextRootInstance.namespaceURI
+        : getChildNamespace(null, "");
+      break;
     default:
-      return 32;
+      (fiber = 8 === fiber ? nextRootInstance.parentNode : nextRootInstance),
+        (nextRootInstance = fiber.namespaceURI || null),
+        (fiber = fiber.tagName),
+        (nextRootInstance = getChildNamespace(nextRootInstance, fiber));
   }
+  pop(contextStackCursor);
+  push(contextStackCursor, nextRootInstance);
 }
-function addEventBubbleListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, !1);
-  return listener;
+function popHostContainer() {
+  pop(contextStackCursor);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
 }
-function addEventCaptureListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, !0);
-  return listener;
+function pushHostContext(fiber) {
+  var context = contextStackCursor.current;
+  var JSCompiler_inline_result = getChildNamespace(context, fiber.type);
+  context !== JSCompiler_inline_result &&
+    (push(contextFiberStackCursor, fiber),
+    push(contextStackCursor, JSCompiler_inline_result));
 }
-function addEventCaptureListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, {
-    capture: !0,
-    passive: passive
-  });
-  return listener;
+function popHostContext(fiber) {
+  contextFiberStackCursor.current === fiber &&
+    (pop(contextStackCursor), pop(contextFiberStackCursor));
 }
-function addEventBubbleListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, { passive: passive });
-  return listener;
+var hydrationParentFiber = null,
+  nextHydratableInstance = null,
+  isHydrating = !1,
+  hydrationErrors = null,
+  rootOrSingletonContext = !1;
+function deleteHydratableInstance(returnFiber, instance) {
+  var fiber = createFiber(5, null, null, 0);
+  fiber.elementType = "DELETED";
+  fiber.stateNode = instance;
+  fiber.return = returnFiber;
+  instance = returnFiber.deletions;
+  null === instance
+    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
+    : instance.push(fiber);
 }
-var root = null,
-  startText = null,
-  fallbackText = null;
-function getData() {
-  if (fallbackText) return fallbackText;
-  var start,
-    startValue = startText,
-    startLength = startValue.length,
-    end,
-    endValue = "value" in root ? root.value : root.textContent,
-    endLength = endValue.length;
-  for (
-    start = 0;
-    start < startLength && startValue[start] === endValue[start];
-    start++
-  );
-  var minEnd = startLength - start;
-  for (
-    end = 1;
-    end <= minEnd &&
-    startValue[startLength - end] === endValue[endLength - end];
-    end++
-  );
-  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & -4097) | 2;
 }
-function getEventCharCode(nativeEvent) {
-  var keyCode = nativeEvent.keyCode;
-  "charCode" in nativeEvent
-    ? ((nativeEvent = nativeEvent.charCode),
-      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
-    : (nativeEvent = keyCode);
-  10 === nativeEvent && (nativeEvent = 13);
-  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
+function tryHydrateInstance(fiber, nextInstance) {
+  var type = fiber.type;
+  nextInstance =
+    1 !== nextInstance.nodeType ||
+    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
+      (rootOrSingletonContext = !1),
+      !0)
+    : !1;
 }
-function functionThatReturnsTrue() {
-  return !0;
+function tryHydrateText(fiber, nextInstance) {
+  nextInstance =
+    "" === fiber.pendingProps
+      ? null
+      : 3 !== nextInstance.nodeType
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = null),
+      !0)
+    : !1;
 }
-function functionThatReturnsFalse() {
+function tryHydrateSuspense(fiber, nextInstance) {
+  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
+  if (null !== nextInstance) {
+    var JSCompiler_inline_result =
+      null !== treeContextProvider
+        ? { id: treeContextId, overflow: treeContextOverflow }
+        : null;
+    fiber.memoizedState = {
+      dehydrated: nextInstance,
+      treeContext: JSCompiler_inline_result,
+      retryLane: 1073741824
+    };
+    JSCompiler_inline_result = createFiber(18, null, null, 0);
+    JSCompiler_inline_result.stateNode = nextInstance;
+    JSCompiler_inline_result.return = fiber;
+    fiber.child = JSCompiler_inline_result;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = null;
+    return !0;
+  }
   return !1;
 }
-function createSyntheticEvent(Interface) {
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-    for (var propName in Interface)
-      Interface.hasOwnProperty(propName) &&
-        ((reactName = Interface[propName]),
-        (this[propName] = reactName
-          ? reactName(nativeEvent)
-          : nativeEvent[propName]));
-    this.isDefaultPrevented = (
-      null != nativeEvent.defaultPrevented
-        ? nativeEvent.defaultPrevented
-        : !1 === nativeEvent.returnValue
-    )
-      ? functionThatReturnsTrue
-      : functionThatReturnsFalse;
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  }
-  assign(SyntheticBaseEvent.prototype, {
-    preventDefault: function () {
-      this.defaultPrevented = !0;
-      var event = this.nativeEvent;
-      event &&
-        (event.preventDefault
-          ? event.preventDefault()
-          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
-        (this.isDefaultPrevented = functionThatReturnsTrue));
-    },
-    stopPropagation: function () {
-      var event = this.nativeEvent;
-      event &&
-        (event.stopPropagation
-          ? event.stopPropagation()
-          : "unknown" !== typeof event.cancelBubble &&
-            (event.cancelBubble = !0),
-        (this.isPropagationStopped = functionThatReturnsTrue));
-    },
-    persist: function () {},
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
+function shouldClientRenderOnMismatch(fiber) {
+  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
 }
-var EventInterface = {
-    eventPhase: 0,
-    bubbles: 0,
-    cancelable: 0,
-    timeStamp: function (event) {
-      return event.timeStamp || Date.now();
-    },
-    defaultPrevented: 0,
-    isTrusted: 0
-  },
-  SyntheticEvent = createSyntheticEvent(EventInterface),
-  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
-  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
-  lastMovementX,
-  lastMovementY,
-  lastMouseEvent,
-  MouseEventInterface = assign({}, UIEventInterface, {
-    screenX: 0,
-    screenY: 0,
-    clientX: 0,
-    clientY: 0,
-    pageX: 0,
-    pageY: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    getModifierState: getEventModifierState,
-    button: 0,
-    buttons: 0,
-    relatedTarget: function (event) {
-      return void 0 === event.relatedTarget
-        ? event.fromElement === event.srcElement
-          ? event.toElement
-          : event.fromElement
-        : event.relatedTarget;
-    },
-    movementX: function (event) {
-      if ("movementX" in event) return event.movementX;
-      event !== lastMouseEvent &&
-        (lastMouseEvent && "mousemove" === event.type
-          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
-            (lastMovementY = event.screenY - lastMouseEvent.screenY))
-          : (lastMovementY = lastMovementX = 0),
-        (lastMouseEvent = event));
-      return lastMovementX;
-    },
-    movementY: function (event) {
-      return "movementY" in event ? event.movementY : lastMovementY;
-    }
-  }),
-  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
-  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
-  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
-  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
-  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
-  AnimationEventInterface = assign({}, EventInterface, {
-    animationName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
-  ClipboardEventInterface = assign({}, EventInterface, {
-    clipboardData: function (event) {
-      return "clipboardData" in event
-        ? event.clipboardData
-        : window.clipboardData;
-    }
-  }),
-  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
-  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
-  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
-  normalizeKey = {
-    Esc: "Escape",
-    Spacebar: " ",
-    Left: "ArrowLeft",
-    Up: "ArrowUp",
-    Right: "ArrowRight",
-    Down: "ArrowDown",
-    Del: "Delete",
-    Win: "OS",
-    Menu: "ContextMenu",
-    Apps: "ContextMenu",
-    Scroll: "ScrollLock",
-    MozPrintableKey: "Unidentified"
-  },
-  translateToKey = {
-    8: "Backspace",
-    9: "Tab",
-    12: "Clear",
-    13: "Enter",
-    16: "Shift",
-    17: "Control",
-    18: "Alt",
-    19: "Pause",
-    20: "CapsLock",
-    27: "Escape",
-    32: " ",
-    33: "PageUp",
-    34: "PageDown",
-    35: "End",
-    36: "Home",
-    37: "ArrowLeft",
-    38: "ArrowUp",
-    39: "ArrowRight",
-    40: "ArrowDown",
-    45: "Insert",
-    46: "Delete",
-    112: "F1",
-    113: "F2",
-    114: "F3",
-    115: "F4",
-    116: "F5",
-    117: "F6",
-    118: "F7",
-    119: "F8",
-    120: "F9",
-    121: "F10",
-    122: "F11",
-    123: "F12",
-    144: "NumLock",
-    145: "ScrollLock",
-    224: "Meta"
-  },
-  modifierKeyToProp = {
-    Alt: "altKey",
-    Control: "ctrlKey",
-    Meta: "metaKey",
-    Shift: "shiftKey"
-  };
-function modifierStateGetter(keyArg) {
-  var nativeEvent = this.nativeEvent;
-  return nativeEvent.getModifierState
-    ? nativeEvent.getModifierState(keyArg)
-    : (keyArg = modifierKeyToProp[keyArg])
-    ? !!nativeEvent[keyArg]
-    : !1;
+function throwOnHydrationMismatch() {
+  throw Error(formatProdErrorMessage(418));
 }
-function getEventModifierState() {
-  return modifierStateGetter;
+function advanceToFirstAttemptableInstance(fiber) {
+  for (
+    ;
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    );
+
+  )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-    key: function (nativeEvent) {
-      if (nativeEvent.key) {
-        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
-        if ("Unidentified" !== key) return key;
-      }
-      return "keypress" === nativeEvent.type
-        ? ((nativeEvent = getEventCharCode(nativeEvent)),
-          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
-        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
-        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
-        : "";
-    },
-    code: 0,
-    location: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    repeat: 0,
-    locale: 0,
-    getModifierState: getEventModifierState,
-    charCode: function (event) {
-      return "keypress" === event.type ? getEventCharCode(event) : 0;
-    },
-    keyCode: function (event) {
-      return "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    },
-    which: function (event) {
-      return "keypress" === event.type
-        ? getEventCharCode(event)
-        : "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    }
-  }),
-  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
-  PointerEventInterface = assign({}, MouseEventInterface, {
-    pointerId: 0,
-    width: 0,
-    height: 0,
-    pressure: 0,
-    tangentialPressure: 0,
-    tiltX: 0,
-    tiltY: 0,
-    twist: 0,
-    pointerType: 0,
-    isPrimary: 0
-  }),
-  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
-  TouchEventInterface = assign({}, UIEventInterface, {
-    touches: 0,
-    targetTouches: 0,
-    changedTouches: 0,
-    altKey: 0,
-    metaKey: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    getModifierState: getEventModifierState
-  }),
-  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
-  TransitionEventInterface = assign({}, EventInterface, {
-    propertyName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
-  WheelEventInterface = assign({}, MouseEventInterface, {
-    deltaX: function (event) {
-      return "deltaX" in event
-        ? event.deltaX
-        : "wheelDeltaX" in event
-        ? -event.wheelDeltaX
-        : 0;
-    },
-    deltaY: function (event) {
-      return "deltaY" in event
-        ? event.deltaY
-        : "wheelDeltaY" in event
-        ? -event.wheelDeltaY
-        : "wheelDelta" in event
-        ? -event.wheelDelta
-        : 0;
-    },
-    deltaZ: 0,
-    deltaMode: 0
-  }),
-  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
-  END_KEYCODES = [9, 13, 27, 32],
-  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
-  documentMode = null;
-canUseDOM &&
-  "documentMode" in document &&
-  (documentMode = document.documentMode);
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
-  useFallbackCompositionData =
-    canUseDOM &&
-    (!canUseCompositionEvent ||
-      (documentMode && 8 < documentMode && 11 >= documentMode)),
-  SPACEBAR_CHAR = String.fromCharCode(32),
-  hasSpaceKeypress = !1;
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
-    case "keydown":
-      return 229 !== nativeEvent.keyCode;
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      return !0;
-    default:
-      return !1;
-  }
+function advanceToFirstAttemptableTextInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-function getDataFromCustomEvent(nativeEvent) {
-  nativeEvent = nativeEvent.detail;
-  return "object" === typeof nativeEvent && "data" in nativeEvent
-    ? nativeEvent.data
-    : null;
+function advanceToFirstAttemptableSuspenseInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-var isComposing = !1;
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
-    case "keypress":
-      if (32 !== nativeEvent.which) return null;
-      hasSpaceKeypress = !0;
-      return SPACEBAR_CHAR;
-    case "textInput":
-      return (
-        (domEventName = nativeEvent.data),
-        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
-      );
-    default:
-      return null;
+function prepareToHydrateHostInstance(fiber) {
+  var instance = fiber.stateNode,
+    type = fiber.type,
+    props = fiber.memoizedProps;
+  instance[internalInstanceKey] = fiber;
+  instance[internalPropsKey] = props;
+  switch (type) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", instance);
+      listenToNonDelegatedEvent("close", instance);
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "video":
+    case "audio":
+      for (var i = 0; i < mediaEventTypes.length; i++)
+        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", instance);
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", instance);
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", instance);
+      break;
+    case "input":
+      initWrapperState$2(instance, props);
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "select":
+      instance._wrapperState = { wasMultiple: !!props.multiple };
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "textarea":
+      initWrapperState(instance, props),
+        listenToNonDelegatedEvent("invalid", instance);
   }
-}
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  if (isComposing)
-    return "compositionend" === domEventName ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-      ? ((domEventName = getData()),
-        (fallbackText = startText = root = null),
-        (isComposing = !1),
-        domEventName)
-      : null;
-  switch (domEventName) {
-    case "paste":
-      return null;
-    case "keypress":
-      if (
-        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
-        (nativeEvent.ctrlKey && nativeEvent.altKey)
-      ) {
-        if (nativeEvent.char && 1 < nativeEvent.char.length)
-          return nativeEvent.char;
-        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
-      }
-      return null;
-    case "compositionend":
-      return useFallbackCompositionData && "ko" !== nativeEvent.locale
-        ? null
-        : nativeEvent.data;
+  assertValidProps(type, props);
+  var updatePayload = null,
+    propKey;
+  for (propKey in props)
+    props.hasOwnProperty(propKey) &&
+      ((i = props[propKey]),
+      "children" === propKey
+        ? "string" === typeof i
+          ? instance.textContent !== i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", i]))
+          : "number" === typeof i &&
+            instance.textContent !== "" + i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", "" + i]))
+        : registrationNameDependencies.hasOwnProperty(propKey) &&
+          null != i &&
+          "onScroll" === propKey &&
+          listenToNonDelegatedEvent("scroll", instance));
+  switch (type) {
+    case "input":
+      track(instance);
+      postMountWrapper$3(instance, props, !0);
+      break;
+    case "textarea":
+      track(instance);
+      postMountWrapper(instance);
+      break;
+    case "select":
+    case "option":
+      break;
     default:
-      return null;
+      "function" === typeof props.onClick && (instance.onclick = noop);
   }
+  instance = updatePayload;
+  fiber.updateQueue = instance;
+  return null !== instance ? !0 : !1;
 }
-var supportedInputTypes = {
-  color: !0,
-  date: !0,
-  datetime: !0,
-  "datetime-local": !0,
-  email: !0,
-  month: !0,
-  number: !0,
-  password: !0,
-  range: !0,
-  search: !0,
-  tel: !0,
-  text: !0,
-  time: !0,
-  url: !0,
-  week: !0
-};
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return "input" === nodeName
-    ? !!supportedInputTypes[elem.type]
-    : "textarea" === nodeName
-    ? !0
-    : !1;
+function popToNextHostParent(fiber) {
+  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
+    switch (hydrationParentFiber.tag) {
+      case 3:
+      case 27:
+        rootOrSingletonContext = !0;
+        return;
+      case 5:
+      case 13:
+        rootOrSingletonContext = !1;
+        return;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
 }
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
-) {
-  enqueueStateRestore(target);
-  inst = accumulateTwoPhaseListeners(inst, "onChange");
-  0 < inst.length &&
-    ((nativeEvent = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    )),
-    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) return !1;
+  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
+  var shouldClear = !1;
+  3 === fiber.tag ||
+    27 === fiber.tag ||
+    (5 === fiber.tag &&
+      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
+    (shouldClear = !0);
+  if (shouldClear && (shouldClear = nextHydratableInstance))
+    if (shouldClientRenderOnMismatch(fiber))
+      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
+    else
+      for (; shouldClear; )
+        deleteHydratableInstance(fiber, shouldClear),
+          (shouldClear = getNextHydratable(shouldClear.nextSibling));
+  popToNextHostParent(fiber);
+  if (13 === fiber.tag) {
+    fiber = fiber.memoizedState;
+    fiber = null !== fiber ? fiber.dehydrated : null;
+    if (!fiber) throw Error(formatProdErrorMessage(317));
+    a: {
+      fiber = fiber.nextSibling;
+      for (shouldClear = 0; fiber; ) {
+        if (8 === fiber.nodeType) {
+          var data = fiber.data;
+          if ("/$" === data) {
+            if (0 === shouldClear) {
+              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
+              break a;
+            }
+            shouldClear--;
+          } else
+            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
+        }
+        fiber = fiber.nextSibling;
+      }
+      nextHydratableInstance = null;
+    }
+  } else
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratable(fiber.stateNode.nextSibling)
+      : null;
+  return !0;
 }
-var activeElement$1 = null,
-  activeElementInst$1 = null;
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
+function warnIfUnhydratedTailNodes() {
+  for (var nextInstance = nextHydratableInstance; nextInstance; )
+    nextInstance = getNextHydratable(nextInstance.nextSibling);
 }
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
-  if (updateValueIfChanged(targetNode)) return targetInst;
-}
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if ("change" === domEventName) return targetInst;
-}
-var isInputEventSupported = !1;
-if (canUseDOM) {
-  var JSCompiler_inline_result$jscomp$263;
-  if (canUseDOM) {
-    var isSupported$jscomp$inline_419 = "oninput" in document;
-    if (!isSupported$jscomp$inline_419) {
-      var element$jscomp$inline_420 = document.createElement("div");
-      element$jscomp$inline_420.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_419 =
-        "function" === typeof element$jscomp$inline_420.oninput;
-    }
-    JSCompiler_inline_result$jscomp$263 = isSupported$jscomp$inline_419;
-  } else JSCompiler_inline_result$jscomp$263 = !1;
-  isInputEventSupported =
-    JSCompiler_inline_result$jscomp$263 &&
-    (!document.documentMode || 9 < document.documentMode);
+function resetHydrationState() {
+  nextHydratableInstance = hydrationParentFiber = null;
+  isHydrating = !1;
 }
-function stopWatchingForValueChange() {
-  activeElement$1 &&
-    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
-    (activeElementInst$1 = activeElement$1 = null));
+function queueHydrationError(error) {
+  null === hydrationErrors
+    ? (hydrationErrors = [error])
+    : hydrationErrors.push(error);
 }
-function handlePropertyChange(nativeEvent) {
-  if (
-    "value" === nativeEvent.propertyName &&
-    getInstIfValueChanged(activeElementInst$1)
+var concurrentQueues = [],
+  concurrentQueuesIndex = 0,
+  concurrentlyUpdatedLanes = 0;
+function finishQueueingConcurrentUpdates() {
+  for (
+    var endIndex = concurrentQueuesIndex,
+      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
+    i < endIndex;
+
   ) {
-    var dispatchQueue = [];
-    createAndAccumulateChangeEvent(
-      dispatchQueue,
-      activeElementInst$1,
-      nativeEvent,
-      getEventTarget(nativeEvent)
-    );
-    batchedUpdates$1(runEventInBatch, dispatchQueue);
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    if (null !== queue && null !== update) {
+      var pending = queue.pending;
+      null === pending
+        ? (update.next = update)
+        : ((update.next = pending.next), (pending.next = update));
+      queue.pending = update;
+    }
+    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
   }
 }
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  "focusin" === domEventName
-    ? (stopWatchingForValueChange(),
-      (activeElement$1 = target),
-      (activeElementInst$1 = targetInst),
-      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
-    : "focusout" === domEventName && stopWatchingForValueChange();
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes |= lane;
+  fiber.lanes |= lane;
+  fiber = fiber.alternate;
+  null !== fiber && (fiber.lanes |= lane);
 }
-function getTargetInstForInputEventPolyfill(domEventName) {
-  if (
-    "selectionchange" === domEventName ||
-    "keyup" === domEventName ||
-    "keydown" === domEventName
-  )
-    return getInstIfValueChanged(activeElementInst$1);
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
 }
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  sourceFiber.lanes |= lane;
+  var alternate = sourceFiber.alternate;
+  null !== alternate && (alternate.lanes |= lane);
+  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
+    (parent.childLanes |= lane),
+      (alternate = parent.alternate),
+      null !== alternate && (alternate.childLanes |= lane),
+      22 === parent.tag &&
+        ((sourceFiber = parent.stateNode),
+        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
+      (sourceFiber = parent),
+      (parent = parent.return);
+  isHidden &&
+    null !== update &&
+    3 === sourceFiber.tag &&
+    ((parent = sourceFiber.stateNode),
+    (isHidden = 31 - clz32(lane)),
+    (parent = parent.hiddenUpdates),
+    (sourceFiber = parent[isHidden]),
+    null === sourceFiber
+      ? (parent[isHidden] = [update])
+      : sourceFiber.push(update),
+    (update.lane = lane | 1073741824));
 }
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if ("input" === domEventName || "change" === domEventName)
-    return getInstIfValueChanged(targetInst);
+function getRootForUpdatedFiber(sourceFiber) {
+  if (50 < nestedUpdateCount)
+    throw (
+      ((nestedUpdateCount = 0),
+      (rootWithNestedUpdates = null),
+      Error(formatProdErrorMessage(185)))
+    );
+  for (var parent = sourceFiber.return; null !== parent; )
+    (sourceFiber = parent), (parent = sourceFiber.return);
+  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
 }
-function is(x, y) {
-  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+var hasForceUpdate = !1;
+function initializeUpdateQueue(fiber) {
+  fiber.updateQueue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
+    callbacks: null
+  };
 }
-var objectIs = "function" === typeof Object.is ? Object.is : is;
-function shallowEqual(objA, objB) {
-  if (objectIs(objA, objB)) return !0;
+function cloneUpdateQueue(current, workInProgress) {
+  current = current.updateQueue;
+  workInProgress.updateQueue === current &&
+    (workInProgress.updateQueue = {
+      baseState: current.baseState,
+      firstBaseUpdate: current.firstBaseUpdate,
+      lastBaseUpdate: current.lastBaseUpdate,
+      shared: current.shared,
+      callbacks: null
+    });
+}
+function createUpdate(lane) {
+  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
+}
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
+  if (null === updateQueue) return null;
+  updateQueue = updateQueue.shared;
   if (
-    "object" !== typeof objA ||
-    null === objA ||
-    "object" !== typeof objB ||
-    null === objB
+    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
+    0 === (executionContext & 2)
   )
-    return !1;
-  var keysA = Object.keys(objA),
-    keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) return !1;
-  for (keysB = 0; keysB < keysA.length; keysB++) {
-    var currentKey = keysA[keysB];
-    if (
-      !hasOwnProperty.call(objB, currentKey) ||
-      !objectIs(objA[currentKey], objB[currentKey])
-    )
-      return !1;
-  }
-  return !0;
-}
-function getLeafNode(node) {
-  for (; node && node.firstChild; ) node = node.firstChild;
-  return node;
+    return (
+      enqueueUpdate$1(fiber, updateQueue, update, lane),
+      getRootForUpdatedFiber(fiber)
+    );
+  var pending = updateQueue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  updateQueue.pending = update;
+  update = getRootForUpdatedFiber(fiber);
+  markUpdateLaneFromFiberToRoot(fiber, null, lane);
+  return update;
 }
-function getNodeForCharacterOffset(root, offset) {
-  var node = getLeafNode(root);
-  root = 0;
-  for (var nodeEnd; node; ) {
-    if (3 === node.nodeType) {
-      nodeEnd = root + node.textContent.length;
-      if (root <= offset && nodeEnd >= offset)
-        return { node: node, offset: offset - root };
-      root = nodeEnd;
-    }
-    a: {
-      for (; node; ) {
-        if (node.nextSibling) {
-          node = node.nextSibling;
-          break a;
-        }
-        node = node.parentNode;
-      }
-      node = void 0;
-    }
-    node = getLeafNode(node);
+function entangleTransitions(root, fiber, lane) {
+  fiber = fiber.updateQueue;
+  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
+    var queueLanes = fiber.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    fiber.lanes = lane;
+    markRootEntangled(root, lane);
   }
 }
-function containsNode$1(outerNode, innerNode) {
-  return outerNode && innerNode
-    ? outerNode === innerNode
-      ? !0
-      : outerNode && 3 === outerNode.nodeType
-      ? !1
-      : innerNode && 3 === innerNode.nodeType
-      ? containsNode$1(outerNode, innerNode.parentNode)
-      : "contains" in outerNode
-      ? outerNode.contains(innerNode)
-      : outerNode.compareDocumentPosition
-      ? !!(outerNode.compareDocumentPosition(innerNode) & 16)
-      : !1
-    : !1;
-}
-function getActiveElementDeep() {
-  for (
-    var win = window, element = getActiveElement();
-    element instanceof win.HTMLIFrameElement;
-
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  var queue = workInProgress.updateQueue,
+    current = workInProgress.alternate;
+  if (
+    null !== current &&
+    ((current = current.updateQueue), queue === current)
   ) {
-    try {
-      var JSCompiler_inline_result =
-        "string" === typeof element.contentWindow.location.href;
-    } catch (err) {
-      JSCompiler_inline_result = !1;
-    }
-    if (JSCompiler_inline_result) win = element.contentWindow;
-    else break;
-    element = getActiveElement(win.document);
-  }
-  return element;
-}
-function hasSelectionCapabilities(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName &&
-    (("input" === nodeName &&
-      ("text" === elem.type ||
-        "search" === elem.type ||
-        "tel" === elem.type ||
-        "url" === elem.type ||
-        "password" === elem.type)) ||
-      "textarea" === nodeName ||
-      "true" === elem.contentEditable)
-  );
+    var newFirst = null,
+      newLast = null;
+    queue = queue.firstBaseUpdate;
+    if (null !== queue) {
+      do {
+        var clone = {
+          lane: queue.lane,
+          tag: queue.tag,
+          payload: queue.payload,
+          callback: null,
+          next: null
+        };
+        null === newLast
+          ? (newFirst = newLast = clone)
+          : (newLast = newLast.next = clone);
+        queue = queue.next;
+      } while (null !== queue);
+      null === newLast
+        ? (newFirst = newLast = capturedUpdate)
+        : (newLast = newLast.next = capturedUpdate);
+    } else newFirst = newLast = capturedUpdate;
+    queue = {
+      baseState: current.baseState,
+      firstBaseUpdate: newFirst,
+      lastBaseUpdate: newLast,
+      shared: current.shared,
+      callbacks: current.callbacks
+    };
+    workInProgress.updateQueue = queue;
+    return;
+  }
+  workInProgress = queue.lastBaseUpdate;
+  null === workInProgress
+    ? (queue.firstBaseUpdate = capturedUpdate)
+    : (workInProgress.next = capturedUpdate);
+  queue.lastBaseUpdate = capturedUpdate;
 }
-function restoreSelection(priorSelectionInformation) {
-  var curFocusedElem = getActiveElementDeep(),
-    priorFocusedElem = priorSelectionInformation.focusedElem,
-    priorSelectionRange = priorSelectionInformation.selectionRange;
-  if (
-    curFocusedElem !== priorFocusedElem &&
-    priorFocusedElem &&
-    priorFocusedElem.ownerDocument &&
-    containsNode$1(
-      priorFocusedElem.ownerDocument.documentElement,
-      priorFocusedElem
-    )
-  ) {
-    if (
-      null !== priorSelectionRange &&
-      hasSelectionCapabilities(priorFocusedElem)
-    )
+function processUpdateQueue(
+  workInProgress$jscomp$0,
+  props,
+  instance$jscomp$0,
+  renderLanes
+) {
+  var queue = workInProgress$jscomp$0.updateQueue;
+  hasForceUpdate = !1;
+  var firstBaseUpdate = queue.firstBaseUpdate,
+    lastBaseUpdate = queue.lastBaseUpdate,
+    pendingQueue = queue.shared.pending;
+  if (null !== pendingQueue) {
+    queue.shared.pending = null;
+    var lastPendingUpdate = pendingQueue,
+      firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null;
+    null === lastBaseUpdate
+      ? (firstBaseUpdate = firstPendingUpdate)
+      : (lastBaseUpdate.next = firstPendingUpdate);
+    lastBaseUpdate = lastPendingUpdate;
+    var current = workInProgress$jscomp$0.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      (pendingQueue = current.lastBaseUpdate),
+      pendingQueue !== lastBaseUpdate &&
+        (null === pendingQueue
+          ? (current.firstBaseUpdate = firstPendingUpdate)
+          : (pendingQueue.next = firstPendingUpdate),
+        (current.lastBaseUpdate = lastPendingUpdate)));
+  }
+  if (null !== firstBaseUpdate) {
+    var newState = queue.baseState;
+    lastBaseUpdate = 0;
+    current = firstPendingUpdate = lastPendingUpdate = null;
+    pendingQueue = firstBaseUpdate;
+    do {
+      var updateLane = pendingQueue.lane & -1073741825,
+        isHiddenUpdate = updateLane !== pendingQueue.lane;
       if (
-        ((curFocusedElem = priorSelectionRange.start),
-        (priorSelectionInformation = priorSelectionRange.end),
-        void 0 === priorSelectionInformation &&
-          (priorSelectionInformation = curFocusedElem),
-        "selectionStart" in priorFocusedElem)
-      )
-        (priorFocusedElem.selectionStart = curFocusedElem),
-          (priorFocusedElem.selectionEnd = Math.min(
-            priorSelectionInformation,
-            priorFocusedElem.value.length
-          ));
-      else if (
-        ((priorSelectionInformation =
-          ((curFocusedElem = priorFocusedElem.ownerDocument || document) &&
-            curFocusedElem.defaultView) ||
-          window),
-        priorSelectionInformation.getSelection)
+        isHiddenUpdate
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes & updateLane) === updateLane
       ) {
-        priorSelectionInformation = priorSelectionInformation.getSelection();
-        var length = priorFocusedElem.textContent.length,
-          start = Math.min(priorSelectionRange.start, length);
-        priorSelectionRange =
-          void 0 === priorSelectionRange.end
-            ? start
-            : Math.min(priorSelectionRange.end, length);
-        !priorSelectionInformation.extend &&
-          start > priorSelectionRange &&
-          ((length = priorSelectionRange),
-          (priorSelectionRange = start),
-          (start = length));
-        length = getNodeForCharacterOffset(priorFocusedElem, start);
-        var endMarker = getNodeForCharacterOffset(
-          priorFocusedElem,
-          priorSelectionRange
-        );
-        length &&
-          endMarker &&
-          (1 !== priorSelectionInformation.rangeCount ||
-            priorSelectionInformation.anchorNode !== length.node ||
-            priorSelectionInformation.anchorOffset !== length.offset ||
-            priorSelectionInformation.focusNode !== endMarker.node ||
-            priorSelectionInformation.focusOffset !== endMarker.offset) &&
-          ((curFocusedElem = curFocusedElem.createRange()),
-          curFocusedElem.setStart(length.node, length.offset),
-          priorSelectionInformation.removeAllRanges(),
-          start > priorSelectionRange
-            ? (priorSelectionInformation.addRange(curFocusedElem),
-              priorSelectionInformation.extend(
-                endMarker.node,
-                endMarker.offset
-              ))
-            : (curFocusedElem.setEnd(endMarker.node, endMarker.offset),
-              priorSelectionInformation.addRange(curFocusedElem)));
-      }
-    curFocusedElem = [];
+        null !== current &&
+          (current = current.next =
+            {
+              lane: 0,
+              tag: pendingQueue.tag,
+              payload: pendingQueue.payload,
+              callback: null,
+              next: null
+            });
+        a: {
+          var workInProgress = workInProgress$jscomp$0,
+            update = pendingQueue;
+          updateLane = props;
+          var instance = instance$jscomp$0;
+          switch (update.tag) {
+            case 1:
+              workInProgress = update.payload;
+              if ("function" === typeof workInProgress) {
+                newState = workInProgress.call(instance, newState, updateLane);
+                break a;
+              }
+              newState = workInProgress;
+              break a;
+            case 3:
+              workInProgress.flags = (workInProgress.flags & -65537) | 128;
+            case 0:
+              workInProgress = update.payload;
+              updateLane =
+                "function" === typeof workInProgress
+                  ? workInProgress.call(instance, newState, updateLane)
+                  : workInProgress;
+              if (null === updateLane || void 0 === updateLane) break a;
+              newState = assign({}, newState, updateLane);
+              break a;
+            case 2:
+              hasForceUpdate = !0;
+          }
+        }
+        updateLane = pendingQueue.callback;
+        null !== updateLane &&
+          ((workInProgress$jscomp$0.flags |= 64),
+          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
+          (isHiddenUpdate = queue.callbacks),
+          null === isHiddenUpdate
+            ? (queue.callbacks = [updateLane])
+            : isHiddenUpdate.push(updateLane));
+      } else
+        (isHiddenUpdate = {
+          lane: updateLane,
+          tag: pendingQueue.tag,
+          payload: pendingQueue.payload,
+          callback: pendingQueue.callback,
+          next: null
+        }),
+          null === current
+            ? ((firstPendingUpdate = current = isHiddenUpdate),
+              (lastPendingUpdate = newState))
+            : (current = current.next = isHiddenUpdate),
+          (lastBaseUpdate |= updateLane);
+      pendingQueue = pendingQueue.next;
+      if (null === pendingQueue)
+        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
+          break;
+        else
+          (isHiddenUpdate = pendingQueue),
+            (pendingQueue = isHiddenUpdate.next),
+            (isHiddenUpdate.next = null),
+            (queue.lastBaseUpdate = isHiddenUpdate),
+            (queue.shared.pending = null);
+    } while (1);
+    null === current && (lastPendingUpdate = newState);
+    queue.baseState = lastPendingUpdate;
+    queue.firstBaseUpdate = firstPendingUpdate;
+    queue.lastBaseUpdate = current;
+    null === firstBaseUpdate && (queue.shared.lanes = 0);
+    workInProgressRootSkippedLanes |= lastBaseUpdate;
+    workInProgress$jscomp$0.lanes = lastBaseUpdate;
+    workInProgress$jscomp$0.memoizedState = newState;
+  }
+}
+function callCallback(callback, context) {
+  if ("function" !== typeof callback)
+    throw Error(formatProdErrorMessage(191, callback));
+  callback.call(context);
+}
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
+  if (null !== callbacks)
     for (
-      priorSelectionInformation = priorFocusedElem;
-      (priorSelectionInformation = priorSelectionInformation.parentNode);
-
+      updateQueue.callbacks = null, updateQueue = 0;
+      updateQueue < callbacks.length;
+      updateQueue++
     )
-      1 === priorSelectionInformation.nodeType &&
-        curFocusedElem.push({
-          element: priorSelectionInformation,
-          left: priorSelectionInformation.scrollLeft,
-          top: priorSelectionInformation.scrollTop
-        });
-    "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
-    for (
-      priorFocusedElem = 0;
-      priorFocusedElem < curFocusedElem.length;
-      priorFocusedElem++
+      callCallback(callbacks[updateQueue], context);
+}
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) return !0;
+  if (
+    "object" !== typeof objA ||
+    null === objA ||
+    "object" !== typeof objB ||
+    null === objB
+  )
+    return !1;
+  var keysA = Object.keys(objA),
+    keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return !1;
+  for (keysB = 0; keysB < keysA.length; keysB++) {
+    var currentKey = keysA[keysB];
+    if (
+      !hasOwnProperty.call(objB, currentKey) ||
+      !objectIs(objA[currentKey], objB[currentKey])
     )
-      (priorSelectionInformation = curFocusedElem[priorFocusedElem]),
-        (priorSelectionInformation.element.scrollLeft =
-          priorSelectionInformation.left),
-        (priorSelectionInformation.element.scrollTop =
-          priorSelectionInformation.top);
+      return !1;
   }
+  return !0;
 }
-var skipSelectionChangeEvent =
-    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
-  activeElement = null,
-  activeElementInst = null,
-  lastSelection = null,
-  mouseDown = !1;
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  var doc =
-    nativeEventTarget.window === nativeEventTarget
-      ? nativeEventTarget.document
-      : 9 === nativeEventTarget.nodeType
-      ? nativeEventTarget
-      : nativeEventTarget.ownerDocument;
-  mouseDown ||
-    null == activeElement ||
-    activeElement !== getActiveElement(doc) ||
-    ((doc = activeElement),
-    "selectionStart" in doc && hasSelectionCapabilities(doc)
-      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
-      : ((doc = (
-          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
-          window
-        ).getSelection()),
-        (doc = {
-          anchorNode: doc.anchorNode,
-          anchorOffset: doc.anchorOffset,
-          focusNode: doc.focusNode,
-          focusOffset: doc.focusOffset
-        })),
-    (lastSelection && shallowEqual(lastSelection, doc)) ||
-      ((lastSelection = doc),
-      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
-      0 < doc.length &&
-        ((nativeEvent = new SyntheticEvent(
-          "onSelect",
-          "select",
-          null,
-          nativeEvent,
-          nativeEventTarget
-        )),
-        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
-        (nativeEvent.target = activeElement))));
+var SuspenseException = Error(formatProdErrorMessage(460));
+function isThenableResolved(thenable) {
+  thenable = thenable.status;
+  return "fulfilled" === thenable || "rejected" === thenable;
 }
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
+function noop$1() {}
+function trackUsedThenable(thenableState, thenable, index) {
+  index = thenableState[index];
+  void 0 === index
+    ? thenableState.push(thenable)
+    : index !== thenable && (thenable.then(noop$1, noop$1), (thenable = index));
+  switch (thenable.status) {
+    case "fulfilled":
+      return thenable.value;
+    case "rejected":
+      throw thenable.reason;
+    default:
+      "string" === typeof thenable.status
+        ? thenable.then(noop$1, noop$1)
+        : ((thenableState = thenable),
+          (thenableState.status = "pending"),
+          thenableState.then(
+            function (fulfilledValue) {
+              if ("pending" === thenable.status) {
+                var fulfilledThenable = thenable;
+                fulfilledThenable.status = "fulfilled";
+                fulfilledThenable.value = fulfilledValue;
+              }
+            },
+            function (error) {
+              if ("pending" === thenable.status) {
+                var rejectedThenable = thenable;
+                rejectedThenable.status = "rejected";
+                rejectedThenable.reason = error;
+              }
+            }
+          ));
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+      }
+      suspendedThenable = thenable;
+      throw SuspenseException;
+  }
 }
-var vendorPrefixes = {
-    animationend: makePrefixMap("Animation", "AnimationEnd"),
-    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-    animationstart: makePrefixMap("Animation", "AnimationStart"),
-    transitionend: makePrefixMap("Transition", "TransitionEnd")
-  },
-  prefixedEventNames = {},
-  style = {};
-canUseDOM &&
-  ((style = document.createElement("div").style),
-  "AnimationEvent" in window ||
-    (delete vendorPrefixes.animationend.animation,
-    delete vendorPrefixes.animationiteration.animation,
-    delete vendorPrefixes.animationstart.animation),
-  "TransitionEvent" in window ||
-    delete vendorPrefixes.transitionend.transition);
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
-  if (!vendorPrefixes[eventName]) return eventName;
-  var prefixMap = vendorPrefixes[eventName],
-    styleProp;
-  for (styleProp in prefixMap)
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
-  return eventName;
+var suspendedThenable = null,
+  thenableState$1 = null,
+  thenableIndexCounter$1 = 0;
+function unwrapThenable(thenable) {
+  var index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+  null === thenableState$1 && (thenableState$1 = []);
+  return trackUsedThenable(thenableState$1, thenable, index);
 }
-var ANIMATION_END = getVendorPrefixedEventName("animationend"),
-  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
-  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
-  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
-  topLevelEventsToReactNames = new Map(),
-  simpleEventPluginEvents =
-    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
-      " "
-    );
-topLevelEventsToReactNames.set("beforeblur", null);
-topLevelEventsToReactNames.set("afterblur", null);
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
+function coerceRef(returnFiber, current, element) {
+  returnFiber = element.ref;
+  if (
+    null !== returnFiber &&
+    "function" !== typeof returnFiber &&
+    "object" !== typeof returnFiber
+  ) {
+    if (element._owner) {
+      element = element._owner;
+      if (element) {
+        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
+        var inst = element.stateNode;
+      }
+      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
+      var resolvedInst = inst,
+        stringRef = "" + returnFiber;
+      if (
+        null !== current &&
+        null !== current.ref &&
+        "function" === typeof current.ref &&
+        current.ref._stringRef === stringRef
+      )
+        return current.ref;
+      current = function (value) {
+        var refs = resolvedInst.refs;
+        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
+      };
+      current._stringRef = stringRef;
+      return current;
+    }
+    if ("string" !== typeof returnFiber)
+      throw Error(formatProdErrorMessage(284));
+    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
+  }
+  return returnFiber;
 }
-for (
-  var i$jscomp$inline_460 = 0;
-  i$jscomp$inline_460 < simpleEventPluginEvents.length;
-  i$jscomp$inline_460++
-) {
-  var eventName$jscomp$inline_461 =
-      simpleEventPluginEvents[i$jscomp$inline_460],
-    domEventName$jscomp$inline_462 = eventName$jscomp$inline_461.toLowerCase(),
-    capitalizedEvent$jscomp$inline_463 =
-      eventName$jscomp$inline_461[0].toUpperCase() +
-      eventName$jscomp$inline_461.slice(1);
-  registerSimpleEvent(
-    domEventName$jscomp$inline_462,
-    "on" + capitalizedEvent$jscomp$inline_463
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  returnFiber = Object.prototype.toString.call(newChild);
+  throw Error(
+    formatProdErrorMessage(
+      31,
+      "[object Object]" === returnFiber
+        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
+        : returnFiber
+    )
   );
 }
-registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-registerSimpleEvent("dblclick", "onDoubleClick");
-registerSimpleEvent("focusin", "onFocus");
-registerSimpleEvent("focusout", "onBlur");
-registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
-registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
-registerTwoPhaseEvent(
-  "onChange",
-  "change click focusin focusout input keydown keyup selectionchange".split(" ")
-);
-registerTwoPhaseEvent(
-  "onSelect",
-  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
-    " "
-  )
-);
-registerTwoPhaseEvent("onBeforeInput", [
-  "compositionend",
-  "keypress",
-  "textInput",
-  "paste"
-]);
-registerTwoPhaseEvent(
-  "onCompositionEnd",
-  "compositionend focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionStart",
-  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionUpdate",
-  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
-);
-var mediaEventTypes =
-    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
-      " "
-    ),
-  nonDelegatedEvents = new Set(
-    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
-  );
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
-  event.currentTarget = null;
+function resolveLazy(lazyType) {
+  var init = lazyType._init;
+  return init(lazyType._payload);
 }
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  eventSystemFlags = 0 !== (eventSystemFlags & 4);
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event;
-    _dispatchQueue$i = _dispatchQueue$i.listeners;
-    a: {
-      var previousInstance = void 0;
-      if (eventSystemFlags)
-        for (
-          var i$jscomp$0 = _dispatchQueue$i.length - 1;
-          0 <= i$jscomp$0;
-          i$jscomp$0--
-        ) {
-          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
-            instance = _dispatchListeners$i.instance,
-            currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
-      else
-        for (
-          i$jscomp$0 = 0;
-          i$jscomp$0 < _dispatchQueue$i.length;
-          i$jscomp$0++
-        ) {
-          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
-          instance = _dispatchListeners$i.instance;
-          currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (shouldTrackSideEffects) {
+      var deletions = returnFiber.deletions;
+      null === deletions
+        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
+        : deletions.push(childToDelete);
     }
   }
-  if (hasRethrowError)
-    throw (
-      ((dispatchQueue = rethrowError),
-      (hasRethrowError = !1),
-      (rethrowError = null),
-      dispatchQueue)
-    );
-}
-function listenToNonDelegatedEvent(domEventName, targetElement) {
-  var listenerSet = getEventListenerSet(targetElement),
-    listenerSetKey = domEventName + "__bubble";
-  listenerSet.has(listenerSetKey) ||
-    (addTrappedEventListener(targetElement, domEventName, 2, !1),
-    listenerSet.add(listenerSetKey));
-}
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
-  var eventSystemFlags = 0;
-  isCapturePhaseListener && (eventSystemFlags |= 4);
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
-}
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = !0;
-    allNativeEvents.forEach(function (domEventName) {
-      "selectionchange" !== domEventName &&
-        (nonDelegatedEvents.has(domEventName) ||
-          listenToNativeEvent(domEventName, !1, rootContainerElement),
-        listenToNativeEvent(domEventName, !0, rootContainerElement));
-    });
-    var ownerDocument =
-      9 === rootContainerElement.nodeType
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
-    null === ownerDocument ||
-      ownerDocument[listeningMarker] ||
-      ((ownerDocument[listeningMarker] = !0),
-      listenToNativeEvent("selectionchange", !1, ownerDocument));
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) return null;
+    for (; null !== currentFirstChild; )
+      deleteChild(returnFiber, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return null;
   }
-}
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  eventSystemFlags = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  );
-  var isPassiveListener = void 0;
-  !passiveBrowserEventsSupported ||
-    ("touchstart" !== domEventName &&
-      "touchmove" !== domEventName &&
-      "wheel" !== domEventName) ||
-    (isPassiveListener = !0);
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = eventSystemFlags;
-    eventSystemFlags = function () {
-      targetContainer.removeEventListener(
-        domEventName,
-        unsubscribeListener,
-        isCapturePhaseListener
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    for (returnFiber = new Map(); null !== currentFirstChild; )
+      null !== currentFirstChild.key
+        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
+        : returnFiber.set(currentFirstChild.index, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return returnFiber;
+  }
+  function useFiber(fiber, pendingProps) {
+    fiber = createWorkInProgress(fiber, pendingProps);
+    fiber.index = 0;
+    fiber.sibling = null;
+    return fiber;
+  }
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+    if (!shouldTrackSideEffects)
+      return (newFiber.flags |= 1048576), lastPlacedIndex;
+    newIndex = newFiber.alternate;
+    if (null !== newIndex)
+      return (
+        (newIndex = newIndex.index),
+        newIndex < lastPlacedIndex
+          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
+          : newIndex
       );
-      for (
-        var _len = arguments.length, p = Array(_len), _key = 0;
-        _key < _len;
-        _key++
-      )
-        p[_key] = arguments[_key];
-      return originalListener.apply(this, p);
-    };
+    newFiber.flags |= 16777218;
+    return lastPlacedIndex;
   }
-  var unsubscribeListener = isCapturePhaseListener
-    ? void 0 !== isPassiveListener
-      ? addEventCaptureListenerWithPassiveFlag(
-          targetContainer,
-          domEventName,
-          eventSystemFlags,
-          isPassiveListener
-        )
-      : addEventCaptureListener(targetContainer, domEventName, eventSystemFlags)
-    : void 0 !== isPassiveListener
-    ? addEventBubbleListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        eventSystemFlags,
-        isPassiveListener
-      )
-    : addEventBubbleListener(targetContainer, domEventName, eventSystemFlags);
-}
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst$jscomp$0,
-  targetContainer
-) {
-  var ancestorInst = targetInst$jscomp$0;
-  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+  function placeSingleChild(newFiber) {
+    shouldTrackSideEffects &&
+      null === newFiber.alternate &&
+      (newFiber.flags |= 16777218);
+    return newFiber;
+  }
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (null === current || 6 !== current.tag)
+      return (
+        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, textContent);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateElement(returnFiber, current, element, lanes) {
+    var elementType = element.type;
+    if (elementType === REACT_FRAGMENT_TYPE)
+      return updateFragment(
+        returnFiber,
+        current,
+        element.props.children,
+        lanes,
+        element.key
+      );
     if (
-      enableLegacyFBSupport &&
-      "click" === domEventName &&
-      0 === (eventSystemFlags & 20) &&
-      nativeEvent !== currentReplayingEvent
-    ) {
-      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
-      return;
-    }
-    if (null !== targetInst$jscomp$0)
-      a: for (;;) {
-        if (null === targetInst$jscomp$0) return;
-        var nodeTag = targetInst$jscomp$0.tag;
-        if (3 === nodeTag || 4 === nodeTag) {
-          var container = targetInst$jscomp$0.stateNode.containerInfo;
-          if (
-            container === targetContainer ||
-            (8 === container.nodeType &&
-              container.parentNode === targetContainer)
-          )
-            break;
-          if (4 === nodeTag)
-            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
-              var grandTag = nodeTag.tag;
-              if (3 === grandTag || 4 === grandTag)
-                if (
-                  ((grandTag = nodeTag.stateNode.containerInfo),
-                  grandTag === targetContainer ||
-                    (8 === grandTag.nodeType &&
-                      grandTag.parentNode === targetContainer))
-                )
-                  return;
-              nodeTag = nodeTag.return;
-            }
-          for (; null !== container; ) {
-            nodeTag = getClosestInstanceFromNode(container);
-            if (null === nodeTag) return;
-            grandTag = nodeTag.tag;
-            if (
-              5 === grandTag ||
-              6 === grandTag ||
-              26 === grandTag ||
-              27 === grandTag
-            ) {
-              targetInst$jscomp$0 = ancestorInst = nodeTag;
-              continue a;
-            }
-            container = container.parentNode;
-          }
-        }
-        targetInst$jscomp$0 = targetInst$jscomp$0.return;
-      }
+      null !== current &&
+      (current.elementType === elementType ||
+        ("object" === typeof elementType &&
+          null !== elementType &&
+          elementType.$$typeof === REACT_LAZY_TYPE &&
+          resolveLazy(elementType) === current.type))
+    )
+      return (
+        (lanes = useFiber(current, element.props)),
+        (lanes.ref = coerceRef(returnFiber, current, element)),
+        (lanes.return = returnFiber),
+        lanes
+      );
+    lanes = createFiberFromTypeAndProps(
+      element.type,
+      element.key,
+      element.props,
+      null,
+      returnFiber.mode,
+      lanes
+    );
+    lanes.ref = coerceRef(returnFiber, current, element);
+    lanes.return = returnFiber;
+    return lanes;
   }
-  batchedUpdates$1(function () {
-    var targetInst = ancestorInst,
-      nativeEventTarget = getEventTarget(nativeEvent),
-      dispatchQueue = [];
-    a: {
-      var reactName = topLevelEventsToReactNames.get(domEventName);
-      if (void 0 !== reactName) {
-        var SyntheticEventCtor = SyntheticEvent,
-          reactEventType = domEventName;
-        switch (domEventName) {
-          case "keypress":
-            if (0 === getEventCharCode(nativeEvent)) break a;
-          case "keydown":
-          case "keyup":
-            SyntheticEventCtor = SyntheticKeyboardEvent;
-            break;
-          case "focusin":
-            reactEventType = "focus";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "focusout":
-            reactEventType = "blur";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "beforeblur":
-          case "afterblur":
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "click":
-            if (2 === nativeEvent.button) break a;
-          case "auxclick":
-          case "dblclick":
-          case "mousedown":
-          case "mousemove":
-          case "mouseup":
-          case "mouseout":
-          case "mouseover":
-          case "contextmenu":
-            SyntheticEventCtor = SyntheticMouseEvent;
-            break;
-          case "drag":
-          case "dragend":
-          case "dragenter":
-          case "dragexit":
-          case "dragleave":
-          case "dragover":
-          case "dragstart":
-          case "drop":
-            SyntheticEventCtor = SyntheticDragEvent;
-            break;
-          case "touchcancel":
-          case "touchend":
-          case "touchmove":
-          case "touchstart":
-            SyntheticEventCtor = SyntheticTouchEvent;
-            break;
-          case ANIMATION_END:
-          case ANIMATION_ITERATION:
-          case ANIMATION_START:
-            SyntheticEventCtor = SyntheticAnimationEvent;
-            break;
-          case TRANSITION_END:
-            SyntheticEventCtor = SyntheticTransitionEvent;
-            break;
-          case "scroll":
-            SyntheticEventCtor = SyntheticUIEvent;
-            break;
-          case "wheel":
-            SyntheticEventCtor = SyntheticWheelEvent;
-            break;
-          case "copy":
-          case "cut":
-          case "paste":
-            SyntheticEventCtor = SyntheticClipboardEvent;
-            break;
-          case "gotpointercapture":
-          case "lostpointercapture":
-          case "pointercancel":
-          case "pointerdown":
-          case "pointermove":
-          case "pointerout":
-          case "pointerover":
-          case "pointerup":
-            SyntheticEventCtor = SyntheticPointerEvent;
-        }
-        var inCapturePhase = 0 !== (eventSystemFlags & 4);
-        eventSystemFlags & 1
-          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
-              reactEventType,
-              targetContainer,
-              inCapturePhase
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (
+      null === current ||
+      4 !== current.tag ||
+      current.stateNode.containerInfo !== portal.containerInfo ||
+      current.stateNode.implementation !== portal.implementation
+    )
+      return (
+        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, portal.children || []);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (null === current || 7 !== current.tag)
+      return (
+        (current = createFiberFromFragment(
+          fragment,
+          returnFiber.mode,
+          lanes,
+          key
+        )),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, fragment);
+    current.return = returnFiber;
+    return current;
+  }
+  function createChild(returnFiber, newChild, lanes) {
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return (
+        (newChild = createFiberFromText(
+          "" + newChild,
+          returnFiber.mode,
+          lanes
+        )),
+        (newChild.return = returnFiber),
+        newChild
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (lanes = createFiberFromTypeAndProps(
+              newChild.type,
+              newChild.key,
+              newChild.props,
+              null,
+              returnFiber.mode,
+              lanes
             )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })))
-          : ((inCapturePhase = accumulateSinglePhaseListeners(
-              targetInst,
-              reactName,
-              nativeEvent.type,
-              inCapturePhase,
-              !inCapturePhase && "scroll" === domEventName,
-              nativeEvent
+            (lanes.ref = coerceRef(returnFiber, null, newChild)),
+            (lanes.return = returnFiber),
+            lanes
+          );
+        case REACT_PORTAL_TYPE:
+          return (
+            (newChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
             )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })));
+            (newChild.return = returnFiber),
+            newChild
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return createChild(returnFiber, init(newChild._payload), lanes);
       }
-    }
-    if (0 === (eventSystemFlags & 7)) {
-      a: {
-        reactName =
-          "mouseover" === domEventName || "pointerover" === domEventName;
-        SyntheticEventCtor =
-          "mouseout" === domEventName || "pointerout" === domEventName;
-        if (
-          reactName &&
-          nativeEvent !== currentReplayingEvent &&
-          (reactEventType =
-            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
-          (getClosestInstanceFromNode(reactEventType) ||
-            reactEventType[internalContainerInstanceKey])
-        )
-          break a;
-        if (SyntheticEventCtor || reactName) {
-          reactName =
-            nativeEventTarget.window === nativeEventTarget
-              ? nativeEventTarget
-              : (reactName = nativeEventTarget.ownerDocument)
-              ? reactName.defaultView || reactName.parentWindow
-              : window;
-          if (SyntheticEventCtor) {
-            if (
-              ((reactEventType =
-                nativeEvent.relatedTarget || nativeEvent.toElement),
-              (SyntheticEventCtor = targetInst),
-              (reactEventType = reactEventType
-                ? getClosestInstanceFromNode(reactEventType)
-                : null),
-              null !== reactEventType)
-            ) {
-              inCapturePhase = getNearestMountedFiber(reactEventType);
-              var tag = reactEventType.tag;
-              if (
-                reactEventType !== inCapturePhase ||
-                (5 !== tag && 27 !== tag && 6 !== tag)
-              )
-                reactEventType = null;
-            }
-          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
-          if (SyntheticEventCtor !== reactEventType) {
-            tag = SyntheticMouseEvent;
-            var leaveEventType = "onMouseLeave",
-              enterEventType = "onMouseEnter",
-              eventTypePrefix = "mouse";
-            if ("pointerout" === domEventName || "pointerover" === domEventName)
-              (tag = SyntheticPointerEvent),
-                (leaveEventType = "onPointerLeave"),
-                (enterEventType = "onPointerEnter"),
-                (eventTypePrefix = "pointer");
-            inCapturePhase =
-              null == SyntheticEventCtor
-                ? reactName
-                : getNodeFromInstance(SyntheticEventCtor);
-            var toNode =
-              null == reactEventType
-                ? reactName
-                : getNodeFromInstance(reactEventType);
-            reactName = new tag(
-              leaveEventType,
-              eventTypePrefix + "leave",
-              SyntheticEventCtor,
-              nativeEvent,
-              nativeEventTarget
-            );
-            reactName.target = inCapturePhase;
-            reactName.relatedTarget = toNode;
-            leaveEventType = null;
-            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
-              ((tag = new tag(
-                enterEventType,
-                eventTypePrefix + "enter",
-                reactEventType,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              (tag.target = toNode),
-              (tag.relatedTarget = inCapturePhase),
-              (leaveEventType = tag));
-            inCapturePhase = leaveEventType;
-            if (SyntheticEventCtor && reactEventType)
-              b: {
-                tag = SyntheticEventCtor;
-                enterEventType = reactEventType;
-                eventTypePrefix = 0;
-                for (toNode = tag; toNode; toNode = getParent(toNode))
-                  eventTypePrefix++;
-                toNode = 0;
-                for (
-                  leaveEventType = enterEventType;
-                  leaveEventType;
-                  leaveEventType = getParent(leaveEventType)
-                )
-                  toNode++;
-                for (; 0 < eventTypePrefix - toNode; )
-                  (tag = getParent(tag)), eventTypePrefix--;
-                for (; 0 < toNode - eventTypePrefix; )
-                  (enterEventType = getParent(enterEventType)), toNode--;
-                for (; eventTypePrefix--; ) {
-                  if (
-                    tag === enterEventType ||
-                    (null !== enterEventType &&
-                      tag === enterEventType.alternate)
-                  )
-                    break b;
-                  tag = getParent(tag);
-                  enterEventType = getParent(enterEventType);
-                }
-                tag = null;
-              }
-            else tag = null;
-            null !== SyntheticEventCtor &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                reactName,
-                SyntheticEventCtor,
-                tag,
-                !1
-              );
-            null !== reactEventType &&
-              null !== inCapturePhase &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                inCapturePhase,
-                reactEventType,
-                tag,
-                !0
-              );
-          }
-        }
-      }
-      a: {
-        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
-        SyntheticEventCtor =
-          reactName.nodeName && reactName.nodeName.toLowerCase();
-        if (
-          "select" === SyntheticEventCtor ||
-          ("input" === SyntheticEventCtor && "file" === reactName.type)
-        )
-          var getTargetInstFunc = getTargetInstForChangeEvent;
-        else if (isTextInputElement(reactName))
-          if (isInputEventSupported)
-            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-          else {
-            getTargetInstFunc = getTargetInstForInputEventPolyfill;
-            var handleEventFunc = handleEventsForInputEventPolyfill;
-          }
-        else
-          (SyntheticEventCtor = reactName.nodeName),
-            !SyntheticEventCtor ||
-            "input" !== SyntheticEventCtor.toLowerCase() ||
-            ("checkbox" !== reactName.type && "radio" !== reactName.type)
-              ? enableCustomElementPropertySupport &&
-                targetInst &&
-                isCustomComponent(
-                  targetInst.elementType,
-                  targetInst.memoizedProps
-                ) &&
-                (getTargetInstFunc = getTargetInstForChangeEvent)
-              : (getTargetInstFunc = getTargetInstForClickEvent);
-        if (
-          getTargetInstFunc &&
-          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
-        ) {
-          createAndAccumulateChangeEvent(
-            dispatchQueue,
-            getTargetInstFunc,
-            nativeEvent,
-            nativeEventTarget
-          );
-          break a;
-        }
-        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
-        "focusout" === domEventName &&
-          (handleEventFunc = reactName._wrapperState) &&
-          handleEventFunc.controlled &&
-          "number" === reactName.type &&
-          (disableInputAttributeSyncing ||
-            setDefaultValue(reactName, "number", reactName.value));
-      }
-      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
-      switch (domEventName) {
-        case "focusin":
-          if (
-            isTextInputElement(handleEventFunc) ||
-            "true" === handleEventFunc.contentEditable
-          )
-            (activeElement = handleEventFunc),
-              (activeElementInst = targetInst),
-              (lastSelection = null);
-          break;
-        case "focusout":
-          lastSelection = activeElementInst = activeElement = null;
-          break;
-        case "mousedown":
-          mouseDown = !0;
-          break;
-        case "contextmenu":
-        case "mouseup":
-        case "dragend":
-          mouseDown = !1;
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-          break;
-        case "selectionchange":
-          if (skipSelectionChangeEvent) break;
-        case "keydown":
-        case "keyup":
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-      }
-      var fallbackData;
-      if (canUseCompositionEvent)
-        b: {
-          switch (domEventName) {
-            case "compositionstart":
-              var eventType = "onCompositionStart";
-              break b;
-            case "compositionend":
-              eventType = "onCompositionEnd";
-              break b;
-            case "compositionupdate":
-              eventType = "onCompositionUpdate";
-              break b;
-          }
-          eventType = void 0;
-        }
-      else
-        isComposing
-          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
-            (eventType = "onCompositionEnd")
-          : "keydown" === domEventName &&
-            229 === nativeEvent.keyCode &&
-            (eventType = "onCompositionStart");
-      eventType &&
-        (useFallbackCompositionData &&
-          "ko" !== nativeEvent.locale &&
-          (isComposing || "onCompositionStart" !== eventType
-            ? "onCompositionEnd" === eventType &&
-              isComposing &&
-              (fallbackData = getData())
-            : ((root = nativeEventTarget),
-              (startText = "value" in root ? root.value : root.textContent),
-              (isComposing = !0))),
-        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
-        0 < handleEventFunc.length &&
-          ((eventType = new SyntheticCompositionEvent(
-            eventType,
-            domEventName,
-            null,
-            nativeEvent,
-            nativeEventTarget
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (newChild = createFiberFromFragment(
+            newChild,
+            returnFiber.mode,
+            lanes,
+            null
           )),
-          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
-          fallbackData
-            ? (eventType.data = fallbackData)
-            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
-              null !== fallbackData && (eventType.data = fallbackData))));
+          (newChild.return = returnFiber),
+          newChild
+        );
+      if ("function" === typeof newChild.then)
+        return createChild(returnFiber, unwrapThenable(newChild), lanes);
       if (
-        (fallbackData = canUseTextInputEvent
-          ? getNativeBeforeInputChars(domEventName, nativeEvent)
-          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
       )
-        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
-          0 < targetInst.length &&
-            ((nativeEventTarget = new SyntheticCompositionEvent(
-              "onBeforeInput",
-              "beforeinput",
-              null,
-              nativeEvent,
-              nativeEventTarget
-            )),
-            dispatchQueue.push({
-              event: nativeEventTarget,
-              listeners: targetInst
-            }),
-            (nativeEventTarget.data = fallbackData));
+        return createChild(
+          returnFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-    processDispatchQueue(dispatchQueue, eventSystemFlags);
-  });
-}
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
-}
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  reactName = inCapturePhase
-    ? null !== reactName
-      ? reactName + "Capture"
-      : null
-    : reactName;
-  for (
-    var listeners = [], instance = targetFiber, lastHostComponent = null;
-    null !== instance;
-
-  ) {
-    var _instance = instance;
-    targetFiber = _instance.stateNode;
-    _instance = _instance.tag;
-    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
-    null === targetFiber
-      ? 21 === _instance &&
-        null !== lastHostComponent &&
-        null !== targetFiber &&
-        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }))
-      : ((lastHostComponent = targetFiber),
-        (targetFiber =
-          lastHostComponent[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }),
-        null !== reactName &&
-          ((targetFiber = getListener(instance, reactName)),
-          null != targetFiber &&
-            listeners.push(
-              createDispatchListener(instance, targetFiber, lastHostComponent)
-            )));
-    if (accumulateTargetOnly) break;
-    "beforeblur" === nativeEvent.type &&
-      ((targetFiber = nativeEvent._detachedInterceptFiber),
-      null === targetFiber ||
-        (targetFiber !== instance && targetFiber !== instance.alternate) ||
-        (listeners = []));
-    instance = instance.return;
+    return null;
   }
-  return listeners;
-}
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  for (
-    var captureName = reactName + "Capture", listeners = [];
-    null !== targetFiber;
-
-  ) {
-    var _instance2 = targetFiber,
-      stateNode = _instance2.stateNode;
-    _instance2 = _instance2.tag;
-    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
-      null === stateNode ||
-      ((_instance2 = getListener(targetFiber, captureName)),
-      null != _instance2 &&
-        listeners.unshift(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ),
-      (_instance2 = getListener(targetFiber, reactName)),
-      null != _instance2 &&
-        listeners.push(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ));
-    targetFiber = targetFiber.return;
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    var key = null !== oldFiber ? oldFiber.key : null;
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return null !== key
+        ? null
+        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return newChild.key === key
+            ? updateElement(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_PORTAL_TYPE:
+          return newChild.key === key
+            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_LAZY_TYPE:
+          return (
+            (key = newChild._init),
+            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
+          );
+      }
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return null !== key
+          ? null
+          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      if ("function" === typeof newChild.then)
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return null;
   }
-  return listeners;
-}
-function getParent(inst) {
-  if (null === inst) return null;
-  do inst = inst.return;
-  while (inst && 5 !== inst.tag && 27 !== inst.tag);
-  return inst ? inst : null;
-}
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  for (
-    var registrationName = event._reactName, listeners = [];
-    null !== target && target !== common;
-
+  function updateFromMap(
+    existingChildren,
+    returnFiber,
+    newIdx,
+    newChild,
+    lanes
   ) {
-    var _instance3 = target,
-      alternate = _instance3.alternate,
-      stateNode = _instance3.stateNode;
-    _instance3 = _instance3.tag;
-    if (null !== alternate && alternate === common) break;
-    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
-      null === stateNode ||
-      ((alternate = stateNode),
-      inCapturePhase
-        ? ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.unshift(
-              createDispatchListener(target, stateNode, alternate)
-            ))
-        : inCapturePhase ||
-          ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.push(
-              createDispatchListener(target, stateNode, alternate)
-            )));
-    target = target.return;
-  }
-  0 !== listeners.length &&
-    dispatchQueue.push({ event: event, listeners: listeners });
-}
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [],
-    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
-  null !== eventListeners &&
-    eventListeners.forEach(function (entry) {
-      entry.type === reactEventType &&
-        entry.capture === inCapturePhase &&
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
-        );
-    });
-  return listeners;
-}
-var NORMALIZE_NEWLINES_REGEX = /\r\n?/g,
-  NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
-function normalizeMarkupForTextOrAttribute(markup) {
-  return ("string" === typeof markup ? markup : "" + markup)
-    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
-    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
-}
-function getOwnerDocumentFromRootContainer(rootContainerElement) {
-  return 9 === rootContainerElement.nodeType
-    ? rootContainerElement
-    : rootContainerElement.ownerDocument;
-}
-function noop$1() {}
-function createHTMLElement(type, props, ownerDocument) {
-  return "string" === typeof props.is
-    ? ownerDocument.createElement(type, { is: props.is })
-    : ownerDocument.createElement(type);
-}
-function setInitialProperties(domElement, tag, rawProps) {
-  var isCustomComponentTag = isCustomComponent(tag, rawProps);
-  switch (tag) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", domElement);
-      listenToNonDelegatedEvent("close", domElement);
-      var props = rawProps;
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
-    case "video":
-    case "audio":
-      for (props = 0; props < mediaEventTypes.length; props++)
-        listenToNonDelegatedEvent(mediaEventTypes[props], domElement);
-      props = rawProps;
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", domElement);
-      props = rawProps;
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", domElement);
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", domElement);
-      props = rawProps;
-      break;
-    case "input":
-      initWrapperState$2(domElement, rawProps);
-      props = getHostProps$2(domElement, rawProps);
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    case "option":
-      props = rawProps;
-      break;
-    case "select":
-      domElement._wrapperState = { wasMultiple: !!rawProps.multiple };
-      props = assign({}, rawProps, { value: void 0 });
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    case "textarea":
-      initWrapperState(domElement, rawProps);
-      props = getHostProps(domElement, rawProps);
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    default:
-      props = rawProps;
-  }
-  assertValidProps(tag, props);
-  var nextProps = props,
-    propKey;
-  for (propKey in nextProps)
-    if (nextProps.hasOwnProperty(propKey)) {
-      var nextProp = nextProps[propKey];
-      "style" === propKey
-        ? setValueForStyles(domElement, nextProp)
-        : "dangerouslySetInnerHTML" === propKey
-        ? ((nextProp = nextProp ? nextProp.__html : void 0),
-          null != nextProp && setInnerHTML$1(domElement, nextProp))
-        : "children" === propKey
-        ? "string" === typeof nextProp
-          ? "body" === tag ||
-            ("textarea" === tag && "" === nextProp) ||
-            setTextContent(domElement, nextProp)
-          : "number" === typeof nextProp &&
-            "body" !== tag &&
-            setTextContent(domElement, "" + nextProp)
-        : "suppressContentEditableWarning" !== propKey &&
-          "suppressHydrationWarning" !== propKey &&
-          "autoFocus" !== propKey &&
-          (registrationNameDependencies.hasOwnProperty(propKey)
-            ? null != nextProp &&
-              "onScroll" === propKey &&
-              listenToNonDelegatedEvent("scroll", domElement)
-            : null != nextProp &&
-              setValueForProperty(
-                domElement,
-                propKey,
-                nextProp,
-                isCustomComponentTag
-              ));
-    }
-  switch (tag) {
-    case "input":
-      track(domElement);
-      postMountWrapper$3(domElement, rawProps, !1);
-      break;
-    case "textarea":
-      track(domElement);
-      postMountWrapper(domElement);
-      break;
-    case "option":
-      null != rawProps.value &&
-        domElement.setAttribute("value", "" + getToStringValue(rawProps.value));
-      break;
-    case "select":
-      domElement.multiple = !!rawProps.multiple;
-      tag = rawProps.value;
-      null != tag
-        ? updateOptions(domElement, !!rawProps.multiple, tag, !1)
-        : null != rawProps.defaultValue &&
-          updateOptions(
-            domElement,
-            !!rawProps.multiple,
-            rawProps.defaultValue,
-            !0
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return (
+        (existingChildren = existingChildren.get(newIdx) || null),
+        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updateElement(returnFiber, existingChildren, newChild, lanes)
           );
-      break;
-    default:
-      "function" === typeof props.onClick && (domElement.onclick = noop$1);
-  }
-}
-function updateProperties(
-  domElement,
-  updatePayload,
-  tag,
-  lastRawProps,
-  nextRawProps
-) {
-  "input" === tag &&
-    "radio" === nextRawProps.type &&
-    null != nextRawProps.name &&
-    updateChecked(domElement, nextRawProps);
-  isCustomComponent(tag, lastRawProps);
-  lastRawProps = isCustomComponent(tag, nextRawProps);
-  for (var i = 0; i < updatePayload.length; i += 2) {
-    var propKey = updatePayload[i],
-      propValue = updatePayload[i + 1];
-    "style" === propKey
-      ? setValueForStyles(domElement, propValue)
-      : "dangerouslySetInnerHTML" === propKey
-      ? setInnerHTML$1(domElement, propValue)
-      : "children" === propKey
-      ? setTextContent(domElement, propValue)
-      : setValueForProperty(domElement, propKey, propValue, lastRawProps);
-  }
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, nextRawProps);
-      break;
-    case "textarea":
-      updateWrapper(domElement, nextRawProps);
-      break;
-    case "select":
-      (updatePayload = domElement._wrapperState.wasMultiple),
-        (domElement._wrapperState.wasMultiple = !!nextRawProps.multiple),
-        (tag = nextRawProps.value),
-        null != tag
-          ? updateOptions(domElement, !!nextRawProps.multiple, tag, !1)
-          : updatePayload !== !!nextRawProps.multiple &&
-            (null != nextRawProps.defaultValue
-              ? updateOptions(
-                  domElement,
-                  !!nextRawProps.multiple,
-                  nextRawProps.defaultValue,
-                  !0
-                )
-              : updateOptions(
-                  domElement,
-                  !!nextRawProps.multiple,
-                  nextRawProps.multiple ? [] : "",
-                  !1
-                ));
+        case REACT_PORTAL_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updatePortal(returnFiber, existingChildren, newChild, lanes)
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return updateFromMap(
+            existingChildren,
+            returnFiber,
+            newIdx,
+            init(newChild._payload),
+            lanes
+          );
+      }
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (existingChildren = existingChildren.get(newIdx) || null),
+          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
+        );
+      if ("function" === typeof newChild.then)
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return null;
   }
-}
-var valueStack = [],
-  index = -1;
-function createCursor(defaultValue) {
-  return { current: defaultValue };
-}
-function pop(cursor) {
-  0 > index ||
-    ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
-}
-function push(cursor, value) {
-  index++;
-  valueStack[index] = cursor.current;
-  cursor.current = value;
-}
-var contextStackCursor = createCursor(null),
-  contextFiberStackCursor = createCursor(null),
-  rootInstanceStackCursor = createCursor(null);
-function pushHostContainer(fiber, nextRootInstance) {
-  push(rootInstanceStackCursor, nextRootInstance);
-  push(contextFiberStackCursor, fiber);
-  push(contextStackCursor, null);
-  fiber = nextRootInstance.nodeType;
-  switch (fiber) {
-    case 9:
-    case 11:
-      nextRootInstance = (nextRootInstance = nextRootInstance.documentElement)
-        ? nextRootInstance.namespaceURI
-        : getChildNamespace(null, "");
-      break;
-    default:
-      (fiber = 8 === fiber ? nextRootInstance.parentNode : nextRootInstance),
-        (nextRootInstance = fiber.namespaceURI || null),
-        (fiber = fiber.tagName),
-        (nextRootInstance = getChildNamespace(nextRootInstance, fiber));
-  }
-  pop(contextStackCursor);
-  push(contextStackCursor, nextRootInstance);
-}
-function popHostContainer() {
-  pop(contextStackCursor);
-  pop(contextFiberStackCursor);
-  pop(rootInstanceStackCursor);
-}
-function pushHostContext(fiber) {
-  var context = contextStackCursor.current;
-  var JSCompiler_inline_result = getChildNamespace(context, fiber.type);
-  context !== JSCompiler_inline_result &&
-    (push(contextFiberStackCursor, fiber),
-    push(contextStackCursor, JSCompiler_inline_result));
-}
-function popHostContext(fiber) {
-  contextFiberStackCursor.current === fiber &&
-    (pop(contextStackCursor), pop(contextFiberStackCursor));
-}
-var Dispatcher$1 = Internals.Dispatcher,
-  lastCurrentDocument = null,
-  previousDispatcher = null,
-  ReactDOMClientDispatcher = {
-    prefetchDNS: prefetchDNS$1,
-    preconnect: preconnect$1,
-    preload: preload$1,
-    preinit: preinit$1
-  },
-  preloadPropsMap = new Map(),
-  preconnectsSet = new Set();
-function getHoistableRoot(container) {
-  return "function" === typeof container.getRootNode
-    ? container.getRootNode()
-    : container.ownerDocument;
-}
-function getCurrentResourceRoot() {
-  var currentContainer = rootInstanceStackCursor.current;
-  return currentContainer ? getHoistableRoot(currentContainer) : null;
-}
-function getDocumentForPreloads() {
-  var root = getCurrentResourceRoot();
-  if (root) return root.ownerDocument || root;
-  try {
-    return lastCurrentDocument || window.document;
-  } catch (error) {
-    return null;
-  }
-}
-function preconnectAs(rel, crossOrigin, href) {
-  var ownerDocument = getDocumentForPreloads();
-  if ("string" === typeof href && href && ownerDocument) {
-    var limitedEscapedHref =
-      escapeSelectorAttributeValueInsideDoubleQuotes(href);
-    limitedEscapedHref =
-      'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
-    "string" === typeof crossOrigin &&
-      (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
-    preconnectsSet.has(limitedEscapedHref) ||
-      (preconnectsSet.add(limitedEscapedHref),
-      (rel = { rel: rel, crossOrigin: crossOrigin, href: href }),
-      null === ownerDocument.querySelector(limitedEscapedHref) &&
-        ((crossOrigin = ownerDocument.createElement("link")),
-        setInitialProperties(crossOrigin, "link", rel),
-        markNodeAsHoistable(crossOrigin),
-        ownerDocument.head.appendChild(crossOrigin)));
-  }
-}
-function prefetchDNS$1(href) {
-  preconnectAs("dns-prefetch", null, href);
-}
-function preconnect$1(href, options) {
-  preconnectAs(
-    "preconnect",
-    null == options || "string" !== typeof options.crossOrigin
-      ? null
-      : "use-credentials" === options.crossOrigin
-      ? "use-credentials"
-      : "",
-    href
-  );
-}
-function preload$1(href, options) {
-  var ownerDocument = getDocumentForPreloads();
-  if (
-    "string" === typeof href &&
-    href &&
-    "object" === typeof options &&
-    null !== options &&
-    ownerDocument
+  function reconcileChildrenArray(
+    returnFiber,
+    currentFirstChild,
+    newChildren,
+    lanes
   ) {
-    var as = options.as,
-      limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href),
-      key = (limitedEscapedHref =
-        'link[rel="preload"][as="' +
-        as +
-        '"][href="' +
-        limitedEscapedHref +
-        '"]');
-    switch (as) {
-      case "style":
-        key = getStyleKey(href);
+    for (
+      var resultingFirstChild = null,
+        previousNewFiber = null,
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null;
+      null !== oldFiber && newIdx < newChildren.length;
+      newIdx++
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(
+        returnFiber,
+        oldFiber,
+        newChildren[newIdx],
+        lanes
+      );
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
         break;
-      case "script":
-        key = getScriptKey(href);
+      }
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (resultingFirstChild = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
     }
-    preloadPropsMap.has(key) ||
-      ((href = {
-        href: href,
-        rel: "preload",
-        as: as,
-        crossOrigin: "font" === as ? "" : options.crossOrigin,
-        integrity: options.integrity,
-        type: options.type
-      }),
-      preloadPropsMap.set(key, href),
-      null === ownerDocument.querySelector(limitedEscapedHref) &&
-        ((options = ownerDocument.createElement("link")),
-        setInitialProperties(options, "link", href),
-        markNodeAsHoistable(options),
-        ownerDocument.head.appendChild(options)));
+    if (newIdx === newChildren.length)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        resultingFirstChild
+      );
+    if (null === oldFiber) {
+      for (; newIdx < newChildren.length; newIdx++)
+        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
+          null !== oldFiber &&
+            ((currentFirstChild = placeChild(
+              oldFiber,
+              currentFirstChild,
+              newIdx
+            )),
+            null === previousNewFiber
+              ? (resultingFirstChild = oldFiber)
+              : (previousNewFiber.sibling = oldFiber),
+            (previousNewFiber = oldFiber));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return resultingFirstChild;
+    }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      newIdx < newChildren.length;
+      newIdx++
+    )
+      (nextOldFiber = updateFromMap(
+        oldFiber,
+        returnFiber,
+        newIdx,
+        newChildren[newIdx],
+        lanes
+      )),
+        null !== nextOldFiber &&
+          (shouldTrackSideEffects &&
+            null !== nextOldFiber.alternate &&
+            oldFiber.delete(
+              null === nextOldFiber.key ? newIdx : nextOldFiber.key
+            ),
+          (currentFirstChild = placeChild(
+            nextOldFiber,
+            currentFirstChild,
+            newIdx
+          )),
+          null === previousNewFiber
+            ? (resultingFirstChild = nextOldFiber)
+            : (previousNewFiber.sibling = nextOldFiber),
+          (previousNewFiber = nextOldFiber));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return resultingFirstChild;
   }
-}
-function preinit$1(href, options) {
-  if (
-    "string" === typeof href &&
-    href &&
-    "object" === typeof options &&
-    null !== options
+  function reconcileChildrenIterator(
+    returnFiber,
+    currentFirstChild,
+    newChildrenIterable,
+    lanes
   ) {
-    var resourceRoot = getCurrentResourceRoot(),
-      as = options.as;
-    if (resourceRoot)
-      switch (as) {
-        case "style":
-          as = getResourcesFromRoot(resourceRoot).hoistableStyles;
-          var key$37 = getStyleKey(href),
-            precedence = options.precedence || "default",
-            resource = as.get(key$37);
-          if (resource) break;
-          resource = resourceRoot.querySelector(
-            getStylesheetSelectorFromKey(key$37)
-          );
-          resource ||
-            ((href = {
-              rel: "stylesheet",
-              href: href,
-              "data-precedence": precedence,
-              crossOrigin: options.crossOrigin
-            }),
-            (options = preloadPropsMap.get(key$37)) &&
-              adoptPreloadPropsForStylesheet(href, options),
-            (resource = (
-              resourceRoot.ownerDocument || resourceRoot
-            ).createElement("link")),
-            markNodeAsHoistable(resource),
-            setInitialProperties(resource, "link", href),
-            insertStylesheet(resource, precedence, resourceRoot));
-          resource = { type: "stylesheet", instance: resource, count: 1 };
-          as.set(key$37, resource);
-          break;
-        case "script":
-          (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
-            (key$37 = getScriptKey(href)),
-            (precedence = as.get(key$37)),
-            precedence ||
-              ((precedence = resourceRoot.querySelector(
-                "script[async]" + key$37
-              )),
-              precedence ||
-                ((href = {
-                  src: href,
-                  async: !0,
-                  crossOrigin: options.crossOrigin,
-                  integrity: options.integrity
-                }),
-                (options = preloadPropsMap.get(key$37)) &&
-                  adoptPreloadPropsForScript(href, options),
-                (options = resourceRoot.ownerDocument || resourceRoot),
-                (precedence = options.createElement("script")),
-                markNodeAsHoistable(precedence),
-                setInitialProperties(precedence, "link", href),
-                options.head.appendChild(precedence)),
-              (precedence = { type: "script", instance: precedence, count: 1 }),
-              as.set(key$37, precedence));
-      }
-    else if ("style" === as || "script" === as)
-      if ((resourceRoot = getDocumentForPreloads())) {
-        key$37 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
-        precedence = key$37 =
-          'link[rel="preload"][as="' + as + '"][href="' + key$37 + '"]';
-        switch (as) {
-          case "style":
-            precedence = getStyleKey(href);
-            break;
-          case "script":
-            precedence = getScriptKey(href);
-        }
-        preloadPropsMap.has(precedence) ||
-          ((href = {
-            href: href,
-            rel: "preload",
-            as: as,
-            crossOrigin: "font" === as ? "" : options.crossOrigin,
-            integrity: options.integrity
-          }),
-          preloadPropsMap.set(precedence, href),
-          null === resourceRoot.querySelector(key$37) &&
-            ((options = resourceRoot.createElement("link")),
-            setInitialProperties(options, "link", href),
-            markNodeAsHoistable(options),
-            resourceRoot.head.appendChild(options)));
-      }
-  }
-}
-function getResource(type, currentProps, pendingProps) {
-  currentProps = getCurrentResourceRoot();
-  if (!currentProps) throw Error(formatProdErrorMessage(446));
-  switch (type) {
-    case "meta":
-    case "title":
-      return null;
-    case "style":
-      return "string" === typeof pendingProps.precedence &&
-        "string" === typeof pendingProps.href
-        ? ((pendingProps = getStyleKey(pendingProps.href)),
-          (currentProps = getResourcesFromRoot(currentProps).hoistableStyles),
-          (type = currentProps.get(pendingProps)),
-          type ||
-            ((type = { type: "style", instance: null, count: 0 }),
-            currentProps.set(pendingProps, type)),
-          type)
-        : { type: "void", instance: null, count: 0 };
-    case "link":
-      if (
-        "stylesheet" === pendingProps.rel &&
-        "string" === typeof pendingProps.href &&
-        "string" === typeof pendingProps.precedence
-      ) {
-        var key$44 = getStyleKey(pendingProps.href),
-          styles$45 = getResourcesFromRoot(currentProps).hoistableStyles;
-        type = styles$45.get(key$44);
-        type ||
-          ((currentProps = currentProps.ownerDocument || currentProps),
-          (type = { type: "stylesheet", instance: null, count: 0 }),
-          styles$45.set(key$44, type),
-          preloadPropsMap.has(key$44) ||
-            ((pendingProps = {
-              rel: "preload",
-              as: "style",
-              href: pendingProps.href,
-              crossOrigin: pendingProps.crossOrigin,
-              integrity: pendingProps.integrity,
-              media: pendingProps.media,
-              hrefLang: pendingProps.hrefLang,
-              referrerPolicy: pendingProps.referrerPolicy
-            }),
-            preloadPropsMap.set(key$44, pendingProps),
-            currentProps.querySelector(getStylesheetSelectorFromKey(key$44)) ||
-              null !==
-                currentProps.querySelector(
-                  'link[rel="preload"][as="style"][' + key$44 + "]"
-                ) ||
-              ((key$44 = currentProps.createElement("link")),
-              setInitialProperties(key$44, "link", pendingProps),
-              markNodeAsHoistable(key$44),
-              currentProps.head.appendChild(key$44))));
-        return type;
+    var iteratorFn = getIteratorFn(newChildrenIterable);
+    if ("function" !== typeof iteratorFn)
+      throw Error(formatProdErrorMessage(150));
+    newChildrenIterable = iteratorFn.call(newChildrenIterable);
+    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
+    for (
+      var previousNewFiber = (iteratorFn = null),
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null,
+        step = newChildrenIterable.next();
+      null !== oldFiber && !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
+        break;
       }
-      return null;
-    case "script":
-      return "string" === typeof pendingProps.src && !0 === pendingProps.async
-        ? ((pendingProps = getScriptKey(pendingProps.src)),
-          (currentProps = getResourcesFromRoot(currentProps).hoistableScripts),
-          (type = currentProps.get(pendingProps)),
-          type ||
-            ((type = { type: "script", instance: null, count: 0 }),
-            currentProps.set(pendingProps, type)),
-          type)
-        : { type: "void", instance: null, count: 0 };
-    default:
-      throw Error(formatProdErrorMessage(444, type));
-  }
-}
-function getStyleKey(href) {
-  return 'href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
-}
-function getStylesheetSelectorFromKey(key) {
-  return 'link[rel="stylesheet"][' + key + "]";
-}
-function getScriptKey(src) {
-  return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
-}
-function acquireResource(hoistableRoot, resource, props) {
-  resource.count++;
-  if (null === resource.instance)
-    switch (resource.type) {
-      case "style":
-        var key = getStyleKey(props.href);
-        if ((key = hoistableRoot.querySelector("style[data-" + key + "]")))
-          return (resource.instance = key), markNodeAsHoistable(key), key;
-        var styleProps = assign({}, props, {
-          "data-href": props.href,
-          "data-precedence": props.precedence,
-          href: null,
-          precedence: null
-        });
-        key = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
-          "style"
-        );
-        markNodeAsHoistable(key);
-        setInitialProperties(key, "style", styleProps);
-        insertStylesheet(key, props.precedence, hoistableRoot);
-        return (resource.instance = key);
-      case "stylesheet":
-        styleProps = getStyleKey(props.href);
-        var instance$51 = hoistableRoot.querySelector(
-          getStylesheetSelectorFromKey(styleProps)
-        );
-        if (instance$51)
-          return (
-            (resource.instance = instance$51),
-            markNodeAsHoistable(instance$51),
-            instance$51
-          );
-        key = assign({}, props, {
-          "data-precedence": props.precedence,
-          precedence: null
-        });
-        (styleProps = preloadPropsMap.get(styleProps)) &&
-          adoptPreloadPropsForStylesheet(key, styleProps);
-        instance$51 = (
-          hoistableRoot.ownerDocument || hoistableRoot
-        ).createElement("link");
-        markNodeAsHoistable(instance$51);
-        var linkInstance = instance$51;
-        linkInstance._p = new Promise(function (resolve, reject) {
-          linkInstance.onload = resolve;
-          linkInstance.onerror = reject;
-        }).then(
-          function () {
-            return (linkInstance._p.s = "l");
-          },
-          function () {
-            return (linkInstance._p.s = "e");
-          }
-        );
-        setInitialProperties(instance$51, "link", key);
-        insertStylesheet(instance$51, props.precedence, hoistableRoot);
-        return (resource.instance = instance$51);
-      case "script":
-        instance$51 = getScriptKey(props.src);
-        if (
-          (styleProps = hoistableRoot.querySelector(
-            "script[async]" + instance$51
-          ))
-        )
-          return (
-            (resource.instance = styleProps),
-            markNodeAsHoistable(styleProps),
-            styleProps
-          );
-        key = props;
-        if ((styleProps = preloadPropsMap.get(instance$51)))
-          (key = assign({}, props)),
-            adoptPreloadPropsForScript(key, styleProps);
-        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
-        styleProps = hoistableRoot.createElement("script");
-        markNodeAsHoistable(styleProps);
-        setInitialProperties(styleProps, "link", key);
-        hoistableRoot.head.appendChild(styleProps);
-        return (resource.instance = styleProps);
-      case "void":
-        return null;
-      default:
-        throw Error(formatProdErrorMessage(443, resource.type));
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (iteratorFn = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
     }
-  return resource.instance;
-}
-function insertStylesheet(instance, precedence, root) {
-  for (
-    var nodes = root.querySelectorAll(
-        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
-      ),
-      last = nodes.length ? nodes[nodes.length - 1] : null,
-      prior = last,
-      i = 0;
-    i < nodes.length;
-    i++
-  ) {
-    var node = nodes[i];
-    if (node.dataset.precedence === precedence) prior = node;
-    else if (prior !== last) break;
-  }
-  prior
-    ? prior.parentNode.insertBefore(instance, prior.nextSibling)
-    : ((precedence = 9 === root.nodeType ? root.head : root),
-      precedence.insertBefore(instance, precedence.firstChild));
-}
-function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
-  null == stylesheetProps.crossOrigin &&
-    (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
-  null == stylesheetProps.referrerPolicy &&
-    (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
-  null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
-}
-function adoptPreloadPropsForScript(scriptProps, preloadProps) {
-  null == scriptProps.crossOrigin &&
-    (scriptProps.crossOrigin = preloadProps.crossOrigin);
-  null == scriptProps.referrerPolicy &&
-    (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
-  null == scriptProps.integrity &&
-    (scriptProps.referrerPolicy = preloadProps.integrity);
-}
-var tagCaches = null;
-function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
-  if (null === tagCaches) {
-    var cache = new Map();
-    var caches = (tagCaches = new Map());
-    caches.set(ownerDocument, cache);
-  } else
-    (caches = tagCaches),
-      (cache = caches.get(ownerDocument)),
-      cache || ((cache = new Map()), caches.set(ownerDocument, cache));
-  if (cache.has(type)) return cache;
-  cache.set(type, null);
-  ownerDocument = ownerDocument.getElementsByTagName(type);
-  for (caches = 0; caches < ownerDocument.length; caches++) {
-    var node = ownerDocument[caches];
-    if (
-      !(
-        node[internalHoistableMarker] ||
-        node[internalInstanceKey] ||
-        ("link" === type && "stylesheet" === node.getAttribute("rel"))
-      ) &&
-      "http://www.w3.org/2000/svg" !== node.namespaceURI
-    ) {
-      var nodeKey = node.getAttribute(keyAttribute) || "";
-      nodeKey = type + nodeKey;
-      var existing = cache.get(nodeKey);
-      existing ? existing.push(node) : cache.set(nodeKey, [node]);
+    if (step.done)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        iteratorFn
+      );
+    if (null === oldFiber) {
+      for (; !step.done; newIdx++, step = newChildrenIterable.next())
+        (step = createChild(returnFiber, step.value, lanes)),
+          null !== step &&
+            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+            null === previousNewFiber
+              ? (iteratorFn = step)
+              : (previousNewFiber.sibling = step),
+            (previousNewFiber = step));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return iteratorFn;
     }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    )
+      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
+        null !== step &&
+          (shouldTrackSideEffects &&
+            null !== step.alternate &&
+            oldFiber.delete(null === step.key ? newIdx : step.key),
+          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+          null === previousNewFiber
+            ? (iteratorFn = step)
+            : (previousNewFiber.sibling = step),
+          (previousNewFiber = step));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return iteratorFn;
   }
-  return cache;
-}
-function mountHoistable(hoistableRoot, type, instance) {
-  hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
-  hoistableRoot.head.insertBefore(
-    instance,
-    "title" === type ? hoistableRoot.querySelector("head > title") : null
-  );
-}
-var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
-function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
-  return value.replace(
-    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
-    function (ch) {
-      return "\\" + ch.charCodeAt(0).toString(16);
-    }
-  );
-}
-var eventsEnabled = null,
-  selectionInformation = null;
-function shouldSetTextContent(type, props) {
-  return (
-    "textarea" === type ||
-    "noscript" === type ||
-    "string" === typeof props.children ||
-    "number" === typeof props.children ||
-    ("object" === typeof props.dangerouslySetInnerHTML &&
-      null !== props.dangerouslySetInnerHTML &&
-      null != props.dangerouslySetInnerHTML.__html)
-  );
-}
-var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
-  cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
-  localPromise = "function" === typeof Promise ? Promise : void 0,
-  localRequestAnimationFrame =
-    "function" === typeof requestAnimationFrame
-      ? requestAnimationFrame
-      : scheduleTimeout;
-function getInstanceFromScope(scopeInstance) {
-  scopeInstance = scopeInstance[internalInstanceKey] || null;
-  return scopeInstance;
-}
-var scheduleMicrotask =
-  "function" === typeof queueMicrotask
-    ? queueMicrotask
-    : "undefined" !== typeof localPromise
-    ? function (callback) {
-        return localPromise
-          .resolve(null)
-          .then(callback)
-          .catch(handleErrorInNextTick);
+  function reconcileChildFibersImpl(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    "object" === typeof newChild &&
+      null !== newChild &&
+      newChild.type === REACT_FRAGMENT_TYPE &&
+      null === newChild.key &&
+      (newChild = newChild.props.children);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          a: {
+            for (
+              var key = newChild.key, child = currentFirstChild;
+              null !== child;
+
+            ) {
+              if (child.key === key) {
+                key = newChild.type;
+                if (key === REACT_FRAGMENT_TYPE) {
+                  if (7 === child.tag) {
+                    deleteRemainingChildren(returnFiber, child.sibling);
+                    currentFirstChild = useFiber(
+                      child,
+                      newChild.props.children
+                    );
+                    currentFirstChild.return = returnFiber;
+                    returnFiber = currentFirstChild;
+                    break a;
+                  }
+                } else if (
+                  child.elementType === key ||
+                  ("object" === typeof key &&
+                    null !== key &&
+                    key.$$typeof === REACT_LAZY_TYPE &&
+                    resolveLazy(key) === child.type)
+                ) {
+                  deleteRemainingChildren(returnFiber, child.sibling);
+                  currentFirstChild = useFiber(child, newChild.props);
+                  currentFirstChild.ref = coerceRef(
+                    returnFiber,
+                    child,
+                    newChild
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                }
+                deleteRemainingChildren(returnFiber, child);
+                break;
+              } else deleteChild(returnFiber, child);
+              child = child.sibling;
+            }
+            newChild.type === REACT_FRAGMENT_TYPE
+              ? ((currentFirstChild = createFiberFromFragment(
+                  newChild.props.children,
+                  returnFiber.mode,
+                  lanes,
+                  newChild.key
+                )),
+                (currentFirstChild.return = returnFiber),
+                (returnFiber = currentFirstChild))
+              : ((lanes = createFiberFromTypeAndProps(
+                  newChild.type,
+                  newChild.key,
+                  newChild.props,
+                  null,
+                  returnFiber.mode,
+                  lanes
+                )),
+                (lanes.ref = coerceRef(
+                  returnFiber,
+                  currentFirstChild,
+                  newChild
+                )),
+                (lanes.return = returnFiber),
+                (returnFiber = lanes));
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_PORTAL_TYPE:
+          a: {
+            for (child = newChild.key; null !== currentFirstChild; ) {
+              if (currentFirstChild.key === child)
+                if (
+                  4 === currentFirstChild.tag &&
+                  currentFirstChild.stateNode.containerInfo ===
+                    newChild.containerInfo &&
+                  currentFirstChild.stateNode.implementation ===
+                    newChild.implementation
+                ) {
+                  deleteRemainingChildren(
+                    returnFiber,
+                    currentFirstChild.sibling
+                  );
+                  currentFirstChild = useFiber(
+                    currentFirstChild,
+                    newChild.children || []
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                } else {
+                  deleteRemainingChildren(returnFiber, currentFirstChild);
+                  break;
+                }
+              else deleteChild(returnFiber, currentFirstChild);
+              currentFirstChild = currentFirstChild.sibling;
+            }
+            currentFirstChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
+            );
+            currentFirstChild.return = returnFiber;
+            returnFiber = currentFirstChild;
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_LAZY_TYPE:
+          return (
+            (child = newChild._init),
+            reconcileChildFibers(
+              returnFiber,
+              currentFirstChild,
+              child(newChild._payload),
+              lanes
+            )
+          );
       }
-    : scheduleTimeout;
-function handleErrorInNextTick(error) {
-  setTimeout(function () {
-    throw error;
-  });
-}
-function createEvent(type, bubbles) {
-  var event = document.createEvent("Event");
-  event.initEvent(type, bubbles, !1);
-  return event;
-}
-function dispatchBeforeDetachedBlur(target, internalInstanceHandle) {
-  var event = createEvent("beforeblur", !0);
-  event._detachedInterceptFiber = internalInstanceHandle;
-  target.dispatchEvent(event);
-}
-function dispatchAfterDetachedBlur(target) {
-  var event = createEvent("afterblur", !1);
-  event.relatedTarget = target;
-  document.dispatchEvent(event);
+      if (isArrayImpl(newChild))
+        return reconcileChildrenArray(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if (getIteratorFn(newChild))
+        return reconcileChildrenIterator(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if ("function" === typeof newChild.then)
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+      ? ((newChild = "" + newChild),
+        null !== currentFirstChild && 6 === currentFirstChild.tag
+          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
+            (currentFirstChild = useFiber(currentFirstChild, newChild)),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild))
+          : (deleteRemainingChildren(returnFiber, currentFirstChild),
+            (currentFirstChild = createFiberFromText(
+              newChild,
+              returnFiber.mode,
+              lanes
+            )),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild)),
+        placeSingleChild(returnFiber))
+      : deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
+  function reconcileChildFibers(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    thenableIndexCounter$1 = 0;
+    returnFiber = reconcileChildFibersImpl(
+      returnFiber,
+      currentFirstChild,
+      newChild,
+      lanes
+    );
+    thenableState$1 = null;
+    return returnFiber;
+  }
+  return reconcileChildFibers;
 }
-function clearSuspenseBoundary(parentInstance, suspenseInstance) {
-  var node = suspenseInstance,
-    depth = 0;
-  do {
-    var nextNode = node.nextSibling;
-    parentInstance.removeChild(node);
-    if (nextNode && 8 === nextNode.nodeType)
-      if (((node = nextNode.data), "/$" === node)) {
-        if (0 === depth) {
-          parentInstance.removeChild(nextNode);
-          retryIfBlockedOn(suspenseInstance);
-          return;
-        }
-        depth--;
-      } else ("$" !== node && "$?" !== node && "$!" !== node) || depth++;
-    node = nextNode;
-  } while (node);
-  retryIfBlockedOn(suspenseInstance);
+var reconcileChildFibers = createChildReconciler(!0),
+  mountChildFibers = createChildReconciler(!1),
+  currentTreeHiddenStackCursor = createCursor(null),
+  prevRenderLanesStackCursor = createCursor(0);
+function pushHiddenContext(fiber, context) {
+  fiber = renderLanes;
+  push(prevRenderLanesStackCursor, fiber);
+  push(currentTreeHiddenStackCursor, context);
+  renderLanes = fiber | context.baseLanes;
 }
-function clearContainerSparingly(container) {
-  var nextNode = container.firstChild;
-  nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
-  for (; nextNode; ) {
-    var node = nextNode;
-    nextNode = nextNode.nextSibling;
-    switch (node.nodeName) {
-      case "HTML":
-      case "HEAD":
-      case "BODY":
-        clearContainerSparingly(node);
-        detachDeletedInstance(node);
-        continue;
-      case "STYLE":
-        continue;
-      case "LINK":
-        if ("stylesheet" === node.rel.toLowerCase()) continue;
+function reuseHiddenContextOnStack() {
+  push(prevRenderLanesStackCursor, renderLanes);
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+}
+function popHiddenContext() {
+  renderLanes = prevRenderLanesStackCursor.current;
+  pop(currentTreeHiddenStackCursor);
+  pop(prevRenderLanesStackCursor);
+}
+var suspenseHandlerStackCursor = createCursor(null),
+  shellBoundary = null;
+function pushPrimaryTreeSuspenseHandler(handler) {
+  var current = handler.alternate;
+  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
+  (null !== current && null === currentTreeHiddenStackCursor.current)
+    ? (push(suspenseHandlerStackCursor, handler),
+      null === shellBoundary &&
+        (null === current || null !== currentTreeHiddenStackCursor.current
+          ? (shellBoundary = handler)
+          : null !== current.memoizedState && (shellBoundary = handler)))
+    : null === shellBoundary
+    ? push(suspenseHandlerStackCursor, handler)
+    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (22 === fiber.tag) {
+    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
+      var current = fiber.alternate;
+      null !== current &&
+        null !== current.memoizedState &&
+        (shellBoundary = fiber);
     }
-    container.removeChild(node);
-  }
+  } else reuseSuspenseHandlerOnStack();
 }
-function shouldSkipHydratableForInstance(instance, type, props) {
-  if (1 !== instance.nodeType) return !1;
-  if (
-    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
-    instance[internalHoistableMarker]
-  )
-    return !0;
-  switch (type) {
-    case "meta":
-      if (!instance.hasAttribute("itemprop")) return !0;
-      break;
-    case "link":
-      type = instance.getAttribute("rel");
-      if (
-        ("stylesheet" === type && instance.hasAttribute("data-precedence")) ||
-        type !== props.rel ||
-        instance.getAttribute("href") !==
-          (null == props.href ? null : props.href) ||
-        instance.getAttribute("crossorigin") !==
-          (null == props.crossOrigin ? null : props.crossOrigin) ||
-        instance.getAttribute("title") !==
-          (null == props.title ? null : props.title)
-      )
-        return !0;
-      break;
-    case "style":
-      if (instance.hasAttribute("data-precedence")) return !0;
-      break;
-    case "script":
+function reuseSuspenseHandlerOnStack() {
+  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+  shellBoundary === fiber && (shellBoundary = null);
+}
+var suspenseStackCursor = createCursor(0);
+function findFirstSuspended(row) {
+  for (var node = row; null !== node; ) {
+    if (13 === node.tag) {
+      var state = node.memoizedState;
       if (
-        ((type = instance.getAttribute("src")) &&
-          instance.hasAttribute("async") &&
-          !instance.hasAttribute("itemprop")) ||
-        type !== (null == props.src ? null : props.src) ||
-        instance.getAttribute("type") !==
-          (null == props.type ? null : props.type) ||
-        instance.getAttribute("crossorigin") !==
-          (null == props.crossOrigin ? null : props.crossOrigin)
+        null !== state &&
+        ((state = state.dehydrated),
+        null === state || "$?" === state.data || "$!" === state.data)
       )
-        return !0;
-  }
-  return !1;
-}
-function getNextHydratable(node) {
-  for (; null != node; node = node.nextSibling) {
-    var nodeType = node.nodeType;
-    if (1 === nodeType || 3 === nodeType) break;
-    if (8 === nodeType) {
-      nodeType = node.data;
-      if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType) break;
-      if ("/$" === nodeType) return null;
+        return node;
+    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+      if (0 !== (node.flags & 128)) return node;
+    } else if (null !== node.child) {
+      node.child.return = node;
+      node = node.child;
+      continue;
     }
-  }
-  return node;
-}
-function getParentSuspenseInstance(targetInstance) {
-  targetInstance = targetInstance.previousSibling;
-  for (var depth = 0; targetInstance; ) {
-    if (8 === targetInstance.nodeType) {
-      var data = targetInstance.data;
-      if ("$" === data || "$!" === data || "$?" === data) {
-        if (0 === depth) return targetInstance;
-        depth--;
-      } else "/$" === data && depth++;
+    if (node === row) break;
+    for (; null === node.sibling; ) {
+      if (null === node.return || node.return === row) return null;
+      node = node.return;
     }
-    targetInstance = targetInstance.previousSibling;
+    node.sibling.return = node.return;
+    node = node.sibling;
   }
   return null;
 }
-function requestPostPaintCallback(callback) {
-  localRequestAnimationFrame(function () {
-    localRequestAnimationFrame(function (time) {
-      return callback(time);
-    });
-  });
+var workInProgressSources = [];
+function resetWorkInProgressVersions() {
+  for (var i = 0; i < workInProgressSources.length; i++)
+    workInProgressSources[i]._workInProgressVersionPrimary = null;
+  workInProgressSources.length = 0;
 }
-function isHostHoistableType(type, props, hostContext) {
-  if ("http://www.w3.org/2000/svg" === hostContext || null != props.itemProp)
-    return !1;
-  switch (type) {
-    case "meta":
-    case "title":
-      return !0;
-    case "style":
-      if (
-        "string" !== typeof props.precedence ||
-        "string" !== typeof props.href ||
-        "" === props.href
-      )
-        break;
-      return !0;
-    case "link":
-      if (
-        "string" !== typeof props.rel ||
-        "string" !== typeof props.href ||
-        "" === props.href ||
-        props.onLoad ||
-        props.onError
-      )
-        break;
-      switch (props.rel) {
-        case "stylesheet":
-          return (
-            (type = props.disabled),
-            "string" === typeof props.precedence && null == type
-          );
-        default:
-          return !0;
-      }
-    case "script":
-      if (
-        !0 === props.async &&
-        !props.onLoad &&
-        !props.onError &&
-        "string" === typeof props.src &&
-        props.src
-      )
-        return !0;
-  }
-  return !1;
-}
-function resolveSingletonInstance(type, props, rootContainerInstance) {
-  props = getOwnerDocumentFromRootContainer(rootContainerInstance);
-  switch (type) {
-    case "html":
-      type = props.documentElement;
-      if (!type) throw Error(formatProdErrorMessage(452));
-      return type;
-    case "head":
-      type = props.head;
-      if (!type) throw Error(formatProdErrorMessage(453));
-      return type;
-    case "body":
-      type = props.body;
-      if (!type) throw Error(formatProdErrorMessage(454));
-      return type;
-    default:
-      throw Error(formatProdErrorMessage(451));
-  }
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
+  renderLanes$1 = 0,
+  currentlyRenderingFiber$1 = null,
+  currentHook = null,
+  workInProgressHook = null,
+  didScheduleRenderPhaseUpdate = !1,
+  didScheduleRenderPhaseUpdateDuringThisPass = !1,
+  shouldDoubleInvokeUserFnsInHooksDEV = !1,
+  localIdCounter = 0,
+  thenableIndexCounter = 0,
+  thenableState = null,
+  globalClientIdCounter = 0;
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
 }
-var emptyContextObject = {},
-  syncQueue = null,
-  includesLegacySyncCallbacks = !1,
-  isFlushingSyncQueue = !1;
-function scheduleSyncCallback(callback) {
-  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (null === prevDeps) return !1;
+  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
+    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+  return !0;
 }
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = !0;
-  scheduleSyncCallback(callback);
+function renderWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg,
+  nextRenderLanes
+) {
+  renderLanes$1 = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = 0;
+  ReactCurrentDispatcher$1.current =
+    null === current || null === current.memoizedState
+      ? HooksDispatcherOnMount
+      : HooksDispatcherOnUpdate;
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  nextRenderLanes = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  didScheduleRenderPhaseUpdateDuringThisPass &&
+    (nextRenderLanes = renderWithHooksAgain(
+      workInProgress,
+      Component,
+      props,
+      secondArg
+    ));
+  finishRenderingHooks(current);
+  return nextRenderLanes;
 }
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && null !== syncQueue) {
-    isFlushingSyncQueue = !0;
-    var previousUpdatePriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
-      var callback = queue[i];
-      try {
-        do callback = callback(!0);
-        while (null !== callback);
-      } catch (error) {
-        null === errors ? (errors = [error]) : errors.push(error);
-      }
-    }
-    syncQueue = null;
-    includesLegacySyncCallbacks = !1;
-    currentUpdatePriority = previousUpdatePriority;
-    isFlushingSyncQueue = !1;
-    if (null !== errors) {
-      if (1 < errors.length) {
-        if ("function" === typeof AggregateError)
-          throw new AggregateError(errors);
-        for (
-          previousUpdatePriority = 1;
-          previousUpdatePriority < errors.length;
-          previousUpdatePriority++
-        )
-          scheduleCallback$2(
-            ImmediatePriority,
-            throwError.bind(null, errors[previousUpdatePriority])
-          );
-      }
-      throw errors[0];
-    }
-  }
-  return null;
+function finishRenderingHooks(current) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdate = !1;
+  thenableIndexCounter = 0;
+  thenableState = null;
+  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
+  enableLazyContextPropagation &&
+    null !== current &&
+    !didReceiveUpdate &&
+    ((current = current.dependencies),
+    null !== current &&
+      checkIfContextChanged(current) &&
+      (didReceiveUpdate = !0));
 }
-function throwError(error) {
-  throw error;
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  var numberOfReRenders = 0;
+  do {
+    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = !1;
+    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
+    numberOfReRenders += 1;
+    workInProgressHook = currentHook = null;
+    workInProgress.updateQueue = null;
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    var children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+  return children;
 }
-var forkStack = [],
-  forkStackIndex = 0,
-  treeForkProvider = null,
-  treeForkCount = 0,
-  idStack = [],
-  idStackIndex = 0,
-  treeContextProvider = null,
-  treeContextId = 1,
-  treeContextOverflow = "";
-function pushTreeFork(workInProgress, totalChildren) {
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
+function checkDidRenderIdHook() {
+  var didRenderIdHook = 0 !== localIdCounter;
+  localIdCounter = 0;
+  return didRenderIdHook;
 }
-function pushTreeId(workInProgress, totalChildren, index) {
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  workInProgress = treeContextOverflow;
-  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
-  baseIdWithLeadingBit &= ~(1 << baseLength);
-  index += 1;
-  var length = 32 - clz32(totalChildren) + baseLength;
-  if (30 < length) {
-    var numberOfOverflowBits = baseLength - (baseLength % 5);
-    length = (
-      baseIdWithLeadingBit &
-      ((1 << numberOfOverflowBits) - 1)
-    ).toString(32);
-    baseIdWithLeadingBit >>= numberOfOverflowBits;
-    baseLength -= numberOfOverflowBits;
-    treeContextId =
-      (1 << (32 - clz32(totalChildren) + baseLength)) |
-      (index << baseLength) |
-      baseIdWithLeadingBit;
-    treeContextOverflow = length + workInProgress;
-  } else
-    (treeContextId =
-      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
-      (treeContextOverflow = workInProgress);
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue;
+  workInProgress.flags &= -2053;
+  current.lanes &= ~lanes;
 }
-function pushMaterializedTreeId(workInProgress) {
-  null !== workInProgress.return &&
-    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
+function resetHooksOnUnwind() {
+  if (didScheduleRenderPhaseUpdate) {
+    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
+      var queue = hook.queue;
+      null !== queue && (queue.pending = null);
+      hook = hook.next;
+    }
+    didScheduleRenderPhaseUpdate = !1;
+  }
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdateDuringThisPass = !1;
+  thenableIndexCounter = localIdCounter = 0;
+  thenableState = null;
 }
-function popTreeContext(workInProgress) {
-  for (; workInProgress === treeForkProvider; )
-    (treeForkProvider = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null),
-      (treeForkCount = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null);
-  for (; workInProgress === treeContextProvider; )
-    (treeContextProvider = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextOverflow = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextId = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null);
-}
-var hydrationParentFiber = null,
-  nextHydratableInstance = null,
-  isHydrating = !1,
-  hydrationErrors = null,
-  rootOrSingletonContext = !1;
-function deleteHydratableInstance(returnFiber, instance) {
-  var fiber = createFiber(5, null, null, 0);
-  fiber.elementType = "DELETED";
-  fiber.stateNode = instance;
-  fiber.return = returnFiber;
-  instance = returnFiber.deletions;
-  null === instance
-    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
-    : instance.push(fiber);
-}
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & -4097) | 2;
-}
-function tryHydrateInstance(fiber, nextInstance) {
-  var type = fiber.type;
-  nextInstance =
-    1 !== nextInstance.nodeType ||
-    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
-      (rootOrSingletonContext = !1),
-      !0)
-    : !1;
-}
-function tryHydrateText(fiber, nextInstance) {
-  nextInstance =
-    "" === fiber.pendingProps
-      ? null
-      : 3 !== nextInstance.nodeType
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = null),
-      !0)
-    : !1;
+function mountWorkInProgressHook() {
+  var hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+  null === workInProgressHook
+    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
+    : (workInProgressHook = workInProgressHook.next = hook);
+  return workInProgressHook;
 }
-function tryHydrateSuspense(fiber, nextInstance) {
-  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
-  if (null !== nextInstance) {
-    var JSCompiler_inline_result =
-      null !== treeContextProvider
-        ? { id: treeContextId, overflow: treeContextOverflow }
-        : null;
-    fiber.memoizedState = {
-      dehydrated: nextInstance,
-      treeContext: JSCompiler_inline_result,
-      retryLane: 1073741824
+function updateWorkInProgressHook() {
+  if (null === currentHook) {
+    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
+    nextCurrentHook =
+      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+  } else nextCurrentHook = currentHook.next;
+  var nextWorkInProgressHook =
+    null === workInProgressHook
+      ? currentlyRenderingFiber$1.memoizedState
+      : workInProgressHook.next;
+  if (null !== nextWorkInProgressHook)
+    (workInProgressHook = nextWorkInProgressHook),
+      (currentHook = nextCurrentHook);
+  else {
+    if (null === nextCurrentHook) {
+      if (null === currentlyRenderingFiber$1.alternate)
+        throw Error(formatProdErrorMessage(467));
+      throw Error(formatProdErrorMessage(310));
+    }
+    currentHook = nextCurrentHook;
+    nextCurrentHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
     };
-    JSCompiler_inline_result = createFiber(18, null, null, 0);
-    JSCompiler_inline_result.stateNode = nextInstance;
-    JSCompiler_inline_result.return = fiber;
-    fiber.child = JSCompiler_inline_result;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = null;
-    return !0;
+    null === workInProgressHook
+      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
+          nextCurrentHook)
+      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
   }
-  return !1;
-}
-function shouldClientRenderOnMismatch(fiber) {
-  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
-}
-function throwOnHydrationMismatch() {
-  throw Error(formatProdErrorMessage(418));
+  return workInProgressHook;
 }
-function advanceToFirstAttemptableInstance(fiber) {
-  for (
-    ;
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    );
-
-  )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+var createFunctionComponentUpdateQueue;
+createFunctionComponentUpdateQueue = function () {
+  return { lastEffect: null, events: null, stores: null, memoCache: null };
+};
+function use(usable) {
+  if (null !== usable && "object" === typeof usable) {
+    if ("function" === typeof usable.then) {
+      var index$48 = thenableIndexCounter;
+      thenableIndexCounter += 1;
+      null === thenableState && (thenableState = []);
+      usable = trackUsedThenable(thenableState, usable, index$48);
+      null === currentlyRenderingFiber$1.alternate &&
+        (null === workInProgressHook
+          ? null === currentlyRenderingFiber$1.memoizedState
+          : null === workInProgressHook.next) &&
+        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
+      return usable;
+    }
+    if (
+      usable.$$typeof === REACT_CONTEXT_TYPE ||
+      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    )
+      return readContext(usable);
+  }
+  throw Error(formatProdErrorMessage(438, String(usable)));
 }
-function advanceToFirstAttemptableTextInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function useMemoCache(size) {
+  var memoCache = null,
+    updateQueue = currentlyRenderingFiber$1.updateQueue;
+  null !== updateQueue && (memoCache = updateQueue.memoCache);
+  if (null == memoCache) {
+    var current = currentlyRenderingFiber$1.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      null !== current &&
+        ((current = current.memoCache),
+        null != current &&
+          (memoCache = {
+            data: current.data.map(function (array) {
+              return array.slice();
+            }),
+            index: 0
+          })));
+  }
+  null == memoCache && (memoCache = { data: [], index: 0 });
+  null === updateQueue &&
+    ((updateQueue = createFunctionComponentUpdateQueue()),
+    (currentlyRenderingFiber$1.updateQueue = updateQueue));
+  updateQueue.memoCache = memoCache;
+  updateQueue = memoCache.data[memoCache.index];
+  if (void 0 === updateQueue)
+    for (
+      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
+      current < size;
+      current++
+    )
+      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
+  memoCache.index++;
+  return updateQueue;
 }
-function advanceToFirstAttemptableSuspenseInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function basicStateReducer(state, action) {
+  return "function" === typeof action ? action(state) : action;
 }
-function prepareToHydrateHostInstance(fiber) {
-  var instance = fiber.stateNode,
-    type = fiber.type,
-    props = fiber.memoizedProps;
-  instance[internalInstanceKey] = fiber;
-  instance[internalPropsKey] = props;
-  switch (type) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", instance);
-      listenToNonDelegatedEvent("close", instance);
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "video":
-    case "audio":
-      for (var i = 0; i < mediaEventTypes.length; i++)
-        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", instance);
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", instance);
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", instance);
-      break;
-    case "input":
-      initWrapperState$2(instance, props);
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "select":
-      instance._wrapperState = { wasMultiple: !!props.multiple };
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "textarea":
-      initWrapperState(instance, props),
-        listenToNonDelegatedEvent("invalid", instance);
-  }
-  assertValidProps(type, props);
-  var updatePayload = null,
-    propKey;
-  for (propKey in props)
-    props.hasOwnProperty(propKey) &&
-      ((i = props[propKey]),
-      "children" === propKey
-        ? "string" === typeof i
-          ? instance.textContent !== i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", i]))
-          : "number" === typeof i &&
-            instance.textContent !== "" + i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", "" + i]))
-        : registrationNameDependencies.hasOwnProperty(propKey) &&
-          null != i &&
-          "onScroll" === propKey &&
-          listenToNonDelegatedEvent("scroll", instance));
-  switch (type) {
-    case "input":
-      track(instance);
-      postMountWrapper$3(instance, props, !0);
-      break;
-    case "textarea":
-      track(instance);
-      postMountWrapper(instance);
-      break;
-    case "select":
-    case "option":
-      break;
-    default:
-      "function" === typeof props.onClick && (instance.onclick = noop$1);
-  }
-  instance = updatePayload;
-  fiber.updateQueue = instance;
-  return null !== instance ? !0 : !1;
-}
-function popToNextHostParent(fiber) {
-  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
-    switch (hydrationParentFiber.tag) {
-      case 3:
-      case 27:
-        rootOrSingletonContext = !0;
-        return;
-      case 5:
-      case 13:
-        rootOrSingletonContext = !1;
-        return;
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
+function updateReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var current = currentHook,
+    baseQueue = current.baseQueue,
+    pendingQueue = queue.pending;
+  if (null !== pendingQueue) {
+    if (null !== baseQueue) {
+      var baseFirst = baseQueue.next;
+      baseQueue.next = pendingQueue.next;
+      pendingQueue.next = baseFirst;
     }
-}
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) return !1;
-  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
-  var shouldClear = !1;
-  3 === fiber.tag ||
-    27 === fiber.tag ||
-    (5 === fiber.tag &&
-      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
-    (shouldClear = !0);
-  if (shouldClear && (shouldClear = nextHydratableInstance))
-    if (shouldClientRenderOnMismatch(fiber))
-      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
-    else
-      for (; shouldClear; )
-        deleteHydratableInstance(fiber, shouldClear),
-          (shouldClear = getNextHydratable(shouldClear.nextSibling));
-  popToNextHostParent(fiber);
-  if (13 === fiber.tag) {
-    fiber = fiber.memoizedState;
-    fiber = null !== fiber ? fiber.dehydrated : null;
-    if (!fiber) throw Error(formatProdErrorMessage(317));
-    a: {
-      fiber = fiber.nextSibling;
-      for (shouldClear = 0; fiber; ) {
-        if (8 === fiber.nodeType) {
-          var data = fiber.data;
-          if ("/$" === data) {
-            if (0 === shouldClear) {
-              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
-              break a;
-            }
-            shouldClear--;
-          } else
-            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
-        }
-        fiber = fiber.nextSibling;
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
+  }
+  if (null !== baseQueue) {
+    pendingQueue = baseQueue.next;
+    current = current.baseState;
+    var newBaseQueueFirst = (baseFirst = null),
+      newBaseQueueLast = null,
+      update = pendingQueue;
+    do {
+      var updateLane = update.lane & -1073741825;
+      if (
+        updateLane !== update.lane
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes$1 & updateLane) === updateLane
+      )
+        null !== newBaseQueueLast &&
+          (newBaseQueueLast = newBaseQueueLast.next =
+            {
+              lane: 0,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            }),
+          (updateLane = update.action),
+          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
+          (current = update.hasEagerState
+            ? update.eagerState
+            : reducer(current, updateLane));
+      else {
+        var clone = {
+          lane: updateLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+        null === newBaseQueueLast
+          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
+            (baseFirst = current))
+          : (newBaseQueueLast = newBaseQueueLast.next = clone);
+        currentlyRenderingFiber$1.lanes |= updateLane;
+        workInProgressRootSkippedLanes |= updateLane;
       }
-      nextHydratableInstance = null;
-    }
-  } else
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratable(fiber.stateNode.nextSibling)
-      : null;
-  return !0;
-}
-function warnIfUnhydratedTailNodes() {
-  for (var nextInstance = nextHydratableInstance; nextInstance; )
-    nextInstance = getNextHydratable(nextInstance.nextSibling);
-}
-function resetHydrationState() {
-  nextHydratableInstance = hydrationParentFiber = null;
-  isHydrating = !1;
-}
-function queueHydrationError(error) {
-  null === hydrationErrors
-    ? (hydrationErrors = [error])
-    : hydrationErrors.push(error);
-}
-var concurrentQueues = [],
-  concurrentQueuesIndex = 0,
-  concurrentlyUpdatedLanes = 0;
-function finishQueueingConcurrentUpdates() {
-  for (
-    var endIndex = concurrentQueuesIndex,
-      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
-    i < endIndex;
-
-  ) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    if (null !== queue && null !== update) {
-      var pending = queue.pending;
-      null === pending
-        ? (update.next = update)
-        : ((update.next = pending.next), (pending.next = update));
-      queue.pending = update;
-    }
-    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+      update = update.next;
+    } while (null !== update && update !== pendingQueue);
+    null === newBaseQueueLast
+      ? (baseFirst = current)
+      : (newBaseQueueLast.next = newBaseQueueFirst);
+    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = current;
+    hook.baseState = baseFirst;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = current;
   }
+  null === baseQueue && (queue.lanes = 0);
+  return [hook.memoizedState, queue.dispatch];
 }
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes |= lane;
-  fiber.lanes |= lane;
-  fiber = fiber.alternate;
-  null !== fiber && (fiber.lanes |= lane);
+function rerenderReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var dispatch = queue.dispatch,
+    lastRenderPhaseUpdate = queue.pending,
+    newState = hook.memoizedState;
+  if (null !== lastRenderPhaseUpdate) {
+    queue.pending = null;
+    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
+    do (newState = reducer(newState, update.action)), (update = update.next);
+    while (update !== lastRenderPhaseUpdate);
+    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = newState;
+    null === hook.baseQueue && (hook.baseState = newState);
+    queue.lastRenderedState = newState;
+  }
+  return [newState, dispatch];
 }
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
+function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+  var getVersion = source._getVersion;
+  getVersion = getVersion(source._source);
+  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
+  if (null !== JSCompiler_inline_result)
+    root = JSCompiler_inline_result === getVersion;
+  else if (
+    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
+  )
+    (source._workInProgressVersionPrimary = getVersion),
+      workInProgressSources.push(source);
+  if (root) return getSnapshot(source._source);
+  workInProgressSources.push(source);
+  throw Error(formatProdErrorMessage(350));
 }
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  sourceFiber.lanes |= lane;
-  var alternate = sourceFiber.alternate;
-  null !== alternate && (alternate.lanes |= lane);
-  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
-    (parent.childLanes |= lane),
-      (alternate = parent.alternate),
-      null !== alternate && (alternate.childLanes |= lane),
-      22 === parent.tag &&
-        ((sourceFiber = parent.stateNode),
-        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
-      (sourceFiber = parent),
-      (parent = parent.return);
-  isHidden &&
-    null !== update &&
-    3 === sourceFiber.tag &&
-    ((parent = sourceFiber.stateNode),
-    (isHidden = 31 - clz32(lane)),
-    (parent = parent.hiddenUpdates),
-    (sourceFiber = parent[isHidden]),
-    null === sourceFiber
-      ? (parent[isHidden] = [update])
-      : sourceFiber.push(update),
-    (update.lane = lane | 1073741824));
+function useMutableSource(hook, source, getSnapshot, subscribe) {
+  var root = workInProgressRoot;
+  if (null === root) throw Error(formatProdErrorMessage(349));
+  var getVersion = source._getVersion,
+    version = getVersion(source._source),
+    dispatcher = ReactCurrentDispatcher$1.current,
+    _dispatcher$useState = dispatcher.useState(function () {
+      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    }),
+    setSnapshot = _dispatcher$useState[1],
+    snapshot = _dispatcher$useState[0];
+  _dispatcher$useState = workInProgressHook;
+  var memoizedState = hook.memoizedState,
+    refs = memoizedState.refs,
+    prevGetSnapshot = refs.getSnapshot,
+    prevSource = memoizedState.source;
+  memoizedState = memoizedState.subscribe;
+  var fiber = currentlyRenderingFiber$1;
+  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
+  dispatcher.useEffect(
+    function () {
+      refs.getSnapshot = getSnapshot;
+      refs.setSnapshot = setSnapshot;
+      var maybeNewVersion = getVersion(source._source);
+      objectIs(version, maybeNewVersion) ||
+        ((maybeNewVersion = getSnapshot(source._source)),
+        objectIs(snapshot, maybeNewVersion) ||
+          (setSnapshot(maybeNewVersion),
+          (maybeNewVersion = requestUpdateLane(fiber)),
+          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
+        markRootEntangled(root, root.mutableReadLanes));
+    },
+    [getSnapshot, source, subscribe]
+  );
+  dispatcher.useEffect(
+    function () {
+      return subscribe(source._source, function () {
+        var latestGetSnapshot = refs.getSnapshot,
+          latestSetSnapshot = refs.setSnapshot;
+        try {
+          latestSetSnapshot(latestGetSnapshot(source._source));
+          var lane = requestUpdateLane(fiber);
+          root.mutableReadLanes |= lane & root.pendingLanes;
+        } catch (error) {
+          latestSetSnapshot(function () {
+            throw error;
+          });
+        }
+      });
+    },
+    [source, subscribe]
+  );
+  (objectIs(prevGetSnapshot, getSnapshot) &&
+    objectIs(prevSource, source) &&
+    objectIs(memoizedState, subscribe)) ||
+    ((hook = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: snapshot
+    }),
+    (hook.dispatch = setSnapshot =
+      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
+    (_dispatcher$useState.queue = hook),
+    (_dispatcher$useState.baseQueue = null),
+    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
+    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
+      snapshot));
+  return snapshot;
 }
-function getRootForUpdatedFiber(sourceFiber) {
-  if (50 < nestedUpdateCount)
-    throw (
-      ((nestedUpdateCount = 0),
-      (rootWithNestedUpdates = null),
-      Error(formatProdErrorMessage(185)))
-    );
-  for (var parent = sourceFiber.return; null !== parent; )
-    (sourceFiber = parent), (parent = sourceFiber.return);
-  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
+function updateMutableSource(source, getSnapshot, subscribe) {
+  var hook = updateWorkInProgressHook();
+  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
-var hasForceUpdate = !1;
-function initializeUpdateQueue(fiber) {
-  fiber.updateQueue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
-    callbacks: null
-  };
+function updateSyncExternalStore(subscribe, getSnapshot) {
+  var fiber = currentlyRenderingFiber$1,
+    hook = updateWorkInProgressHook(),
+    nextSnapshot = getSnapshot(),
+    snapshotChanged = !objectIs(
+      (currentHook || hook).memoizedState,
+      nextSnapshot
+    );
+  snapshotChanged &&
+    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
+  hook = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
+    subscribe
+  ]);
+  if (
+    hook.getSnapshot !== getSnapshot ||
+    snapshotChanged ||
+    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
+  ) {
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
+      void 0,
+      null
+    );
+    subscribe = workInProgressRoot;
+    if (null === subscribe) throw Error(formatProdErrorMessage(349));
+    includesBlockingLane(subscribe, renderLanes$1) ||
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+  }
+  return nextSnapshot;
 }
-function cloneUpdateQueue(current, workInProgress) {
-  current = current.updateQueue;
-  workInProgress.updateQueue === current &&
-    (workInProgress.updateQueue = {
-      baseState: current.baseState,
-      firstBaseUpdate: current.firstBaseUpdate,
-      lastBaseUpdate: current.lastBaseUpdate,
-      shared: current.shared,
-      callbacks: null
-    });
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= 16384;
+  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
+  getSnapshot = currentlyRenderingFiber$1.updateQueue;
+  null === getSnapshot
+    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
+      (getSnapshot.stores = [fiber]))
+    : ((renderedSnapshot = getSnapshot.stores),
+      null === renderedSnapshot
+        ? (getSnapshot.stores = [fiber])
+        : renderedSnapshot.push(fiber));
 }
-function createUpdate(lane) {
-  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot;
+  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
 }
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
-  if (null === updateQueue) return null;
-  updateQueue = updateQueue.shared;
-  if (
-    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
-    0 === (executionContext & 2)
-  )
-    return (
-      enqueueUpdate$1(fiber, updateQueue, update, lane),
-      getRootForUpdatedFiber(fiber)
-    );
-  var pending = updateQueue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  updateQueue.pending = update;
-  update = getRootForUpdatedFiber(fiber);
-  markUpdateLaneFromFiberToRoot(fiber, null, lane);
-  return update;
+function subscribeToStore(fiber, inst, subscribe) {
+  return subscribe(function () {
+    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+  });
 }
-function entangleTransitions(root, fiber, lane) {
-  fiber = fiber.updateQueue;
-  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
-    var queueLanes = fiber.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    fiber.lanes = lane;
-    markRootEntangled(root, lane);
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  inst = inst.value;
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(inst, nextValue);
+  } catch (error) {
+    return !0;
   }
 }
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  var queue = workInProgress.updateQueue,
-    current = workInProgress.alternate;
-  if (
-    null !== current &&
-    ((current = current.updateQueue), queue === current)
-  ) {
-    var newFirst = null,
-      newLast = null;
-    queue = queue.firstBaseUpdate;
-    if (null !== queue) {
-      do {
-        var clone = {
-          lane: queue.lane,
-          tag: queue.tag,
-          payload: queue.payload,
-          callback: null,
-          next: null
-        };
-        null === newLast
-          ? (newFirst = newLast = clone)
-          : (newLast = newLast.next = clone);
-        queue = queue.next;
-      } while (null !== queue);
-      null === newLast
-        ? (newFirst = newLast = capturedUpdate)
-        : (newLast = newLast.next = capturedUpdate);
-    } else newFirst = newLast = capturedUpdate;
-    queue = {
-      baseState: current.baseState,
-      firstBaseUpdate: newFirst,
-      lastBaseUpdate: newLast,
-      shared: current.shared,
-      callbacks: current.callbacks
-    };
-    workInProgress.updateQueue = queue;
-    return;
-  }
-  workInProgress = queue.lastBaseUpdate;
-  null === workInProgress
-    ? (queue.firstBaseUpdate = capturedUpdate)
-    : (workInProgress.next = capturedUpdate);
-  queue.lastBaseUpdate = capturedUpdate;
+function forceStoreRerender(fiber) {
+  var root = enqueueConcurrentRenderForLane(fiber, 2);
+  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
 }
-function processUpdateQueue(
-  workInProgress$jscomp$0,
-  props,
-  instance$jscomp$0,
-  renderLanes
-) {
-  var queue = workInProgress$jscomp$0.updateQueue;
-  hasForceUpdate = !1;
-  var firstBaseUpdate = queue.firstBaseUpdate,
-    lastBaseUpdate = queue.lastBaseUpdate,
-    pendingQueue = queue.shared.pending;
-  if (null !== pendingQueue) {
-    queue.shared.pending = null;
-    var lastPendingUpdate = pendingQueue,
-      firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null;
-    null === lastBaseUpdate
-      ? (firstBaseUpdate = firstPendingUpdate)
-      : (lastBaseUpdate.next = firstPendingUpdate);
-    lastBaseUpdate = lastPendingUpdate;
-    var current = workInProgress$jscomp$0.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      (pendingQueue = current.lastBaseUpdate),
-      pendingQueue !== lastBaseUpdate &&
-        (null === pendingQueue
-          ? (current.firstBaseUpdate = firstPendingUpdate)
-          : (pendingQueue.next = firstPendingUpdate),
-        (current.lastBaseUpdate = lastPendingUpdate)));
-  }
-  if (null !== firstBaseUpdate) {
-    var newState = queue.baseState;
-    lastBaseUpdate = 0;
-    current = firstPendingUpdate = lastPendingUpdate = null;
-    pendingQueue = firstBaseUpdate;
-    do {
-      var updateLane = pendingQueue.lane & -1073741825,
-        isHiddenUpdate = updateLane !== pendingQueue.lane;
-      if (
-        isHiddenUpdate
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes & updateLane) === updateLane
-      ) {
-        null !== current &&
-          (current = current.next =
-            {
-              lane: 0,
-              tag: pendingQueue.tag,
-              payload: pendingQueue.payload,
-              callback: null,
-              next: null
-            });
-        a: {
-          var workInProgress = workInProgress$jscomp$0,
-            update = pendingQueue;
-          updateLane = props;
-          var instance = instance$jscomp$0;
-          switch (update.tag) {
-            case 1:
-              workInProgress = update.payload;
-              if ("function" === typeof workInProgress) {
-                newState = workInProgress.call(instance, newState, updateLane);
-                break a;
-              }
-              newState = workInProgress;
-              break a;
-            case 3:
-              workInProgress.flags = (workInProgress.flags & -65537) | 128;
-            case 0:
-              workInProgress = update.payload;
-              updateLane =
-                "function" === typeof workInProgress
-                  ? workInProgress.call(instance, newState, updateLane)
-                  : workInProgress;
-              if (null === updateLane || void 0 === updateLane) break a;
-              newState = assign({}, newState, updateLane);
-              break a;
-            case 2:
-              hasForceUpdate = !0;
-          }
-        }
-        updateLane = pendingQueue.callback;
-        null !== updateLane &&
-          ((workInProgress$jscomp$0.flags |= 64),
-          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
-          (isHiddenUpdate = queue.callbacks),
-          null === isHiddenUpdate
-            ? (queue.callbacks = [updateLane])
-            : isHiddenUpdate.push(updateLane));
-      } else
-        (isHiddenUpdate = {
-          lane: updateLane,
-          tag: pendingQueue.tag,
-          payload: pendingQueue.payload,
-          callback: pendingQueue.callback,
-          next: null
-        }),
-          null === current
-            ? ((firstPendingUpdate = current = isHiddenUpdate),
-              (lastPendingUpdate = newState))
-            : (current = current.next = isHiddenUpdate),
-          (lastBaseUpdate |= updateLane);
-      pendingQueue = pendingQueue.next;
-      if (null === pendingQueue)
-        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
-          break;
-        else
-          (isHiddenUpdate = pendingQueue),
-            (pendingQueue = isHiddenUpdate.next),
-            (isHiddenUpdate.next = null),
-            (queue.lastBaseUpdate = isHiddenUpdate),
-            (queue.shared.pending = null);
-    } while (1);
-    null === current && (lastPendingUpdate = newState);
-    queue.baseState = lastPendingUpdate;
-    queue.firstBaseUpdate = firstPendingUpdate;
-    queue.lastBaseUpdate = current;
-    null === firstBaseUpdate && (queue.shared.lanes = 0);
-    workInProgressRootSkippedLanes |= lastBaseUpdate;
-    workInProgress$jscomp$0.lanes = lastBaseUpdate;
-    workInProgress$jscomp$0.memoizedState = newState;
-  }
+function mountState(initialState) {
+  var hook = mountWorkInProgressHook();
+  "function" === typeof initialState && (initialState = initialState());
+  hook.memoizedState = hook.baseState = initialState;
+  initialState = {
+    pending: null,
+    lanes: 0,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = initialState;
+  initialState = initialState.dispatch = dispatchSetState.bind(
+    null,
+    currentlyRenderingFiber$1,
+    initialState
+  );
+  return [hook.memoizedState, initialState];
 }
-function callCallback(callback, context) {
-  if ("function" !== typeof callback)
-    throw Error(formatProdErrorMessage(191, callback));
-  callback.call(context);
+function pushEffect(tag, create, destroy, deps) {
+  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
+  create = currentlyRenderingFiber$1.updateQueue;
+  null === create
+    ? ((create = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = create),
+      (create.lastEffect = tag.next = tag))
+    : ((destroy = create.lastEffect),
+      null === destroy
+        ? (create.lastEffect = tag.next = tag)
+        : ((deps = destroy.next),
+          (destroy.next = tag),
+          (tag.next = deps),
+          (create.lastEffect = tag)));
+  return tag;
 }
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
-  if (null !== callbacks)
-    for (
-      updateQueue.callbacks = null, updateQueue = 0;
-      updateQueue < callbacks.length;
-      updateQueue++
-    )
-      callCallback(callbacks[updateQueue], context);
+function updateRef() {
+  return updateWorkInProgressHook().memoizedState;
 }
-var SuspenseException = Error(formatProdErrorMessage(460));
-function isThenableResolved(thenable) {
-  thenable = thenable.status;
-  return "fulfilled" === thenable || "rejected" === thenable;
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = mountWorkInProgressHook();
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    1 | hookFlags,
+    create,
+    void 0,
+    void 0 === deps ? null : deps
+  );
 }
-function noop() {}
-function trackUsedThenable(thenableState, thenable, index) {
-  index = thenableState[index];
-  void 0 === index
-    ? thenableState.push(thenable)
-    : index !== thenable && (thenable.then(noop, noop), (thenable = index));
-  switch (thenable.status) {
-    case "fulfilled":
-      return thenable.value;
-    case "rejected":
-      throw thenable.reason;
-    default:
-      "string" === typeof thenable.status
-        ? thenable.then(noop, noop)
-        : ((thenableState = thenable),
-          (thenableState.status = "pending"),
-          thenableState.then(
-            function (fulfilledValue) {
-              if ("pending" === thenable.status) {
-                var fulfilledThenable = thenable;
-                fulfilledThenable.status = "fulfilled";
-                fulfilledThenable.value = fulfilledValue;
-              }
-            },
-            function (error) {
-              if ("pending" === thenable.status) {
-                var rejectedThenable = thenable;
-                rejectedThenable.status = "rejected";
-                rejectedThenable.reason = error;
-              }
-            }
-          ));
-      switch (thenable.status) {
-        case "fulfilled":
-          return thenable.value;
-        case "rejected":
-          throw thenable.reason;
-      }
-      suspendedThenable = thenable;
-      throw SuspenseException;
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var destroy = void 0;
+  if (null !== currentHook) {
+    var prevEffect = currentHook.memoizedState;
+    destroy = prevEffect.destroy;
+    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
+      return;
+    }
   }
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
 }
-var suspendedThenable = null,
-  thenableState$1 = null,
-  thenableIndexCounter$1 = 0;
-function unwrapThenable(thenable) {
-  var index = thenableIndexCounter$1;
-  thenableIndexCounter$1 += 1;
-  null === thenableState$1 && (thenableState$1 = []);
-  return trackUsedThenable(thenableState$1, thenable, index);
+function mountEffect(create, deps) {
+  mountEffectImpl(8390656, 8, create, deps);
 }
-function coerceRef(returnFiber, current, element) {
-  returnFiber = element.ref;
-  if (
-    null !== returnFiber &&
-    "function" !== typeof returnFiber &&
-    "object" !== typeof returnFiber
-  ) {
-    if (element._owner) {
-      element = element._owner;
-      if (element) {
-        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
-        var inst = element.stateNode;
-      }
-      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
-      var resolvedInst = inst,
-        stringRef = "" + returnFiber;
-      if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
-      )
-        return current.ref;
-      current = function (value) {
-        var refs = resolvedInst.refs;
-        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
-      };
-      current._stringRef = stringRef;
-      return current;
-    }
-    if ("string" !== typeof returnFiber)
-      throw Error(formatProdErrorMessage(284));
-    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
+function updateEffect(create, deps) {
+  updateEffectImpl(2048, 8, create, deps);
+}
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= 4;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+  if (null === componentUpdateQueue)
+    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
+      (componentUpdateQueue.events = [payload]);
+  else {
+    var events = componentUpdateQueue.events;
+    null === events
+      ? (componentUpdateQueue.events = [payload])
+      : events.push(payload);
   }
-  return returnFiber;
 }
-function throwOnInvalidObjectType(returnFiber, newChild) {
-  returnFiber = Object.prototype.toString.call(newChild);
-  throw Error(
-    formatProdErrorMessage(
-      31,
-      "[object Object]" === returnFiber
-        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
-        : returnFiber
-    )
-  );
+function updateEvent(callback) {
+  var ref = updateWorkInProgressHook().memoizedState;
+  useEffectEventImpl({ ref: ref, nextImpl: callback });
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
 }
-function resolveLazy(lazyType) {
-  var init = lazyType._init;
-  return init(lazyType._payload);
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(4, 2, create, deps);
 }
-function createChildReconciler(shouldTrackSideEffects) {
-  function deleteChild(returnFiber, childToDelete) {
-    if (shouldTrackSideEffects) {
-      var deletions = returnFiber.deletions;
-      null === deletions
-        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
-        : deletions.push(childToDelete);
-    }
-  }
-  function deleteRemainingChildren(returnFiber, currentFirstChild) {
-    if (!shouldTrackSideEffects) return null;
-    for (; null !== currentFirstChild; )
-      deleteChild(returnFiber, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return null;
-  }
-  function mapRemainingChildren(returnFiber, currentFirstChild) {
-    for (returnFiber = new Map(); null !== currentFirstChild; )
-      null !== currentFirstChild.key
-        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
-        : returnFiber.set(currentFirstChild.index, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return returnFiber;
-  }
-  function useFiber(fiber, pendingProps) {
-    fiber = createWorkInProgress(fiber, pendingProps);
-    fiber.index = 0;
-    fiber.sibling = null;
-    return fiber;
-  }
-  function placeChild(newFiber, lastPlacedIndex, newIndex) {
-    newFiber.index = newIndex;
-    if (!shouldTrackSideEffects)
-      return (newFiber.flags |= 1048576), lastPlacedIndex;
-    newIndex = newFiber.alternate;
-    if (null !== newIndex)
-      return (
-        (newIndex = newIndex.index),
-        newIndex < lastPlacedIndex
-          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
-          : newIndex
-      );
-    newFiber.flags |= 16777218;
-    return lastPlacedIndex;
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(4, 4, create, deps);
+}
+function imperativeHandleEffect(create, ref) {
+  if ("function" === typeof ref)
+    return (
+      (create = create()),
+      ref(create),
+      function () {
+        ref(null);
+      }
+    );
+  if (null !== ref && void 0 !== ref)
+    return (
+      (create = create()),
+      (ref.current = create),
+      function () {
+        ref.current = null;
+      }
+    );
+}
+function updateImperativeHandle(ref, create, deps) {
+  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+}
+function mountDebugValue() {}
+function updateCallback(callback, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  hook.memoizedState = [callback, deps];
+  return callback;
+}
+function updateMemo(nextCreate, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+  nextCreate = nextCreate();
+  hook.memoizedState = [nextCreate, deps];
+  return nextCreate;
+}
+function updateDeferredValueImpl(hook, prevValue, value) {
+  if (0 === (renderLanes$1 & 42))
+    return (
+      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
+      (hook.memoizedState = value)
+    );
+  objectIs(value, prevValue) ||
+    ((value = claimNextTransitionLane()),
+    (currentlyRenderingFiber$1.lanes |= value),
+    (workInProgressRootSkippedLanes |= value),
+    (hook.baseState = !0));
+  return prevValue;
+}
+function startTransition(setPending, callback, options) {
+  var previousPriority = currentUpdatePriority;
+  currentUpdatePriority =
+    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
+  setPending(!0);
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+  enableTransitionTracing &&
+    void 0 !== options &&
+    void 0 !== options.name &&
+    ((ReactCurrentBatchConfig$3.transition.name = options.name),
+    (ReactCurrentBatchConfig$3.transition.startTime = now$1()));
+  try {
+    setPending(!1), callback();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$3.transition = prevTransition);
   }
-  function placeSingleChild(newFiber) {
-    shouldTrackSideEffects &&
-      null === newFiber.alternate &&
-      (newFiber.flags |= 16777218);
-    return newFiber;
+}
+function updateId() {
+  return updateWorkInProgressHook().memoizedState;
+}
+function updateRefresh() {
+  return updateWorkInProgressHook().memoizedState;
+}
+function refreshCache(fiber, seedKey, seedValue) {
+  for (var provider = fiber.return; null !== provider; ) {
+    switch (provider.tag) {
+      case 24:
+      case 3:
+        var lane = requestUpdateLane(provider);
+        fiber = createUpdate(lane);
+        var root$54 = enqueueUpdate(provider, fiber, lane);
+        if (null !== root$54) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root$54, provider, lane, eventTime);
+          entangleTransitions(root$54, provider, lane);
+        }
+        provider = createCache();
+        null !== seedKey &&
+          void 0 !== seedKey &&
+          null !== root$54 &&
+          provider.data.set(seedKey, seedValue);
+        fiber.payload = { cache: provider };
+        return;
+    }
+    provider = provider.return;
   }
-  function updateTextNode(returnFiber, current, textContent, lanes) {
-    if (null === current || 6 !== current.tag)
-      return (
-        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, textContent);
-    current.return = returnFiber;
-    return current;
+}
+function dispatchReducerAction(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber);
+  action = {
+    lane: lane,
+    action: action,
+    hasEagerState: !1,
+    eagerState: null,
+    next: null
+  };
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
+  else if (
+    (enqueueUpdate$1(fiber, queue, action, lane),
+    (action = getRootForUpdatedFiber(fiber)),
+    null !== action)
+  ) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
+    entangleTransitionUpdate(action, queue, lane);
   }
-  function updateElement(returnFiber, current, element, lanes) {
-    var elementType = element.type;
-    if (elementType === REACT_FRAGMENT_TYPE)
-      return updateFragment(
-        returnFiber,
-        current,
-        element.props.children,
-        lanes,
-        element.key
-      );
+  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
+}
+function dispatchSetState(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber),
+    update = {
+      lane: lane,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
+  else {
+    var alternate = fiber.alternate;
     if (
-      null !== current &&
-      (current.elementType === elementType ||
-        ("object" === typeof elementType &&
-          null !== elementType &&
-          elementType.$$typeof === REACT_LAZY_TYPE &&
-          resolveLazy(elementType) === current.type))
+      0 === fiber.lanes &&
+      (null === alternate || 0 === alternate.lanes) &&
+      ((alternate = queue.lastRenderedReducer), null !== alternate)
     )
-      return (
-        (lanes = useFiber(current, element.props)),
-        (lanes.ref = coerceRef(returnFiber, current, element)),
-        (lanes.return = returnFiber),
-        lanes
-      );
-    lanes = createFiberFromTypeAndProps(
-      element.type,
-      element.key,
-      element.props,
+      try {
+        var currentState = queue.lastRenderedState,
+          eagerState = alternate(currentState, action);
+        update.hasEagerState = !0;
+        update.eagerState = eagerState;
+        if (objectIs(eagerState, currentState)) {
+          enqueueUpdate$1(fiber, queue, update, 0);
+          null === workInProgressRoot && finishQueueingConcurrentUpdates();
+          return;
+        }
+      } catch (error) {
+      } finally {
+      }
+    enqueueUpdate$1(fiber, queue, update, lane);
+    action = getRootForUpdatedFiber(fiber);
+    null !== action &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(action, fiber, lane, update),
+      entangleTransitionUpdate(action, queue, lane));
+  }
+  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
+}
+function isRenderPhaseUpdate(fiber) {
+  var alternate = fiber.alternate;
+  return (
+    fiber === currentlyRenderingFiber$1 ||
+    (null !== alternate && alternate === currentlyRenderingFiber$1)
+  );
+}
+function enqueueRenderPhaseUpdate(queue, update) {
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
+    !0;
+  var pending = queue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  queue.pending = update;
+}
+function entangleTransitionUpdate(root, queue, lane) {
+  if (0 !== (lane & 8388480)) {
+    var queueLanes = queue.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    queue.lanes = lane;
+    markRootEntangled(root, lane);
+  }
+}
+var ContextOnlyDispatcher = {
+  readContext: readContext,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useMutableSource: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+ContextOnlyDispatcher.use = throwInvalidHookError;
+ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+var HooksDispatcherOnMount = {
+  readContext: readContext,
+  useCallback: function (callback, deps) {
+    mountWorkInProgressHook().memoizedState = [
+      callback,
+      void 0 === deps ? null : deps
+    ];
+    return callback;
+  },
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: function (ref, create, deps) {
+    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+    mountEffectImpl(
+      4194308,
+      4,
+      imperativeHandleEffect.bind(null, create, ref),
+      deps
+    );
+  },
+  useLayoutEffect: function (create, deps) {
+    return mountEffectImpl(4194308, 4, create, deps);
+  },
+  useInsertionEffect: function (create, deps) {
+    mountEffectImpl(4, 2, create, deps);
+  },
+  useMemo: function (nextCreate, deps) {
+    var hook = mountWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+    nextCreate = nextCreate();
+    hook.memoizedState = [nextCreate, deps];
+    return nextCreate;
+  },
+  useReducer: function (reducer, initialArg, init) {
+    var hook = mountWorkInProgressHook();
+    initialArg = void 0 !== init ? init(initialArg) : initialArg;
+    hook.memoizedState = hook.baseState = initialArg;
+    reducer = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: reducer,
+      lastRenderedState: initialArg
+    };
+    hook.queue = reducer;
+    reducer = reducer.dispatch = dispatchReducerAction.bind(
       null,
-      returnFiber.mode,
-      lanes
+      currentlyRenderingFiber$1,
+      reducer
     );
-    lanes.ref = coerceRef(returnFiber, current, element);
-    lanes.return = returnFiber;
-    return lanes;
-  }
-  function updatePortal(returnFiber, current, portal, lanes) {
-    if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
-    )
+    return [hook.memoizedState, reducer];
+  },
+  useRef: function (initialValue) {
+    var hook = mountWorkInProgressHook();
+    if (enableUseRefAccessWarning)
       return (
-        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
+        (initialValue = { current: initialValue }),
+        (hook.memoizedState = initialValue)
       );
-    current = useFiber(current, portal.children || []);
-    current.return = returnFiber;
-    return current;
+    initialValue = { current: initialValue };
+    return (hook.memoizedState = initialValue);
+  },
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    return (mountWorkInProgressHook().memoizedState = value);
+  },
+  useTransition: function () {
+    var _mountState = mountState(!1),
+      isPending = _mountState[0];
+    _mountState = startTransition.bind(null, _mountState[1]);
+    mountWorkInProgressHook().memoizedState = _mountState;
+    return [isPending, _mountState];
+  },
+  useMutableSource: function (source, getSnapshot, subscribe) {
+    var hook = mountWorkInProgressHook();
+    hook.memoizedState = {
+      refs: { getSnapshot: getSnapshot, setSnapshot: null },
+      source: source,
+      subscribe: subscribe
+    };
+    return useMutableSource(hook, source, getSnapshot, subscribe);
+  },
+  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+    var fiber = currentlyRenderingFiber$1,
+      hook = mountWorkInProgressHook();
+    if (isHydrating) {
+      if (void 0 === getServerSnapshot)
+        throw Error(formatProdErrorMessage(407));
+      getServerSnapshot = getServerSnapshot();
+    } else {
+      getServerSnapshot = getSnapshot();
+      var root$50 = workInProgressRoot;
+      if (null === root$50) throw Error(formatProdErrorMessage(349));
+      includesBlockingLane(root$50, renderLanes$1) ||
+        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
+    }
+    hook.memoizedState = getServerSnapshot;
+    root$50 = { value: getServerSnapshot, getSnapshot: getSnapshot };
+    hook.queue = root$50;
+    mountEffect(subscribeToStore.bind(null, fiber, root$50, subscribe), [
+      subscribe
+    ]);
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(
+        null,
+        fiber,
+        root$50,
+        getServerSnapshot,
+        getSnapshot
+      ),
+      void 0,
+      null
+    );
+    return getServerSnapshot;
+  },
+  useId: function () {
+    var hook = mountWorkInProgressHook(),
+      identifierPrefix = workInProgressRoot.identifierPrefix;
+    if (isHydrating) {
+      var JSCompiler_inline_result = treeContextOverflow;
+      var idWithLeadingBit = treeContextId;
+      JSCompiler_inline_result =
+        (
+          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
+        ).toString(32) + JSCompiler_inline_result;
+      identifierPrefix =
+        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
+      JSCompiler_inline_result = localIdCounter++;
+      0 < JSCompiler_inline_result &&
+        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
+      identifierPrefix += ":";
+    } else
+      (JSCompiler_inline_result = globalClientIdCounter++),
+        (identifierPrefix =
+          ":" +
+          identifierPrefix +
+          "r" +
+          JSCompiler_inline_result.toString(32) +
+          ":");
+    return (hook.memoizedState = identifierPrefix);
+  },
+  useCacheRefresh: function () {
+    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
+      null,
+      currentlyRenderingFiber$1
+    ));
   }
-  function updateFragment(returnFiber, current, fragment, lanes, key) {
-    if (null === current || 7 !== current.tag)
-      return (
-        (current = createFiberFromFragment(
-          fragment,
-          returnFiber.mode,
-          lanes,
-          key
-        )),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, fragment);
-    current.return = returnFiber;
-    return current;
+};
+HooksDispatcherOnMount.use = use;
+HooksDispatcherOnMount.useMemoCache = useMemoCache;
+HooksDispatcherOnMount.useEffectEvent = function (callback) {
+  var hook = mountWorkInProgressHook(),
+    ref = { impl: callback };
+  hook.memoizedState = ref;
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
+};
+var HooksDispatcherOnUpdate = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: function () {
+    return updateReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = updateReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
+HooksDispatcherOnUpdate.use = use;
+HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+var HooksDispatcherOnRerender = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: function () {
+    return rerenderReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return null === currentHook
+      ? (hook.memoizedState = value)
+      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = rerenderReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+HooksDispatcherOnRerender.use = use;
+HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+var now = Scheduler.unstable_now,
+  commitTime = 0,
+  layoutEffectStartTime = -1,
+  profilerStartTime = -1,
+  passiveEffectStartTime = -1,
+  currentUpdateIsNested = !1,
+  nestedUpdateScheduled = !1;
+function startProfilerTimer(fiber) {
+  profilerStartTime = now();
+  0 > fiber.actualStartTime && (fiber.actualStartTime = now());
+}
+function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+  if (0 <= profilerStartTime) {
+    var elapsedTime = now() - profilerStartTime;
+    fiber.actualDuration += elapsedTime;
+    overrideBaseTime && (fiber.selfBaseDuration = elapsedTime);
+    profilerStartTime = -1;
   }
-  function createChild(returnFiber, newChild, lanes) {
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return (
-        (newChild = createFiberFromText(
-          "" + newChild,
-          returnFiber.mode,
-          lanes
-        )),
-        (newChild.return = returnFiber),
-        newChild
-      );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (lanes = createFiberFromTypeAndProps(
-              newChild.type,
-              newChild.key,
-              newChild.props,
-              null,
-              returnFiber.mode,
-              lanes
-            )),
-            (lanes.ref = coerceRef(returnFiber, null, newChild)),
-            (lanes.return = returnFiber),
-            lanes
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (newChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (newChild.return = returnFiber),
-            newChild
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return createChild(returnFiber, init(newChild._payload), lanes);
+}
+function recordLayoutEffectDuration(fiber) {
+  if (0 <= layoutEffectStartTime) {
+    var elapsedTime = now() - layoutEffectStartTime;
+    layoutEffectStartTime = -1;
+    for (fiber = fiber.return; null !== fiber; ) {
+      switch (fiber.tag) {
+        case 3:
+          fiber.stateNode.effectDuration += elapsedTime;
+          return;
+        case 12:
+          fiber.stateNode.effectDuration += elapsedTime;
+          return;
       }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (newChild = createFiberFromFragment(
-            newChild,
-            returnFiber.mode,
-            lanes,
-            null
-          )),
-          (newChild.return = returnFiber),
-          newChild
-        );
-      if ("function" === typeof newChild.then)
-        return createChild(returnFiber, unwrapThenable(newChild), lanes);
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return createChild(
-          returnFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
+      fiber = fiber.return;
     }
-    return null;
   }
-  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
-    var key = null !== oldFiber ? oldFiber.key : null;
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return null !== key
-        ? null
-        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return newChild.key === key
-            ? updateElement(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_PORTAL_TYPE:
-          return newChild.key === key
-            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_LAZY_TYPE:
-          return (
-            (key = newChild._init),
-            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
-          );
+}
+function recordPassiveEffectDuration(fiber) {
+  if (0 <= passiveEffectStartTime) {
+    var elapsedTime = now() - passiveEffectStartTime;
+    passiveEffectStartTime = -1;
+    for (fiber = fiber.return; null !== fiber; ) {
+      switch (fiber.tag) {
+        case 3:
+          fiber = fiber.stateNode;
+          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
+          return;
+        case 12:
+          fiber = fiber.stateNode;
+          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
+          return;
       }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return null !== key
-          ? null
-          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
-      if ("function" === typeof newChild.then)
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
+      fiber = fiber.return;
     }
-    return null;
   }
-  function updateFromMap(
-    existingChildren,
-    returnFiber,
-    newIdx,
-    newChild,
-    lanes
-  ) {
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return (
-        (existingChildren = existingChildren.get(newIdx) || null),
-        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
-      );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updateElement(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updatePortal(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return updateFromMap(
-            existingChildren,
-            returnFiber,
-            newIdx,
-            init(newChild._payload),
-            lanes
-          );
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (existingChildren = existingChildren.get(newIdx) || null),
-          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
-        );
-      if ("function" === typeof newChild.then)
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
+}
+function startLayoutEffectTimer() {
+  layoutEffectStartTime = now();
+}
+function transferActualDuration(fiber) {
+  for (var child = fiber.child; child; )
+    (fiber.actualDuration += child.actualDuration), (child = child.sibling);
+}
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    baseProps = assign({}, baseProps);
+    Component = Component.defaultProps;
+    for (var propName in Component)
+      void 0 === baseProps[propName] &&
+        (baseProps[propName] = Component[propName]);
+    return baseProps;
   }
-  function reconcileChildrenArray(
-    returnFiber,
-    currentFirstChild,
-    newChildren,
-    lanes
-  ) {
-    for (
-      var resultingFirstChild = null,
-        previousNewFiber = null,
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null;
-      null !== oldFiber && newIdx < newChildren.length;
-      newIdx++
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(
-        returnFiber,
-        oldFiber,
-        newChildren[newIdx],
-        lanes
-      );
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
-      }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (resultingFirstChild = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
-    }
-    if (newIdx === newChildren.length)
-      return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        resultingFirstChild
-      );
-    if (null === oldFiber) {
-      for (; newIdx < newChildren.length; newIdx++)
-        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
-          null !== oldFiber &&
-            ((currentFirstChild = placeChild(
-              oldFiber,
-              currentFirstChild,
-              newIdx
-            )),
-            null === previousNewFiber
-              ? (resultingFirstChild = oldFiber)
-              : (previousNewFiber.sibling = oldFiber),
-            (previousNewFiber = oldFiber));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return resultingFirstChild;
-    }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      newIdx < newChildren.length;
-      newIdx++
-    )
-      (nextOldFiber = updateFromMap(
-        oldFiber,
-        returnFiber,
-        newIdx,
-        newChildren[newIdx],
-        lanes
-      )),
-        null !== nextOldFiber &&
-          (shouldTrackSideEffects &&
-            null !== nextOldFiber.alternate &&
-            oldFiber.delete(
-              null === nextOldFiber.key ? newIdx : nextOldFiber.key
-            ),
-          (currentFirstChild = placeChild(
-            nextOldFiber,
-            currentFirstChild,
-            newIdx
-          )),
-          null === previousNewFiber
-            ? (resultingFirstChild = nextOldFiber)
-            : (previousNewFiber.sibling = nextOldFiber),
-          (previousNewFiber = nextOldFiber));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return resultingFirstChild;
+  return baseProps;
+}
+function applyDerivedStateFromProps(
+  workInProgress,
+  ctor,
+  getDerivedStateFromProps,
+  nextProps
+) {
+  ctor = workInProgress.memoizedState;
+  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+  getDerivedStateFromProps =
+    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
+      ? ctor
+      : assign({}, ctor, getDerivedStateFromProps);
+  workInProgress.memoizedState = getDerivedStateFromProps;
+  0 === workInProgress.lanes &&
+    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
+}
+var classComponentUpdater = {
+  isMounted: function (component) {
+    return (component = component._reactInternals)
+      ? getNearestMountedFiber(component) === component
+      : !1;
+  },
+  enqueueSetState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
+  },
+  enqueueReplaceState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 1;
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
+  },
+  enqueueForceUpdate: function (inst, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 2;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    callback = enqueueUpdate(inst, update, lane);
+    null !== callback &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(callback, inst, lane, update),
+      entangleTransitions(callback, inst, lane));
+    enableSchedulingProfiler &&
+      enableSchedulingProfiler &&
+      null !== injectedProfilingHooks &&
+      "function" === typeof injectedProfilingHooks.markForceUpdateScheduled &&
+      injectedProfilingHooks.markForceUpdateScheduled(inst, lane);
   }
-  function reconcileChildrenIterator(
-    returnFiber,
-    currentFirstChild,
-    newChildrenIterable,
-    lanes
-  ) {
-    var iteratorFn = getIteratorFn(newChildrenIterable);
-    if ("function" !== typeof iteratorFn)
-      throw Error(formatProdErrorMessage(150));
-    newChildrenIterable = iteratorFn.call(newChildrenIterable);
-    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
-    for (
-      var previousNewFiber = (iteratorFn = null),
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null,
-        step = newChildrenIterable.next();
-      null !== oldFiber && !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
-      }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (iteratorFn = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
-    }
-    if (step.done)
-      return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        iteratorFn
-      );
-    if (null === oldFiber) {
-      for (; !step.done; newIdx++, step = newChildrenIterable.next())
-        (step = createChild(returnFiber, step.value, lanes)),
-          null !== step &&
-            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-            null === previousNewFiber
-              ? (iteratorFn = step)
-              : (previousNewFiber.sibling = step),
-            (previousNewFiber = step));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return iteratorFn;
-    }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    )
-      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
-        null !== step &&
-          (shouldTrackSideEffects &&
-            null !== step.alternate &&
-            oldFiber.delete(null === step.key ? newIdx : step.key),
-          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-          null === previousNewFiber
-            ? (iteratorFn = step)
-            : (previousNewFiber.sibling = step),
-          (previousNewFiber = step));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return iteratorFn;
+};
+function checkShouldComponentUpdate(
+  workInProgress,
+  ctor,
+  oldProps,
+  newProps,
+  oldState,
+  newState,
+  nextContext
+) {
+  workInProgress = workInProgress.stateNode;
+  return "function" === typeof workInProgress.shouldComponentUpdate
+    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
+    : ctor.prototype && ctor.prototype.isPureReactComponent
+    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
+    : !0;
+}
+function constructClassInstance(workInProgress, ctor, props) {
+  var context = emptyContextObject,
+    contextType = ctor.contextType;
+  "object" === typeof contextType &&
+    null !== contextType &&
+    (context = readContext(contextType));
+  ctor = new ctor(props, context);
+  workInProgress.memoizedState =
+    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+  ctor.updater = classComponentUpdater;
+  workInProgress.stateNode = ctor;
+  ctor._reactInternals = workInProgress;
+  return ctor;
+}
+function callComponentWillReceiveProps(
+  workInProgress,
+  instance,
+  newProps,
+  nextContext
+) {
+  workInProgress = instance.state;
+  "function" === typeof instance.componentWillReceiveProps &&
+    instance.componentWillReceiveProps(newProps, nextContext);
+  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  instance.state !== workInProgress &&
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+}
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  var instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  var contextType = ctor.contextType;
+  instance.context =
+    "object" === typeof contextType && null !== contextType
+      ? readContext(contextType)
+      : emptyContextObject;
+  instance.state = workInProgress.memoizedState;
+  contextType = ctor.getDerivedStateFromProps;
+  "function" === typeof contextType &&
+    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof ctor.getDerivedStateFromProps ||
+    "function" === typeof instance.getSnapshotBeforeUpdate ||
+    ("function" !== typeof instance.UNSAFE_componentWillMount &&
+      "function" !== typeof instance.componentWillMount) ||
+    ((ctor = instance.state),
+    "function" === typeof instance.componentWillMount &&
+      instance.componentWillMount(),
+    "function" === typeof instance.UNSAFE_componentWillMount &&
+      instance.UNSAFE_componentWillMount(),
+    ctor !== instance.state &&
+      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof instance.componentDidMount &&
+    (workInProgress.flags |= 4194308);
+}
+function createCapturedValueAtFiber(value, source) {
+  try {
+    var info = "",
+      node = source;
+    do (info += describeFiber(node)), (node = node.return);
+    while (node);
+    var JSCompiler_inline_result = info;
+  } catch (x) {
+    JSCompiler_inline_result =
+      "\nError generating stack: " + x.message + "\n" + x.stack;
   }
-  function reconcileChildFibersImpl(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    "object" === typeof newChild &&
-      null !== newChild &&
-      newChild.type === REACT_FRAGMENT_TYPE &&
-      null === newChild.key &&
-      (newChild = newChild.props.children);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          a: {
-            for (
-              var key = newChild.key, child = currentFirstChild;
-              null !== child;
-
-            ) {
-              if (child.key === key) {
-                key = newChild.type;
-                if (key === REACT_FRAGMENT_TYPE) {
-                  if (7 === child.tag) {
-                    deleteRemainingChildren(returnFiber, child.sibling);
-                    currentFirstChild = useFiber(
-                      child,
-                      newChild.props.children
-                    );
-                    currentFirstChild.return = returnFiber;
-                    returnFiber = currentFirstChild;
-                    break a;
-                  }
-                } else if (
-                  child.elementType === key ||
-                  ("object" === typeof key &&
-                    null !== key &&
-                    key.$$typeof === REACT_LAZY_TYPE &&
-                    resolveLazy(key) === child.type)
-                ) {
-                  deleteRemainingChildren(returnFiber, child.sibling);
-                  currentFirstChild = useFiber(child, newChild.props);
-                  currentFirstChild.ref = coerceRef(
-                    returnFiber,
-                    child,
-                    newChild
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                }
-                deleteRemainingChildren(returnFiber, child);
-                break;
-              } else deleteChild(returnFiber, child);
-              child = child.sibling;
-            }
-            newChild.type === REACT_FRAGMENT_TYPE
-              ? ((currentFirstChild = createFiberFromFragment(
-                  newChild.props.children,
-                  returnFiber.mode,
-                  lanes,
-                  newChild.key
-                )),
-                (currentFirstChild.return = returnFiber),
-                (returnFiber = currentFirstChild))
-              : ((lanes = createFiberFromTypeAndProps(
-                  newChild.type,
-                  newChild.key,
-                  newChild.props,
-                  null,
-                  returnFiber.mode,
-                  lanes
-                )),
-                (lanes.ref = coerceRef(
-                  returnFiber,
-                  currentFirstChild,
-                  newChild
-                )),
-                (lanes.return = returnFiber),
-                (returnFiber = lanes));
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_PORTAL_TYPE:
-          a: {
-            for (child = newChild.key; null !== currentFirstChild; ) {
-              if (currentFirstChild.key === child)
-                if (
-                  4 === currentFirstChild.tag &&
-                  currentFirstChild.stateNode.containerInfo ===
-                    newChild.containerInfo &&
-                  currentFirstChild.stateNode.implementation ===
-                    newChild.implementation
-                ) {
-                  deleteRemainingChildren(
-                    returnFiber,
-                    currentFirstChild.sibling
-                  );
-                  currentFirstChild = useFiber(
-                    currentFirstChild,
-                    newChild.children || []
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                } else {
-                  deleteRemainingChildren(returnFiber, currentFirstChild);
-                  break;
-                }
-              else deleteChild(returnFiber, currentFirstChild);
-              currentFirstChild = currentFirstChild.sibling;
-            }
-            currentFirstChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            );
-            currentFirstChild.return = returnFiber;
-            returnFiber = currentFirstChild;
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_LAZY_TYPE:
-          return (
-            (child = newChild._init),
-            reconcileChildFibers(
-              returnFiber,
-              currentFirstChild,
-              child(newChild._payload),
-              lanes
-            )
-          );
-      }
-      if (isArrayImpl(newChild))
-        return reconcileChildrenArray(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if (getIteratorFn(newChild))
-        return reconcileChildrenIterator(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if ("function" === typeof newChild.then)
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-      ? ((newChild = "" + newChild),
-        null !== currentFirstChild && 6 === currentFirstChild.tag
-          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
-            (currentFirstChild = useFiber(currentFirstChild, newChild)),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild))
-          : (deleteRemainingChildren(returnFiber, currentFirstChild),
-            (currentFirstChild = createFiberFromText(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild)),
-        placeSingleChild(returnFiber))
-      : deleteRemainingChildren(returnFiber, currentFirstChild);
-  }
-  function reconcileChildFibers(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    thenableIndexCounter$1 = 0;
-    returnFiber = reconcileChildFibersImpl(
-      returnFiber,
-      currentFirstChild,
-      newChild,
-      lanes
-    );
-    thenableState$1 = null;
-    return returnFiber;
-  }
-  return reconcileChildFibers;
-}
-var reconcileChildFibers = createChildReconciler(!0),
-  mountChildFibers = createChildReconciler(!1),
-  currentTreeHiddenStackCursor = createCursor(null),
-  prevRenderLanesStackCursor = createCursor(0);
-function pushHiddenContext(fiber, context) {
-  fiber = renderLanes;
-  push(prevRenderLanesStackCursor, fiber);
-  push(currentTreeHiddenStackCursor, context);
-  renderLanes = fiber | context.baseLanes;
-}
-function reuseHiddenContextOnStack() {
-  push(prevRenderLanesStackCursor, renderLanes);
-  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
-}
-function popHiddenContext() {
-  renderLanes = prevRenderLanesStackCursor.current;
-  pop(currentTreeHiddenStackCursor);
-  pop(prevRenderLanesStackCursor);
-}
-var suspenseHandlerStackCursor = createCursor(null),
-  shellBoundary = null;
-function pushPrimaryTreeSuspenseHandler(handler) {
-  var current = handler.alternate;
-  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
-  (null !== current && null === currentTreeHiddenStackCursor.current)
-    ? (push(suspenseHandlerStackCursor, handler),
-      null === shellBoundary &&
-        (null === current || null !== currentTreeHiddenStackCursor.current
-          ? (shellBoundary = handler)
-          : null !== current.memoizedState && (shellBoundary = handler)))
-    : null === shellBoundary
-    ? push(suspenseHandlerStackCursor, handler)
-    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
-}
-function pushOffscreenSuspenseHandler(fiber) {
-  if (22 === fiber.tag) {
-    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
-      var current = fiber.alternate;
-      null !== current &&
-        null !== current.memoizedState &&
-        (shellBoundary = fiber);
-    }
-  } else reuseSuspenseHandlerOnStack();
-}
-function reuseSuspenseHandlerOnStack() {
-  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+  return {
+    value: value,
+    source: source,
+    stack: JSCompiler_inline_result,
+    digest: null
+  };
 }
-function popSuspenseHandler(fiber) {
-  pop(suspenseHandlerStackCursor);
-  shellBoundary === fiber && (shellBoundary = null);
+function createCapturedValue(value, digest, stack) {
+  return {
+    value: value,
+    source: null,
+    stack: null != stack ? stack : null,
+    digest: null != digest ? digest : null
+  };
 }
-var suspenseStackCursor = createCursor(0);
-function findFirstSuspended(row) {
-  for (var node = row; null !== node; ) {
-    if (13 === node.tag) {
-      var state = node.memoizedState;
-      if (
-        null !== state &&
-        ((state = state.dehydrated),
-        null === state || "$?" === state.data || "$!" === state.data)
-      )
-        return node;
-    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
-      if (0 !== (node.flags & 128)) return node;
-    } else if (null !== node.child) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
-    if (node === row) break;
-    for (; null === node.sibling; ) {
-      if (null === node.return || node.return === row) return null;
-      node = node.return;
-    }
-    node.sibling.return = node.return;
-    node = node.sibling;
+var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
+if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
+  throw Error(formatProdErrorMessage(320));
+function logCapturedError(boundary, errorInfo) {
+  try {
+    !1 !==
+      ReactFiberErrorDialogWWW.showErrorDialog({
+        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
+        error: errorInfo.value,
+        errorBoundary:
+          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
+      }) && console.error(errorInfo.value);
+  } catch (e) {
+    setTimeout(function () {
+      throw e;
+    });
   }
-  return null;
-}
-var workInProgressSources = [];
-function resetWorkInProgressVersions() {
-  for (var i = 0; i < workInProgressSources.length; i++)
-    workInProgressSources[i]._workInProgressVersionPrimary = null;
-  workInProgressSources.length = 0;
 }
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
-  renderLanes$1 = 0,
-  currentlyRenderingFiber$1 = null,
-  currentHook = null,
-  workInProgressHook = null,
-  didScheduleRenderPhaseUpdate = !1,
-  didScheduleRenderPhaseUpdateDuringThisPass = !1,
-  shouldDoubleInvokeUserFnsInHooksDEV = !1,
-  localIdCounter = 0,
-  thenableIndexCounter = 0,
-  thenableState = null,
-  globalClientIdCounter = 0;
-function throwInvalidHookError() {
-  throw Error(formatProdErrorMessage(321));
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  lane.payload = { element: null };
+  var error = errorInfo.value;
+  lane.callback = function () {
+    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
+    logCapturedError(fiber, errorInfo);
+  };
+  return lane;
 }
-function areHookInputsEqual(nextDeps, prevDeps) {
-  if (null === prevDeps) return !1;
-  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
-    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
-  return !0;
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+  if ("function" === typeof getDerivedStateFromError) {
+    var error = errorInfo.value;
+    lane.payload = function () {
+      return getDerivedStateFromError(error);
+    };
+    lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+    };
+  }
+  var inst = fiber.stateNode;
+  null !== inst &&
+    "function" === typeof inst.componentDidCatch &&
+    (lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+      "function" !== typeof getDerivedStateFromError &&
+        (null === legacyErrorBoundariesThatAlreadyFailed
+          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
+          : legacyErrorBoundariesThatAlreadyFailed.add(this));
+      var stack = errorInfo.stack;
+      this.componentDidCatch(errorInfo.value, {
+        componentStack: null !== stack ? stack : ""
+      });
+    });
+  return lane;
 }
-function renderWithHooks(
-  current,
-  workInProgress,
-  Component,
-  props,
-  secondArg,
-  nextRenderLanes
+function markSuspenseBoundaryShouldCapture(
+  suspenseBoundary,
+  returnFiber,
+  sourceFiber,
+  root,
+  rootRenderLanes
 ) {
-  renderLanes$1 = nextRenderLanes;
-  currentlyRenderingFiber$1 = workInProgress;
-  workInProgress.memoizedState = null;
-  workInProgress.updateQueue = null;
-  workInProgress.lanes = 0;
-  ReactCurrentDispatcher$1.current =
-    null === current || null === current.memoizedState
-      ? HooksDispatcherOnMount
-      : HooksDispatcherOnUpdate;
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  nextRenderLanes = Component(props, secondArg);
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  didScheduleRenderPhaseUpdateDuringThisPass &&
-    (nextRenderLanes = renderWithHooksAgain(
-      workInProgress,
-      Component,
-      props,
-      secondArg
-    ));
-  finishRenderingHooks(current);
-  return nextRenderLanes;
-}
-function finishRenderingHooks(current) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdate = !1;
-  thenableIndexCounter = 0;
-  thenableState = null;
-  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
-  enableLazyContextPropagation &&
-    null !== current &&
-    !didReceiveUpdate &&
-    ((current = current.dependencies),
-    null !== current &&
-      checkIfContextChanged(current) &&
-      (didReceiveUpdate = !0));
-}
-function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
-  var numberOfReRenders = 0;
-  do {
-    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
-    thenableIndexCounter = 0;
-    didScheduleRenderPhaseUpdateDuringThisPass = !1;
-    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
-    numberOfReRenders += 1;
-    workInProgressHook = currentHook = null;
-    workInProgress.updateQueue = null;
-    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
-    var children = Component(props, secondArg);
-  } while (didScheduleRenderPhaseUpdateDuringThisPass);
-  return children;
-}
-function checkDidRenderIdHook() {
-  var didRenderIdHook = 0 !== localIdCounter;
-  localIdCounter = 0;
-  return didRenderIdHook;
+  if (0 === (suspenseBoundary.mode & 1))
+    return (
+      suspenseBoundary === returnFiber
+        ? (suspenseBoundary.flags |= 65536)
+        : ((suspenseBoundary.flags |= 128),
+          (sourceFiber.flags |= 131072),
+          (sourceFiber.flags &= -52805),
+          1 === sourceFiber.tag &&
+            (null === sourceFiber.alternate
+              ? (sourceFiber.tag = 17)
+              : ((returnFiber = createUpdate(2)),
+                (returnFiber.tag = 2),
+                enqueueUpdate(sourceFiber, returnFiber, 2))),
+          (sourceFiber.lanes |= 2)),
+      suspenseBoundary
+    );
+  suspenseBoundary.flags |= 65536;
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
 }
-function bailoutHooks(current, workInProgress, lanes) {
-  workInProgress.updateQueue = current.updateQueue;
-  workInProgress.flags &= -2053;
-  current.lanes &= ~lanes;
+function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
+  if (enableTransitionTracing && null !== pendingTransitions) {
+    var transitionStart = pendingTransitions.transitionStart,
+      onTransitionStart = callbacks.onTransitionStart;
+    null !== transitionStart &&
+      null != onTransitionStart &&
+      transitionStart.forEach(function (transition) {
+        return onTransitionStart(transition.name, transition.startTime);
+      });
+    transitionStart = pendingTransitions.markerProgress;
+    var onMarkerProgress = callbacks.onMarkerProgress;
+    null != onMarkerProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (markerInstance, markerName) {
+        if (null !== markerInstance.transitions) {
+          var pending =
+            null !== markerInstance.pendingBoundaries
+              ? Array.from(markerInstance.pendingBoundaries.values())
+              : [];
+          markerInstance.transitions.forEach(function (transition) {
+            onMarkerProgress(
+              transition.name,
+              markerName,
+              transition.startTime,
+              endTime,
+              pending
+            );
+          });
+        }
+      });
+    transitionStart = pendingTransitions.markerComplete;
+    var onMarkerComplete = callbacks.onMarkerComplete;
+    null !== transitionStart &&
+      null != onMarkerComplete &&
+      transitionStart.forEach(function (transitions, markerName) {
+        transitions.forEach(function (transition) {
+          onMarkerComplete(
+            transition.name,
+            markerName,
+            transition.startTime,
+            endTime
+          );
+        });
+      });
+    transitionStart = pendingTransitions.markerIncomplete;
+    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
+    null != onMarkerIncomplete &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (_ref, markerName) {
+        var aborts = _ref.aborts;
+        _ref.transitions.forEach(function (transition) {
+          var filteredAborts = [];
+          aborts.forEach(function (abort) {
+            switch (abort.reason) {
+              case "marker":
+                filteredAborts.push({
+                  type: "marker",
+                  name: abort.name,
+                  endTime: endTime
+                });
+                break;
+              case "suspense":
+                filteredAborts.push({
+                  type: "suspense",
+                  name: abort.name,
+                  endTime: endTime
+                });
+            }
+          });
+          0 < filteredAborts.length &&
+            onMarkerIncomplete(
+              transition.name,
+              markerName,
+              transition.startTime,
+              filteredAborts
+            );
+        });
+      });
+    transitionStart = pendingTransitions.transitionProgress;
+    var onTransitionProgress = callbacks.onTransitionProgress;
+    null != onTransitionProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (pending, transition) {
+        onTransitionProgress(
+          transition.name,
+          transition.startTime,
+          endTime,
+          Array.from(pending.values())
+        );
+      });
+    pendingTransitions = pendingTransitions.transitionComplete;
+    var onTransitionComplete = callbacks.onTransitionComplete;
+    null !== pendingTransitions &&
+      null != onTransitionComplete &&
+      pendingTransitions.forEach(function (transition) {
+        return onTransitionComplete(
+          transition.name,
+          transition.startTime,
+          endTime
+        );
+      });
+  }
 }
-function resetHooksOnUnwind() {
-  if (didScheduleRenderPhaseUpdate) {
-    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
-      var queue = hook.queue;
-      null !== queue && (queue.pending = null);
-      hook = hook.next;
-    }
-    didScheduleRenderPhaseUpdate = !1;
+var markerInstanceStack = createCursor(null);
+function pushRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    var transitions = workInProgressTransitions,
+      root$66 = workInProgress.stateNode;
+    null !== transitions &&
+      transitions.forEach(function (transition) {
+        if (!root$66.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: 0,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root$66.incompleteTransitions.set(transition, markerInstance);
+        }
+      });
+    var markerInstances = [];
+    root$66.incompleteTransitions.forEach(function (markerInstance) {
+      markerInstances.push(markerInstance);
+    });
+    push(markerInstanceStack, markerInstances);
   }
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdateDuringThisPass = !1;
-  thenableIndexCounter = localIdCounter = 0;
-  thenableState = null;
 }
-function mountWorkInProgressHook() {
-  var hook = {
-    memoizedState: null,
-    baseState: null,
-    baseQueue: null,
-    queue: null,
-    next: null
-  };
-  null === workInProgressHook
-    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
-    : (workInProgressHook = workInProgressHook.next = hook);
-  return workInProgressHook;
+function pushMarkerInstance(workInProgress, markerInstance) {
+  enableTransitionTracing &&
+    (null === markerInstanceStack.current
+      ? push(markerInstanceStack, [markerInstance])
+      : push(
+          markerInstanceStack,
+          markerInstanceStack.current.concat(markerInstance)
+        ));
 }
-function updateWorkInProgressHook() {
-  if (null === currentHook) {
-    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
-    nextCurrentHook =
-      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
-  } else nextCurrentHook = currentHook.next;
-  var nextWorkInProgressHook =
-    null === workInProgressHook
-      ? currentlyRenderingFiber$1.memoizedState
-      : workInProgressHook.next;
-  if (null !== nextWorkInProgressHook)
-    (workInProgressHook = nextWorkInProgressHook),
-      (currentHook = nextCurrentHook);
-  else {
-    if (null === nextCurrentHook) {
-      if (null === currentlyRenderingFiber$1.alternate)
-        throw Error(formatProdErrorMessage(467));
-      throw Error(formatProdErrorMessage(310));
-    }
-    currentHook = nextCurrentHook;
-    nextCurrentHook = {
-      memoizedState: currentHook.memoizedState,
-      baseState: currentHook.baseState,
-      baseQueue: currentHook.baseQueue,
-      queue: currentHook.queue,
-      next: null
-    };
-    null === workInProgressHook
-      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
-          nextCurrentHook)
-      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
-  }
-  return workInProgressHook;
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
+  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
+  didReceiveUpdate = !1;
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  workInProgress.child =
+    null === current
+      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
+      : reconcileChildFibers(
+          workInProgress,
+          current.child,
+          nextChildren,
+          renderLanes
+        );
 }
-var createFunctionComponentUpdateQueue;
-createFunctionComponentUpdateQueue = function () {
-  return { lastEffect: null, events: null, stores: null, memoCache: null };
-};
-function use(usable) {
-  if (null !== usable && "object" === typeof usable) {
-    if ("function" === typeof usable.then) {
-      var index$91 = thenableIndexCounter;
-      thenableIndexCounter += 1;
-      null === thenableState && (thenableState = []);
-      usable = trackUsedThenable(thenableState, usable, index$91);
-      null === currentlyRenderingFiber$1.alternate &&
-        (null === workInProgressHook
-          ? null === currentlyRenderingFiber$1.memoizedState
-          : null === workInProgressHook.next) &&
-        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
-      return usable;
-    }
+function updateForwardRef(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  Component = Component.render;
+  var ref = workInProgress.ref;
+  prepareToReadContext(workInProgress, renderLanes);
+  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+  nextProps = renderWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    ref,
+    renderLanes
+  );
+  Component = checkDidRenderIdHook();
+  enableSchedulingProfiler && markComponentRenderStopped();
+  if (null !== current && !didReceiveUpdate)
+    return (
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+    );
+  isHydrating && Component && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, nextProps, renderLanes);
+  return workInProgress.child;
+}
+function updateMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null === current) {
+    var type = Component.type;
     if (
-      usable.$$typeof === REACT_CONTEXT_TYPE ||
-      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      "function" === typeof type &&
+      !shouldConstruct(type) &&
+      void 0 === type.defaultProps &&
+      null === Component.compare &&
+      void 0 === Component.defaultProps
     )
-      return readContext(usable);
+      return (
+        (workInProgress.tag = 15),
+        (workInProgress.type = type),
+        updateSimpleMemoComponent(
+          current,
+          workInProgress,
+          type,
+          nextProps,
+          renderLanes
+        )
+      );
+    current = createFiberFromTypeAndProps(
+      Component.type,
+      null,
+      nextProps,
+      workInProgress,
+      workInProgress.mode,
+      renderLanes
+    );
+    current.ref = workInProgress.ref;
+    current.return = workInProgress;
+    return (workInProgress.child = current);
   }
-  throw Error(formatProdErrorMessage(438, String(usable)));
-}
-function useMemoCache(size) {
-  var memoCache = null,
-    updateQueue = currentlyRenderingFiber$1.updateQueue;
-  null !== updateQueue && (memoCache = updateQueue.memoCache);
-  if (null == memoCache) {
-    var current = currentlyRenderingFiber$1.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      null !== current &&
-        ((current = current.memoCache),
-        null != current &&
-          (memoCache = {
-            data: current.data.map(function (array) {
-              return array.slice();
-            }),
-            index: 0
-          })));
+  type = current.child;
+  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+    var prevProps = type.memoizedProps;
+    Component = Component.compare;
+    Component = null !== Component ? Component : shallowEqual;
+    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
-  null == memoCache && (memoCache = { data: [], index: 0 });
-  null === updateQueue &&
-    ((updateQueue = createFunctionComponentUpdateQueue()),
-    (currentlyRenderingFiber$1.updateQueue = updateQueue));
-  updateQueue.memoCache = memoCache;
-  updateQueue = memoCache.data[memoCache.index];
-  if (void 0 === updateQueue)
-    for (
-      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
-      current < size;
-      current++
-    )
-      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
-  memoCache.index++;
-  return updateQueue;
-}
-function basicStateReducer(state, action) {
-  return "function" === typeof action ? action(state) : action;
+  workInProgress.flags |= 1;
+  current = createWorkInProgress(type, nextProps);
+  current.ref = workInProgress.ref;
+  current.return = workInProgress;
+  return (workInProgress.child = current);
 }
-function updateReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var current = currentHook,
-    baseQueue = current.baseQueue,
-    pendingQueue = queue.pending;
-  if (null !== pendingQueue) {
-    if (null !== baseQueue) {
-      var baseFirst = baseQueue.next;
-      baseQueue.next = pendingQueue.next;
-      pendingQueue.next = baseFirst;
-    }
-    current.baseQueue = baseQueue = pendingQueue;
-    queue.pending = null;
-  }
-  if (null !== baseQueue) {
-    pendingQueue = baseQueue.next;
-    current = current.baseState;
-    var newBaseQueueFirst = (baseFirst = null),
-      newBaseQueueLast = null,
-      update = pendingQueue;
-    do {
-      var updateLane = update.lane & -1073741825;
+function updateSimpleMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null !== current) {
+    var prevProps = current.memoizedProps;
+    if (
+      shallowEqual(prevProps, nextProps) &&
+      current.ref === workInProgress.ref
+    )
       if (
-        updateLane !== update.lane
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes$1 & updateLane) === updateLane
+        ((didReceiveUpdate = !1),
+        (workInProgress.pendingProps = nextProps = prevProps),
+        checkScheduledUpdateOrContext(current, renderLanes))
       )
-        null !== newBaseQueueLast &&
-          (newBaseQueueLast = newBaseQueueLast.next =
-            {
-              lane: 0,
-              action: update.action,
-              hasEagerState: update.hasEagerState,
-              eagerState: update.eagerState,
-              next: null
-            }),
-          (updateLane = update.action),
-          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
-          (current = update.hasEagerState
-            ? update.eagerState
-            : reducer(current, updateLane));
-      else {
-        var clone = {
-          lane: updateLane,
-          action: update.action,
-          hasEagerState: update.hasEagerState,
-          eagerState: update.eagerState,
-          next: null
-        };
-        null === newBaseQueueLast
-          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
-            (baseFirst = current))
-          : (newBaseQueueLast = newBaseQueueLast.next = clone);
-        currentlyRenderingFiber$1.lanes |= updateLane;
-        workInProgressRootSkippedLanes |= updateLane;
-      }
-      update = update.next;
-    } while (null !== update && update !== pendingQueue);
-    null === newBaseQueueLast
-      ? (baseFirst = current)
-      : (newBaseQueueLast.next = newBaseQueueFirst);
-    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = current;
-    hook.baseState = baseFirst;
-    hook.baseQueue = newBaseQueueLast;
-    queue.lastRenderedState = current;
-  }
-  null === baseQueue && (queue.lanes = 0);
-  return [hook.memoizedState, queue.dispatch];
-}
-function rerenderReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var dispatch = queue.dispatch,
-    lastRenderPhaseUpdate = queue.pending,
-    newState = hook.memoizedState;
-  if (null !== lastRenderPhaseUpdate) {
-    queue.pending = null;
-    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
-    do (newState = reducer(newState, update.action)), (update = update.next);
-    while (update !== lastRenderPhaseUpdate);
-    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = newState;
-    null === hook.baseQueue && (hook.baseState = newState);
-    queue.lastRenderedState = newState;
+        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
+      else
+        return (
+          (workInProgress.lanes = current.lanes),
+          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
+        );
   }
-  return [newState, dispatch];
-}
-function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
-  var getVersion = source._getVersion;
-  getVersion = getVersion(source._source);
-  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
-  if (null !== JSCompiler_inline_result)
-    root = JSCompiler_inline_result === getVersion;
-  else if (
-    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
-  )
-    (source._workInProgressVersionPrimary = getVersion),
-      workInProgressSources.push(source);
-  if (root) return getSnapshot(source._source);
-  workInProgressSources.push(source);
-  throw Error(formatProdErrorMessage(350));
-}
-function useMutableSource(hook, source, getSnapshot, subscribe) {
-  var root = workInProgressRoot;
-  if (null === root) throw Error(formatProdErrorMessage(349));
-  var getVersion = source._getVersion,
-    version = getVersion(source._source),
-    dispatcher = ReactCurrentDispatcher$1.current,
-    _dispatcher$useState = dispatcher.useState(function () {
-      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    }),
-    setSnapshot = _dispatcher$useState[1],
-    snapshot = _dispatcher$useState[0];
-  _dispatcher$useState = workInProgressHook;
-  var memoizedState = hook.memoizedState,
-    refs = memoizedState.refs,
-    prevGetSnapshot = refs.getSnapshot,
-    prevSource = memoizedState.source;
-  memoizedState = memoizedState.subscribe;
-  var fiber = currentlyRenderingFiber$1;
-  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
-  dispatcher.useEffect(
-    function () {
-      refs.getSnapshot = getSnapshot;
-      refs.setSnapshot = setSnapshot;
-      var maybeNewVersion = getVersion(source._source);
-      objectIs(version, maybeNewVersion) ||
-        ((maybeNewVersion = getSnapshot(source._source)),
-        objectIs(snapshot, maybeNewVersion) ||
-          (setSnapshot(maybeNewVersion),
-          (maybeNewVersion = requestUpdateLane(fiber)),
-          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
-        markRootEntangled(root, root.mutableReadLanes));
-    },
-    [getSnapshot, source, subscribe]
-  );
-  dispatcher.useEffect(
-    function () {
-      return subscribe(source._source, function () {
-        var latestGetSnapshot = refs.getSnapshot,
-          latestSetSnapshot = refs.setSnapshot;
-        try {
-          latestSetSnapshot(latestGetSnapshot(source._source));
-          var lane = requestUpdateLane(fiber);
-          root.mutableReadLanes |= lane & root.pendingLanes;
-        } catch (error) {
-          latestSetSnapshot(function () {
-            throw error;
-          });
-        }
-      });
-    },
-    [source, subscribe]
+  return updateFunctionComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    renderLanes
   );
-  (objectIs(prevGetSnapshot, getSnapshot) &&
-    objectIs(prevSource, source) &&
-    objectIs(memoizedState, subscribe)) ||
-    ((hook = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: basicStateReducer,
-      lastRenderedState: snapshot
-    }),
-    (hook.dispatch = setSnapshot =
-      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
-    (_dispatcher$useState.queue = hook),
-    (_dispatcher$useState.baseQueue = null),
-    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
-    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
-      snapshot));
-  return snapshot;
-}
-function updateMutableSource(source, getSnapshot, subscribe) {
-  var hook = updateWorkInProgressHook();
-  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
-function updateSyncExternalStore(subscribe, getSnapshot) {
-  var fiber = currentlyRenderingFiber$1,
-    hook = updateWorkInProgressHook(),
-    nextSnapshot = getSnapshot(),
-    snapshotChanged = !objectIs(
-      (currentHook || hook).memoizedState,
-      nextSnapshot
-    );
-  snapshotChanged &&
-    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
-  hook = hook.queue;
-  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
-    subscribe
-  ]);
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    nextChildren = nextProps.children,
+    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
+    prevState = null !== current ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
   if (
-    hook.getSnapshot !== getSnapshot ||
-    snapshotChanged ||
-    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
+    "hidden" === nextProps.mode ||
+    "unstable-defer-without-hiding" === nextProps.mode ||
+    nextIsDetached
   ) {
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
-      void 0,
-      null
-    );
-    subscribe = workInProgressRoot;
-    if (null === subscribe) throw Error(formatProdErrorMessage(349));
-    includesBlockingLane(subscribe, renderLanes$1) ||
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
-  }
-  return nextSnapshot;
-}
-function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
-  fiber.flags |= 16384;
-  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
-  getSnapshot = currentlyRenderingFiber$1.updateQueue;
-  null === getSnapshot
-    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
-      (getSnapshot.stores = [fiber]))
-    : ((renderedSnapshot = getSnapshot.stores),
-      null === renderedSnapshot
-        ? (getSnapshot.stores = [fiber])
-        : renderedSnapshot.push(fiber));
-}
-function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
-  inst.value = nextSnapshot;
-  inst.getSnapshot = getSnapshot;
-  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
-}
-function subscribeToStore(fiber, inst, subscribe) {
-  return subscribe(function () {
-    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
-  });
-}
-function checkIfSnapshotChanged(inst) {
-  var latestGetSnapshot = inst.getSnapshot;
-  inst = inst.value;
-  try {
-    var nextValue = latestGetSnapshot();
-    return !objectIs(inst, nextValue);
-  } catch (error) {
-    return !0;
-  }
+    if (0 !== (workInProgress.flags & 128)) {
+      nextChildren =
+        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+      if (null !== current) {
+        prevState = workInProgress.child = current.child;
+        for (nextProps = 0; null !== prevState; )
+          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
+            (prevState = prevState.sibling);
+        workInProgress.childLanes = nextProps & ~nextChildren;
+      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes
+      );
+    }
+    if (0 === (workInProgress.mode & 1))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current && pushTransition(workInProgress, null, null),
+        reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else if (0 !== (renderLanes & 1073741824))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current &&
+          pushTransition(
+            workInProgress,
+            null !== prevState ? prevState.cachePool : null,
+            null
+          ),
+        null !== prevState
+          ? pushHiddenContext(workInProgress, prevState)
+          : reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else
+      return (
+        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
+        deferHiddenOffscreenComponent(
+          current,
+          workInProgress,
+          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
+          renderLanes
+        )
+      );
+  } else if (null !== prevState) {
+    nextProps = prevState.cachePool;
+    nextIsDetached = null;
+    if (enableTransitionTracing) {
+      var instance = workInProgress.stateNode;
+      null !== instance &&
+        null != instance._transitions &&
+        (nextIsDetached = Array.from(instance._transitions));
+    }
+    pushTransition(workInProgress, nextProps, nextIsDetached);
+    pushHiddenContext(workInProgress, prevState);
+    reuseSuspenseHandlerOnStack();
+    workInProgress.memoizedState = null;
+  } else
+    null !== current && pushTransition(workInProgress, null, null),
+      reuseHiddenContextOnStack(),
+      reuseSuspenseHandlerOnStack();
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
-function forceStoreRerender(fiber) {
-  var root = enqueueConcurrentRenderForLane(fiber, 2);
-  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
-}
-function mountState(initialState) {
-  var hook = mountWorkInProgressHook();
-  "function" === typeof initialState && (initialState = initialState());
-  hook.memoizedState = hook.baseState = initialState;
-  initialState = {
-    pending: null,
-    lanes: 0,
-    dispatch: null,
-    lastRenderedReducer: basicStateReducer,
-    lastRenderedState: initialState
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
+  var JSCompiler_inline_result = peekCacheFromPool();
+  JSCompiler_inline_result =
+    null === JSCompiler_inline_result
+      ? null
+      : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
+  workInProgress.memoizedState = {
+    baseLanes: nextBaseLanes,
+    cachePool: JSCompiler_inline_result
   };
-  hook.queue = initialState;
-  initialState = initialState.dispatch = dispatchSetState.bind(
-    null,
-    currentlyRenderingFiber$1,
-    initialState
-  );
-  return [hook.memoizedState, initialState];
-}
-function pushEffect(tag, create, destroy, deps) {
-  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
-  create = currentlyRenderingFiber$1.updateQueue;
-  null === create
-    ? ((create = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = create),
-      (create.lastEffect = tag.next = tag))
-    : ((destroy = create.lastEffect),
-      null === destroy
-        ? (create.lastEffect = tag.next = tag)
-        : ((deps = destroy.next),
-          (destroy.next = tag),
-          (tag.next = deps),
-          (create.lastEffect = tag)));
-  return tag;
+  null !== current && pushTransition(workInProgress, null, null);
+  reuseHiddenContextOnStack();
+  pushOffscreenSuspenseHandler(workInProgress);
+  enableLazyContextPropagation &&
+    null !== current &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
+  return null;
 }
-function updateRef() {
-  return updateWorkInProgressHook().memoizedState;
+function markRef$1(current, workInProgress) {
+  var ref = workInProgress.ref;
+  if (
+    (null === current && null !== ref) ||
+    (null !== current && current.ref !== ref)
+  )
+    (workInProgress.flags |= 512), (workInProgress.flags |= 2097152);
 }
-function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = mountWorkInProgressHook();
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    1 | hookFlags,
-    create,
+function updateFunctionComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  prepareToReadContext(workInProgress, renderLanes);
+  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+  Component = renderWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
     void 0,
-    void 0 === deps ? null : deps
+    renderLanes
   );
-}
-function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var destroy = void 0;
-  if (null !== currentHook) {
-    var prevEffect = currentHook.memoizedState;
-    destroy = prevEffect.destroy;
-    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
-      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
-      return;
-    }
-  }
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
-}
-function mountEffect(create, deps) {
-  mountEffectImpl(8390656, 8, create, deps);
-}
-function updateEffect(create, deps) {
-  updateEffectImpl(2048, 8, create, deps);
-}
-function useEffectEventImpl(payload) {
-  currentlyRenderingFiber$1.flags |= 4;
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
-  if (null === componentUpdateQueue)
-    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
-      (componentUpdateQueue.events = [payload]);
-  else {
-    var events = componentUpdateQueue.events;
-    null === events
-      ? (componentUpdateQueue.events = [payload])
-      : events.push(payload);
-  }
-}
-function updateEvent(callback) {
-  var ref = updateWorkInProgressHook().memoizedState;
-  useEffectEventImpl({ ref: ref, nextImpl: callback });
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
-}
-function updateInsertionEffect(create, deps) {
-  return updateEffectImpl(4, 2, create, deps);
-}
-function updateLayoutEffect(create, deps) {
-  return updateEffectImpl(4, 4, create, deps);
-}
-function imperativeHandleEffect(create, ref) {
-  if ("function" === typeof ref)
-    return (
-      (create = create()),
-      ref(create),
-      function () {
-        ref(null);
-      }
-    );
-  if (null !== ref && void 0 !== ref)
+  nextProps = checkDidRenderIdHook();
+  enableSchedulingProfiler && markComponentRenderStopped();
+  if (null !== current && !didReceiveUpdate)
     return (
-      (create = create()),
-      (ref.current = create),
-      function () {
-        ref.current = null;
-      }
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
     );
+  isHydrating && nextProps && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, Component, renderLanes);
+  return workInProgress.child;
 }
-function updateImperativeHandle(ref, create, deps) {
-  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
-}
-function mountDebugValue() {}
-function updateCallback(callback, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  hook.memoizedState = [callback, deps];
-  return callback;
-}
-function updateMemo(nextCreate, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-  nextCreate = nextCreate();
-  hook.memoizedState = [nextCreate, deps];
-  return nextCreate;
-}
-function updateDeferredValueImpl(hook, prevValue, value) {
-  if (0 === (renderLanes$1 & 42))
+function replayFunctionComponent(
+  current,
+  workInProgress,
+  nextProps,
+  Component,
+  renderLanes
+) {
+  prepareToReadContext(workInProgress, renderLanes);
+  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+  nextProps = renderWithHooksAgain(
+    workInProgress,
+    Component,
+    nextProps,
+    void 0
+  );
+  finishRenderingHooks(current);
+  Component = checkDidRenderIdHook();
+  enableSchedulingProfiler && markComponentRenderStopped();
+  if (null !== current && !didReceiveUpdate)
     return (
-      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
-      (hook.memoizedState = value)
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
     );
-  objectIs(value, prevValue) ||
-    ((value = claimNextTransitionLane()),
-    (currentlyRenderingFiber$1.lanes |= value),
-    (workInProgressRootSkippedLanes |= value),
-    (hook.baseState = !0));
-  return prevValue;
-}
-function startTransition(setPending, callback, options) {
-  var previousPriority = currentUpdatePriority;
-  currentUpdatePriority =
-    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
-  setPending(!0);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
-  enableTransitionTracing &&
-    void 0 !== options &&
-    void 0 !== options.name &&
-    ((ReactCurrentBatchConfig$2.transition.name = options.name),
-    (ReactCurrentBatchConfig$2.transition.startTime = now$1()));
-  try {
-    setPending(!1), callback();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$2.transition = prevTransition);
-  }
-}
-function updateId() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function updateRefresh() {
-  return updateWorkInProgressHook().memoizedState;
+  isHydrating && Component && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, nextProps, renderLanes);
+  return workInProgress.child;
 }
-function refreshCache(fiber, seedKey, seedValue) {
-  for (var provider = fiber.return; null !== provider; ) {
-    switch (provider.tag) {
-      case 24:
-      case 3:
-        var lane = requestUpdateLane(provider);
-        fiber = createUpdate(lane);
-        var root$97 = enqueueUpdate(provider, fiber, lane);
-        if (null !== root$97) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root$97, provider, lane, eventTime);
-          entangleTransitions(root$97, provider, lane);
-        }
-        provider = createCache();
-        null !== seedKey &&
-          void 0 !== seedKey &&
-          null !== root$97 &&
-          provider.data.set(seedKey, seedValue);
-        fiber.payload = { cache: provider };
-        return;
-    }
-    provider = provider.return;
+function updateClassComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  prepareToReadContext(workInProgress, renderLanes);
+  if (null === workInProgress.stateNode)
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+      constructClassInstance(workInProgress, Component, nextProps),
+      mountClassInstance(workInProgress, Component, nextProps, renderLanes),
+      (nextProps = !0);
+  else if (null === current) {
+    var instance = workInProgress.stateNode,
+      oldProps = workInProgress.memoizedProps;
+    instance.props = oldProps;
+    var oldContext = instance.context,
+      contextType = Component.contextType,
+      nextContext = emptyContextObject;
+    "object" === typeof contextType &&
+      null !== contextType &&
+      (nextContext = readContext(contextType));
+    var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+    (contextType =
+      "function" === typeof getDerivedStateFromProps ||
+      "function" === typeof instance.getSnapshotBeforeUpdate) ||
+      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
+        "function" !== typeof instance.componentWillReceiveProps) ||
+      ((oldProps !== nextProps || oldContext !== nextContext) &&
+        callComponentWillReceiveProps(
+          workInProgress,
+          instance,
+          nextProps,
+          nextContext
+        ));
+    hasForceUpdate = !1;
+    var oldState = workInProgress.memoizedState;
+    instance.state = oldState;
+    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+    oldContext = workInProgress.memoizedState;
+    oldProps !== nextProps || oldState !== oldContext || hasForceUpdate
+      ? ("function" === typeof getDerivedStateFromProps &&
+          (applyDerivedStateFromProps(
+            workInProgress,
+            Component,
+            getDerivedStateFromProps,
+            nextProps
+          ),
+          (oldContext = workInProgress.memoizedState)),
+        (oldProps =
+          hasForceUpdate ||
+          checkShouldComponentUpdate(
+            workInProgress,
+            Component,
+            oldProps,
+            nextProps,
+            oldState,
+            oldContext,
+            nextContext
+          ))
+          ? (contextType ||
+              ("function" !== typeof instance.UNSAFE_componentWillMount &&
+                "function" !== typeof instance.componentWillMount) ||
+              ("function" === typeof instance.componentWillMount &&
+                instance.componentWillMount(),
+              "function" === typeof instance.UNSAFE_componentWillMount &&
+                instance.UNSAFE_componentWillMount()),
+            "function" === typeof instance.componentDidMount &&
+              (workInProgress.flags |= 4194308))
+          : ("function" === typeof instance.componentDidMount &&
+              (workInProgress.flags |= 4194308),
+            (workInProgress.memoizedProps = nextProps),
+            (workInProgress.memoizedState = oldContext)),
+        (instance.props = nextProps),
+        (instance.state = oldContext),
+        (instance.context = nextContext),
+        (nextProps = oldProps))
+      : ("function" === typeof instance.componentDidMount &&
+          (workInProgress.flags |= 4194308),
+        (nextProps = !1));
+  } else {
+    instance = workInProgress.stateNode;
+    cloneUpdateQueue(current, workInProgress);
+    nextContext = workInProgress.memoizedProps;
+    contextType =
+      workInProgress.type === workInProgress.elementType
+        ? nextContext
+        : resolveDefaultProps(workInProgress.type, nextContext);
+    instance.props = contextType;
+    getDerivedStateFromProps = workInProgress.pendingProps;
+    var oldContext$jscomp$0 = instance.context;
+    oldContext = Component.contextType;
+    oldProps = emptyContextObject;
+    "object" === typeof oldContext &&
+      null !== oldContext &&
+      (oldProps = readContext(oldContext));
+    oldState = Component.getDerivedStateFromProps;
+    (oldContext =
+      "function" === typeof oldState ||
+      "function" === typeof instance.getSnapshotBeforeUpdate) ||
+      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
+        "function" !== typeof instance.componentWillReceiveProps) ||
+      ((nextContext !== getDerivedStateFromProps ||
+        oldContext$jscomp$0 !== oldProps) &&
+        callComponentWillReceiveProps(
+          workInProgress,
+          instance,
+          nextProps,
+          oldProps
+        ));
+    hasForceUpdate = !1;
+    oldContext$jscomp$0 = workInProgress.memoizedState;
+    instance.state = oldContext$jscomp$0;
+    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+    var newState = workInProgress.memoizedState;
+    nextContext !== getDerivedStateFromProps ||
+    oldContext$jscomp$0 !== newState ||
+    hasForceUpdate ||
+    (enableLazyContextPropagation &&
+      null !== current &&
+      null !== current.dependencies &&
+      checkIfContextChanged(current.dependencies))
+      ? ("function" === typeof oldState &&
+          (applyDerivedStateFromProps(
+            workInProgress,
+            Component,
+            oldState,
+            nextProps
+          ),
+          (newState = workInProgress.memoizedState)),
+        (contextType =
+          hasForceUpdate ||
+          checkShouldComponentUpdate(
+            workInProgress,
+            Component,
+            contextType,
+            nextProps,
+            oldContext$jscomp$0,
+            newState,
+            oldProps
+          ) ||
+          (enableLazyContextPropagation &&
+            null !== current &&
+            null !== current.dependencies &&
+            checkIfContextChanged(current.dependencies)))
+          ? (oldContext ||
+              ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
+                "function" !== typeof instance.componentWillUpdate) ||
+              ("function" === typeof instance.componentWillUpdate &&
+                instance.componentWillUpdate(nextProps, newState, oldProps),
+              "function" === typeof instance.UNSAFE_componentWillUpdate &&
+                instance.UNSAFE_componentWillUpdate(
+                  nextProps,
+                  newState,
+                  oldProps
+                )),
+            "function" === typeof instance.componentDidUpdate &&
+              (workInProgress.flags |= 4),
+            "function" === typeof instance.getSnapshotBeforeUpdate &&
+              (workInProgress.flags |= 1024))
+          : ("function" !== typeof instance.componentDidUpdate ||
+              (nextContext === current.memoizedProps &&
+                oldContext$jscomp$0 === current.memoizedState) ||
+              (workInProgress.flags |= 4),
+            "function" !== typeof instance.getSnapshotBeforeUpdate ||
+              (nextContext === current.memoizedProps &&
+                oldContext$jscomp$0 === current.memoizedState) ||
+              (workInProgress.flags |= 1024),
+            (workInProgress.memoizedProps = nextProps),
+            (workInProgress.memoizedState = newState)),
+        (instance.props = nextProps),
+        (instance.state = newState),
+        (instance.context = oldProps),
+        (nextProps = contextType))
+      : ("function" !== typeof instance.componentDidUpdate ||
+          (nextContext === current.memoizedProps &&
+            oldContext$jscomp$0 === current.memoizedState) ||
+          (workInProgress.flags |= 4),
+        "function" !== typeof instance.getSnapshotBeforeUpdate ||
+          (nextContext === current.memoizedProps &&
+            oldContext$jscomp$0 === current.memoizedState) ||
+          (workInProgress.flags |= 1024),
+        (nextProps = !1));
   }
+  return finishClassComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    !1,
+    renderLanes
+  );
 }
-function dispatchReducerAction(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber);
-  action = {
-    lane: lane,
-    action: action,
-    hasEagerState: !1,
-    eagerState: null,
-    next: null
-  };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
-  else if (
-    (enqueueUpdate$1(fiber, queue, action, lane),
-    (action = getRootForUpdatedFiber(fiber)),
-    null !== action)
-  ) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
-    entangleTransitionUpdate(action, queue, lane);
-  }
-  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
+function finishClassComponent(
+  current,
+  workInProgress,
+  Component,
+  shouldUpdate,
+  hasContext,
+  renderLanes
+) {
+  markRef$1(current, workInProgress);
+  hasContext = 0 !== (workInProgress.flags & 128);
+  if (!shouldUpdate && !hasContext)
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  shouldUpdate = workInProgress.stateNode;
+  ReactCurrentOwner$1.current = workInProgress;
+  hasContext && "function" !== typeof Component.getDerivedStateFromError
+    ? ((Component = null), (profilerStartTime = -1))
+    : (enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
+      (Component = shouldUpdate.render()),
+      enableSchedulingProfiler && markComponentRenderStopped());
+  workInProgress.flags |= 1;
+  null !== current && hasContext
+    ? ((workInProgress.child = reconcileChildFibers(
+        workInProgress,
+        current.child,
+        null,
+        renderLanes
+      )),
+      (workInProgress.child = reconcileChildFibers(
+        workInProgress,
+        null,
+        Component,
+        renderLanes
+      )))
+    : reconcileChildren(current, workInProgress, Component, renderLanes);
+  workInProgress.memoizedState = shouldUpdate.state;
+  return workInProgress.child;
 }
-function dispatchSetState(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber),
-    update = {
-      lane: lane,
-      action: action,
-      hasEagerState: !1,
-      eagerState: null,
-      next: null
-    };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
-  else {
-    var alternate = fiber.alternate;
-    if (
-      0 === fiber.lanes &&
-      (null === alternate || 0 === alternate.lanes) &&
-      ((alternate = queue.lastRenderedReducer), null !== alternate)
-    )
-      try {
-        var currentState = queue.lastRenderedState,
-          eagerState = alternate(currentState, action);
-        update.hasEagerState = !0;
-        update.eagerState = eagerState;
-        if (objectIs(eagerState, currentState)) {
-          enqueueUpdate$1(fiber, queue, update, 0);
-          null === workInProgressRoot && finishQueueingConcurrentUpdates();
-          return;
-        }
-      } catch (error) {
-      } finally {
-      }
-    enqueueUpdate$1(fiber, queue, update, lane);
-    action = getRootForUpdatedFiber(fiber);
-    null !== action &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(action, fiber, lane, update),
-      entangleTransitionUpdate(action, queue, lane));
-  }
-  enableSchedulingProfiler && markStateUpdateScheduled(fiber, lane);
-}
-function isRenderPhaseUpdate(fiber) {
-  var alternate = fiber.alternate;
-  return (
-    fiber === currentlyRenderingFiber$1 ||
-    (null !== alternate && alternate === currentlyRenderingFiber$1)
-  );
-}
-function enqueueRenderPhaseUpdate(queue, update) {
-  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
-    !0;
-  var pending = queue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  queue.pending = update;
+function mountHostRootWithoutHydrating(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes,
+  recoverableError
+) {
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= 256;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
-function entangleTransitionUpdate(root, queue, lane) {
-  if (0 !== (lane & 8388480)) {
-    var queueLanes = queue.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    queue.lanes = lane;
-    markRootEntangled(root, lane);
-  }
+var SUSPENDED_MARKER = { dehydrated: null, treeContext: null, retryLane: 0 };
+function mountSuspenseOffscreenState(renderLanes) {
+  return { baseLanes: renderLanes, cachePool: getSuspendedCache() };
 }
-var ContextOnlyDispatcher = {
-  readContext: readContext,
-  useCallback: throwInvalidHookError,
-  useContext: throwInvalidHookError,
-  useEffect: throwInvalidHookError,
-  useImperativeHandle: throwInvalidHookError,
-  useInsertionEffect: throwInvalidHookError,
-  useLayoutEffect: throwInvalidHookError,
-  useMemo: throwInvalidHookError,
-  useReducer: throwInvalidHookError,
-  useRef: throwInvalidHookError,
-  useState: throwInvalidHookError,
-  useDebugValue: throwInvalidHookError,
-  useDeferredValue: throwInvalidHookError,
-  useTransition: throwInvalidHookError,
-  useMutableSource: throwInvalidHookError,
-  useSyncExternalStore: throwInvalidHookError,
-  useId: throwInvalidHookError
-};
-ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
-ContextOnlyDispatcher.use = throwInvalidHookError;
-ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
-ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
-var HooksDispatcherOnMount = {
-  readContext: readContext,
-  useCallback: function (callback, deps) {
-    mountWorkInProgressHook().memoizedState = [
-      callback,
-      void 0 === deps ? null : deps
-    ];
-    return callback;
-  },
-  useContext: readContext,
-  useEffect: mountEffect,
-  useImperativeHandle: function (ref, create, deps) {
-    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-    mountEffectImpl(
-      4194308,
-      4,
-      imperativeHandleEffect.bind(null, create, ref),
-      deps
-    );
-  },
-  useLayoutEffect: function (create, deps) {
-    return mountEffectImpl(4194308, 4, create, deps);
-  },
-  useInsertionEffect: function (create, deps) {
-    mountEffectImpl(4, 2, create, deps);
-  },
-  useMemo: function (nextCreate, deps) {
-    var hook = mountWorkInProgressHook();
-    deps = void 0 === deps ? null : deps;
-    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-    nextCreate = nextCreate();
-    hook.memoizedState = [nextCreate, deps];
-    return nextCreate;
-  },
-  useReducer: function (reducer, initialArg, init) {
-    var hook = mountWorkInProgressHook();
-    initialArg = void 0 !== init ? init(initialArg) : initialArg;
-    hook.memoizedState = hook.baseState = initialArg;
-    reducer = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: reducer,
-      lastRenderedState: initialArg
-    };
-    hook.queue = reducer;
-    reducer = reducer.dispatch = dispatchReducerAction.bind(
-      null,
-      currentlyRenderingFiber$1,
-      reducer
-    );
-    return [hook.memoizedState, reducer];
-  },
-  useRef: function (initialValue) {
-    var hook = mountWorkInProgressHook();
-    if (enableUseRefAccessWarning)
-      return (
-        (initialValue = { current: initialValue }),
-        (hook.memoizedState = initialValue)
-      );
-    initialValue = { current: initialValue };
-    return (hook.memoizedState = initialValue);
-  },
-  useState: mountState,
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    return (mountWorkInProgressHook().memoizedState = value);
-  },
-  useTransition: function () {
-    var _mountState = mountState(!1),
-      isPending = _mountState[0];
-    _mountState = startTransition.bind(null, _mountState[1]);
-    mountWorkInProgressHook().memoizedState = _mountState;
-    return [isPending, _mountState];
-  },
-  useMutableSource: function (source, getSnapshot, subscribe) {
-    var hook = mountWorkInProgressHook();
-    hook.memoizedState = {
-      refs: { getSnapshot: getSnapshot, setSnapshot: null },
-      source: source,
-      subscribe: subscribe
-    };
-    return useMutableSource(hook, source, getSnapshot, subscribe);
-  },
-  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-    var fiber = currentlyRenderingFiber$1,
-      hook = mountWorkInProgressHook();
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    showFallback = !1,
+    didSuspend = 0 !== (workInProgress.flags & 128),
+    JSCompiler_temp;
+  (JSCompiler_temp = didSuspend) ||
+    (JSCompiler_temp =
+      null !== current && null === current.memoizedState
+        ? !1
+        : 0 !== (suspenseStackCursor.current & 2));
+  JSCompiler_temp && ((showFallback = !0), (workInProgress.flags &= -129));
+  if (null === current) {
     if (isHydrating) {
-      if (void 0 === getServerSnapshot)
-        throw Error(formatProdErrorMessage(407));
-      getServerSnapshot = getServerSnapshot();
-    } else {
-      getServerSnapshot = getSnapshot();
-      var root$93 = workInProgressRoot;
-      if (null === root$93) throw Error(formatProdErrorMessage(349));
-      includesBlockingLane(root$93, renderLanes$1) ||
-        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
-    }
-    hook.memoizedState = getServerSnapshot;
-    root$93 = { value: getServerSnapshot, getSnapshot: getSnapshot };
-    hook.queue = root$93;
-    mountEffect(subscribeToStore.bind(null, fiber, root$93, subscribe), [
-      subscribe
-    ]);
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(
-        null,
-        fiber,
-        root$93,
-        getServerSnapshot,
-        getSnapshot
-      ),
-      void 0,
-      null
-    );
-    return getServerSnapshot;
-  },
-  useId: function () {
-    var hook = mountWorkInProgressHook(),
-      identifierPrefix = workInProgressRoot.identifierPrefix;
-    if (isHydrating) {
-      var JSCompiler_inline_result = treeContextOverflow;
-      var idWithLeadingBit = treeContextId;
-      JSCompiler_inline_result =
-        (
-          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
-        ).toString(32) + JSCompiler_inline_result;
-      identifierPrefix =
-        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
-      JSCompiler_inline_result = localIdCounter++;
-      0 < JSCompiler_inline_result &&
-        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
-      identifierPrefix += ":";
-    } else
-      (JSCompiler_inline_result = globalClientIdCounter++),
-        (identifierPrefix =
-          ":" +
-          identifierPrefix +
-          "r" +
-          JSCompiler_inline_result.toString(32) +
-          ":");
-    return (hook.memoizedState = identifierPrefix);
-  },
-  useCacheRefresh: function () {
-    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
-      null,
-      currentlyRenderingFiber$1
-    ));
-  }
-};
-HooksDispatcherOnMount.use = use;
-HooksDispatcherOnMount.useMemoCache = useMemoCache;
-HooksDispatcherOnMount.useEffectEvent = function (callback) {
-  var hook = mountWorkInProgressHook(),
-    ref = { impl: callback };
-  hook.memoizedState = ref;
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
-};
-var HooksDispatcherOnUpdate = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: updateReducer,
-  useRef: updateRef,
-  useState: function () {
-    return updateReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = updateReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
-HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
-HooksDispatcherOnUpdate.use = use;
-HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
-var HooksDispatcherOnRerender = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: rerenderReducer,
-  useRef: updateRef,
-  useState: function () {
-    return rerenderReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return null === currentHook
-      ? (hook.memoizedState = value)
-      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = rerenderReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
-HooksDispatcherOnRerender.use = use;
-HooksDispatcherOnRerender.useMemoCache = useMemoCache;
-HooksDispatcherOnRerender.useEffectEvent = updateEvent;
-var now = Scheduler.unstable_now,
-  commitTime = 0,
-  layoutEffectStartTime = -1,
-  profilerStartTime = -1,
-  passiveEffectStartTime = -1,
-  currentUpdateIsNested = !1,
-  nestedUpdateScheduled = !1;
-function startProfilerTimer(fiber) {
-  profilerStartTime = now();
-  0 > fiber.actualStartTime && (fiber.actualStartTime = now());
-}
-function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
-  if (0 <= profilerStartTime) {
-    var elapsedTime = now() - profilerStartTime;
-    fiber.actualDuration += elapsedTime;
-    overrideBaseTime && (fiber.selfBaseDuration = elapsedTime);
-    profilerStartTime = -1;
-  }
-}
-function recordLayoutEffectDuration(fiber) {
-  if (0 <= layoutEffectStartTime) {
-    var elapsedTime = now() - layoutEffectStartTime;
-    layoutEffectStartTime = -1;
-    for (fiber = fiber.return; null !== fiber; ) {
-      switch (fiber.tag) {
-        case 3:
-          fiber.stateNode.effectDuration += elapsedTime;
-          return;
-        case 12:
-          fiber.stateNode.effectDuration += elapsedTime;
-          return;
-      }
-      fiber = fiber.return;
-    }
-  }
-}
-function recordPassiveEffectDuration(fiber) {
-  if (0 <= passiveEffectStartTime) {
-    var elapsedTime = now() - passiveEffectStartTime;
-    passiveEffectStartTime = -1;
-    for (fiber = fiber.return; null !== fiber; ) {
-      switch (fiber.tag) {
-        case 3:
-          fiber = fiber.stateNode;
-          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
-          return;
-        case 12:
-          fiber = fiber.stateNode;
-          null !== fiber && (fiber.passiveEffectDuration += elapsedTime);
-          return;
-      }
-      fiber = fiber.return;
+      showFallback
+        ? pushPrimaryTreeSuspenseHandler(workInProgress)
+        : reuseSuspenseHandlerOnStack();
+      isHydrating &&
+        (((current = nextHydratableInstance),
+        rootOrSingletonContext && advanceToFirstAttemptableSuspenseInstance(),
+        (didSuspend = nextHydratableInstance),
+        didSuspend)
+          ? tryHydrateSuspense(workInProgress, didSuspend) ||
+            (shouldClientRenderOnMismatch(workInProgress) &&
+              throwOnHydrationMismatch(),
+            (nextHydratableInstance = getNextHydratable(
+              didSuspend.nextSibling
+            )),
+            (JSCompiler_temp = hydrationParentFiber),
+            rootOrSingletonContext &&
+              advanceToFirstAttemptableSuspenseInstance(),
+            nextHydratableInstance &&
+            tryHydrateSuspense(workInProgress, nextHydratableInstance)
+              ? deleteHydratableInstance(JSCompiler_temp, didSuspend)
+              : (insertNonHydratedInstance(
+                  hydrationParentFiber,
+                  workInProgress
+                ),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = current)))
+          : (shouldClientRenderOnMismatch(workInProgress) &&
+              throwOnHydrationMismatch(),
+            insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+            (isHydrating = !1),
+            (hydrationParentFiber = workInProgress),
+            (nextHydratableInstance = current)));
+      current = workInProgress.memoizedState;
+      if (
+        null !== current &&
+        ((current = current.dehydrated), null !== current)
+      )
+        return (
+          0 === (workInProgress.mode & 1)
+            ? (workInProgress.lanes = 2)
+            : "$!" === current.data
+            ? (workInProgress.lanes = 16)
+            : (workInProgress.lanes = 1073741824),
+          null
+        );
+      popSuspenseHandler(workInProgress);
     }
+    current = nextProps.children;
+    didSuspend = nextProps.fallback;
+    if (showFallback)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (current = mountSuspenseFallbackChildren(
+          workInProgress,
+          current,
+          didSuspend,
+          renderLanes
+        )),
+        (nextProps = workInProgress.child),
+        (nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes)),
+        (workInProgress.memoizedState = SUSPENDED_MARKER),
+        enableTransitionTracing &&
+          ((workInProgress = enableTransitionTracing
+            ? transitionStack.current
+            : null),
+          null !== workInProgress &&
+            ((renderLanes = enableTransitionTracing
+              ? markerInstanceStack.current
+              : null),
+            (showFallback = nextProps.updateQueue),
+            null === showFallback
+              ? (nextProps.updateQueue = {
+                  transitions: workInProgress,
+                  markerInstances: renderLanes,
+                  wakeables: null
+                })
+              : ((showFallback.transitions = workInProgress),
+                (showFallback.markerInstances = renderLanes)))),
+        current
+      );
+    if ("number" === typeof nextProps.unstable_expectedLoadTime)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (current = mountSuspenseFallbackChildren(
+          workInProgress,
+          current,
+          didSuspend,
+          renderLanes
+        )),
+        (workInProgress.child.memoizedState =
+          mountSuspenseOffscreenState(renderLanes)),
+        (workInProgress.memoizedState = SUSPENDED_MARKER),
+        (workInProgress.lanes = 8388608),
+        current
+      );
+    pushPrimaryTreeSuspenseHandler(workInProgress);
+    return mountSuspensePrimaryChildren(workInProgress, current);
   }
-}
-function startLayoutEffectTimer() {
-  layoutEffectStartTime = now();
-}
-function transferActualDuration(fiber) {
-  for (var child = fiber.child; child; )
-    (fiber.actualDuration += child.actualDuration), (child = child.sibling);
-}
-function resolveDefaultProps(Component, baseProps) {
-  if (Component && Component.defaultProps) {
-    baseProps = assign({}, baseProps);
-    Component = Component.defaultProps;
-    for (var propName in Component)
-      void 0 === baseProps[propName] &&
-        (baseProps[propName] = Component[propName]);
-    return baseProps;
+  JSCompiler_temp = current.memoizedState;
+  if (null !== JSCompiler_temp) {
+    var dehydrated$73 = JSCompiler_temp.dehydrated;
+    if (null !== dehydrated$73)
+      return updateDehydratedSuspenseComponent(
+        current,
+        workInProgress,
+        didSuspend,
+        nextProps,
+        dehydrated$73,
+        JSCompiler_temp,
+        renderLanes
+      );
   }
-  return baseProps;
-}
-function applyDerivedStateFromProps(
-  workInProgress,
-  ctor,
-  getDerivedStateFromProps,
-  nextProps
-) {
-  ctor = workInProgress.memoizedState;
-  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
-  getDerivedStateFromProps =
-    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
-      ? ctor
-      : assign({}, ctor, getDerivedStateFromProps);
-  workInProgress.memoizedState = getDerivedStateFromProps;
-  0 === workInProgress.lanes &&
-    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
-}
-var classComponentUpdater = {
-  isMounted: function (component) {
-    return (component = component._reactInternals)
-      ? getNearestMountedFiber(component) === component
-      : !1;
-  },
-  enqueueSetState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
-  },
-  enqueueReplaceState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 1;
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-    enableSchedulingProfiler && markStateUpdateScheduled(inst, lane);
-  },
-  enqueueForceUpdate: function (inst, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 2;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    callback = enqueueUpdate(inst, update, lane);
-    null !== callback &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(callback, inst, lane, update),
-      entangleTransitions(callback, inst, lane));
-    enableSchedulingProfiler &&
-      enableSchedulingProfiler &&
-      null !== injectedProfilingHooks &&
-      "function" === typeof injectedProfilingHooks.markForceUpdateScheduled &&
-      injectedProfilingHooks.markForceUpdateScheduled(inst, lane);
+  if (showFallback) {
+    reuseSuspenseHandlerOnStack();
+    showFallback = nextProps.fallback;
+    didSuspend = workInProgress.mode;
+    JSCompiler_temp = current.child;
+    dehydrated$73 = JSCompiler_temp.sibling;
+    var primaryChildProps = { mode: "hidden", children: nextProps.children };
+    0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
+      ? ((nextProps = workInProgress.child),
+        (nextProps.childLanes = 0),
+        (nextProps.pendingProps = primaryChildProps),
+        workInProgress.mode & 2 &&
+          ((nextProps.actualDuration = 0),
+          (nextProps.actualStartTime = -1),
+          (nextProps.selfBaseDuration = JSCompiler_temp.selfBaseDuration),
+          (nextProps.treeBaseDuration = JSCompiler_temp.treeBaseDuration)),
+        (workInProgress.deletions = null))
+      : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
+        (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
+    null !== dehydrated$73
+      ? (showFallback = createWorkInProgress(dehydrated$73, showFallback))
+      : ((showFallback = createFiberFromFragment(
+          showFallback,
+          didSuspend,
+          renderLanes,
+          null
+        )),
+        (showFallback.flags |= 2));
+    showFallback.return = workInProgress;
+    nextProps.return = workInProgress;
+    nextProps.sibling = showFallback;
+    workInProgress.child = nextProps;
+    nextProps = showFallback;
+    showFallback = workInProgress.child;
+    didSuspend = current.child.memoizedState;
+    null === didSuspend
+      ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
+      : ((JSCompiler_temp = didSuspend.cachePool),
+        null !== JSCompiler_temp
+          ? ((dehydrated$73 = CacheContext._currentValue),
+            (JSCompiler_temp =
+              JSCompiler_temp.parent !== dehydrated$73
+                ? { parent: dehydrated$73, pool: dehydrated$73 }
+                : JSCompiler_temp))
+          : (JSCompiler_temp = getSuspendedCache()),
+        (didSuspend = {
+          baseLanes: didSuspend.baseLanes | renderLanes,
+          cachePool: JSCompiler_temp
+        }));
+    showFallback.memoizedState = didSuspend;
+    enableTransitionTracing &&
+      ((didSuspend = enableTransitionTracing ? transitionStack.current : null),
+      null !== didSuspend &&
+        ((JSCompiler_temp = enableTransitionTracing
+          ? markerInstanceStack.current
+          : null),
+        (dehydrated$73 = showFallback.updateQueue),
+        (primaryChildProps = current.updateQueue),
+        null === dehydrated$73
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables: null
+            })
+          : dehydrated$73 === primaryChildProps
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables:
+                null !== primaryChildProps ? primaryChildProps.wakeables : null
+            })
+          : ((dehydrated$73.transitions = didSuspend),
+            (dehydrated$73.markerInstances = JSCompiler_temp))));
+    showFallback.childLanes = current.childLanes & ~renderLanes;
+    workInProgress.memoizedState = SUSPENDED_MARKER;
+    return nextProps;
   }
-};
-function checkShouldComponentUpdate(
+  pushPrimaryTreeSuspenseHandler(workInProgress);
+  showFallback = current.child;
+  current = showFallback.sibling;
+  nextProps = createWorkInProgress(showFallback, {
+    mode: "visible",
+    children: nextProps.children
+  });
+  0 === (workInProgress.mode & 1) && (nextProps.lanes = renderLanes);
+  nextProps.return = workInProgress;
+  nextProps.sibling = null;
+  null !== current &&
+    ((renderLanes = workInProgress.deletions),
+    null === renderLanes
+      ? ((workInProgress.deletions = [current]), (workInProgress.flags |= 16))
+      : renderLanes.push(current));
+  workInProgress.child = nextProps;
+  workInProgress.memoizedState = null;
+  return nextProps;
+}
+function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
+  primaryChildren = createFiberFromOffscreen(
+    { mode: "visible", children: primaryChildren },
+    workInProgress.mode,
+    0,
+    null
+  );
+  primaryChildren.return = workInProgress;
+  return (workInProgress.child = primaryChildren);
+}
+function mountSuspenseFallbackChildren(
   workInProgress,
-  ctor,
-  oldProps,
-  newProps,
-  oldState,
-  newState,
-  nextContext
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
 ) {
-  workInProgress = workInProgress.stateNode;
-  return "function" === typeof workInProgress.shouldComponentUpdate
-    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
-    : ctor.prototype && ctor.prototype.isPureReactComponent
-    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
-    : !0;
-}
-function constructClassInstance(workInProgress, ctor, props) {
-  var context = emptyContextObject,
-    contextType = ctor.contextType;
-  "object" === typeof contextType &&
-    null !== contextType &&
-    (context = readContext(contextType));
-  ctor = new ctor(props, context);
-  workInProgress.memoizedState =
-    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
-  ctor.updater = classComponentUpdater;
-  workInProgress.stateNode = ctor;
-  ctor._reactInternals = workInProgress;
-  return ctor;
+  var mode = workInProgress.mode,
+    progressedPrimaryFragment = workInProgress.child;
+  primaryChildren = { mode: "hidden", children: primaryChildren };
+  0 === (mode & 1) && null !== progressedPrimaryFragment
+    ? ((progressedPrimaryFragment.childLanes = 0),
+      (progressedPrimaryFragment.pendingProps = primaryChildren),
+      workInProgress.mode & 2 &&
+        ((progressedPrimaryFragment.actualDuration = 0),
+        (progressedPrimaryFragment.actualStartTime = -1),
+        (progressedPrimaryFragment.selfBaseDuration = 0),
+        (progressedPrimaryFragment.treeBaseDuration = 0)))
+    : (progressedPrimaryFragment = createFiberFromOffscreen(
+        primaryChildren,
+        mode,
+        0,
+        null
+      ));
+  fallbackChildren = createFiberFromFragment(
+    fallbackChildren,
+    mode,
+    renderLanes,
+    null
+  );
+  progressedPrimaryFragment.return = workInProgress;
+  fallbackChildren.return = workInProgress;
+  progressedPrimaryFragment.sibling = fallbackChildren;
+  workInProgress.child = progressedPrimaryFragment;
+  return fallbackChildren;
 }
-function callComponentWillReceiveProps(
+function retrySuspenseComponentWithoutHydrating(
+  current,
   workInProgress,
-  instance,
-  newProps,
-  nextContext
+  renderLanes,
+  recoverableError
 ) {
-  workInProgress = instance.state;
-  "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, nextContext);
-  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
-  instance.state !== workInProgress &&
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  null !== recoverableError && queueHydrationError(recoverableError);
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  current = mountSuspensePrimaryChildren(
+    workInProgress,
+    workInProgress.pendingProps.children
+  );
+  current.flags |= 2;
+  workInProgress.memoizedState = null;
+  return current;
 }
-function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  var instance = workInProgress.stateNode;
-  instance.props = newProps;
-  instance.state = workInProgress.memoizedState;
-  instance.refs = {};
-  initializeUpdateQueue(workInProgress);
-  var contextType = ctor.contextType;
-  instance.context =
-    "object" === typeof contextType && null !== contextType
-      ? readContext(contextType)
-      : emptyContextObject;
-  instance.state = workInProgress.memoizedState;
-  contextType = ctor.getDerivedStateFromProps;
-  "function" === typeof contextType &&
-    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof ctor.getDerivedStateFromProps ||
-    "function" === typeof instance.getSnapshotBeforeUpdate ||
-    ("function" !== typeof instance.UNSAFE_componentWillMount &&
-      "function" !== typeof instance.componentWillMount) ||
-    ((ctor = instance.state),
-    "function" === typeof instance.componentWillMount &&
-      instance.componentWillMount(),
-    "function" === typeof instance.UNSAFE_componentWillMount &&
-      instance.UNSAFE_componentWillMount(),
-    ctor !== instance.state &&
-      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
-    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof instance.componentDidMount &&
-    (workInProgress.flags |= 4194308);
-}
-function createCapturedValueAtFiber(value, source) {
-  try {
-    var info = "",
-      node = source;
-    do (info += describeFiber(node)), (node = node.return);
-    while (node);
-    var JSCompiler_inline_result = info;
-  } catch (x) {
-    JSCompiler_inline_result =
-      "\nError generating stack: " + x.message + "\n" + x.stack;
+function updateDehydratedSuspenseComponent(
+  current,
+  workInProgress,
+  didSuspend,
+  nextProps,
+  suspenseInstance,
+  suspenseState,
+  renderLanes
+) {
+  if (didSuspend) {
+    if (workInProgress.flags & 256)
+      return (
+        pushPrimaryTreeSuspenseHandler(workInProgress),
+        (workInProgress.flags &= -257),
+        (suspenseState = createCapturedValue(
+          Error(formatProdErrorMessage(422))
+        )),
+        retrySuspenseComponentWithoutHydrating(
+          current,
+          workInProgress,
+          renderLanes,
+          suspenseState
+        )
+      );
+    if (null !== workInProgress.memoizedState)
+      return (
+        reuseSuspenseHandlerOnStack(),
+        (workInProgress.child = current.child),
+        (workInProgress.flags |= 128),
+        null
+      );
+    reuseSuspenseHandlerOnStack();
+    suspenseState = nextProps.fallback;
+    suspenseInstance = workInProgress.mode;
+    nextProps = createFiberFromOffscreen(
+      { mode: "visible", children: nextProps.children },
+      suspenseInstance,
+      0,
+      null
+    );
+    suspenseState = createFiberFromFragment(
+      suspenseState,
+      suspenseInstance,
+      renderLanes,
+      null
+    );
+    suspenseState.flags |= 2;
+    nextProps.return = workInProgress;
+    suspenseState.return = workInProgress;
+    nextProps.sibling = suspenseState;
+    workInProgress.child = nextProps;
+    0 !== (workInProgress.mode & 1) &&
+      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+    workInProgress.child.memoizedState =
+      mountSuspenseOffscreenState(renderLanes);
+    workInProgress.memoizedState = SUSPENDED_MARKER;
+    return suspenseState;
   }
-  return {
-    value: value,
-    source: source,
-    stack: JSCompiler_inline_result,
-    digest: null
-  };
-}
-function createCapturedValue(value, digest, stack) {
-  return {
-    value: value,
-    source: null,
-    stack: null != stack ? stack : null,
-    digest: null != digest ? digest : null
-  };
-}
-var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
-if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
-  throw Error(formatProdErrorMessage(320));
-function logCapturedError(boundary, errorInfo) {
-  try {
-    !1 !==
-      ReactFiberErrorDialogWWW.showErrorDialog({
-        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
-        error: errorInfo.value,
-        errorBoundary:
-          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
-      }) && console.error(errorInfo.value);
-  } catch (e$104) {
-    setTimeout(function () {
-      throw e$104;
-    });
+  pushPrimaryTreeSuspenseHandler(workInProgress);
+  if (0 === (workInProgress.mode & 1))
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      null
+    );
+  if ("$!" === suspenseInstance.data) {
+    suspenseState =
+      suspenseInstance.nextSibling && suspenseInstance.nextSibling.dataset;
+    if (suspenseState) var digest = suspenseState.dgst;
+    suspenseState = digest;
+    nextProps = Error(formatProdErrorMessage(419));
+    nextProps.digest = suspenseState;
+    suspenseState = createCapturedValue(nextProps, suspenseState, void 0);
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      suspenseState
+    );
   }
-}
-function createRootErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  lane.payload = { element: null };
-  var error = errorInfo.value;
-  lane.callback = function () {
-    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
-    logCapturedError(fiber, errorInfo);
-  };
-  return lane;
-}
-function createClassErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
-  if ("function" === typeof getDerivedStateFromError) {
-    var error = errorInfo.value;
-    lane.payload = function () {
-      return getDerivedStateFromError(error);
-    };
-    lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-    };
+  enableLazyContextPropagation &&
+    !didReceiveUpdate &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !1);
+  digest = 0 !== (renderLanes & current.childLanes);
+  if (didReceiveUpdate || digest) {
+    nextProps = workInProgressRoot;
+    if (null !== nextProps) {
+      suspenseInstance = renderLanes & -renderLanes;
+      if (enableUnifiedSyncLane && 0 !== (suspenseInstance & 42))
+        suspenseInstance = 1;
+      else
+        switch (suspenseInstance) {
+          case 2:
+            suspenseInstance = 1;
+            break;
+          case 8:
+            suspenseInstance = 4;
+            break;
+          case 32:
+            suspenseInstance = 16;
+            break;
+          case 128:
+          case 256:
+          case 512:
+          case 1024:
+          case 2048:
+          case 4096:
+          case 8192:
+          case 16384:
+          case 32768:
+          case 65536:
+          case 131072:
+          case 262144:
+          case 524288:
+          case 1048576:
+          case 2097152:
+          case 4194304:
+          case 8388608:
+          case 16777216:
+          case 33554432:
+          case 67108864:
+            suspenseInstance = 64;
+            break;
+          case 536870912:
+            suspenseInstance = 268435456;
+            break;
+          default:
+            suspenseInstance = 0;
+        }
+      suspenseInstance =
+        0 !== (suspenseInstance & (nextProps.suspendedLanes | renderLanes))
+          ? 0
+          : suspenseInstance;
+      if (
+        0 !== suspenseInstance &&
+        suspenseInstance !== suspenseState.retryLane
+      )
+        throw (
+          ((suspenseState.retryLane = suspenseInstance),
+          enqueueConcurrentRenderForLane(current, suspenseInstance),
+          scheduleUpdateOnFiber(nextProps, current, suspenseInstance, -1),
+          SelectiveHydrationException)
+        );
+    }
+    renderDidSuspendDelayIfPossible();
+    return retrySuspenseComponentWithoutHydrating(
+      current,
+      workInProgress,
+      renderLanes,
+      null
+    );
   }
-  var inst = fiber.stateNode;
-  null !== inst &&
-    "function" === typeof inst.componentDidCatch &&
-    (lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-      "function" !== typeof getDerivedStateFromError &&
-        (null === legacyErrorBoundariesThatAlreadyFailed
-          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
-          : legacyErrorBoundariesThatAlreadyFailed.add(this));
-      var stack = errorInfo.stack;
-      this.componentDidCatch(errorInfo.value, {
-        componentStack: null !== stack ? stack : ""
-      });
-    });
-  return lane;
-}
-function markSuspenseBoundaryShouldCapture(
-  suspenseBoundary,
-  returnFiber,
-  sourceFiber,
-  root,
-  rootRenderLanes
-) {
-  if (0 === (suspenseBoundary.mode & 1))
+  if ("$?" === suspenseInstance.data)
     return (
-      suspenseBoundary === returnFiber
-        ? (suspenseBoundary.flags |= 65536)
-        : ((suspenseBoundary.flags |= 128),
-          (sourceFiber.flags |= 131072),
-          (sourceFiber.flags &= -52805),
-          1 === sourceFiber.tag &&
-            (null === sourceFiber.alternate
-              ? (sourceFiber.tag = 17)
-              : ((returnFiber = createUpdate(2)),
-                (returnFiber.tag = 2),
-                enqueueUpdate(sourceFiber, returnFiber, 2))),
-          (sourceFiber.lanes |= 2)),
-      suspenseBoundary
+      (workInProgress.flags |= 128),
+      (workInProgress.child = current.child),
+      (workInProgress = retryDehydratedSuspenseBoundary.bind(null, current)),
+      (suspenseInstance._reactRetry = workInProgress),
+      null
     );
-  suspenseBoundary.flags |= 65536;
-  suspenseBoundary.lanes = rootRenderLanes;
-  return suspenseBoundary;
-}
-function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
-  if (enableTransitionTracing && null !== pendingTransitions) {
-    var transitionStart = pendingTransitions.transitionStart,
-      onTransitionStart = callbacks.onTransitionStart;
-    null !== transitionStart &&
-      null != onTransitionStart &&
-      transitionStart.forEach(function (transition) {
-        return onTransitionStart(transition.name, transition.startTime);
-      });
-    transitionStart = pendingTransitions.markerProgress;
-    var onMarkerProgress = callbacks.onMarkerProgress;
-    null != onMarkerProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (markerInstance, markerName) {
-        if (null !== markerInstance.transitions) {
-          var pending =
-            null !== markerInstance.pendingBoundaries
-              ? Array.from(markerInstance.pendingBoundaries.values())
-              : [];
-          markerInstance.transitions.forEach(function (transition) {
-            onMarkerProgress(
-              transition.name,
-              markerName,
-              transition.startTime,
-              endTime,
-              pending
-            );
-          });
-        }
-      });
-    transitionStart = pendingTransitions.markerComplete;
-    var onMarkerComplete = callbacks.onMarkerComplete;
-    null !== transitionStart &&
-      null != onMarkerComplete &&
-      transitionStart.forEach(function (transitions, markerName) {
-        transitions.forEach(function (transition) {
-          onMarkerComplete(
-            transition.name,
-            markerName,
-            transition.startTime,
-            endTime
-          );
-        });
-      });
-    transitionStart = pendingTransitions.markerIncomplete;
-    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
-    null != onMarkerIncomplete &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (_ref, markerName) {
-        var aborts = _ref.aborts;
-        _ref.transitions.forEach(function (transition) {
-          var filteredAborts = [];
-          aborts.forEach(function (abort) {
-            switch (abort.reason) {
-              case "marker":
-                filteredAborts.push({
-                  type: "marker",
-                  name: abort.name,
-                  endTime: endTime
-                });
-                break;
-              case "suspense":
-                filteredAborts.push({
-                  type: "suspense",
-                  name: abort.name,
-                  endTime: endTime
-                });
-            }
-          });
-          0 < filteredAborts.length &&
-            onMarkerIncomplete(
-              transition.name,
-              markerName,
-              transition.startTime,
-              filteredAborts
-            );
-        });
-      });
-    transitionStart = pendingTransitions.transitionProgress;
-    var onTransitionProgress = callbacks.onTransitionProgress;
-    null != onTransitionProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (pending, transition) {
-        onTransitionProgress(
-          transition.name,
-          transition.startTime,
-          endTime,
-          Array.from(pending.values())
-        );
-      });
-    pendingTransitions = pendingTransitions.transitionComplete;
-    var onTransitionComplete = callbacks.onTransitionComplete;
-    null !== pendingTransitions &&
-      null != onTransitionComplete &&
-      pendingTransitions.forEach(function (transition) {
-        return onTransitionComplete(
-          transition.name,
-          transition.startTime,
-          endTime
-        );
-      });
-  }
-}
-var markerInstanceStack = createCursor(null);
-function pushRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    var transitions = workInProgressTransitions,
-      root$110 = workInProgress.stateNode;
-    null !== transitions &&
-      transitions.forEach(function (transition) {
-        if (!root$110.incompleteTransitions.has(transition)) {
-          var markerInstance = {
-            tag: 0,
-            transitions: new Set([transition]),
-            pendingBoundaries: null,
-            aborts: null,
-            name: null
-          };
-          root$110.incompleteTransitions.set(transition, markerInstance);
-        }
-      });
-    var markerInstances = [];
-    root$110.incompleteTransitions.forEach(function (markerInstance) {
-      markerInstances.push(markerInstance);
-    });
-    push(markerInstanceStack, markerInstances);
-  }
-}
-function pushMarkerInstance(workInProgress, markerInstance) {
-  enableTransitionTracing &&
-    (null === markerInstanceStack.current
-      ? push(markerInstanceStack, [markerInstance])
-      : push(
-          markerInstanceStack,
-          markerInstanceStack.current.concat(markerInstance)
-        ));
-}
-var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
-  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
-  didReceiveUpdate = !1;
-function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
-  workInProgress.child =
-    null === current
-      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
-      : reconcileChildFibers(
-          workInProgress,
-          current.child,
-          nextChildren,
-          renderLanes
-        );
-}
-function updateForwardRef(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  Component = Component.render;
-  var ref = workInProgress.ref;
-  prepareToReadContext(workInProgress, renderLanes);
-  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-  nextProps = renderWithHooks(
-    current,
+  current = suspenseState.treeContext;
+  nextHydratableInstance = getNextHydratable(suspenseInstance.nextSibling);
+  hydrationParentFiber = workInProgress;
+  isHydrating = !0;
+  hydrationErrors = null;
+  rootOrSingletonContext = !1;
+  null !== current &&
+    ((idStack[idStackIndex++] = treeContextId),
+    (idStack[idStackIndex++] = treeContextOverflow),
+    (idStack[idStackIndex++] = treeContextProvider),
+    (treeContextId = current.id),
+    (treeContextOverflow = current.overflow),
+    (treeContextProvider = workInProgress));
+  workInProgress = mountSuspensePrimaryChildren(
     workInProgress,
-    Component,
-    nextProps,
-    ref,
-    renderLanes
+    nextProps.children
   );
-  Component = checkDidRenderIdHook();
-  enableSchedulingProfiler && markComponentRenderStopped();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && Component && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, nextProps, renderLanes);
-  return workInProgress.child;
+  workInProgress.flags |= 4096;
+  return workInProgress;
 }
-function updateMemoComponent(
-  current,
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes |= renderLanes;
+  var alternate = fiber.alternate;
+  null !== alternate && (alternate.lanes |= renderLanes);
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+}
+function initSuspenseListRenderState(
   workInProgress,
-  Component,
-  nextProps,
-  renderLanes
+  isBackwards,
+  tail,
+  lastContentRow,
+  tailMode
 ) {
-  if (null === current) {
-    var type = Component.type;
-    if (
-      "function" === typeof type &&
-      !shouldConstruct(type) &&
-      void 0 === type.defaultProps &&
-      null === Component.compare &&
-      void 0 === Component.defaultProps
-    )
-      return (
-        (workInProgress.tag = 15),
-        (workInProgress.type = type),
-        updateSimpleMemoComponent(
-          current,
-          workInProgress,
-          type,
-          nextProps,
-          renderLanes
-        )
-      );
-    current = createFiberFromTypeAndProps(
-      Component.type,
-      null,
-      nextProps,
-      workInProgress,
-      workInProgress.mode,
-      renderLanes
-    );
-    current.ref = workInProgress.ref;
-    current.return = workInProgress;
-    return (workInProgress.child = current);
+  var renderState = workInProgress.memoizedState;
+  null === renderState
+    ? (workInProgress.memoizedState = {
+        isBackwards: isBackwards,
+        rendering: null,
+        renderingStartTime: 0,
+        last: lastContentRow,
+        tail: tail,
+        tailMode: tailMode
+      })
+    : ((renderState.isBackwards = isBackwards),
+      (renderState.rendering = null),
+      (renderState.renderingStartTime = 0),
+      (renderState.last = lastContentRow),
+      (renderState.tail = tail),
+      (renderState.tailMode = tailMode));
+}
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    revealOrder = nextProps.revealOrder,
+    tailMode = nextProps.tail;
+  reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
+  nextProps = suspenseStackCursor.current;
+  if (0 !== (nextProps & 2))
+    (nextProps = (nextProps & 1) | 2), (workInProgress.flags |= 128);
+  else {
+    if (null !== current && 0 !== (current.flags & 128))
+      a: for (current = workInProgress.child; null !== current; ) {
+        if (13 === current.tag)
+          null !== current.memoizedState &&
+            scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
+        else if (19 === current.tag)
+          scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
+        else if (null !== current.child) {
+          current.child.return = current;
+          current = current.child;
+          continue;
+        }
+        if (current === workInProgress) break a;
+        for (; null === current.sibling; ) {
+          if (null === current.return || current.return === workInProgress)
+            break a;
+          current = current.return;
+        }
+        current.sibling.return = current.return;
+        current = current.sibling;
+      }
+    nextProps &= 1;
   }
-  type = current.child;
-  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
-    var prevProps = type.memoizedProps;
-    Component = Component.compare;
-    Component = null !== Component ? Component : shallowEqual;
-    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  push(suspenseStackCursor, nextProps);
+  if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;
+  else
+    switch (revealOrder) {
+      case "forwards":
+        renderLanes = workInProgress.child;
+        for (revealOrder = null; null !== renderLanes; )
+          (current = renderLanes.alternate),
+            null !== current &&
+              null === findFirstSuspended(current) &&
+              (revealOrder = renderLanes),
+            (renderLanes = renderLanes.sibling);
+        renderLanes = revealOrder;
+        null === renderLanes
+          ? ((revealOrder = workInProgress.child),
+            (workInProgress.child = null))
+          : ((revealOrder = renderLanes.sibling), (renderLanes.sibling = null));
+        initSuspenseListRenderState(
+          workInProgress,
+          !1,
+          revealOrder,
+          renderLanes,
+          tailMode
+        );
+        break;
+      case "backwards":
+        renderLanes = null;
+        revealOrder = workInProgress.child;
+        for (workInProgress.child = null; null !== revealOrder; ) {
+          current = revealOrder.alternate;
+          if (null !== current && null === findFirstSuspended(current)) {
+            workInProgress.child = revealOrder;
+            break;
+          }
+          current = revealOrder.sibling;
+          revealOrder.sibling = renderLanes;
+          renderLanes = revealOrder;
+          revealOrder = current;
+        }
+        initSuspenseListRenderState(
+          workInProgress,
+          !0,
+          renderLanes,
+          null,
+          tailMode
+        );
+        break;
+      case "together":
+        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+        break;
+      default:
+        workInProgress.memoizedState = null;
+    }
+  return workInProgress.child;
+}
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  0 === (workInProgress.mode & 1) &&
+    null !== current &&
+    ((current.alternate = null),
+    (workInProgress.alternate = null),
+    (workInProgress.flags |= 2));
+}
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  null !== current && (workInProgress.dependencies = current.dependencies);
+  profilerStartTime = -1;
+  workInProgressRootSkippedLanes |= workInProgress.lanes;
+  if (0 === (renderLanes & workInProgress.childLanes))
+    if (enableLazyContextPropagation && null !== current) {
+      if (
+        (propagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+          !1
+        ),
+        0 === (renderLanes & workInProgress.childLanes))
+      )
+        return null;
+    } else return null;
+  if (null !== current && workInProgress.child !== current.child)
+    throw Error(formatProdErrorMessage(153));
+  if (null !== workInProgress.child) {
+    current = workInProgress.child;
+    renderLanes = createWorkInProgress(current, current.pendingProps);
+    workInProgress.child = renderLanes;
+    for (renderLanes.return = workInProgress; null !== current.sibling; )
+      (current = current.sibling),
+        (renderLanes = renderLanes.sibling =
+          createWorkInProgress(current, current.pendingProps)),
+        (renderLanes.return = workInProgress);
+    renderLanes.sibling = null;
   }
-  workInProgress.flags |= 1;
-  current = createWorkInProgress(type, nextProps);
-  current.ref = workInProgress.ref;
-  current.return = workInProgress;
-  return (workInProgress.child = current);
+  return workInProgress.child;
 }
-function updateSimpleMemoComponent(
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  return 0 !== (current.lanes & renderLanes) ||
+    (enableLazyContextPropagation &&
+      ((current = current.dependencies),
+      null !== current && checkIfContextChanged(current)))
+    ? !0
+    : !1;
+}
+function attemptEarlyBailoutIfNoScheduledUpdate(
   current,
   workInProgress,
-  Component,
-  nextProps,
   renderLanes
 ) {
-  if (null !== current) {
-    var prevProps = current.memoizedProps;
-    if (
-      shallowEqual(prevProps, nextProps) &&
-      current.ref === workInProgress.ref
-    )
-      if (
-        ((didReceiveUpdate = !1),
-        (workInProgress.pendingProps = nextProps = prevProps),
-        checkScheduledUpdateOrContext(current, renderLanes))
-      )
-        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
-      else
-        return (
-          (workInProgress.lanes = current.lanes),
-          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-        );
-  }
-  return updateFunctionComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    renderLanes
-  );
-}
-function updateOffscreenComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    nextChildren = nextProps.children,
-    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
-    prevState = null !== current ? current.memoizedState : null;
-  markRef$1(current, workInProgress);
-  if (
-    "hidden" === nextProps.mode ||
-    "unstable-defer-without-hiding" === nextProps.mode ||
-    nextIsDetached
-  ) {
-    if (0 !== (workInProgress.flags & 128)) {
-      nextChildren =
-        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
-      if (null !== current) {
-        prevState = workInProgress.child = current.child;
-        for (nextProps = 0; null !== prevState; )
-          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
-            (prevState = prevState.sibling);
-        workInProgress.childLanes = nextProps & ~nextChildren;
-      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
-      return deferHiddenOffscreenComponent(
-        current,
+  switch (workInProgress.tag) {
+    case 3:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      enableTransitionTracing &&
+        push(transitionStack, workInProgressTransitions);
+      enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      resetHydrationState();
+      break;
+    case 27:
+    case 5:
+      pushHostContext(workInProgress);
+      break;
+    case 4:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
+    case 10:
+      pushProvider(
         workInProgress,
-        nextChildren,
-        renderLanes
+        workInProgress.type._context,
+        workInProgress.memoizedProps.value
       );
-    }
-    if (0 === (workInProgress.mode & 1))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current && pushTransition(workInProgress, null, null),
-        reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else if (0 !== (renderLanes & 1073741824))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current &&
-          pushTransition(
-            workInProgress,
-            null !== prevState ? prevState.cachePool : null,
-            null
-          ),
-        null !== prevState
-          ? pushHiddenContext(workInProgress, prevState)
-          : reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else
-      return (
-        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
-        deferHiddenOffscreenComponent(
+      break;
+    case 12:
+      0 !== (renderLanes & workInProgress.childLanes) &&
+        (workInProgress.flags |= 4);
+      var stateNode = workInProgress.stateNode;
+      stateNode.effectDuration = 0;
+      stateNode.passiveEffectDuration = 0;
+      break;
+    case 13:
+      stateNode = workInProgress.memoizedState;
+      if (null !== stateNode) {
+        if (null !== stateNode.dehydrated)
+          return (
+            pushPrimaryTreeSuspenseHandler(workInProgress),
+            (workInProgress.flags |= 128),
+            null
+          );
+        if (0 !== (renderLanes & workInProgress.child.childLanes))
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+        current = bailoutOnAlreadyFinishedWork(
           current,
           workInProgress,
-          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
           renderLanes
-        )
+        );
+        return null !== current ? current.sibling : null;
+      }
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      break;
+    case 19:
+      var didSuspendBefore = 0 !== (current.flags & 128);
+      stateNode = 0 !== (renderLanes & workInProgress.childLanes);
+      enableLazyContextPropagation &&
+        !stateNode &&
+        (propagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+          !1
+        ),
+        (stateNode = 0 !== (renderLanes & workInProgress.childLanes)));
+      if (didSuspendBefore) {
+        if (stateNode)
+          return updateSuspenseListComponent(
+            current,
+            workInProgress,
+            renderLanes
+          );
+        workInProgress.flags |= 128;
+      }
+      didSuspendBefore = workInProgress.memoizedState;
+      null !== didSuspendBefore &&
+        ((didSuspendBefore.rendering = null),
+        (didSuspendBefore.tail = null),
+        (didSuspendBefore.lastEffect = null));
+      push(suspenseStackCursor, suspenseStackCursor.current);
+      if (stateNode) break;
+      else return null;
+    case 22:
+    case 23:
+      return (
+        (workInProgress.lanes = 0),
+        updateOffscreenComponent(current, workInProgress, renderLanes)
       );
-  } else if (null !== prevState) {
-    nextProps = prevState.cachePool;
-    nextIsDetached = null;
-    if (enableTransitionTracing) {
-      var instance = workInProgress.stateNode;
-      null !== instance &&
-        null != instance._transitions &&
-        (nextIsDetached = Array.from(instance._transitions));
-    }
-    pushTransition(workInProgress, nextProps, nextIsDetached);
-    pushHiddenContext(workInProgress, prevState);
-    reuseSuspenseHandlerOnStack();
-    workInProgress.memoizedState = null;
-  } else
-    null !== current && pushTransition(workInProgress, null, null),
-      reuseHiddenContextOnStack(),
-      reuseSuspenseHandlerOnStack();
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+    case 24:
+      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        ((stateNode = workInProgress.stateNode),
+        null !== stateNode && pushMarkerInstance(workInProgress, stateNode));
+  }
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
 }
-function deferHiddenOffscreenComponent(
-  current,
-  workInProgress,
-  nextBaseLanes,
-  renderLanes
-) {
-  var JSCompiler_inline_result = peekCacheFromPool();
-  JSCompiler_inline_result =
-    null === JSCompiler_inline_result
-      ? null
-      : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
-  workInProgress.memoizedState = {
-    baseLanes: nextBaseLanes,
-    cachePool: JSCompiler_inline_result
-  };
-  null !== current && pushTransition(workInProgress, null, null);
-  reuseHiddenContextOnStack();
-  pushOffscreenSuspenseHandler(workInProgress);
-  enableLazyContextPropagation &&
-    null !== current &&
-    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
-  return null;
+var valueCursor = createCursor(null),
+  currentlyRenderingFiber = null,
+  lastContextDependency = null,
+  lastFullyObservedContext = null;
+function resetContextDependencies() {
+  lastFullyObservedContext =
+    lastContextDependency =
+    currentlyRenderingFiber =
+      null;
 }
-function markRef$1(current, workInProgress) {
-  var ref = workInProgress.ref;
-  if (
-    (null === current && null !== ref) ||
-    (null !== current && current.ref !== ref)
-  )
-    (workInProgress.flags |= 512), (workInProgress.flags |= 2097152);
+function pushProvider(providerFiber, context, nextValue) {
+  push(valueCursor, context._currentValue);
+  context._currentValue = nextValue;
 }
-function updateFunctionComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  prepareToReadContext(workInProgress, renderLanes);
-  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-  Component = renderWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    void 0,
-    renderLanes
-  );
-  nextProps = checkDidRenderIdHook();
-  enableSchedulingProfiler && markComponentRenderStopped();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && nextProps && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, Component, renderLanes);
-  return workInProgress.child;
+function popProvider(context) {
+  var currentValue = valueCursor.current;
+  context._currentValue =
+    currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED
+      ? context._defaultValue
+      : currentValue;
+  pop(valueCursor);
 }
-function replayFunctionComponent(
-  current,
-  workInProgress,
-  nextProps,
-  Component,
-  renderLanes
-) {
-  prepareToReadContext(workInProgress, renderLanes);
-  enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-  nextProps = renderWithHooksAgain(
-    workInProgress,
-    Component,
-    nextProps,
-    void 0
-  );
-  finishRenderingHooks(current);
-  Component = checkDidRenderIdHook();
-  enableSchedulingProfiler && markComponentRenderStopped();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && Component && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, nextProps, renderLanes);
-  return workInProgress.child;
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  for (; null !== parent; ) {
+    var alternate = parent.alternate;
+    (parent.childLanes & renderLanes) !== renderLanes
+      ? ((parent.childLanes |= renderLanes),
+        null !== alternate && (alternate.childLanes |= renderLanes))
+      : null !== alternate &&
+        (alternate.childLanes & renderLanes) !== renderLanes &&
+        (alternate.childLanes |= renderLanes);
+    if (parent === propagationRoot) break;
+    parent = parent.return;
+  }
 }
-function updateClassComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  prepareToReadContext(workInProgress, renderLanes);
-  if (null === workInProgress.stateNode)
-    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-      constructClassInstance(workInProgress, Component, nextProps),
-      mountClassInstance(workInProgress, Component, nextProps, renderLanes),
-      (nextProps = !0);
-  else if (null === current) {
-    var instance = workInProgress.stateNode,
-      oldProps = workInProgress.memoizedProps;
-    instance.props = oldProps;
-    var oldContext = instance.context,
-      contextType = Component.contextType,
-      nextContext = emptyContextObject;
-    "object" === typeof contextType &&
-      null !== contextType &&
-      (nextContext = readContext(contextType));
-    var getDerivedStateFromProps = Component.getDerivedStateFromProps;
-    (contextType =
-      "function" === typeof getDerivedStateFromProps ||
-      "function" === typeof instance.getSnapshotBeforeUpdate) ||
-      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
-        "function" !== typeof instance.componentWillReceiveProps) ||
-      ((oldProps !== nextProps || oldContext !== nextContext) &&
-        callComponentWillReceiveProps(
-          workInProgress,
-          instance,
-          nextProps,
-          nextContext
-        ));
-    hasForceUpdate = !1;
-    var oldState = workInProgress.memoizedState;
-    instance.state = oldState;
-    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
-    oldContext = workInProgress.memoizedState;
-    oldProps !== nextProps || oldState !== oldContext || hasForceUpdate
-      ? ("function" === typeof getDerivedStateFromProps &&
-          (applyDerivedStateFromProps(
-            workInProgress,
-            Component,
-            getDerivedStateFromProps,
-            nextProps
-          ),
-          (oldContext = workInProgress.memoizedState)),
-        (oldProps =
-          hasForceUpdate ||
-          checkShouldComponentUpdate(
-            workInProgress,
-            Component,
-            oldProps,
-            nextProps,
-            oldState,
-            oldContext,
-            nextContext
-          ))
-          ? (contextType ||
-              ("function" !== typeof instance.UNSAFE_componentWillMount &&
-                "function" !== typeof instance.componentWillMount) ||
-              ("function" === typeof instance.componentWillMount &&
-                instance.componentWillMount(),
-              "function" === typeof instance.UNSAFE_componentWillMount &&
-                instance.UNSAFE_componentWillMount()),
-            "function" === typeof instance.componentDidMount &&
-              (workInProgress.flags |= 4194308))
-          : ("function" === typeof instance.componentDidMount &&
-              (workInProgress.flags |= 4194308),
-            (workInProgress.memoizedProps = nextProps),
-            (workInProgress.memoizedState = oldContext)),
-        (instance.props = nextProps),
-        (instance.state = oldContext),
-        (instance.context = nextContext),
-        (nextProps = oldProps))
-      : ("function" === typeof instance.componentDidMount &&
-          (workInProgress.flags |= 4194308),
-        (nextProps = !1));
-  } else {
-    instance = workInProgress.stateNode;
-    cloneUpdateQueue(current, workInProgress);
-    nextContext = workInProgress.memoizedProps;
-    contextType =
-      workInProgress.type === workInProgress.elementType
-        ? nextContext
-        : resolveDefaultProps(workInProgress.type, nextContext);
-    instance.props = contextType;
-    getDerivedStateFromProps = workInProgress.pendingProps;
-    var oldContext$jscomp$0 = instance.context;
-    oldContext = Component.contextType;
-    oldProps = emptyContextObject;
-    "object" === typeof oldContext &&
-      null !== oldContext &&
-      (oldProps = readContext(oldContext));
-    oldState = Component.getDerivedStateFromProps;
-    (oldContext =
-      "function" === typeof oldState ||
-      "function" === typeof instance.getSnapshotBeforeUpdate) ||
-      ("function" !== typeof instance.UNSAFE_componentWillReceiveProps &&
-        "function" !== typeof instance.componentWillReceiveProps) ||
-      ((nextContext !== getDerivedStateFromProps ||
-        oldContext$jscomp$0 !== oldProps) &&
-        callComponentWillReceiveProps(
-          workInProgress,
-          instance,
-          nextProps,
-          oldProps
-        ));
-    hasForceUpdate = !1;
-    oldContext$jscomp$0 = workInProgress.memoizedState;
-    instance.state = oldContext$jscomp$0;
-    processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
-    var newState = workInProgress.memoizedState;
-    nextContext !== getDerivedStateFromProps ||
-    oldContext$jscomp$0 !== newState ||
-    hasForceUpdate ||
-    (enableLazyContextPropagation &&
-      null !== current &&
-      null !== current.dependencies &&
-      checkIfContextChanged(current.dependencies))
-      ? ("function" === typeof oldState &&
-          (applyDerivedStateFromProps(
-            workInProgress,
-            Component,
-            oldState,
-            nextProps
-          ),
-          (newState = workInProgress.memoizedState)),
-        (contextType =
-          hasForceUpdate ||
-          checkShouldComponentUpdate(
-            workInProgress,
-            Component,
-            contextType,
-            nextProps,
-            oldContext$jscomp$0,
-            newState,
-            oldProps
-          ) ||
-          (enableLazyContextPropagation &&
-            null !== current &&
-            null !== current.dependencies &&
-            checkIfContextChanged(current.dependencies)))
-          ? (oldContext ||
-              ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
-                "function" !== typeof instance.componentWillUpdate) ||
-              ("function" === typeof instance.componentWillUpdate &&
-                instance.componentWillUpdate(nextProps, newState, oldProps),
-              "function" === typeof instance.UNSAFE_componentWillUpdate &&
-                instance.UNSAFE_componentWillUpdate(
-                  nextProps,
-                  newState,
-                  oldProps
-                )),
-            "function" === typeof instance.componentDidUpdate &&
-              (workInProgress.flags |= 4),
-            "function" === typeof instance.getSnapshotBeforeUpdate &&
-              (workInProgress.flags |= 1024))
-          : ("function" !== typeof instance.componentDidUpdate ||
-              (nextContext === current.memoizedProps &&
-                oldContext$jscomp$0 === current.memoizedState) ||
-              (workInProgress.flags |= 4),
-            "function" !== typeof instance.getSnapshotBeforeUpdate ||
-              (nextContext === current.memoizedProps &&
-                oldContext$jscomp$0 === current.memoizedState) ||
-              (workInProgress.flags |= 1024),
-            (workInProgress.memoizedProps = nextProps),
-            (workInProgress.memoizedState = newState)),
-        (instance.props = nextProps),
-        (instance.state = newState),
-        (instance.context = oldProps),
-        (nextProps = contextType))
-      : ("function" !== typeof instance.componentDidUpdate ||
-          (nextContext === current.memoizedProps &&
-            oldContext$jscomp$0 === current.memoizedState) ||
-          (workInProgress.flags |= 4),
-        "function" !== typeof instance.getSnapshotBeforeUpdate ||
-          (nextContext === current.memoizedProps &&
-            oldContext$jscomp$0 === current.memoizedState) ||
-          (workInProgress.flags |= 1024),
-        (nextProps = !1));
+function propagateContextChange(workInProgress, context, renderLanes) {
+  if (enableLazyContextPropagation)
+    propagateContextChanges(workInProgress, [context], renderLanes, !0);
+  else if (!enableLazyContextPropagation) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber; ) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        for (var dependency = list.firstContext; null !== dependency; ) {
+          if (dependency.context === context) {
+            if (1 === fiber.tag) {
+              dependency = createUpdate(renderLanes & -renderLanes);
+              dependency.tag = 2;
+              var updateQueue = fiber.updateQueue;
+              if (null !== updateQueue) {
+                updateQueue = updateQueue.shared;
+                var pending = updateQueue.pending;
+                null === pending
+                  ? (dependency.next = dependency)
+                  : ((dependency.next = pending.next),
+                    (pending.next = dependency));
+                updateQueue.pending = dependency;
+              }
+            }
+            fiber.lanes |= renderLanes;
+            dependency = fiber.alternate;
+            null !== dependency && (dependency.lanes |= renderLanes);
+            scheduleContextWorkOnParentPath(
+              fiber.return,
+              renderLanes,
+              workInProgress
+            );
+            list.lanes |= renderLanes;
+            break;
+          }
+          dependency = dependency.next;
+        }
+      } else if (10 === fiber.tag)
+        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+      else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = fiber.sibling;
+      } else 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;
+    }
   }
-  return finishClassComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    !1,
-    renderLanes
-  );
-}
-function finishClassComponent(
-  current,
-  workInProgress,
-  Component,
-  shouldUpdate,
-  hasContext,
-  renderLanes
-) {
-  markRef$1(current, workInProgress);
-  hasContext = 0 !== (workInProgress.flags & 128);
-  if (!shouldUpdate && !hasContext)
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  shouldUpdate = workInProgress.stateNode;
-  ReactCurrentOwner$1.current = workInProgress;
-  hasContext && "function" !== typeof Component.getDerivedStateFromError
-    ? ((Component = null), (profilerStartTime = -1))
-    : (enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
-      (Component = shouldUpdate.render()),
-      enableSchedulingProfiler && markComponentRenderStopped());
-  workInProgress.flags |= 1;
-  null !== current && hasContext
-    ? ((workInProgress.child = reconcileChildFibers(
-        workInProgress,
-        current.child,
-        null,
-        renderLanes
-      )),
-      (workInProgress.child = reconcileChildFibers(
-        workInProgress,
-        null,
-        Component,
-        renderLanes
-      )))
-    : reconcileChildren(current, workInProgress, Component, renderLanes);
-  workInProgress.memoizedState = shouldUpdate.state;
-  return workInProgress.child;
 }
-function mountHostRootWithoutHydrating(
-  current,
+function propagateContextChanges(
   workInProgress,
-  nextChildren,
+  contexts,
   renderLanes,
-  recoverableError
+  forcePropagateEntireTree
 ) {
-  resetHydrationState();
-  queueHydrationError(recoverableError);
-  workInProgress.flags |= 256;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
-var SUSPENDED_MARKER = { dehydrated: null, treeContext: null, retryLane: 0 };
-function mountSuspenseOffscreenState(renderLanes) {
-  return { baseLanes: renderLanes, cachePool: getSuspendedCache() };
-}
-function updateSuspenseComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    showFallback = !1,
-    didSuspend = 0 !== (workInProgress.flags & 128),
-    JSCompiler_temp;
-  (JSCompiler_temp = didSuspend) ||
-    (JSCompiler_temp =
-      null !== current && null === current.memoizedState
-        ? !1
-        : 0 !== (suspenseStackCursor.current & 2));
-  JSCompiler_temp && ((showFallback = !0), (workInProgress.flags &= -129));
-  if (null === current) {
-    if (isHydrating) {
-      showFallback
-        ? pushPrimaryTreeSuspenseHandler(workInProgress)
-        : reuseSuspenseHandlerOnStack();
-      isHydrating &&
-        (((current = nextHydratableInstance),
-        rootOrSingletonContext && advanceToFirstAttemptableSuspenseInstance(),
-        (didSuspend = nextHydratableInstance),
-        didSuspend)
-          ? tryHydrateSuspense(workInProgress, didSuspend) ||
-            (shouldClientRenderOnMismatch(workInProgress) &&
-              throwOnHydrationMismatch(),
-            (nextHydratableInstance = getNextHydratable(
-              didSuspend.nextSibling
-            )),
-            (JSCompiler_temp = hydrationParentFiber),
-            rootOrSingletonContext &&
-              advanceToFirstAttemptableSuspenseInstance(),
-            nextHydratableInstance &&
-            tryHydrateSuspense(workInProgress, nextHydratableInstance)
-              ? deleteHydratableInstance(JSCompiler_temp, didSuspend)
-              : (insertNonHydratedInstance(
-                  hydrationParentFiber,
-                  workInProgress
-                ),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = current)))
-          : (shouldClientRenderOnMismatch(workInProgress) &&
-              throwOnHydrationMismatch(),
-            insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-            (isHydrating = !1),
-            (hydrationParentFiber = workInProgress),
-            (nextHydratableInstance = current)));
-      current = workInProgress.memoizedState;
-      if (
-        null !== current &&
-        ((current = current.dehydrated), null !== current)
-      )
-        return (
-          0 === (workInProgress.mode & 1)
-            ? (workInProgress.lanes = 2)
-            : "$!" === current.data
-            ? (workInProgress.lanes = 16)
-            : (workInProgress.lanes = 1073741824),
-          null
-        );
-      popSuspenseHandler(workInProgress);
+  if (enableLazyContextPropagation) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber; ) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        list = list.firstContext;
+        a: for (; null !== list; ) {
+          var dependency = list;
+          list = fiber;
+          for (var i = 0; i < contexts.length; i++)
+            if (dependency.context === contexts[i]) {
+              list.lanes |= renderLanes;
+              dependency = list.alternate;
+              null !== dependency && (dependency.lanes |= renderLanes);
+              scheduleContextWorkOnParentPath(
+                list.return,
+                renderLanes,
+                workInProgress
+              );
+              forcePropagateEntireTree || (nextFiber = null);
+              break a;
+            }
+          list = dependency.next;
+        }
+      } else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = null;
+      } else 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;
     }
-    current = nextProps.children;
-    didSuspend = nextProps.fallback;
-    if (showFallback)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (current = mountSuspenseFallbackChildren(
-          workInProgress,
-          current,
-          didSuspend,
-          renderLanes
-        )),
-        (nextProps = workInProgress.child),
-        (nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes)),
-        (workInProgress.memoizedState = SUSPENDED_MARKER),
-        enableTransitionTracing &&
-          ((workInProgress = enableTransitionTracing
-            ? transitionStack.current
-            : null),
-          null !== workInProgress &&
-            ((renderLanes = enableTransitionTracing
-              ? markerInstanceStack.current
-              : null),
-            (showFallback = nextProps.updateQueue),
-            null === showFallback
-              ? (nextProps.updateQueue = {
-                  transitions: workInProgress,
-                  markerInstances: renderLanes,
-                  wakeables: null
-                })
-              : ((showFallback.transitions = workInProgress),
-                (showFallback.markerInstances = renderLanes)))),
-        current
-      );
-    if ("number" === typeof nextProps.unstable_expectedLoadTime)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (current = mountSuspenseFallbackChildren(
-          workInProgress,
-          current,
-          didSuspend,
-          renderLanes
-        )),
-        (workInProgress.child.memoizedState =
-          mountSuspenseOffscreenState(renderLanes)),
-        (workInProgress.memoizedState = SUSPENDED_MARKER),
-        (workInProgress.lanes = 8388608),
-        current
-      );
-    pushPrimaryTreeSuspenseHandler(workInProgress);
-    return mountSuspensePrimaryChildren(workInProgress, current);
   }
-  JSCompiler_temp = current.memoizedState;
-  if (null !== JSCompiler_temp) {
-    var dehydrated$117 = JSCompiler_temp.dehydrated;
-    if (null !== dehydrated$117)
-      return updateDehydratedSuspenseComponent(
-        current,
+}
+function propagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (enableLazyContextPropagation) {
+    current = null;
+    for (
+      var parent = workInProgress, isInsidePropagationBailout = !1;
+      null !== parent;
+
+    ) {
+      if (!isInsidePropagationBailout)
+        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
+        else if (0 !== (parent.flags & 262144)) break;
+      if (10 === parent.tag) {
+        var currentParent = parent.alternate;
+        if (null === currentParent) throw Error(formatProdErrorMessage(387));
+        currentParent = currentParent.memoizedProps;
+        if (null !== currentParent) {
+          var context = parent.type._context;
+          objectIs(parent.pendingProps.value, currentParent.value) ||
+            (null !== current ? current.push(context) : (current = [context]));
+        }
+      }
+      parent = parent.return;
+    }
+    null !== current &&
+      propagateContextChanges(
         workInProgress,
-        didSuspend,
-        nextProps,
-        dehydrated$117,
-        JSCompiler_temp,
-        renderLanes
+        current,
+        renderLanes,
+        forcePropagateEntireTree
       );
+    workInProgress.flags |= 262144;
   }
-  if (showFallback) {
-    reuseSuspenseHandlerOnStack();
-    showFallback = nextProps.fallback;
-    didSuspend = workInProgress.mode;
-    JSCompiler_temp = current.child;
-    dehydrated$117 = JSCompiler_temp.sibling;
-    var primaryChildProps = { mode: "hidden", children: nextProps.children };
-    0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
-      ? ((nextProps = workInProgress.child),
-        (nextProps.childLanes = 0),
-        (nextProps.pendingProps = primaryChildProps),
-        workInProgress.mode & 2 &&
-          ((nextProps.actualDuration = 0),
-          (nextProps.actualStartTime = -1),
-          (nextProps.selfBaseDuration = JSCompiler_temp.selfBaseDuration),
-          (nextProps.treeBaseDuration = JSCompiler_temp.treeBaseDuration)),
-        (workInProgress.deletions = null))
-      : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
-        (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
-    null !== dehydrated$117
-      ? (showFallback = createWorkInProgress(dehydrated$117, showFallback))
-      : ((showFallback = createFiberFromFragment(
-          showFallback,
-          didSuspend,
-          renderLanes,
-          null
-        )),
-        (showFallback.flags |= 2));
-    showFallback.return = workInProgress;
-    nextProps.return = workInProgress;
-    nextProps.sibling = showFallback;
-    workInProgress.child = nextProps;
-    nextProps = showFallback;
-    showFallback = workInProgress.child;
-    didSuspend = current.child.memoizedState;
-    null === didSuspend
-      ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
-      : ((JSCompiler_temp = didSuspend.cachePool),
-        null !== JSCompiler_temp
-          ? ((dehydrated$117 = CacheContext._currentValue),
-            (JSCompiler_temp =
-              JSCompiler_temp.parent !== dehydrated$117
-                ? { parent: dehydrated$117, pool: dehydrated$117 }
-                : JSCompiler_temp))
-          : (JSCompiler_temp = getSuspendedCache()),
-        (didSuspend = {
-          baseLanes: didSuspend.baseLanes | renderLanes,
-          cachePool: JSCompiler_temp
-        }));
-    showFallback.memoizedState = didSuspend;
-    enableTransitionTracing &&
-      ((didSuspend = enableTransitionTracing ? transitionStack.current : null),
-      null !== didSuspend &&
-        ((JSCompiler_temp = enableTransitionTracing
-          ? markerInstanceStack.current
-          : null),
-        (dehydrated$117 = showFallback.updateQueue),
-        (primaryChildProps = current.updateQueue),
-        null === dehydrated$117
-          ? (showFallback.updateQueue = {
-              transitions: didSuspend,
-              markerInstances: JSCompiler_temp,
-              wakeables: null
-            })
-          : dehydrated$117 === primaryChildProps
-          ? (showFallback.updateQueue = {
-              transitions: didSuspend,
-              markerInstances: JSCompiler_temp,
-              wakeables:
-                null !== primaryChildProps ? primaryChildProps.wakeables : null
-            })
-          : ((dehydrated$117.transitions = didSuspend),
-            (dehydrated$117.markerInstances = JSCompiler_temp))));
-    showFallback.childLanes = current.childLanes & ~renderLanes;
-    workInProgress.memoizedState = SUSPENDED_MARKER;
-    return nextProps;
+}
+function checkIfContextChanged(currentDependencies) {
+  if (!enableLazyContextPropagation) return !1;
+  for (
+    currentDependencies = currentDependencies.firstContext;
+    null !== currentDependencies;
+
+  ) {
+    if (
+      !objectIs(
+        currentDependencies.context._currentValue,
+        currentDependencies.memoizedValue
+      )
+    )
+      return !0;
+    currentDependencies = currentDependencies.next;
   }
-  pushPrimaryTreeSuspenseHandler(workInProgress);
-  showFallback = current.child;
-  current = showFallback.sibling;
-  nextProps = createWorkInProgress(showFallback, {
-    mode: "visible",
-    children: nextProps.children
-  });
-  0 === (workInProgress.mode & 1) && (nextProps.lanes = renderLanes);
-  nextProps.return = workInProgress;
-  nextProps.sibling = null;
-  null !== current &&
-    ((renderLanes = workInProgress.deletions),
-    null === renderLanes
-      ? ((workInProgress.deletions = [current]), (workInProgress.flags |= 16))
-      : renderLanes.push(current));
-  workInProgress.child = nextProps;
-  workInProgress.memoizedState = null;
-  return nextProps;
+  return !1;
 }
-function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
-  primaryChildren = createFiberFromOffscreen(
-    { mode: "visible", children: primaryChildren },
-    workInProgress.mode,
-    0,
-    null
-  );
-  primaryChildren.return = workInProgress;
-  return (workInProgress.child = primaryChildren);
+function prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastFullyObservedContext = lastContextDependency = null;
+  workInProgress = workInProgress.dependencies;
+  null !== workInProgress &&
+    (enableLazyContextPropagation
+      ? (workInProgress.firstContext = null)
+      : null !== workInProgress.firstContext &&
+        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
+        (workInProgress.firstContext = null)));
 }
-function mountSuspenseFallbackChildren(
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode,
-    progressedPrimaryFragment = workInProgress.child;
-  primaryChildren = { mode: "hidden", children: primaryChildren };
-  0 === (mode & 1) && null !== progressedPrimaryFragment
-    ? ((progressedPrimaryFragment.childLanes = 0),
-      (progressedPrimaryFragment.pendingProps = primaryChildren),
-      workInProgress.mode & 2 &&
-        ((progressedPrimaryFragment.actualDuration = 0),
-        (progressedPrimaryFragment.actualStartTime = -1),
-        (progressedPrimaryFragment.selfBaseDuration = 0),
-        (progressedPrimaryFragment.treeBaseDuration = 0)))
-    : (progressedPrimaryFragment = createFiberFromOffscreen(
-        primaryChildren,
-        mode,
-        0,
-        null
-      ));
-  fallbackChildren = createFiberFromFragment(
-    fallbackChildren,
-    mode,
-    renderLanes,
-    null
-  );
-  progressedPrimaryFragment.return = workInProgress;
-  fallbackChildren.return = workInProgress;
-  progressedPrimaryFragment.sibling = fallbackChildren;
-  workInProgress.child = progressedPrimaryFragment;
-  return fallbackChildren;
+function readContext(context) {
+  return readContextForConsumer(currentlyRenderingFiber, context);
 }
-function retrySuspenseComponentWithoutHydrating(
-  current,
-  workInProgress,
-  renderLanes,
-  recoverableError
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  null === currentlyRenderingFiber &&
+    prepareToReadContext(consumer, renderLanes);
+  return readContextForConsumer(consumer, context);
+}
+function readContextForConsumer(consumer, context) {
+  var value = context._currentValue;
+  if (lastFullyObservedContext !== context)
+    if (
+      ((context = { context: context, memoizedValue: value, next: null }),
+      null === lastContextDependency)
+    ) {
+      if (null === consumer) throw Error(formatProdErrorMessage(308));
+      lastContextDependency = context;
+      consumer.dependencies = { lanes: 0, firstContext: context };
+      enableLazyContextPropagation && (consumer.flags |= 524288);
+    } else lastContextDependency = lastContextDependency.next = context;
+  return value;
+}
+var AbortControllerLocal =
+    "undefined" !== typeof AbortController
+      ? AbortController
+      : function () {
+          var listeners = [],
+            signal = (this.signal = {
+              aborted: !1,
+              addEventListener: function (type, listener) {
+                listeners.push(listener);
+              }
+            });
+          this.abort = function () {
+            signal.aborted = !0;
+            listeners.forEach(function (listener) {
+              return listener();
+            });
+          };
+        },
+  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+  NormalPriority = Scheduler.unstable_NormalPriority,
+  CacheContext = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    Consumer: null,
+    Provider: null,
+    _currentValue: null,
+    _currentValue2: null,
+    _threadCount: 0,
+    _defaultValue: null,
+    _globalName: null
+  };
+function createCache() {
+  return {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+}
+function releaseCache(cache) {
+  cache.refCount--;
+  0 === cache.refCount &&
+    scheduleCallback$1(NormalPriority, function () {
+      cache.controller.abort();
+    });
+}
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
+  resumedCache = createCursor(null),
+  transitionStack = createCursor(null);
+function peekCacheFromPool() {
+  var cacheResumedFromPreviousRender = resumedCache.current;
+  return null !== cacheResumedFromPreviousRender
+    ? cacheResumedFromPreviousRender
+    : workInProgressRoot.pooledCache;
+}
+function pushTransition(
+  offscreenWorkInProgress,
+  prevCachePool,
+  newTransitions
 ) {
-  null !== recoverableError && queueHydrationError(recoverableError);
-  reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-  current = mountSuspensePrimaryChildren(
-    workInProgress,
-    workInProgress.pendingProps.children
-  );
-  current.flags |= 2;
-  workInProgress.memoizedState = null;
-  return current;
+  null === prevCachePool
+    ? push(resumedCache, resumedCache.current)
+    : push(resumedCache, prevCachePool.pool);
+  enableTransitionTracing &&
+    (null === transitionStack.current
+      ? push(transitionStack, newTransitions)
+      : null === newTransitions
+      ? push(transitionStack, transitionStack.current)
+      : push(transitionStack, transitionStack.current.concat(newTransitions)));
 }
-function updateDehydratedSuspenseComponent(
-  current,
-  workInProgress,
-  didSuspend,
-  nextProps,
-  suspenseInstance,
-  suspenseState,
-  renderLanes
+function popTransition(workInProgress, current) {
+  null !== current &&
+    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
+}
+function getSuspendedCache() {
+  var cacheFromPool = peekCacheFromPool();
+  return null === cacheFromPool
+    ? null
+    : { parent: CacheContext._currentValue, pool: cacheFromPool };
+}
+var emptyObject = {};
+function collectScopedNodesFromChildren(
+  startingChild,
+  fn$jscomp$0,
+  scopedNodes$jscomp$0
 ) {
-  if (didSuspend) {
-    if (workInProgress.flags & 256)
-      return (
-        pushPrimaryTreeSuspenseHandler(workInProgress),
-        (workInProgress.flags &= -257),
-        (suspenseState = createCapturedValue(
-          Error(formatProdErrorMessage(422))
-        )),
-        retrySuspenseComponentWithoutHydrating(
-          current,
-          workInProgress,
-          renderLanes,
-          suspenseState
-        )
-      );
-    if (null !== workInProgress.memoizedState)
-      return (
-        reuseSuspenseHandlerOnStack(),
-        (workInProgress.child = current.child),
-        (workInProgress.flags |= 128),
-        null
-      );
-    reuseSuspenseHandlerOnStack();
-    suspenseState = nextProps.fallback;
-    suspenseInstance = workInProgress.mode;
-    nextProps = createFiberFromOffscreen(
-      { mode: "visible", children: nextProps.children },
-      suspenseInstance,
-      0,
-      null
-    );
-    suspenseState = createFiberFromFragment(
-      suspenseState,
-      suspenseInstance,
-      renderLanes,
-      null
-    );
-    suspenseState.flags |= 2;
-    nextProps.return = workInProgress;
-    suspenseState.return = workInProgress;
-    nextProps.sibling = suspenseState;
-    workInProgress.child = nextProps;
-    0 !== (workInProgress.mode & 1) &&
-      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
-    workInProgress.child.memoizedState =
-      mountSuspenseOffscreenState(renderLanes);
-    workInProgress.memoizedState = SUSPENDED_MARKER;
-    return suspenseState;
-  }
-  pushPrimaryTreeSuspenseHandler(workInProgress);
-  if (0 === (workInProgress.mode & 1))
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      null
-    );
-  if ("$!" === suspenseInstance.data) {
-    suspenseState =
-      suspenseInstance.nextSibling && suspenseInstance.nextSibling.dataset;
-    if (suspenseState) var digest = suspenseState.dgst;
-    suspenseState = digest;
-    nextProps = Error(formatProdErrorMessage(419));
-    nextProps.digest = suspenseState;
-    suspenseState = createCapturedValue(nextProps, suspenseState, void 0);
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      suspenseState
-    );
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      fn = fn$jscomp$0,
+      scopedNodes = scopedNodes$jscomp$0;
+    if (5 === node.tag) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        instance = node.stateNode;
+      null !== instance &&
+        !0 === fn(type, memoizedProps || emptyObject, instance) &&
+        scopedNodes.push(instance);
+    }
+    type = node.child;
+    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
+    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
+    startingChild = startingChild.sibling;
   }
-  enableLazyContextPropagation &&
-    !didReceiveUpdate &&
-    propagateParentContextChanges(current, workInProgress, renderLanes, !1);
-  digest = 0 !== (renderLanes & current.childLanes);
-  if (didReceiveUpdate || digest) {
-    nextProps = workInProgressRoot;
-    if (null !== nextProps) {
-      suspenseInstance = renderLanes & -renderLanes;
-      if (enableUnifiedSyncLane && 0 !== (suspenseInstance & 42))
-        suspenseInstance = 1;
-      else
-        switch (suspenseInstance) {
-          case 2:
-            suspenseInstance = 1;
-            break;
-          case 8:
-            suspenseInstance = 4;
-            break;
-          case 32:
-            suspenseInstance = 16;
-            break;
-          case 128:
-          case 256:
-          case 512:
-          case 1024:
-          case 2048:
-          case 4096:
-          case 8192:
-          case 16384:
-          case 32768:
-          case 65536:
-          case 131072:
-          case 262144:
-          case 524288:
-          case 1048576:
-          case 2097152:
-          case 4194304:
-          case 8388608:
-          case 16777216:
-          case 33554432:
-          case 67108864:
-            suspenseInstance = 64;
-            break;
-          case 536870912:
-            suspenseInstance = 268435456;
-            break;
-          default:
-            suspenseInstance = 0;
+}
+function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
+  for (; null !== startingChild; ) {
+    a: {
+      var JSCompiler_inline_result = startingChild;
+      var fn = fn$jscomp$0;
+      if (5 === JSCompiler_inline_result.tag) {
+        var type = JSCompiler_inline_result.type,
+          memoizedProps = JSCompiler_inline_result.memoizedProps,
+          instance = JSCompiler_inline_result.stateNode;
+        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
+          JSCompiler_inline_result = instance;
+          break a;
         }
-      suspenseInstance =
-        0 !== (suspenseInstance & (nextProps.suspendedLanes | renderLanes))
-          ? 0
-          : suspenseInstance;
-      if (
-        0 !== suspenseInstance &&
-        suspenseInstance !== suspenseState.retryLane
-      )
-        throw (
-          ((suspenseState.retryLane = suspenseInstance),
-          enqueueConcurrentRenderForLane(current, suspenseInstance),
-          scheduleUpdateOnFiber(nextProps, current, suspenseInstance, -1),
-          SelectiveHydrationException)
-        );
+      }
+      type = JSCompiler_inline_result.child;
+      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
+        (type = JSCompiler_inline_result.child.sibling.child);
+      JSCompiler_inline_result =
+        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
     }
-    renderDidSuspendDelayIfPossible();
-    return retrySuspenseComponentWithoutHydrating(
-      current,
-      workInProgress,
-      renderLanes,
-      null
-    );
+    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
+    startingChild = startingChild.sibling;
   }
-  if ("$?" === suspenseInstance.data)
-    return (
-      (workInProgress.flags |= 128),
-      (workInProgress.child = current.child),
-      (workInProgress = retryDehydratedSuspenseBoundary.bind(null, current)),
-      (suspenseInstance._reactRetry = workInProgress),
-      null
-    );
-  current = suspenseState.treeContext;
-  nextHydratableInstance = getNextHydratable(suspenseInstance.nextSibling);
-  hydrationParentFiber = workInProgress;
-  isHydrating = !0;
-  hydrationErrors = null;
-  rootOrSingletonContext = !1;
-  null !== current &&
-    ((idStack[idStackIndex++] = treeContextId),
-    (idStack[idStackIndex++] = treeContextOverflow),
-    (idStack[idStackIndex++] = treeContextProvider),
-    (treeContextId = current.id),
-    (treeContextOverflow = current.overflow),
-    (treeContextProvider = workInProgress));
-  workInProgress = mountSuspensePrimaryChildren(
-    workInProgress,
-    nextProps.children
-  );
-  workInProgress.flags |= 4096;
-  return workInProgress;
-}
-function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
-  fiber.lanes |= renderLanes;
-  var alternate = fiber.alternate;
-  null !== alternate && (alternate.lanes |= renderLanes);
-  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+  return null;
 }
-function initSuspenseListRenderState(
-  workInProgress,
-  isBackwards,
-  tail,
-  lastContentRow,
-  tailMode
+function collectNearestChildContextValues(
+  startingChild,
+  context$jscomp$0,
+  childContextValues$jscomp$0
 ) {
-  var renderState = workInProgress.memoizedState;
-  null === renderState
-    ? (workInProgress.memoizedState = {
-        isBackwards: isBackwards,
-        rendering: null,
-        renderingStartTime: 0,
-        last: lastContentRow,
-        tail: tail,
-        tailMode: tailMode
-      })
-    : ((renderState.isBackwards = isBackwards),
-      (renderState.rendering = null),
-      (renderState.renderingStartTime = 0),
-      (renderState.last = lastContentRow),
-      (renderState.tail = tail),
-      (renderState.tailMode = tailMode));
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      context = context$jscomp$0,
+      childContextValues = childContextValues$jscomp$0;
+    if (10 === node.tag && node.type._context === context)
+      childContextValues.push(node.memoizedProps.value);
+    else {
+      var child = node.child;
+      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
+      null !== child &&
+        collectNearestChildContextValues(child, context, childContextValues);
+    }
+    startingChild = startingChild.sibling;
+  }
 }
-function updateSuspenseListComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    revealOrder = nextProps.revealOrder,
-    tailMode = nextProps.tail;
-  reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
-  nextProps = suspenseStackCursor.current;
-  if (0 !== (nextProps & 2))
-    (nextProps = (nextProps & 1) | 2), (workInProgress.flags |= 128);
-  else {
-    if (null !== current && 0 !== (current.flags & 128))
-      a: for (current = workInProgress.child; null !== current; ) {
-        if (13 === current.tag)
-          null !== current.memoizedState &&
-            scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
-        else if (19 === current.tag)
-          scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);
-        else if (null !== current.child) {
-          current.child.return = current;
-          current = current.child;
-          continue;
-        }
-        if (current === workInProgress) break a;
-        for (; null === current.sibling; ) {
-          if (null === current.return || current.return === workInProgress)
-            break a;
-          current = current.return;
-        }
-        current.sibling.return = current.return;
-        current = current.sibling;
-      }
-    nextProps &= 1;
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  var scopedNodes = [];
+  null !== currentFiber &&
+    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
+  return 0 === scopedNodes.length ? null : scopedNodes;
+}
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  return null !== currentFiber
+    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
+    : null;
+}
+function containsNode$1(node) {
+  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
+    if (21 === node.tag && node.stateNode === this) return !0;
+    node = node.return;
   }
-  push(suspenseStackCursor, nextProps);
-  if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;
-  else
-    switch (revealOrder) {
-      case "forwards":
-        renderLanes = workInProgress.child;
-        for (revealOrder = null; null !== renderLanes; )
-          (current = renderLanes.alternate),
-            null !== current &&
-              null === findFirstSuspended(current) &&
-              (revealOrder = renderLanes),
-            (renderLanes = renderLanes.sibling);
-        renderLanes = revealOrder;
-        null === renderLanes
-          ? ((revealOrder = workInProgress.child),
-            (workInProgress.child = null))
-          : ((revealOrder = renderLanes.sibling), (renderLanes.sibling = null));
-        initSuspenseListRenderState(
-          workInProgress,
-          !1,
-          revealOrder,
-          renderLanes,
-          tailMode
-        );
+  return !1;
+}
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return [];
+  currentFiber = currentFiber.child;
+  var childContextValues = [];
+  null !== currentFiber &&
+    collectNearestChildContextValues(currentFiber, context, childContextValues);
+  return childContextValues;
+}
+function markUpdate(workInProgress) {
+  workInProgress.flags |= 4;
+}
+function markRef(workInProgress) {
+  workInProgress.flags |= 2097664;
+}
+function updateHostComponent(current, workInProgress, type, newProps) {
+  var oldProps = current.memoizedProps;
+  if (oldProps !== newProps) {
+    current = workInProgress.stateNode;
+    var updatePayload = null;
+    switch (type) {
+      case "input":
+        oldProps = getHostProps$2(current, oldProps);
+        newProps = getHostProps$2(current, newProps);
+        updatePayload = [];
         break;
-      case "backwards":
-        renderLanes = null;
-        revealOrder = workInProgress.child;
-        for (workInProgress.child = null; null !== revealOrder; ) {
-          current = revealOrder.alternate;
-          if (null !== current && null === findFirstSuspended(current)) {
-            workInProgress.child = revealOrder;
-            break;
-          }
-          current = revealOrder.sibling;
-          revealOrder.sibling = renderLanes;
-          renderLanes = revealOrder;
-          revealOrder = current;
-        }
-        initSuspenseListRenderState(
-          workInProgress,
-          !0,
-          renderLanes,
-          null,
-          tailMode
-        );
+      case "select":
+        oldProps = assign({}, oldProps, { value: void 0 });
+        newProps = assign({}, newProps, { value: void 0 });
+        updatePayload = [];
         break;
-      case "together":
-        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+      case "textarea":
+        oldProps = getHostProps(current, oldProps);
+        newProps = getHostProps(current, newProps);
+        updatePayload = [];
         break;
       default:
-        workInProgress.memoizedState = null;
+        "function" !== typeof oldProps.onClick &&
+          "function" === typeof newProps.onClick &&
+          (current.onclick = noop);
     }
-  return workInProgress.child;
-}
-function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
-  0 === (workInProgress.mode & 1) &&
-    null !== current &&
-    ((current.alternate = null),
-    (workInProgress.alternate = null),
-    (workInProgress.flags |= 2));
-}
-function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
-  null !== current && (workInProgress.dependencies = current.dependencies);
-  profilerStartTime = -1;
-  workInProgressRootSkippedLanes |= workInProgress.lanes;
-  if (0 === (renderLanes & workInProgress.childLanes))
-    if (enableLazyContextPropagation && null !== current) {
+    assertValidProps(type, newProps);
+    var styleName;
+    type = null;
+    for (JSCompiler_inline_result in oldProps)
       if (
-        (propagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes,
-          !1
-        ),
-        0 === (renderLanes & workInProgress.childLanes))
+        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
+        null != oldProps[JSCompiler_inline_result]
       )
-        return null;
-    } else return null;
-  if (null !== current && workInProgress.child !== current.child)
-    throw Error(formatProdErrorMessage(153));
-  if (null !== workInProgress.child) {
-    current = workInProgress.child;
-    renderLanes = createWorkInProgress(current, current.pendingProps);
-    workInProgress.child = renderLanes;
-    for (renderLanes.return = workInProgress; null !== current.sibling; )
-      (current = current.sibling),
-        (renderLanes = renderLanes.sibling =
-          createWorkInProgress(current, current.pendingProps)),
-        (renderLanes.return = workInProgress);
-    renderLanes.sibling = null;
+        if ("style" === JSCompiler_inline_result) {
+          var lastStyle = oldProps[JSCompiler_inline_result];
+          for (styleName in lastStyle)
+            lastStyle.hasOwnProperty(styleName) &&
+              (type || (type = {}), (type[styleName] = ""));
+        } else
+          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
+            "children" !== JSCompiler_inline_result &&
+            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+            "suppressHydrationWarning" !== JSCompiler_inline_result &&
+            "autoFocus" !== JSCompiler_inline_result &&
+            (registrationNameDependencies.hasOwnProperty(
+              JSCompiler_inline_result
+            )
+              ? updatePayload || (updatePayload = [])
+              : (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  null
+                ));
+    for (JSCompiler_inline_result in newProps) {
+      var nextProp = newProps[JSCompiler_inline_result];
+      lastStyle =
+        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
+      if (
+        newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        nextProp !== lastStyle &&
+        (null != nextProp || null != lastStyle)
+      )
+        if ("style" === JSCompiler_inline_result)
+          if (lastStyle) {
+            for (styleName in lastStyle)
+              !lastStyle.hasOwnProperty(styleName) ||
+                (nextProp && nextProp.hasOwnProperty(styleName)) ||
+                (type || (type = {}), (type[styleName] = ""));
+            for (styleName in nextProp)
+              nextProp.hasOwnProperty(styleName) &&
+                lastStyle[styleName] !== nextProp[styleName] &&
+                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+          } else
+            type ||
+              (updatePayload || (updatePayload = []),
+              updatePayload.push(JSCompiler_inline_result, type)),
+              (type = nextProp);
+        else
+          "dangerouslySetInnerHTML" === JSCompiler_inline_result
+            ? ((nextProp = nextProp ? nextProp.__html : void 0),
+              (lastStyle = lastStyle ? lastStyle.__html : void 0),
+              null != nextProp &&
+                lastStyle !== nextProp &&
+                (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  nextProp
+                ))
+            : "children" === JSCompiler_inline_result
+            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
+              (updatePayload = updatePayload || []).push(
+                JSCompiler_inline_result,
+                "" + nextProp
+              )
+            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+              "suppressHydrationWarning" !== JSCompiler_inline_result &&
+              (registrationNameDependencies.hasOwnProperty(
+                JSCompiler_inline_result
+              )
+                ? (null != nextProp &&
+                    "onScroll" === JSCompiler_inline_result &&
+                    listenToNonDelegatedEvent("scroll", current),
+                  updatePayload ||
+                    lastStyle === nextProp ||
+                    (updatePayload = []))
+                : (updatePayload = updatePayload || []).push(
+                    JSCompiler_inline_result,
+                    nextProp
+                  ));
+    }
+    type && (updatePayload = updatePayload || []).push("style", type);
+    var JSCompiler_inline_result = updatePayload;
+    (workInProgress.updateQueue = JSCompiler_inline_result) &&
+      markUpdate(workInProgress);
   }
-  return workInProgress.child;
 }
-function checkScheduledUpdateOrContext(current, renderLanes) {
-  return 0 !== (current.lanes & renderLanes) ||
-    (enableLazyContextPropagation &&
-      ((current = current.dependencies),
-      null !== current && checkIfContextChanged(current)))
-    ? !0
-    : !1;
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (!isHydrating)
+    switch (renderState.tailMode) {
+      case "hidden":
+        hasRenderedATailFallback = renderState.tail;
+        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
+          null !== hasRenderedATailFallback.alternate &&
+            (lastTailNode = hasRenderedATailFallback),
+            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
+        null === lastTailNode
+          ? (renderState.tail = null)
+          : (lastTailNode.sibling = null);
+        break;
+      case "collapsed":
+        lastTailNode = renderState.tail;
+        for (var lastTailNode$105 = null; null !== lastTailNode; )
+          null !== lastTailNode.alternate && (lastTailNode$105 = lastTailNode),
+            (lastTailNode = lastTailNode.sibling);
+        null === lastTailNode$105
+          ? hasRenderedATailFallback || null === renderState.tail
+            ? (renderState.tail = null)
+            : (renderState.tail.sibling = null)
+          : (lastTailNode$105.sibling = null);
+    }
 }
-function attemptEarlyBailoutIfNoScheduledUpdate(
-  current,
-  workInProgress,
-  renderLanes
-) {
+function bubbleProperties(completedWork) {
+  var didBailout =
+      null !== completedWork.alternate &&
+      completedWork.alternate.child === completedWork.child,
+    newChildLanes = 0,
+    subtreeFlags = 0;
+  if (didBailout)
+    if (0 !== (completedWork.mode & 2)) {
+      for (
+        var treeBaseDuration$107 = completedWork.selfBaseDuration,
+          child$108 = completedWork.child;
+        null !== child$108;
+
+      )
+        (newChildLanes |= child$108.lanes | child$108.childLanes),
+          (subtreeFlags |= child$108.subtreeFlags & 14680064),
+          (subtreeFlags |= child$108.flags & 14680064),
+          (treeBaseDuration$107 += child$108.treeBaseDuration),
+          (child$108 = child$108.sibling);
+      completedWork.treeBaseDuration = treeBaseDuration$107;
+    } else
+      for (
+        treeBaseDuration$107 = completedWork.child;
+        null !== treeBaseDuration$107;
+
+      )
+        (newChildLanes |=
+          treeBaseDuration$107.lanes | treeBaseDuration$107.childLanes),
+          (subtreeFlags |= treeBaseDuration$107.subtreeFlags & 14680064),
+          (subtreeFlags |= treeBaseDuration$107.flags & 14680064),
+          (treeBaseDuration$107.return = completedWork),
+          (treeBaseDuration$107 = treeBaseDuration$107.sibling);
+  else if (0 !== (completedWork.mode & 2)) {
+    treeBaseDuration$107 = completedWork.actualDuration;
+    child$108 = completedWork.selfBaseDuration;
+    for (var child = completedWork.child; null !== child; )
+      (newChildLanes |= child.lanes | child.childLanes),
+        (subtreeFlags |= child.subtreeFlags),
+        (subtreeFlags |= child.flags),
+        (treeBaseDuration$107 += child.actualDuration),
+        (child$108 += child.treeBaseDuration),
+        (child = child.sibling);
+    completedWork.actualDuration = treeBaseDuration$107;
+    completedWork.treeBaseDuration = child$108;
+  } else
+    for (
+      treeBaseDuration$107 = completedWork.child;
+      null !== treeBaseDuration$107;
+
+    )
+      (newChildLanes |=
+        treeBaseDuration$107.lanes | treeBaseDuration$107.childLanes),
+        (subtreeFlags |= treeBaseDuration$107.subtreeFlags),
+        (subtreeFlags |= treeBaseDuration$107.flags),
+        (treeBaseDuration$107.return = completedWork),
+        (treeBaseDuration$107 = treeBaseDuration$107.sibling);
+  completedWork.subtreeFlags |= subtreeFlags;
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps;
+  popTreeContext(workInProgress);
   switch (workInProgress.tag) {
+    case 2:
+    case 16:
+    case 15:
+    case 0:
+    case 11:
+    case 7:
+    case 8:
+    case 12:
+    case 9:
+    case 14:
+      return bubbleProperties(workInProgress), null;
+    case 1:
+      return bubbleProperties(workInProgress), null;
     case 3:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      renderLanes = workInProgress.stateNode;
       enableTransitionTracing &&
-        push(transitionStack, workInProgressTransitions);
-      enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
-      resetHydrationState();
-      break;
-    case 27:
-    case 5:
-      pushHostContext(workInProgress);
-      break;
-    case 4:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      break;
-    case 10:
-      pushProvider(
-        workInProgress,
-        workInProgress.type._context,
-        workInProgress.memoizedProps.value
+        null !== workInProgressTransitions &&
+        (workInProgress.flags |= 2048);
+      newProps = null;
+      null !== current && (newProps = current.memoizedState.cache);
+      workInProgress.memoizedState.cache !== newProps &&
+        (workInProgress.flags |= 2048);
+      popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
+      popHostContainer();
+      resetWorkInProgressVersions();
+      renderLanes.pendingContext &&
+        ((renderLanes.context = renderLanes.pendingContext),
+        (renderLanes.pendingContext = null));
+      if (null === current || null === current.child)
+        popHydrationState(workInProgress)
+          ? markUpdate(workInProgress)
+          : null === current ||
+            (current.memoizedState.isDehydrated &&
+              0 === (workInProgress.flags & 256)) ||
+            ((workInProgress.flags |= 1024),
+            null !== hydrationErrors &&
+              (queueRecoverableErrors(hydrationErrors),
+              (hydrationErrors = null)));
+      bubbleProperties(workInProgress);
+      enableTransitionTracing &&
+        0 !== (workInProgress.subtreeFlags & 8192) &&
+        (workInProgress.flags |= 2048);
+      return null;
+    case 26:
+      return (
+        (current ? current.ref : null) !== workInProgress.ref &&
+          markRef(workInProgress),
+        null === current ||
+        current.memoizedState !== workInProgress.memoizedState
+          ? markUpdate(workInProgress)
+          : null === workInProgress.memoizedState &&
+            updateHostComponent(
+              current,
+              workInProgress,
+              workInProgress.type,
+              workInProgress.pendingProps
+            ),
+        bubbleProperties(workInProgress),
+        null
       );
-      break;
-    case 12:
-      0 !== (renderLanes & workInProgress.childLanes) &&
-        (workInProgress.flags |= 4);
-      var stateNode = workInProgress.stateNode;
-      stateNode.effectDuration = 0;
-      stateNode.passiveEffectDuration = 0;
-      break;
-    case 13:
-      stateNode = workInProgress.memoizedState;
-      if (null !== stateNode) {
-        if (null !== stateNode.dehydrated)
-          return (
-            pushPrimaryTreeSuspenseHandler(workInProgress),
-            (workInProgress.flags |= 128),
-            null
-          );
-        if (0 !== (renderLanes & workInProgress.child.childLanes))
-          return updateSuspenseComponent(current, workInProgress, renderLanes);
-        pushPrimaryTreeSuspenseHandler(workInProgress);
-        current = bailoutOnAlreadyFinishedWork(
-          current,
-          workInProgress,
-          renderLanes
-        );
-        return null !== current ? current.sibling : null;
+    case 27:
+      popHostContext(workInProgress);
+      renderLanes = rootInstanceStackCursor.current;
+      var type = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, type, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor.current;
+        popHydrationState(workInProgress)
+          ? prepareToHydrateHostInstance(workInProgress, current)
+          : ((workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              renderLanes
+            )),
+            markUpdate(workInProgress));
+        null !== workInProgress.ref && markRef(workInProgress);
       }
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      break;
-    case 19:
-      var didSuspendBefore = 0 !== (current.flags & 128);
-      stateNode = 0 !== (renderLanes & workInProgress.childLanes);
-      enableLazyContextPropagation &&
-        !stateNode &&
-        (propagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes,
-          !1
-        ),
-        (stateNode = 0 !== (renderLanes & workInProgress.childLanes)));
-      if (didSuspendBefore) {
-        if (stateNode)
-          return updateSuspenseListComponent(
-            current,
-            workInProgress,
-            renderLanes
+      bubbleProperties(workInProgress);
+      return null;
+    case 5:
+      popHostContext(workInProgress);
+      renderLanes = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, renderLanes, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor.current;
+        if (popHydrationState(workInProgress))
+          prepareToHydrateHostInstance(workInProgress, current) &&
+            markUpdate(workInProgress);
+        else {
+          type = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
           );
-        workInProgress.flags |= 128;
-      }
-      didSuspendBefore = workInProgress.memoizedState;
-      null !== didSuspendBefore &&
-        ((didSuspendBefore.rendering = null),
-        (didSuspendBefore.tail = null),
-        (didSuspendBefore.lastEffect = null));
-      push(suspenseStackCursor, suspenseStackCursor.current);
-      if (stateNode) break;
-      else return null;
-    case 22:
-    case 23:
-      return (
-        (workInProgress.lanes = 0),
-        updateOffscreenComponent(current, workInProgress, renderLanes)
-      );
-    case 24:
-      pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
-      break;
-    case 25:
-      enableTransitionTracing &&
-        ((stateNode = workInProgress.stateNode),
-        null !== stateNode && pushMarkerInstance(workInProgress, stateNode));
-  }
-  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-}
-var valueCursor = createCursor(null),
-  currentlyRenderingFiber = null,
-  lastContextDependency = null,
-  lastFullyObservedContext = null;
-function resetContextDependencies() {
-  lastFullyObservedContext =
-    lastContextDependency =
-    currentlyRenderingFiber =
-      null;
-}
-function pushProvider(providerFiber, context, nextValue) {
-  push(valueCursor, context._currentValue);
-  context._currentValue = nextValue;
-}
-function popProvider(context) {
-  var currentValue = valueCursor.current;
-  context._currentValue =
-    currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED
-      ? context._defaultValue
-      : currentValue;
-  pop(valueCursor);
-}
-function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
-  for (; null !== parent; ) {
-    var alternate = parent.alternate;
-    (parent.childLanes & renderLanes) !== renderLanes
-      ? ((parent.childLanes |= renderLanes),
-        null !== alternate && (alternate.childLanes |= renderLanes))
-      : null !== alternate &&
-        (alternate.childLanes & renderLanes) !== renderLanes &&
-        (alternate.childLanes |= renderLanes);
-    if (parent === propagationRoot) break;
-    parent = parent.return;
-  }
-}
-function propagateContextChange(workInProgress, context, renderLanes) {
-  if (enableLazyContextPropagation)
-    propagateContextChanges(workInProgress, [context], renderLanes, !0);
-  else if (!enableLazyContextPropagation) {
-    var fiber = workInProgress.child;
-    null !== fiber && (fiber.return = workInProgress);
-    for (; null !== fiber; ) {
-      var list = fiber.dependencies;
-      if (null !== list) {
-        var nextFiber = fiber.child;
-        for (var dependency = list.firstContext; null !== dependency; ) {
-          if (dependency.context === context) {
-            if (1 === fiber.tag) {
-              dependency = createUpdate(renderLanes & -renderLanes);
-              dependency.tag = 2;
-              var updateQueue = fiber.updateQueue;
-              if (null !== updateQueue) {
-                updateQueue = updateQueue.shared;
-                var pending = updateQueue.pending;
-                null === pending
-                  ? (dependency.next = dependency)
-                  : ((dependency.next = pending.next),
-                    (pending.next = dependency));
-                updateQueue.pending = dependency;
+          switch (current) {
+            case "http://www.w3.org/2000/svg":
+            case "http://www.w3.org/1998/Math/MathML":
+              current = type.createElementNS(current, renderLanes);
+              break;
+            default:
+              switch (renderLanes) {
+                case "svg":
+                  current = type.createElementNS(
+                    "http://www.w3.org/2000/svg",
+                    renderLanes
+                  );
+                  break;
+                case "math":
+                  current = type.createElementNS(
+                    "http://www.w3.org/1998/Math/MathML",
+                    renderLanes
+                  );
+                  break;
+                case "script":
+                  current = type.createElement("div");
+                  current.innerHTML = "<script>\x3c/script>";
+                  current = current.removeChild(current.firstChild);
+                  break;
+                case "select":
+                  current =
+                    "string" === typeof newProps.is
+                      ? type.createElement("select", { is: newProps.is })
+                      : type.createElement("select");
+                  newProps.multiple
+                    ? (current.multiple = !0)
+                    : newProps.size && (current.size = newProps.size);
+                  break;
+                default:
+                  current = createHTMLElement(renderLanes, newProps, type);
               }
-            }
-            fiber.lanes |= renderLanes;
-            dependency = fiber.alternate;
-            null !== dependency && (dependency.lanes |= renderLanes);
-            scheduleContextWorkOnParentPath(
-              fiber.return,
-              renderLanes,
-              workInProgress
-            );
-            list.lanes |= renderLanes;
-            break;
-          }
-          dependency = dependency.next;
-        }
-      } else if (10 === fiber.tag)
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-      else if (18 === fiber.tag) {
-        nextFiber = fiber.return;
-        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
-        nextFiber.lanes |= renderLanes;
-        list = nextFiber.alternate;
-        null !== list && (list.lanes |= renderLanes);
-        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
-        nextFiber = fiber.sibling;
-      } else 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 propagateContextChanges(
-  workInProgress,
-  contexts,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (enableLazyContextPropagation) {
-    var fiber = workInProgress.child;
-    null !== fiber && (fiber.return = workInProgress);
-    for (; null !== fiber; ) {
-      var list = fiber.dependencies;
-      if (null !== list) {
-        var nextFiber = fiber.child;
-        list = list.firstContext;
-        a: for (; null !== list; ) {
-          var dependency = list;
-          list = fiber;
-          for (var i = 0; i < contexts.length; i++)
-            if (dependency.context === contexts[i]) {
-              list.lanes |= renderLanes;
-              dependency = list.alternate;
-              null !== dependency && (dependency.lanes |= renderLanes);
-              scheduleContextWorkOnParentPath(
-                list.return,
-                renderLanes,
-                workInProgress
-              );
-              forcePropagateEntireTree || (nextFiber = null);
-              break a;
+          current[internalInstanceKey] = workInProgress;
+          current[internalPropsKey] = newProps;
+          a: for (type = workInProgress.child; null !== type; ) {
+            if (5 === type.tag || 6 === type.tag)
+              current.appendChild(type.stateNode);
+            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
+              type.child.return = type;
+              type = type.child;
+              continue;
             }
-          list = dependency.next;
-        }
-      } else if (18 === fiber.tag) {
-        nextFiber = fiber.return;
-        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
-        nextFiber.lanes |= renderLanes;
-        list = nextFiber.alternate;
-        null !== list && (list.lanes |= renderLanes);
-        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
-        nextFiber = null;
-      } else nextFiber = fiber.child;
-      if (null !== nextFiber) nextFiber.return = fiber;
-      else
-        for (nextFiber = fiber; null !== nextFiber; ) {
-          if (nextFiber === workInProgress) {
-            nextFiber = null;
-            break;
+            if (type === workInProgress) break a;
+            for (; null === type.sibling; ) {
+              if (null === type.return || type.return === workInProgress)
+                break a;
+              type = type.return;
+            }
+            type.sibling.return = type.return;
+            type = type.sibling;
           }
-          fiber = nextFiber.sibling;
-          if (null !== fiber) {
-            fiber.return = nextFiber.return;
-            nextFiber = fiber;
-            break;
+          workInProgress.stateNode = current;
+          a: switch (
+            (setInitialProperties(current, renderLanes, newProps), renderLanes)
+          ) {
+            case "button":
+            case "input":
+            case "select":
+            case "textarea":
+              current = !!newProps.autoFocus;
+              break a;
+            case "img":
+              current = !0;
+              break a;
+            default:
+              current = !1;
           }
-          nextFiber = nextFiber.return;
-        }
-      fiber = nextFiber;
-    }
-  }
-}
-function propagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (enableLazyContextPropagation) {
-    current = null;
-    for (
-      var parent = workInProgress, isInsidePropagationBailout = !1;
-      null !== parent;
-
-    ) {
-      if (!isInsidePropagationBailout)
-        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
-        else if (0 !== (parent.flags & 262144)) break;
-      if (10 === parent.tag) {
-        var currentParent = parent.alternate;
-        if (null === currentParent) throw Error(formatProdErrorMessage(387));
-        currentParent = currentParent.memoizedProps;
-        if (null !== currentParent) {
-          var context = parent.type._context;
-          objectIs(parent.pendingProps.value, currentParent.value) ||
-            (null !== current ? current.push(context) : (current = [context]));
+          current && markUpdate(workInProgress);
         }
+        null !== workInProgress.ref && markRef(workInProgress);
       }
-      parent = parent.return;
-    }
-    null !== current &&
-      propagateContextChanges(
-        workInProgress,
-        current,
-        renderLanes,
-        forcePropagateEntireTree
-      );
-    workInProgress.flags |= 262144;
-  }
-}
-function checkIfContextChanged(currentDependencies) {
-  if (!enableLazyContextPropagation) return !1;
-  for (
-    currentDependencies = currentDependencies.firstContext;
-    null !== currentDependencies;
-
-  ) {
-    if (
-      !objectIs(
-        currentDependencies.context._currentValue,
-        currentDependencies.memoizedValue
-      )
-    )
-      return !0;
-    currentDependencies = currentDependencies.next;
-  }
-  return !1;
-}
-function prepareToReadContext(workInProgress, renderLanes) {
-  currentlyRenderingFiber = workInProgress;
-  lastFullyObservedContext = lastContextDependency = null;
-  workInProgress = workInProgress.dependencies;
-  null !== workInProgress &&
-    (enableLazyContextPropagation
-      ? (workInProgress.firstContext = null)
-      : null !== workInProgress.firstContext &&
-        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
-        (workInProgress.firstContext = null)));
-}
-function readContext(context) {
-  return readContextForConsumer(currentlyRenderingFiber, context);
-}
-function readContextDuringReconcilation(consumer, context, renderLanes) {
-  null === currentlyRenderingFiber &&
-    prepareToReadContext(consumer, renderLanes);
-  return readContextForConsumer(consumer, context);
-}
-function readContextForConsumer(consumer, context) {
-  var value = context._currentValue;
-  if (lastFullyObservedContext !== context)
-    if (
-      ((context = { context: context, memoizedValue: value, next: null }),
-      null === lastContextDependency)
-    ) {
-      if (null === consumer) throw Error(formatProdErrorMessage(308));
-      lastContextDependency = context;
-      consumer.dependencies = { lanes: 0, firstContext: context };
-      enableLazyContextPropagation && (consumer.flags |= 524288);
-    } else lastContextDependency = lastContextDependency.next = context;
-  return value;
-}
-var AbortControllerLocal =
-    "undefined" !== typeof AbortController
-      ? AbortController
-      : function () {
-          var listeners = [],
-            signal = (this.signal = {
-              aborted: !1,
-              addEventListener: function (type, listener) {
-                listeners.push(listener);
+      bubbleProperties(workInProgress);
+      return null;
+    case 6:
+      if (current && null != workInProgress.stateNode)
+        current.memoizedProps !== newProps && markUpdate(workInProgress);
+      else {
+        if ("string" !== typeof newProps && null === workInProgress.stateNode)
+          throw Error(formatProdErrorMessage(166));
+        current = rootInstanceStackCursor.current;
+        if (popHydrationState(workInProgress)) {
+          newProps = workInProgress.stateNode;
+          current = workInProgress.memoizedProps;
+          newProps[internalInstanceKey] = workInProgress;
+          if ((renderLanes = newProps.nodeValue !== current))
+            if (((type = hydrationParentFiber), null !== type))
+              switch (type.tag) {
+                case 3:
+                  newProps = newProps.nodeValue;
+                  normalizeMarkupForTextOrAttribute(current);
+                  normalizeMarkupForTextOrAttribute(newProps);
+                  break;
+                case 27:
+                case 5:
+                  !0 !== type.memoizedProps.suppressHydrationWarning &&
+                    ((newProps = newProps.nodeValue),
+                    normalizeMarkupForTextOrAttribute(current),
+                    normalizeMarkupForTextOrAttribute(newProps));
               }
-            });
-          this.abort = function () {
-            signal.aborted = !0;
-            listeners.forEach(function (listener) {
-              return listener();
-            });
-          };
-        },
-  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
-  NormalPriority = Scheduler.unstable_NormalPriority,
-  CacheContext = {
-    $$typeof: REACT_CONTEXT_TYPE,
-    Consumer: null,
-    Provider: null,
-    _currentValue: null,
-    _currentValue2: null,
-    _threadCount: 0,
-    _defaultValue: null,
-    _globalName: null
-  };
-function createCache() {
-  return {
-    controller: new AbortControllerLocal(),
-    data: new Map(),
-    refCount: 0
-  };
-}
-function releaseCache(cache) {
-  cache.refCount--;
-  0 === cache.refCount &&
-    scheduleCallback$1(NormalPriority, function () {
-      cache.controller.abort();
-    });
-}
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
-  resumedCache = createCursor(null),
-  transitionStack = createCursor(null);
-function peekCacheFromPool() {
-  var cacheResumedFromPreviousRender = resumedCache.current;
-  return null !== cacheResumedFromPreviousRender
-    ? cacheResumedFromPreviousRender
-    : workInProgressRoot.pooledCache;
-}
-function pushTransition(
-  offscreenWorkInProgress,
-  prevCachePool,
-  newTransitions
-) {
-  null === prevCachePool
-    ? push(resumedCache, resumedCache.current)
-    : push(resumedCache, prevCachePool.pool);
-  enableTransitionTracing &&
-    (null === transitionStack.current
-      ? push(transitionStack, newTransitions)
-      : null === newTransitions
-      ? push(transitionStack, transitionStack.current)
-      : push(transitionStack, transitionStack.current.concat(newTransitions)));
-}
-function popTransition(workInProgress, current) {
-  null !== current &&
-    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
-}
-function getSuspendedCache() {
-  var cacheFromPool = peekCacheFromPool();
-  return null === cacheFromPool
-    ? null
-    : { parent: CacheContext._currentValue, pool: cacheFromPool };
-}
-var emptyObject = {};
-function collectScopedNodesFromChildren(
-  startingChild,
-  fn$jscomp$0,
-  scopedNodes$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      fn = fn$jscomp$0,
-      scopedNodes = scopedNodes$jscomp$0;
-    if (5 === node.tag) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        instance = node.stateNode;
-      null !== instance &&
-        !0 === fn(type, memoizedProps || emptyObject, instance) &&
-        scopedNodes.push(instance);
-    }
-    type = node.child;
-    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
-    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
-    startingChild = startingChild.sibling;
-  }
-}
-function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
-  for (; null !== startingChild; ) {
-    a: {
-      var JSCompiler_inline_result = startingChild;
-      var fn = fn$jscomp$0;
-      if (5 === JSCompiler_inline_result.tag) {
-        var type = JSCompiler_inline_result.type,
-          memoizedProps = JSCompiler_inline_result.memoizedProps,
-          instance = JSCompiler_inline_result.stateNode;
-        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
-          JSCompiler_inline_result = instance;
-          break a;
-        }
+          renderLanes && markUpdate(workInProgress);
+        } else
+          (current =
+            getOwnerDocumentFromRootContainer(current).createTextNode(
+              newProps
+            )),
+            (current[internalInstanceKey] = workInProgress),
+            (workInProgress.stateNode = current);
       }
-      type = JSCompiler_inline_result.child;
-      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
-        (type = JSCompiler_inline_result.child.sibling.child);
-      JSCompiler_inline_result =
-        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
-    }
-    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
-    startingChild = startingChild.sibling;
-  }
-  return null;
-}
-function collectNearestChildContextValues(
-  startingChild,
-  context$jscomp$0,
-  childContextValues$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      context = context$jscomp$0,
-      childContextValues = childContextValues$jscomp$0;
-    if (10 === node.tag && node.type._context === context)
-      childContextValues.push(node.memoizedProps.value);
-    else {
-      var child = node.child;
-      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
-      null !== child &&
-        collectNearestChildContextValues(child, context, childContextValues);
-    }
-    startingChild = startingChild.sibling;
-  }
-}
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  var scopedNodes = [];
-  null !== currentFiber &&
-    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
-  return 0 === scopedNodes.length ? null : scopedNodes;
-}
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  return null !== currentFiber
-    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
-    : null;
-}
-function containsNode(node) {
-  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
-    if (21 === node.tag && node.stateNode === this) return !0;
-    node = node.return;
-  }
-  return !1;
-}
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return [];
-  currentFiber = currentFiber.child;
-  var childContextValues = [];
-  null !== currentFiber &&
-    collectNearestChildContextValues(currentFiber, context, childContextValues);
-  return childContextValues;
-}
-function markUpdate(workInProgress) {
-  workInProgress.flags |= 4;
-}
-function markRef(workInProgress) {
-  workInProgress.flags |= 2097664;
-}
-function updateHostComponent(current, workInProgress, type, newProps) {
-  var oldProps = current.memoizedProps;
-  if (oldProps !== newProps) {
-    current = workInProgress.stateNode;
-    var updatePayload = null;
-    switch (type) {
-      case "input":
-        oldProps = getHostProps$2(current, oldProps);
-        newProps = getHostProps$2(current, newProps);
-        updatePayload = [];
-        break;
-      case "select":
-        oldProps = assign({}, oldProps, { value: void 0 });
-        newProps = assign({}, newProps, { value: void 0 });
-        updatePayload = [];
-        break;
-      case "textarea":
-        oldProps = getHostProps(current, oldProps);
-        newProps = getHostProps(current, newProps);
-        updatePayload = [];
-        break;
-      default:
-        "function" !== typeof oldProps.onClick &&
-          "function" === typeof newProps.onClick &&
-          (current.onclick = noop$1);
-    }
-    assertValidProps(type, newProps);
-    var styleName;
-    type = null;
-    for (JSCompiler_inline_result in oldProps)
+      bubbleProperties(workInProgress);
+      return null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      newProps = workInProgress.memoizedState;
       if (
-        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
-        null != oldProps[JSCompiler_inline_result]
-      )
-        if ("style" === JSCompiler_inline_result) {
-          var lastStyle = oldProps[JSCompiler_inline_result];
-          for (styleName in lastStyle)
-            lastStyle.hasOwnProperty(styleName) &&
-              (type || (type = {}), (type[styleName] = ""));
+        null === current ||
+        (null !== current.memoizedState &&
+          null !== current.memoizedState.dehydrated)
+      ) {
+        if (
+          isHydrating &&
+          null !== nextHydratableInstance &&
+          0 !== (workInProgress.mode & 1) &&
+          0 === (workInProgress.flags & 128)
+        )
+          warnIfUnhydratedTailNodes(),
+            resetHydrationState(),
+            (workInProgress.flags |= 98560),
+            (type = !1);
+        else if (
+          ((type = popHydrationState(workInProgress)),
+          null !== newProps && null !== newProps.dehydrated)
+        ) {
+          if (null === current) {
+            if (!type) throw Error(formatProdErrorMessage(318));
+            type = workInProgress.memoizedState;
+            type = null !== type ? type.dehydrated : null;
+            if (!type) throw Error(formatProdErrorMessage(317));
+            type[internalInstanceKey] = workInProgress;
+            bubbleProperties(workInProgress);
+            0 !== (workInProgress.mode & 2) &&
+              null !== newProps &&
+              ((type = workInProgress.child),
+              null !== type &&
+                (workInProgress.treeBaseDuration -= type.treeBaseDuration));
+          } else
+            resetHydrationState(),
+              0 === (workInProgress.flags & 128) &&
+                (workInProgress.memoizedState = null),
+              (workInProgress.flags |= 4),
+              bubbleProperties(workInProgress),
+              0 !== (workInProgress.mode & 2) &&
+                null !== newProps &&
+                ((type = workInProgress.child),
+                null !== type &&
+                  (workInProgress.treeBaseDuration -= type.treeBaseDuration));
+          type = !1;
         } else
-          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
-            "children" !== JSCompiler_inline_result &&
-            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-            "suppressHydrationWarning" !== JSCompiler_inline_result &&
-            "autoFocus" !== JSCompiler_inline_result &&
-            (registrationNameDependencies.hasOwnProperty(
-              JSCompiler_inline_result
+          null !== hydrationErrors &&
+            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
+            (type = !0);
+        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
+      }
+      if (0 !== (workInProgress.flags & 128))
+        return (
+          (workInProgress.lanes = renderLanes),
+          0 !== (workInProgress.mode & 2) &&
+            transferActualDuration(workInProgress),
+          workInProgress
+        );
+      renderLanes = null !== newProps;
+      current = null !== current && null !== current.memoizedState;
+      if (renderLanes) {
+        newProps = workInProgress.child;
+        type = null;
+        null !== newProps.alternate &&
+          null !== newProps.alternate.memoizedState &&
+          null !== newProps.alternate.memoizedState.cachePool &&
+          (type = newProps.alternate.memoizedState.cachePool.pool);
+        var cache$121 = null;
+        null !== newProps.memoizedState &&
+          null !== newProps.memoizedState.cachePool &&
+          (cache$121 = newProps.memoizedState.cachePool.pool);
+        cache$121 !== type && (newProps.flags |= 2048);
+      }
+      renderLanes !== current &&
+        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
+        renderLanes && (workInProgress.child.flags |= 8192));
+      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
+      null !== workInProgress.updateQueue &&
+        null != workInProgress.memoizedProps.suspenseCallback &&
+        (workInProgress.flags |= 4);
+      bubbleProperties(workInProgress);
+      0 !== (workInProgress.mode & 2) &&
+        renderLanes &&
+        ((current = workInProgress.child),
+        null !== current &&
+          (workInProgress.treeBaseDuration -= current.treeBaseDuration));
+      return null;
+    case 4:
+      return (
+        popHostContainer(),
+        null === current &&
+          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 10:
+      return (
+        popProvider(workInProgress.type._context),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 17:
+      return bubbleProperties(workInProgress), null;
+    case 19:
+      pop(suspenseStackCursor);
+      type = workInProgress.memoizedState;
+      if (null === type) return bubbleProperties(workInProgress), null;
+      newProps = 0 !== (workInProgress.flags & 128);
+      cache$121 = type.rendering;
+      if (null === cache$121)
+        if (newProps) cutOffTailIfNeeded(type, !1);
+        else {
+          if (
+            0 !== workInProgressRootExitStatus ||
+            (null !== current && 0 !== (current.flags & 128))
+          )
+            for (current = workInProgress.child; null !== current; ) {
+              cache$121 = findFirstSuspended(current);
+              if (null !== cache$121) {
+                workInProgress.flags |= 128;
+                cutOffTailIfNeeded(type, !1);
+                current = cache$121.updateQueue;
+                null !== current &&
+                  ((workInProgress.updateQueue = current),
+                  (workInProgress.flags |= 4));
+                workInProgress.subtreeFlags = 0;
+                current = renderLanes;
+                for (renderLanes = workInProgress.child; null !== renderLanes; )
+                  resetWorkInProgress(renderLanes, current),
+                    (renderLanes = renderLanes.sibling);
+                push(
+                  suspenseStackCursor,
+                  (suspenseStackCursor.current & 1) | 2
+                );
+                return workInProgress.child;
+              }
+              current = current.sibling;
+            }
+          null !== type.tail &&
+            now$1() > workInProgressRootRenderTargetTime &&
+            ((workInProgress.flags |= 128),
+            (newProps = !0),
+            cutOffTailIfNeeded(type, !1),
+            (workInProgress.lanes = 8388608));
+        }
+      else {
+        if (!newProps)
+          if (((current = findFirstSuspended(cache$121)), null !== current)) {
+            if (
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              (current = current.updateQueue),
+              null !== current &&
+                ((workInProgress.updateQueue = current),
+                (workInProgress.flags |= 4)),
+              cutOffTailIfNeeded(type, !0),
+              null === type.tail &&
+                "hidden" === type.tailMode &&
+                !cache$121.alternate &&
+                !isHydrating)
             )
-              ? updatePayload || (updatePayload = [])
-              : (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  null
-                ));
-    for (JSCompiler_inline_result in newProps) {
-      var nextProp = newProps[JSCompiler_inline_result];
-      lastStyle =
-        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
-      if (
-        newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        nextProp !== lastStyle &&
-        (null != nextProp || null != lastStyle)
-      )
-        if ("style" === JSCompiler_inline_result)
-          if (lastStyle) {
-            for (styleName in lastStyle)
-              !lastStyle.hasOwnProperty(styleName) ||
-                (nextProp && nextProp.hasOwnProperty(styleName)) ||
-                (type || (type = {}), (type[styleName] = ""));
-            for (styleName in nextProp)
-              nextProp.hasOwnProperty(styleName) &&
-                lastStyle[styleName] !== nextProp[styleName] &&
-                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+              return bubbleProperties(workInProgress), null;
           } else
-            type ||
-              (updatePayload || (updatePayload = []),
-              updatePayload.push(JSCompiler_inline_result, type)),
-              (type = nextProp);
-        else
-          "dangerouslySetInnerHTML" === JSCompiler_inline_result
-            ? ((nextProp = nextProp ? nextProp.__html : void 0),
-              (lastStyle = lastStyle ? lastStyle.__html : void 0),
-              null != nextProp &&
-                lastStyle !== nextProp &&
-                (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  nextProp
-                ))
-            : "children" === JSCompiler_inline_result
-            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
-              (updatePayload = updatePayload || []).push(
-                JSCompiler_inline_result,
-                "" + nextProp
-              )
-            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-              "suppressHydrationWarning" !== JSCompiler_inline_result &&
-              (registrationNameDependencies.hasOwnProperty(
-                JSCompiler_inline_result
-              )
-                ? (null != nextProp &&
-                    "onScroll" === JSCompiler_inline_result &&
-                    listenToNonDelegatedEvent("scroll", current),
-                  updatePayload ||
-                    lastStyle === nextProp ||
-                    (updatePayload = []))
-                : (updatePayload = updatePayload || []).push(
-                    JSCompiler_inline_result,
-                    nextProp
-                  ));
-    }
-    type && (updatePayload = updatePayload || []).push("style", type);
-    var JSCompiler_inline_result = updatePayload;
-    (workInProgress.updateQueue = JSCompiler_inline_result) &&
-      markUpdate(workInProgress);
+            2 * now$1() - type.renderingStartTime >
+              workInProgressRootRenderTargetTime &&
+              1073741824 !== renderLanes &&
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              cutOffTailIfNeeded(type, !1),
+              (workInProgress.lanes = 8388608));
+        type.isBackwards
+          ? ((cache$121.sibling = workInProgress.child),
+            (workInProgress.child = cache$121))
+          : ((current = type.last),
+            null !== current
+              ? (current.sibling = cache$121)
+              : (workInProgress.child = cache$121),
+            (type.last = cache$121));
+      }
+      if (null !== type.tail)
+        return (
+          (workInProgress = type.tail),
+          (type.rendering = workInProgress),
+          (type.tail = workInProgress.sibling),
+          (type.renderingStartTime = now$1()),
+          (workInProgress.sibling = null),
+          (current = suspenseStackCursor.current),
+          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
+          workInProgress
+        );
+      bubbleProperties(workInProgress);
+      return null;
+    case 21:
+      return (
+        null === current
+          ? ((current = {
+              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+              containsNode: containsNode$1,
+              getChildContextValues: getChildContextValues
+            }),
+            (workInProgress.stateNode = current),
+            (current[internalInstanceKey] = workInProgress),
+            null !== workInProgress.ref &&
+              (markRef(workInProgress), markUpdate(workInProgress)))
+          : (null !== workInProgress.ref && markUpdate(workInProgress),
+            current.ref !== workInProgress.ref && markRef(workInProgress)),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        (newProps = null !== workInProgress.memoizedState),
+        23 !== workInProgress.tag &&
+          (null !== current
+            ? (null !== current.memoizedState) !== newProps &&
+              (workInProgress.flags |= 8192)
+            : newProps && (workInProgress.flags |= 8192)),
+        newProps && 0 !== (workInProgress.mode & 1)
+          ? 0 !== (renderLanes & 1073741824) &&
+            0 === (workInProgress.flags & 128) &&
+            (bubbleProperties(workInProgress),
+            23 !== workInProgress.tag &&
+              workInProgress.subtreeFlags & 6 &&
+              (workInProgress.flags |= 8192))
+          : bubbleProperties(workInProgress),
+        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
+        (renderLanes = null),
+        null !== current &&
+          null !== current.memoizedState &&
+          null !== current.memoizedState.cachePool &&
+          (renderLanes = current.memoizedState.cachePool.pool),
+        (newProps = null),
+        null !== workInProgress.memoizedState &&
+          null !== workInProgress.memoizedState.cachePool &&
+          (newProps = workInProgress.memoizedState.cachePool.pool),
+        newProps !== renderLanes && (workInProgress.flags |= 2048),
+        popTransition(workInProgress, current),
+        null
+      );
+    case 24:
+      return (
+        (renderLanes = null),
+        null !== current && (renderLanes = current.memoizedState.cache),
+        workInProgress.memoizedState.cache !== renderLanes &&
+          (workInProgress.flags |= 2048),
+        popProvider(CacheContext),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 25:
+      return (
+        enableTransitionTracing &&
+          (null !== workInProgress.stateNode &&
+            enableTransitionTracing &&
+            pop(markerInstanceStack),
+          bubbleProperties(workInProgress)),
+        null
+      );
   }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (!isHydrating)
-    switch (renderState.tailMode) {
-      case "hidden":
-        hasRenderedATailFallback = renderState.tail;
-        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
-          null !== hasRenderedATailFallback.alternate &&
-            (lastTailNode = hasRenderedATailFallback),
-            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
-        null === lastTailNode
-          ? (renderState.tail = null)
-          : (lastTailNode.sibling = null);
-        break;
-      case "collapsed":
-        lastTailNode = renderState.tail;
-        for (var lastTailNode$149 = null; null !== lastTailNode; )
-          null !== lastTailNode.alternate && (lastTailNode$149 = lastTailNode),
-            (lastTailNode = lastTailNode.sibling);
-        null === lastTailNode$149
-          ? hasRenderedATailFallback || null === renderState.tail
-            ? (renderState.tail = null)
-            : (renderState.tail.sibling = null)
-          : (lastTailNode$149.sibling = null);
-    }
-}
-function bubbleProperties(completedWork) {
-  var didBailout =
-      null !== completedWork.alternate &&
-      completedWork.alternate.child === completedWork.child,
-    newChildLanes = 0,
-    subtreeFlags = 0;
-  if (didBailout)
-    if (0 !== (completedWork.mode & 2)) {
-      for (
-        var treeBaseDuration$151 = completedWork.selfBaseDuration,
-          child$152 = completedWork.child;
-        null !== child$152;
-
-      )
-        (newChildLanes |= child$152.lanes | child$152.childLanes),
-          (subtreeFlags |= child$152.subtreeFlags & 14680064),
-          (subtreeFlags |= child$152.flags & 14680064),
-          (treeBaseDuration$151 += child$152.treeBaseDuration),
-          (child$152 = child$152.sibling);
-      completedWork.treeBaseDuration = treeBaseDuration$151;
-    } else
-      for (
-        treeBaseDuration$151 = completedWork.child;
-        null !== treeBaseDuration$151;
-
-      )
-        (newChildLanes |=
-          treeBaseDuration$151.lanes | treeBaseDuration$151.childLanes),
-          (subtreeFlags |= treeBaseDuration$151.subtreeFlags & 14680064),
-          (subtreeFlags |= treeBaseDuration$151.flags & 14680064),
-          (treeBaseDuration$151.return = completedWork),
-          (treeBaseDuration$151 = treeBaseDuration$151.sibling);
-  else if (0 !== (completedWork.mode & 2)) {
-    treeBaseDuration$151 = completedWork.actualDuration;
-    child$152 = completedWork.selfBaseDuration;
-    for (var child = completedWork.child; null !== child; )
-      (newChildLanes |= child.lanes | child.childLanes),
-        (subtreeFlags |= child.subtreeFlags),
-        (subtreeFlags |= child.flags),
-        (treeBaseDuration$151 += child.actualDuration),
-        (child$152 += child.treeBaseDuration),
-        (child = child.sibling);
-    completedWork.actualDuration = treeBaseDuration$151;
-    completedWork.treeBaseDuration = child$152;
-  } else
-    for (
-      treeBaseDuration$151 = completedWork.child;
-      null !== treeBaseDuration$151;
-
-    )
-      (newChildLanes |=
-        treeBaseDuration$151.lanes | treeBaseDuration$151.childLanes),
-        (subtreeFlags |= treeBaseDuration$151.subtreeFlags),
-        (subtreeFlags |= treeBaseDuration$151.flags),
-        (treeBaseDuration$151.return = completedWork),
-        (treeBaseDuration$151 = treeBaseDuration$151.sibling);
-  completedWork.subtreeFlags |= subtreeFlags;
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
-}
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps;
+function unwindWork(current, workInProgress) {
   popTreeContext(workInProgress);
   switch (workInProgress.tag) {
-    case 2:
-    case 16:
-    case 15:
-    case 0:
-    case 11:
-    case 7:
-    case 8:
-    case 12:
-    case 9:
-    case 14:
-      return bubbleProperties(workInProgress), null;
     case 1:
-      return bubbleProperties(workInProgress), null;
+      return (
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128),
+            0 !== (workInProgress.mode & 2) &&
+              transferActualDuration(workInProgress),
+            workInProgress)
+          : null
+      );
+    case 3:
+      return (
+        popProvider(CacheContext),
+        enableTransitionTracing &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        enableTransitionTracing && pop(transitionStack),
+        popHostContainer(),
+        resetWorkInProgressVersions(),
+        (current = workInProgress.flags),
+        0 !== (current & 65536) && 0 === (current & 128)
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 26:
+    case 27:
+    case 5:
+      return popHostContext(workInProgress), null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      current = workInProgress.memoizedState;
+      if (null !== current && null !== current.dehydrated) {
+        if (null === workInProgress.alternate)
+          throw Error(formatProdErrorMessage(340));
+        resetHydrationState();
+      }
+      current = workInProgress.flags;
+      return current & 65536
+        ? ((workInProgress.flags = (current & -65537) | 128),
+          0 !== (workInProgress.mode & 2) &&
+            transferActualDuration(workInProgress),
+          workInProgress)
+        : null;
+    case 19:
+      return pop(suspenseStackCursor), null;
+    case 4:
+      return popHostContainer(), null;
+    case 10:
+      return popProvider(workInProgress.type._context), null;
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        popTransition(workInProgress, current),
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128),
+            0 !== (workInProgress.mode & 2) &&
+              transferActualDuration(workInProgress),
+            workInProgress)
+          : null
+      );
+    case 24:
+      return popProvider(CacheContext), null;
+    case 25:
+      return (
+        enableTransitionTracing &&
+          null !== workInProgress.stateNode &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        null
+      );
+    default:
+      return null;
+  }
+}
+function unwindInterruptedWork(current, interruptedWork) {
+  popTreeContext(interruptedWork);
+  switch (interruptedWork.tag) {
     case 3:
-      renderLanes = workInProgress.stateNode;
-      enableTransitionTracing &&
-        null !== workInProgressTransitions &&
-        (workInProgress.flags |= 2048);
-      newProps = null;
-      null !== current && (newProps = current.memoizedState.cache);
-      workInProgress.memoizedState.cache !== newProps &&
-        (workInProgress.flags |= 2048);
       popProvider(CacheContext);
       enableTransitionTracing &&
         enableTransitionTracing &&
@@ -10097,593 +7384,80 @@ function completeWork(current, workInProgress, renderLanes) {
       enableTransitionTracing && pop(transitionStack);
       popHostContainer();
       resetWorkInProgressVersions();
-      renderLanes.pendingContext &&
-        ((renderLanes.context = renderLanes.pendingContext),
-        (renderLanes.pendingContext = null));
-      if (null === current || null === current.child)
-        popHydrationState(workInProgress)
-          ? markUpdate(workInProgress)
-          : null === current ||
-            (current.memoizedState.isDehydrated &&
-              0 === (workInProgress.flags & 256)) ||
-            ((workInProgress.flags |= 1024),
-            null !== hydrationErrors &&
-              (queueRecoverableErrors(hydrationErrors),
-              (hydrationErrors = null)));
-      bubbleProperties(workInProgress);
-      enableTransitionTracing &&
-        0 !== (workInProgress.subtreeFlags & 8192) &&
-        (workInProgress.flags |= 2048);
-      return null;
+      break;
     case 26:
-      return (
-        (current ? current.ref : null) !== workInProgress.ref &&
-          markRef(workInProgress),
-        null === current ||
-        current.memoizedState !== workInProgress.memoizedState
-          ? markUpdate(workInProgress)
-          : null === workInProgress.memoizedState &&
-            updateHostComponent(
-              current,
-              workInProgress,
-              workInProgress.type,
-              workInProgress.pendingProps
-            ),
-        bubbleProperties(workInProgress),
-        null
-      );
     case 27:
-      popHostContext(workInProgress);
-      renderLanes = rootInstanceStackCursor.current;
-      var type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, type, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor.current;
-        popHydrationState(workInProgress)
-          ? prepareToHydrateHostInstance(workInProgress, current)
-          : ((workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              renderLanes
-            )),
-            markUpdate(workInProgress));
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
     case 5:
-      popHostContext(workInProgress);
-      renderLanes = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, renderLanes, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor.current;
-        if (popHydrationState(workInProgress))
-          prepareToHydrateHostInstance(workInProgress, current) &&
-            markUpdate(workInProgress);
-        else {
-          type = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
-          );
-          switch (current) {
-            case "http://www.w3.org/2000/svg":
-            case "http://www.w3.org/1998/Math/MathML":
-              current = type.createElementNS(current, renderLanes);
-              break;
-            default:
-              switch (renderLanes) {
-                case "svg":
-                  current = type.createElementNS(
-                    "http://www.w3.org/2000/svg",
-                    renderLanes
-                  );
-                  break;
-                case "math":
-                  current = type.createElementNS(
-                    "http://www.w3.org/1998/Math/MathML",
-                    renderLanes
-                  );
-                  break;
-                case "script":
-                  current = type.createElement("div");
-                  current.innerHTML = "<script>\x3c/script>";
-                  current = current.removeChild(current.firstChild);
-                  break;
-                case "select":
-                  current =
-                    "string" === typeof newProps.is
-                      ? type.createElement("select", { is: newProps.is })
-                      : type.createElement("select");
-                  newProps.multiple
-                    ? (current.multiple = !0)
-                    : newProps.size && (current.size = newProps.size);
-                  break;
-                default:
-                  current = createHTMLElement(renderLanes, newProps, type);
-              }
-          }
-          current[internalInstanceKey] = workInProgress;
-          current[internalPropsKey] = newProps;
-          a: for (type = workInProgress.child; null !== type; ) {
-            if (5 === type.tag || 6 === type.tag)
-              current.appendChild(type.stateNode);
-            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
-              type.child.return = type;
-              type = type.child;
-              continue;
-            }
-            if (type === workInProgress) break a;
-            for (; null === type.sibling; ) {
-              if (null === type.return || type.return === workInProgress)
-                break a;
-              type = type.return;
-            }
-            type.sibling.return = type.return;
-            type = type.sibling;
-          }
-          workInProgress.stateNode = current;
-          a: switch (
-            (setInitialProperties(current, renderLanes, newProps), renderLanes)
-          ) {
-            case "button":
-            case "input":
-            case "select":
-            case "textarea":
-              current = !!newProps.autoFocus;
-              break a;
-            case "img":
-              current = !0;
-              break a;
-            default:
-              current = !1;
-          }
-          current && markUpdate(workInProgress);
-        }
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        current.memoizedProps !== newProps && markUpdate(workInProgress);
-      else {
-        if ("string" !== typeof newProps && null === workInProgress.stateNode)
-          throw Error(formatProdErrorMessage(166));
-        current = rootInstanceStackCursor.current;
-        if (popHydrationState(workInProgress)) {
-          newProps = workInProgress.stateNode;
-          current = workInProgress.memoizedProps;
-          newProps[internalInstanceKey] = workInProgress;
-          if ((renderLanes = newProps.nodeValue !== current))
-            if (((type = hydrationParentFiber), null !== type))
-              switch (type.tag) {
-                case 3:
-                  newProps = newProps.nodeValue;
-                  normalizeMarkupForTextOrAttribute(current);
-                  normalizeMarkupForTextOrAttribute(newProps);
-                  break;
-                case 27:
-                case 5:
-                  !0 !== type.memoizedProps.suppressHydrationWarning &&
-                    ((newProps = newProps.nodeValue),
-                    normalizeMarkupForTextOrAttribute(current),
-                    normalizeMarkupForTextOrAttribute(newProps));
-              }
-          renderLanes && markUpdate(workInProgress);
-        } else
-          (current =
-            getOwnerDocumentFromRootContainer(current).createTextNode(
-              newProps
-            )),
-            (current[internalInstanceKey] = workInProgress),
-            (workInProgress.stateNode = current);
-      }
-      bubbleProperties(workInProgress);
-      return null;
+      popHostContext(interruptedWork);
+      break;
+    case 4:
+      popHostContainer();
+      break;
     case 13:
-      popSuspenseHandler(workInProgress);
-      newProps = workInProgress.memoizedState;
-      if (
-        null === current ||
-        (null !== current.memoizedState &&
-          null !== current.memoizedState.dehydrated)
-      ) {
-        if (
-          isHydrating &&
-          null !== nextHydratableInstance &&
-          0 !== (workInProgress.mode & 1) &&
-          0 === (workInProgress.flags & 128)
-        )
-          warnIfUnhydratedTailNodes(),
-            resetHydrationState(),
-            (workInProgress.flags |= 98560),
-            (type = !1);
-        else if (
-          ((type = popHydrationState(workInProgress)),
-          null !== newProps && null !== newProps.dehydrated)
-        ) {
-          if (null === current) {
-            if (!type) throw Error(formatProdErrorMessage(318));
-            type = workInProgress.memoizedState;
-            type = null !== type ? type.dehydrated : null;
-            if (!type) throw Error(formatProdErrorMessage(317));
-            type[internalInstanceKey] = workInProgress;
-            bubbleProperties(workInProgress);
-            0 !== (workInProgress.mode & 2) &&
-              null !== newProps &&
-              ((type = workInProgress.child),
-              null !== type &&
-                (workInProgress.treeBaseDuration -= type.treeBaseDuration));
-          } else
-            resetHydrationState(),
-              0 === (workInProgress.flags & 128) &&
-                (workInProgress.memoizedState = null),
-              (workInProgress.flags |= 4),
-              bubbleProperties(workInProgress),
-              0 !== (workInProgress.mode & 2) &&
-                null !== newProps &&
-                ((type = workInProgress.child),
-                null !== type &&
-                  (workInProgress.treeBaseDuration -= type.treeBaseDuration));
-          type = !1;
-        } else
-          null !== hydrationErrors &&
-            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
-            (type = !0);
-        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
-      }
-      if (0 !== (workInProgress.flags & 128))
-        return (
-          (workInProgress.lanes = renderLanes),
-          0 !== (workInProgress.mode & 2) &&
-            transferActualDuration(workInProgress),
-          workInProgress
-        );
-      renderLanes = null !== newProps;
-      current = null !== current && null !== current.memoizedState;
-      if (renderLanes) {
-        newProps = workInProgress.child;
-        type = null;
-        null !== newProps.alternate &&
-          null !== newProps.alternate.memoizedState &&
-          null !== newProps.alternate.memoizedState.cachePool &&
-          (type = newProps.alternate.memoizedState.cachePool.pool);
-        var cache$165 = null;
-        null !== newProps.memoizedState &&
-          null !== newProps.memoizedState.cachePool &&
-          (cache$165 = newProps.memoizedState.cachePool.pool);
-        cache$165 !== type && (newProps.flags |= 2048);
-      }
-      renderLanes !== current &&
-        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
-        renderLanes && (workInProgress.child.flags |= 8192));
-      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
-      null !== workInProgress.updateQueue &&
-        null != workInProgress.memoizedProps.suspenseCallback &&
-        (workInProgress.flags |= 4);
-      bubbleProperties(workInProgress);
-      0 !== (workInProgress.mode & 2) &&
-        renderLanes &&
-        ((current = workInProgress.child),
-        null !== current &&
-          (workInProgress.treeBaseDuration -= current.treeBaseDuration));
-      return null;
-    case 4:
-      return (
-        popHostContainer(),
-        null === current &&
-          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 10:
-      return (
-        popProvider(workInProgress.type._context),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 17:
-      return bubbleProperties(workInProgress), null;
+      popSuspenseHandler(interruptedWork);
+      break;
     case 19:
       pop(suspenseStackCursor);
-      type = workInProgress.memoizedState;
-      if (null === type) return bubbleProperties(workInProgress), null;
-      newProps = 0 !== (workInProgress.flags & 128);
-      cache$165 = type.rendering;
-      if (null === cache$165)
-        if (newProps) cutOffTailIfNeeded(type, !1);
-        else {
-          if (
-            0 !== workInProgressRootExitStatus ||
-            (null !== current && 0 !== (current.flags & 128))
-          )
-            for (current = workInProgress.child; null !== current; ) {
-              cache$165 = findFirstSuspended(current);
-              if (null !== cache$165) {
-                workInProgress.flags |= 128;
-                cutOffTailIfNeeded(type, !1);
-                current = cache$165.updateQueue;
-                null !== current &&
-                  ((workInProgress.updateQueue = current),
-                  (workInProgress.flags |= 4));
-                workInProgress.subtreeFlags = 0;
-                current = renderLanes;
-                for (renderLanes = workInProgress.child; null !== renderLanes; )
-                  resetWorkInProgress(renderLanes, current),
-                    (renderLanes = renderLanes.sibling);
-                push(
-                  suspenseStackCursor,
-                  (suspenseStackCursor.current & 1) | 2
-                );
-                return workInProgress.child;
-              }
-              current = current.sibling;
-            }
-          null !== type.tail &&
-            now$1() > workInProgressRootRenderTargetTime &&
-            ((workInProgress.flags |= 128),
-            (newProps = !0),
-            cutOffTailIfNeeded(type, !1),
-            (workInProgress.lanes = 8388608));
-        }
-      else {
-        if (!newProps)
-          if (((current = findFirstSuspended(cache$165)), null !== current)) {
-            if (
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              (current = current.updateQueue),
-              null !== current &&
-                ((workInProgress.updateQueue = current),
-                (workInProgress.flags |= 4)),
-              cutOffTailIfNeeded(type, !0),
-              null === type.tail &&
-                "hidden" === type.tailMode &&
-                !cache$165.alternate &&
-                !isHydrating)
-            )
-              return bubbleProperties(workInProgress), null;
-          } else
-            2 * now$1() - type.renderingStartTime >
-              workInProgressRootRenderTargetTime &&
-              1073741824 !== renderLanes &&
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              cutOffTailIfNeeded(type, !1),
-              (workInProgress.lanes = 8388608));
-        type.isBackwards
-          ? ((cache$165.sibling = workInProgress.child),
-            (workInProgress.child = cache$165))
-          : ((current = type.last),
-            null !== current
-              ? (current.sibling = cache$165)
-              : (workInProgress.child = cache$165),
-            (type.last = cache$165));
-      }
-      if (null !== type.tail)
-        return (
-          (workInProgress = type.tail),
-          (type.rendering = workInProgress),
-          (type.tail = workInProgress.sibling),
-          (type.renderingStartTime = now$1()),
-          (workInProgress.sibling = null),
-          (current = suspenseStackCursor.current),
-          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
-          workInProgress
-        );
-      bubbleProperties(workInProgress);
-      return null;
-    case 21:
-      return (
-        null === current
-          ? ((current = {
-              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-              containsNode: containsNode,
-              getChildContextValues: getChildContextValues
-            }),
-            (workInProgress.stateNode = current),
-            (current[internalInstanceKey] = workInProgress),
-            null !== workInProgress.ref &&
-              (markRef(workInProgress), markUpdate(workInProgress)))
-          : (null !== workInProgress.ref && markUpdate(workInProgress),
-            current.ref !== workInProgress.ref && markRef(workInProgress)),
-        bubbleProperties(workInProgress),
-        null
-      );
+      break;
+    case 10:
+      popProvider(interruptedWork.type._context);
+      break;
     case 22:
     case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        (newProps = null !== workInProgress.memoizedState),
-        23 !== workInProgress.tag &&
-          (null !== current
-            ? (null !== current.memoizedState) !== newProps &&
-              (workInProgress.flags |= 8192)
-            : newProps && (workInProgress.flags |= 8192)),
-        newProps && 0 !== (workInProgress.mode & 1)
-          ? 0 !== (renderLanes & 1073741824) &&
-            0 === (workInProgress.flags & 128) &&
-            (bubbleProperties(workInProgress),
-            23 !== workInProgress.tag &&
-              workInProgress.subtreeFlags & 6 &&
-              (workInProgress.flags |= 8192))
-          : bubbleProperties(workInProgress),
-        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
-        (renderLanes = null),
-        null !== current &&
-          null !== current.memoizedState &&
-          null !== current.memoizedState.cachePool &&
-          (renderLanes = current.memoizedState.cachePool.pool),
-        (newProps = null),
-        null !== workInProgress.memoizedState &&
-          null !== workInProgress.memoizedState.cachePool &&
-          (newProps = workInProgress.memoizedState.cachePool.pool),
-        newProps !== renderLanes && (workInProgress.flags |= 2048),
-        popTransition(workInProgress, current),
-        null
-      );
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
     case 24:
-      return (
-        (renderLanes = null),
-        null !== current && (renderLanes = current.memoizedState.cache),
-        workInProgress.memoizedState.cache !== renderLanes &&
-          (workInProgress.flags |= 2048),
-        popProvider(CacheContext),
-        bubbleProperties(workInProgress),
-        null
-      );
+      popProvider(CacheContext);
+      break;
     case 25:
-      return (
+      enableTransitionTracing &&
+        null !== interruptedWork.stateNode &&
         enableTransitionTracing &&
-          (null !== workInProgress.stateNode &&
-            enableTransitionTracing &&
-            pop(markerInstanceStack),
-          bubbleProperties(workInProgress)),
-        null
-      );
+        pop(markerInstanceStack);
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
-function unwindWork(current, workInProgress) {
-  popTreeContext(workInProgress);
-  switch (workInProgress.tag) {
-    case 1:
-      return (
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128),
-            0 !== (workInProgress.mode & 2) &&
-              transferActualDuration(workInProgress),
-            workInProgress)
-          : null
-      );
-    case 3:
-      return (
-        popProvider(CacheContext),
-        enableTransitionTracing &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        enableTransitionTracing && pop(transitionStack),
-        popHostContainer(),
-        resetWorkInProgressVersions(),
-        (current = workInProgress.flags),
-        0 !== (current & 65536) && 0 === (current & 128)
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 26:
-    case 27:
-    case 5:
-      return popHostContext(workInProgress), null;
-    case 13:
-      popSuspenseHandler(workInProgress);
-      current = workInProgress.memoizedState;
-      if (null !== current && null !== current.dehydrated) {
-        if (null === workInProgress.alternate)
-          throw Error(formatProdErrorMessage(340));
-        resetHydrationState();
-      }
-      current = workInProgress.flags;
-      return current & 65536
-        ? ((workInProgress.flags = (current & -65537) | 128),
-          0 !== (workInProgress.mode & 2) &&
-            transferActualDuration(workInProgress),
-          workInProgress)
-        : null;
-    case 19:
-      return pop(suspenseStackCursor), null;
-    case 4:
-      return popHostContainer(), null;
-    case 10:
-      return popProvider(workInProgress.type._context), null;
-    case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        popTransition(workInProgress, current),
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128),
-            0 !== (workInProgress.mode & 2) &&
-              transferActualDuration(workInProgress),
-            workInProgress)
-          : null
-      );
-    case 24:
-      return popProvider(CacheContext), null;
-    case 25:
-      return (
-        enableTransitionTracing &&
-          null !== workInProgress.stateNode &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        null
-      );
-    default:
-      return null;
-  }
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
+if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
+  throw Error(formatProdErrorMessage(255));
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
 }
-function unwindInterruptedWork(current, interruptedWork) {
-  popTreeContext(interruptedWork);
-  switch (interruptedWork.tag) {
-    case 3:
-      popProvider(CacheContext);
-      enableTransitionTracing &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
-      enableTransitionTracing && pop(transitionStack);
-      popHostContainer();
-      resetWorkInProgressVersions();
-      break;
-    case 26:
-    case 27:
-    case 5:
-      popHostContext(interruptedWork);
-      break;
-    case 4:
-      popHostContainer();
-      break;
-    case 13:
-      popSuspenseHandler(interruptedWork);
-      break;
-    case 19:
-      pop(suspenseStackCursor);
-      break;
-    case 10:
-      popProvider(interruptedWork.type._context);
-      break;
-    case 22:
-    case 23:
-      popSuspenseHandler(interruptedWork);
-      popHiddenContext();
-      popTransition(interruptedWork, current);
-      break;
-    case 24:
-      popProvider(CacheContext);
-      break;
-    case 25:
-      enableTransitionTracing &&
-        null !== interruptedWork.stateNode &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
+var hasError = !1,
+  caughtError = null,
+  hasRethrowError = !1,
+  rethrowError = null,
+  reporter = {
+    onError: function (error) {
+      hasError = !0;
+      caughtError = error;
+    }
+  };
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = !1;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
+}
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
+) {
+  invokeGuardedCallback.apply(this, arguments);
+  if (hasError) {
+    if (hasError) {
+      var error = caughtError;
+      hasError = !1;
+      caughtError = null;
+    } else throw Error(formatProdErrorMessage(198));
+    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
   }
 }
 var offscreenSubtreeIsHidden = !1,
@@ -10764,8 +7538,8 @@ function safelyDetachRef(current, nearestMountedAncestor) {
             recordLayoutEffectDuration(current);
           }
         else ref(null);
-      } catch (error$180) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error$180);
+      } catch (error$136) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$136);
       }
     else ref.current = null;
 }
@@ -10802,7 +7576,7 @@ function commitBeforeMutationEffects(root, firstChild) {
           selection = selection.focusOffset;
           try {
             JSCompiler_temp.nodeType, focusNode.nodeType;
-          } catch (e$28) {
+          } catch (e$208) {
             JSCompiler_temp = null;
             break a;
           }
@@ -10864,12 +7638,8 @@ function commitBeforeMutationEffects(root, firstChild) {
       )
         (anchorOffset = root[JSCompiler_temp]),
           doesFiberContain(anchorOffset, focusedInstanceHandle) &&
-            ((_enabled = shouldFireAfterActiveInstanceBlur = !0),
-            dispatchBeforeDetachedBlur(
-              selectionInformation.focusedElem,
-              anchorOffset
-            ),
-            (_enabled = !1));
+            ((shouldFireAfterActiveInstanceBlur = !0),
+            beforeActiveInstanceBlur(anchorOffset));
     root = firstChild.child;
     if (0 !== (firstChild.subtreeFlags & 9236) && null !== root)
       (root.return = firstChild), (nextEffect = root);
@@ -10905,10 +7675,7 @@ function commitBeforeMutationEffects(root, firstChild) {
           }
           JSCompiler_temp$jscomp$0 &&
             ((shouldFireAfterActiveInstanceBlur = !0),
-            (root = firstChild),
-            (_enabled = !0),
-            dispatchBeforeDetachedBlur(selectionInformation.focusedElem, root),
-            (_enabled = !1));
+            beforeActiveInstanceBlur(firstChild));
           switch (firstChild.tag) {
             case 0:
               if (0 !== (flags & 4)) {
@@ -11076,11 +7843,11 @@ function commitPassiveEffectDurations(finishedRoot, finishedWork) {
         var _finishedWork$memoize = finishedWork.memoizedProps,
           id = _finishedWork$memoize.id;
         _finishedWork$memoize = _finishedWork$memoize.onPostCommit;
-        var commitTime$182 = commitTime,
+        var commitTime$138 = commitTime,
           phase = null === finishedWork.alternate ? "mount" : "update";
         currentUpdateIsNested && (phase = "nested-update");
         "function" === typeof _finishedWork$memoize &&
-          _finishedWork$memoize(id, phase, finishedRoot, commitTime$182);
+          _finishedWork$memoize(id, phase, finishedRoot, commitTime$138);
         finishedWork = finishedWork.return;
         a: for (; null !== finishedWork; ) {
           switch (finishedWork.tag) {
@@ -11107,8 +7874,8 @@ function commitHookLayoutEffects(finishedWork, hookFlags) {
   } else
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error$184) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error$184);
+    } catch (error$140) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error$140);
     }
 }
 function commitClassCallbacks(finishedWork) {
@@ -11207,11 +7974,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
           } else
             try {
               finishedRoot.componentDidMount();
-            } catch (error$185) {
+            } catch (error$141) {
               captureCommitPhaseError(
                 finishedWork,
                 finishedWork.return,
-                error$185
+                error$141
               );
             }
         else {
@@ -11228,11 +7995,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
                   current,
                   finishedRoot.__reactInternalSnapshotBeforeUpdate
                 );
-            } catch (error$186) {
+            } catch (error$142) {
               captureCommitPhaseError(
                 finishedWork,
                 finishedWork.return,
-                error$186
+                error$142
               );
             }
             recordLayoutEffectDuration(finishedWork);
@@ -11243,11 +8010,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
                 current,
                 finishedRoot.__reactInternalSnapshotBeforeUpdate
               );
-            } catch (error$187) {
+            } catch (error$143) {
               captureCommitPhaseError(
                 finishedWork,
                 finishedWork.return,
-                error$187
+                error$143
               );
             }
         }
@@ -11574,7 +8341,7 @@ function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
           (parent = parent._reactRootContainer),
           (null !== parent && void 0 !== parent) ||
             null !== before.onclick ||
-            (before.onclick = noop$1));
+            (before.onclick = noop));
   else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
     for (
       insertOrAppendPlacementNodeIntoContainer(node, before, parent),
@@ -11946,22 +8713,22 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
           try {
             startLayoutEffectTimer(),
               commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-          } catch (error$202) {
+          } catch (error$158) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$202
+              error$158
             );
           }
           recordLayoutEffectDuration(finishedWork);
         } else
           try {
             commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-          } catch (error$203) {
+          } catch (error$159) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$203
+              error$159
             );
           }
       }
@@ -12140,11 +8907,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               newProps
             );
             domElement[internalPropsKey] = newProps;
-          } catch (error$204) {
+          } catch (error$160) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$204
+              error$160
             );
           }
       break;
@@ -12180,8 +8947,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         root = finishedWork.stateNode;
         try {
           setTextContent(root, "");
-        } catch (error$205) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$205);
+        } catch (error$161) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$161);
         }
       }
       if (
@@ -12198,8 +8965,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         try {
           updateProperties(flags, maybeNodes, hoistableRoot, current, root),
             (flags[internalPropsKey] = root);
-        } catch (error$208) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$208);
+        } catch (error$164) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$164);
         }
       break;
     case 6:
@@ -12212,8 +8979,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         flags = finishedWork.memoizedProps;
         try {
           current.nodeValue = flags;
-        } catch (error$209) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$209);
+        } catch (error$165) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$165);
         }
       }
       break;
@@ -12227,8 +8994,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
       if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
         try {
           retryIfBlockedOn(root.containerInfo);
-        } catch (error$210) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$210);
+        } catch (error$166) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$166);
         }
       break;
     case 4:
@@ -12258,8 +9025,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               null !== wakeables && suspenseCallback(new Set(wakeables));
             }
           }
-        } catch (error$212) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$212);
+        } catch (error$168) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$168);
         }
         current = finishedWork.updateQueue;
         null !== current &&
@@ -12337,11 +9104,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
             if (null === current)
               try {
                 root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
-              } catch (error$192) {
+              } catch (error$148) {
                 captureCommitPhaseError(
                   finishedWork,
                   finishedWork.return,
-                  error$192
+                  error$148
                 );
               }
           } else if (
@@ -12416,21 +9183,21 @@ function commitReconciliationEffects(finishedWork) {
             insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
             break;
           case 5:
-            var parent$193 = JSCompiler_inline_result.stateNode;
+            var parent$149 = JSCompiler_inline_result.stateNode;
             JSCompiler_inline_result.flags & 32 &&
-              (setTextContent(parent$193, ""),
+              (setTextContent(parent$149, ""),
               (JSCompiler_inline_result.flags &= -33));
-            var before$194 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before$194, parent$193);
+            var before$150 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before$150, parent$149);
             break;
           case 3:
           case 4:
-            var parent$195 = JSCompiler_inline_result.stateNode.containerInfo,
-              before$196 = getHostSibling(finishedWork);
+            var parent$151 = JSCompiler_inline_result.stateNode.containerInfo,
+              before$152 = getHostSibling(finishedWork);
             insertOrAppendPlacementNodeIntoContainer(
               finishedWork,
-              before$196,
-              parent$195
+              before$152,
+              parent$151
             );
             break;
           default:
@@ -12622,8 +9389,8 @@ function commitHookPassiveMountEffects(finishedWork, hookFlags) {
   } else
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error$218) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error$218);
+    } catch (error$174) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error$174);
     }
 }
 function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
@@ -12922,9 +9689,9 @@ function recursivelyTraverseReconnectPassiveEffects(
           );
         break;
       case 22:
-        var instance$223 = finishedWork.stateNode;
+        var instance$179 = finishedWork.stateNode;
         null !== finishedWork.memoizedState
-          ? instance$223._visibility & 4
+          ? instance$179._visibility & 4
             ? recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -12937,7 +9704,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork
               )
-            : ((instance$223._visibility |= 4),
+            : ((instance$179._visibility |= 4),
               recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -12945,7 +9712,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 committedTransitions,
                 includeWorkInProgressEffects
               ))
-          : ((instance$223._visibility |= 4),
+          : ((instance$179._visibility |= 4),
             recursivelyTraverseReconnectPassiveEffects(
               finishedRoot,
               finishedWork,
@@ -12958,7 +9725,7 @@ function recursivelyTraverseReconnectPassiveEffects(
           commitOffscreenPassiveMountEffects(
             finishedWork.alternate,
             finishedWork,
-            instance$223
+            instance$179
           );
         break;
       case 24:
@@ -13267,7 +10034,7 @@ var ceil = Math.ceil,
   ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
   ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
   ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
   executionContext = 0,
   workInProgressRoot = null,
   workInProgress = null,
@@ -13381,7 +10148,7 @@ function requestUpdateLane(fiber) {
     0 !== workInProgressRootRenderLanes
   )
     return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
-  if (null !== ReactCurrentBatchConfig$1.transition)
+  if (null !== ReactCurrentBatchConfig$2.transition)
     return (
       0 === currentEventTransitionLane &&
         (currentEventTransitionLane = claimNextTransitionLane()),
@@ -13419,7 +10186,7 @@ function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
       }
     if (
       enableTransitionTracing &&
-      ((current = ReactCurrentBatchConfig.transition),
+      ((current = ReactCurrentBatchConfig$1.transition),
       null !== current &&
         null != current.name &&
         (-1 === current.startTime && (current.startTime = now$1()),
@@ -13550,16 +10317,16 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
         didTimeout = renderRootSync(root, lanes);
         if (2 === didTimeout) {
           errorRetryLanes = lanes;
-          var errorRetryLanes$232 = getLanesToRetrySynchronouslyOnError(
+          var errorRetryLanes$188 = getLanesToRetrySynchronouslyOnError(
             root,
             errorRetryLanes
           );
-          0 !== errorRetryLanes$232 &&
-            ((lanes = errorRetryLanes$232),
+          0 !== errorRetryLanes$188 &&
+            ((lanes = errorRetryLanes$188),
             (didTimeout = recoverFromConcurrentError(
               root,
               errorRetryLanes,
-              errorRetryLanes$232
+              errorRetryLanes$188
             )));
         }
         if (1 === didTimeout)
@@ -13613,11 +10380,11 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
           if ((lanes & 8388480) === lanes) break;
           didTimeout = root.eventTimes;
           for (originallyAttemptedLanes = -1; 0 < lanes; )
-            (errorRetryLanes$232 = 31 - clz32(lanes)),
-              (errorRetryLanes = 1 << errorRetryLanes$232),
-              (errorRetryLanes$232 = didTimeout[errorRetryLanes$232]),
-              errorRetryLanes$232 > originallyAttemptedLanes &&
-                (originallyAttemptedLanes = errorRetryLanes$232),
+            (errorRetryLanes$188 = 31 - clz32(lanes)),
+              (errorRetryLanes = 1 << errorRetryLanes$188),
+              (errorRetryLanes$188 = didTimeout[errorRetryLanes$188]),
+              errorRetryLanes$188 > originallyAttemptedLanes &&
+                (originallyAttemptedLanes = errorRetryLanes$188),
               (lanes &= ~errorRetryLanes);
           lanes = originallyAttemptedLanes;
           lanes = now$1() - lanes;
@@ -13740,9 +10507,9 @@ function markRootSuspended(root, suspendedLanes) {
   root.suspendedLanes |= suspendedLanes;
   root.pingedLanes &= ~suspendedLanes;
   for (root = root.expirationTimes; 0 < suspendedLanes; ) {
-    var index$13 = 31 - clz32(suspendedLanes),
-      lane = 1 << index$13;
-    root[index$13] = -1;
+    var index$12 = 31 - clz32(suspendedLanes),
+      lane = 1 << index$12;
+    root[index$12] = -1;
     suspendedLanes &= ~lane;
   }
 }
@@ -13790,7 +10557,7 @@ function performSyncWorkOnRoot(root) {
   ensureRootIsScheduled(root, now$1());
   return null;
 }
-function batchedUpdates(fn, a) {
+function batchedUpdates$1(fn, a) {
   var prevExecutionContext = executionContext;
   executionContext |= 1;
   try {
@@ -13809,18 +10576,18 @@ function flushSync$1(fn) {
     flushPassiveEffects();
   var prevExecutionContext = executionContext;
   executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
     previousPriority = currentUpdatePriority;
   try {
     if (
-      ((ReactCurrentBatchConfig.transition = null),
+      ((ReactCurrentBatchConfig$1.transition = null),
       (currentUpdatePriority = 2),
       fn)
     )
       return fn();
   } finally {
     (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
       (executionContext = prevExecutionContext),
       0 === (executionContext & 6) && flushSyncCallbacks();
   }
@@ -13993,8 +10760,8 @@ function renderRootSync(root, lanes) {
         }
       workLoopSync();
       break;
-    } catch (thrownValue$235) {
-      handleThrow(root, thrownValue$235);
+    } catch (thrownValue$191) {
+      handleThrow(root, thrownValue$191);
     }
   while (1);
   resetContextDependencies();
@@ -14085,8 +10852,8 @@ function renderRootConcurrent(root, lanes) {
         }
       workLoopConcurrent();
       break;
-    } catch (thrownValue$237) {
-      handleThrow(root, thrownValue$237);
+    } catch (thrownValue$193) {
+      handleThrow(root, thrownValue$193);
     }
   while (1);
   resetContextDependencies();
@@ -14254,10 +11021,10 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
                     };
                     suspenseBoundary.updateQueue = newOffscreenQueue;
                   } else {
-                    var wakeables$105 = offscreenQueue.wakeables;
-                    null === wakeables$105
+                    var wakeables$61 = offscreenQueue.wakeables;
+                    null === wakeables$61
                       ? (offscreenQueue.wakeables = new Set([wakeable]))
-                      : wakeables$105.add(wakeable);
+                      : wakeables$61.add(wakeable);
                   }
                   break;
                 }
@@ -14332,1513 +11099,4816 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
           root = root.return;
         } while (null !== root);
       }
-    } catch (error) {
-      throw ((workInProgress = returnFiber), error);
+    } catch (error) {
+      throw ((workInProgress = returnFiber), error);
+    }
+    completeUnitOfWork(unitOfWork);
+  }
+}
+function completeUnitOfWork(unitOfWork) {
+  var completedWork = unitOfWork;
+  do {
+    var current = completedWork.alternate;
+    unitOfWork = completedWork.return;
+    if (0 === (completedWork.flags & 32768)) {
+      if (
+        (0 === (completedWork.mode & 2)
+          ? (current = completeWork(current, completedWork, renderLanes))
+          : (startProfilerTimer(completedWork),
+            (current = completeWork(current, completedWork, renderLanes)),
+            stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1)),
+        null !== current)
+      ) {
+        workInProgress = current;
+        return;
+      }
+    } else {
+      current = unwindWork(current, completedWork);
+      if (null !== current) {
+        current.flags &= 16383;
+        workInProgress = current;
+        return;
+      }
+      if (0 !== (completedWork.mode & 2)) {
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1);
+        current = completedWork.actualDuration;
+        for (var child = completedWork.child; null !== child; )
+          (current += child.actualDuration), (child = child.sibling);
+        completedWork.actualDuration = current;
+      }
+      if (null !== unitOfWork)
+        (unitOfWork.flags |= 32768),
+          (unitOfWork.subtreeFlags = 0),
+          (unitOfWork.deletions = null);
+      else {
+        workInProgressRootExitStatus = 6;
+        workInProgress = null;
+        return;
+      }
+    }
+    completedWork = completedWork.sibling;
+    if (null !== completedWork) {
+      workInProgress = completedWork;
+      return;
+    }
+    workInProgress = completedWork = unitOfWork;
+  } while (null !== completedWork);
+  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+}
+function commitRoot(root, recoverableErrors, transitions) {
+  var previousUpdateLanePriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig$1.transition;
+  try {
+    (ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      commitRootImpl(
+        root,
+        recoverableErrors,
+        transitions,
+        previousUpdateLanePriority
+      );
+  } finally {
+    (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (currentUpdatePriority = previousUpdateLanePriority);
+  }
+  return null;
+}
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
+) {
+  do flushPassiveEffects();
+  while (null !== rootWithPendingPassiveEffects);
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var finishedWork = root.finishedWork,
+    lanes = root.finishedLanes;
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markCommitStarted &&
+    injectedProfilingHooks.markCommitStarted(lanes);
+  if (null === finishedWork)
+    return enableSchedulingProfiler && markCommitStopped(), null;
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
+  root.callbackNode = null;
+  root.callbackPriority = 0;
+  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
+  remainingLanes |= concurrentlyUpdatedLanes;
+  markRootFinished(root, remainingLanes);
+  root === workInProgressRoot &&
+    ((workInProgress = workInProgressRoot = null),
+    (workInProgressRootRenderLanes = 0));
+  (0 === (finishedWork.subtreeFlags & 10256) &&
+    0 === (finishedWork.flags & 10256)) ||
+    rootDoesHavePassiveEffects ||
+    ((rootDoesHavePassiveEffects = !0),
+    (pendingPassiveEffectsRemainingLanes = remainingLanes),
+    (pendingPassiveTransitions = transitions),
+    scheduleCallback(NormalPriority$1, function () {
+      flushPassiveEffects();
+      return null;
+    }));
+  transitions = 0 !== (finishedWork.flags & 15990);
+  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
+    transitions = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    var prevExecutionContext = executionContext;
+    executionContext |= 4;
+    ReactCurrentOwner.current = null;
+    var shouldFireAfterActiveInstanceBlur$196 = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
+    commitTime = now();
+    enableProfilerNestedUpdateScheduledHook &&
+      (rootCommittingMutationOrLayoutEffects = root);
+    commitMutationEffects(root, finishedWork, lanes);
+    shouldFireAfterActiveInstanceBlur$196 &&
+      ((_enabled = !0),
+      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
+      (_enabled = !1));
+    restoreSelection(selectionInformation);
+    _enabled = !!eventsEnabled;
+    selectionInformation = eventsEnabled = null;
+    root.current = finishedWork;
+    enableSchedulingProfiler &&
+      enableSchedulingProfiler &&
+      null !== injectedProfilingHooks &&
+      "function" === typeof injectedProfilingHooks.markLayoutEffectsStarted &&
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    commitLayoutEffects(finishedWork, root, lanes);
+    enableSchedulingProfiler &&
+      enableSchedulingProfiler &&
+      null !== injectedProfilingHooks &&
+      "function" === typeof injectedProfilingHooks.markLayoutEffectsStopped &&
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    enableProfilerNestedUpdateScheduledHook &&
+      (rootCommittingMutationOrLayoutEffects = null);
+    requestPaint();
+    executionContext = prevExecutionContext;
+    currentUpdatePriority = previousPriority;
+    ReactCurrentBatchConfig$1.transition = transitions;
+  } else (root.current = finishedWork), (commitTime = now());
+  rootDoesHavePassiveEffects
+    ? ((rootDoesHavePassiveEffects = !1),
+      (rootWithPendingPassiveEffects = root),
+      (pendingPassiveEffectsLanes = lanes))
+    : releaseRootPooledCache(root, remainingLanes);
+  remainingLanes = root.pendingLanes;
+  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  isDevToolsPresent && root.memoizedUpdaters.clear();
+  ensureRootIsScheduled(root, now$1());
+  if (null !== recoverableErrors)
+    for (
+      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
+      finishedWork < recoverableErrors.length;
+      finishedWork++
+    )
+      (lanes = recoverableErrors[finishedWork]),
+        (remainingLanes = {
+          digest: lanes.digest,
+          componentStack: lanes.stack
+        }),
+        renderPriorityLevel(lanes.value, remainingLanes);
+  if (hasUncaughtError)
+    throw (
+      ((hasUncaughtError = !1),
+      (root = firstUncaughtError),
+      (firstUncaughtError = null),
+      root)
+    );
+  0 !== (pendingPassiveEffectsLanes & 3) &&
+    0 !== root.tag &&
+    flushPassiveEffects();
+  remainingLanes = root.pendingLanes;
+  0 !== (remainingLanes & 3)
+    ? ((nestedUpdateScheduled = !0),
+      root === rootWithNestedUpdates
+        ? nestedUpdateCount++
+        : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root)))
+    : (nestedUpdateCount = 0);
+  flushSyncCallbacks();
+  enableSchedulingProfiler && markCommitStopped();
+  if (enableTransitionTracing) {
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    null !== prevRootTransitionCallbacks &&
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+        null !== prevPendingTransitionCallbacks
+          ? ((currentPendingTransitionCallbacks = null),
+            scheduleCallback(IdlePriority, function () {
+              processTransitionCallbacks(
+                prevPendingTransitionCallbacks,
+                endTime,
+                prevRootTransitionCallbacks
+              );
+            }))
+          : (currentEndTime = endTime);
+      });
+  }
+  return null;
+}
+function releaseRootPooledCache(root, remainingLanes) {
+  0 === (root.pooledCacheLanes &= remainingLanes) &&
+    ((remainingLanes = root.pooledCache),
+    null != remainingLanes &&
+      ((root.pooledCache = null), releaseCache(remainingLanes)));
+}
+function flushPassiveEffects() {
+  if (null !== rootWithPendingPassiveEffects) {
+    var root$197 = rootWithPendingPassiveEffects,
+      remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = 0;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    renderPriority = 32 > renderPriority ? 32 : renderPriority;
+    var prevTransition = ReactCurrentBatchConfig$1.transition,
+      previousPriority = currentUpdatePriority;
+    try {
+      return (
+        (ReactCurrentBatchConfig$1.transition = null),
+        (currentUpdatePriority = renderPriority),
+        flushPassiveEffectsImpl()
+      );
+    } finally {
+      (currentUpdatePriority = previousPriority),
+        (ReactCurrentBatchConfig$1.transition = prevTransition),
+        releaseRootPooledCache(root$197, remainingLanes);
+    }
+  }
+  return !1;
+}
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  pendingPassiveProfilerEffects.push(fiber);
+  rootDoesHavePassiveEffects ||
+    ((rootDoesHavePassiveEffects = !0),
+    scheduleCallback(NormalPriority$1, function () {
+      flushPassiveEffects();
+      return null;
+    }));
+}
+function flushPassiveEffectsImpl() {
+  if (null === rootWithPendingPassiveEffects) return !1;
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects,
+    lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null;
+  pendingPassiveEffectsLanes = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markPassiveEffectsStarted &&
+    injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+  var prevExecutionContext = executionContext;
+  executionContext |= 4;
+  commitPassiveUnmountOnFiber(root.current);
+  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
+  transitions = pendingPassiveProfilerEffects;
+  pendingPassiveProfilerEffects = [];
+  for (lanes = 0; lanes < transitions.length; lanes++)
+    commitPassiveEffectDurations(root, transitions[lanes]);
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markPassiveEffectsStopped &&
+    injectedProfilingHooks.markPassiveEffectsStopped();
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
+      prevRootTransitionCallbacks = root.transitionCallbacks,
+      prevEndTime = currentEndTime;
+    null !== prevPendingTransitionCallbacks &&
+      null !== prevRootTransitionCallbacks &&
+      null !== prevEndTime &&
+      ((currentEndTime = currentPendingTransitionCallbacks = null),
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
+        );
+      }));
+  }
+  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {}
+  root = root.current.stateNode;
+  root.effectDuration = 0;
+  root.passiveEffectDuration = 0;
+  return !0;
+}
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
+  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+  sourceFiber = requestEventTime();
+  null !== rootFiber &&
+    (markRootUpdated(rootFiber, 2, sourceFiber),
+    ensureRootIsScheduled(rootFiber, sourceFiber));
+}
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+  if (3 === sourceFiber.tag)
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+  else
+    for (
+      nearestMountedAncestor = skipUnmountedBoundaries
+        ? nearestMountedAncestor
+        : sourceFiber.return;
+      null !== nearestMountedAncestor;
+
+    ) {
+      if (3 === nearestMountedAncestor.tag) {
+        captureCommitPhaseErrorOnRoot(
+          nearestMountedAncestor,
+          sourceFiber,
+          error
+        );
+        break;
+      } else if (1 === nearestMountedAncestor.tag) {
+        var instance = nearestMountedAncestor.stateNode;
+        if (
+          "function" ===
+            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
+          ("function" === typeof instance.componentDidCatch &&
+            (null === legacyErrorBoundariesThatAlreadyFailed ||
+              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
+        ) {
+          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+          sourceFiber = createClassErrorUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
+          );
+          nearestMountedAncestor = enqueueUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
+          );
+          sourceFiber = requestEventTime();
+          null !== nearestMountedAncestor &&
+            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
+            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
+          break;
+        }
+      }
+      nearestMountedAncestor = nearestMountedAncestor.return;
+    }
+}
+function attachPingListener(root, wakeable, lanes) {
+  var pingCache = root.pingCache;
+  if (null === pingCache) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    var threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else
+    (threadIDs = pingCache.get(wakeable)),
+      void 0 === threadIDs &&
+        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
+  threadIDs.has(lanes) ||
+    ((workInProgressRootDidAttachPingListener = !0),
+    threadIDs.add(lanes),
+    (pingCache = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
+    isDevToolsPresent && restorePendingUpdaters(root, lanes),
+    wakeable.then(pingCache, pingCache));
+}
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
+  null !== pingCache && pingCache.delete(wakeable);
+  wakeable = requestEventTime();
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+  workInProgressRoot === root &&
+    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
+    (4 === workInProgressRootExitStatus ||
+    (3 === workInProgressRootExitStatus &&
+      (workInProgressRootRenderLanes & 125829120) ===
+        workInProgressRootRenderLanes &&
+      500 > now$1() - globalMostRecentFallbackTime)
+      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
+      : (workInProgressRootPingedLanes |= pingedLanes));
+  ensureRootIsScheduled(root, wakeable);
+}
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  0 === retryLane &&
+    (0 === (boundaryFiber.mode & 1)
+      ? (retryLane = 2)
+      : ((retryLane = nextRetryLane),
+        (nextRetryLane <<= 1),
+        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
+  var eventTime = requestEventTime();
+  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+  null !== boundaryFiber &&
+    (markRootUpdated(boundaryFiber, retryLane, eventTime),
+    ensureRootIsScheduled(boundaryFiber, eventTime));
+}
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState,
+    retryLane = 0;
+  null !== suspenseState && (retryLane = suspenseState.retryLane);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = 0;
+  switch (boundaryFiber.tag) {
+    case 13:
+      var retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
+      null !== suspenseState && (retryLane = suspenseState.retryLane);
+      break;
+    case 19:
+      retryCache = boundaryFiber.stateNode;
+      break;
+    case 22:
+      retryCache = boundaryFiber.stateNode._retryCache;
+      break;
+    default:
+      throw Error(formatProdErrorMessage(314));
+  }
+  null !== retryCache && retryCache.delete(wakeable);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+var beginWork;
+beginWork = function (current, workInProgress, renderLanes) {
+  if (null !== current)
+    if (current.memoizedProps !== workInProgress.pendingProps)
+      didReceiveUpdate = !0;
+    else {
+      if (
+        !checkScheduledUpdateOrContext(current, renderLanes) &&
+        0 === (workInProgress.flags & 128)
+      )
+        return (
+          (didReceiveUpdate = !1),
+          attemptEarlyBailoutIfNoScheduledUpdate(
+            current,
+            workInProgress,
+            renderLanes
+          )
+        );
+      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+    }
+  else
+    (didReceiveUpdate = !1),
+      isHydrating &&
+        0 !== (workInProgress.flags & 1048576) &&
+        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
+  workInProgress.lanes = 0;
+  switch (workInProgress.tag) {
+    case 2:
+      var Component = workInProgress.type;
+      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+      current = workInProgress.pendingProps;
+      prepareToReadContext(workInProgress, renderLanes);
+      enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
+      current = renderWithHooks(
+        null,
+        workInProgress,
+        Component,
+        current,
+        void 0,
+        renderLanes
+      );
+      Component = checkDidRenderIdHook();
+      enableSchedulingProfiler && markComponentRenderStopped();
+      workInProgress.flags |= 1;
+      workInProgress.tag = 0;
+      isHydrating && Component && pushMaterializedTreeId(workInProgress);
+      reconcileChildren(null, workInProgress, current, renderLanes);
+      workInProgress = workInProgress.child;
+      return workInProgress;
+    case 16:
+      Component = workInProgress.elementType;
+      a: {
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+        current = workInProgress.pendingProps;
+        var init = Component._init;
+        Component = init(Component._payload);
+        workInProgress.type = Component;
+        init = workInProgress.tag = resolveLazyComponentTag(Component);
+        current = resolveDefaultProps(Component, current);
+        switch (init) {
+          case 0:
+            workInProgress = updateFunctionComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 1:
+            workInProgress = updateClassComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 11:
+            workInProgress = updateForwardRef(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 14:
+            workInProgress = updateMemoComponent(
+              null,
+              workInProgress,
+              Component,
+              resolveDefaultProps(Component.type, current),
+              renderLanes
+            );
+            break a;
+        }
+        throw Error(formatProdErrorMessage(306, Component, ""));
+      }
+      return workInProgress;
+    case 0:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateFunctionComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 1:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateClassComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 3:
+      a: {
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        );
+        if (null === current) throw Error(formatProdErrorMessage(387));
+        Component = workInProgress.pendingProps;
+        var prevState = workInProgress.memoizedState;
+        init = prevState.element;
+        cloneUpdateQueue(current, workInProgress);
+        processUpdateQueue(workInProgress, Component, null, renderLanes);
+        var nextState = workInProgress.memoizedState,
+          root = workInProgress.stateNode;
+        enableTransitionTracing &&
+          push(transitionStack, workInProgressTransitions);
+        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+        Component = nextState.cache;
+        pushProvider(workInProgress, CacheContext, Component);
+        Component !== prevState.cache &&
+          propagateContextChange(workInProgress, CacheContext, renderLanes);
+        Component = nextState.element;
+        if (prevState.isDehydrated)
+          if (
+            ((prevState = {
+              element: Component,
+              isDehydrated: !1,
+              cache: nextState.cache
+            }),
+            (workInProgress.updateQueue.baseState = prevState),
+            (workInProgress.memoizedState = prevState),
+            workInProgress.flags & 256)
+          ) {
+            init = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(423)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              init
+            );
+            break a;
+          } else if (Component !== init) {
+            init = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(424)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              init
+            );
+            break a;
+          } else {
+            nextHydratableInstance = getNextHydratable(
+              workInProgress.stateNode.containerInfo.firstChild
+            );
+            hydrationParentFiber = workInProgress;
+            isHydrating = !0;
+            hydrationErrors = null;
+            rootOrSingletonContext = !0;
+            current = root.mutableSourceEagerHydrationData;
+            if (null != current)
+              for (init = 0; init < current.length; init += 2)
+                (prevState = current[init]),
+                  (prevState._workInProgressVersionPrimary = current[init + 1]),
+                  workInProgressSources.push(prevState);
+            renderLanes = mountChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            );
+            for (workInProgress.child = renderLanes; renderLanes; )
+              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
+                (renderLanes = renderLanes.sibling);
+          }
+        else {
+          resetHydrationState();
+          if (Component === init) {
+            workInProgress = bailoutOnAlreadyFinishedWork(
+              current,
+              workInProgress,
+              renderLanes
+            );
+            break a;
+          }
+          reconcileChildren(current, workInProgress, Component, renderLanes);
+        }
+        workInProgress = workInProgress.child;
+      }
+      return workInProgress;
+    case 26:
+      return (
+        markRef$1(current, workInProgress),
+        (renderLanes = workInProgress.memoizedState =
+          getResource(
+            workInProgress.type,
+            null === current ? null : current.memoizedProps,
+            workInProgress.pendingProps
+          )),
+        null !== current ||
+          isHydrating ||
+          null !== renderLanes ||
+          ((renderLanes = workInProgress.type),
+          (current = workInProgress.pendingProps),
+          (Component = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          )),
+          (Component = createHTMLElement(renderLanes, current, Component)),
+          (Component[internalInstanceKey] = workInProgress),
+          (Component[internalPropsKey] = current),
+          setInitialProperties(Component, renderLanes, current),
+          markNodeAsHoistable(Component),
+          (workInProgress.stateNode = Component)),
+        null
+      );
+    case 27:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          ((Component = workInProgress.stateNode =
+            resolveSingletonInstance(
+              workInProgress.type,
+              workInProgress.pendingProps,
+              rootInstanceStackCursor.current
+            )),
+          (hydrationParentFiber = workInProgress),
+          (rootOrSingletonContext = !0),
+          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
+        (Component = workInProgress.pendingProps.children),
+        null !== current || isHydrating
+          ? reconcileChildren(current, workInProgress, Component, renderLanes)
+          : (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            )),
+        markRef$1(current, workInProgress),
+        workInProgress.child
+      );
+    case 5:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          (((Component = workInProgress.pendingProps),
+          "script" === workInProgress.type
+            ? ((init = Component.onLoad),
+              (prevState = Component.onError),
+              (Component = !(Component.async && (init || prevState))))
+            : (Component = !0),
+          Component)
+            ? ((Component = nextHydratableInstance),
+              rootOrSingletonContext &&
+                advanceToFirstAttemptableInstance(workInProgress),
+              (init = nextHydratableInstance),
+              init)
+              ? tryHydrateInstance(workInProgress, init) ||
+                (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                (nextHydratableInstance = getNextHydratable(init.nextSibling)),
+                (prevState = hydrationParentFiber),
+                rootOrSingletonContext &&
+                  advanceToFirstAttemptableInstance(workInProgress),
+                nextHydratableInstance &&
+                tryHydrateInstance(workInProgress, nextHydratableInstance)
+                  ? deleteHydratableInstance(prevState, init)
+                  : (insertNonHydratedInstance(
+                      hydrationParentFiber,
+                      workInProgress
+                    ),
+                    (isHydrating = !1),
+                    (hydrationParentFiber = workInProgress),
+                    (nextHydratableInstance = Component)))
+              : (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = Component))
+            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress))),
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (prevState = null !== current ? current.memoizedProps : null),
+        (root = init.children),
+        shouldSetTextContent(Component, init)
+          ? (root = null)
+          : null !== prevState &&
+            shouldSetTextContent(Component, prevState) &&
+            (workInProgress.flags |= 32),
+        markRef$1(current, workInProgress),
+        reconcileChildren(current, workInProgress, root, renderLanes),
+        workInProgress.child
+      );
+    case 6:
+      return (
+        null === current &&
+          isHydrating &&
+          (((renderLanes = "" !== workInProgress.pendingProps),
+          (current = nextHydratableInstance),
+          rootOrSingletonContext &&
+            renderLanes &&
+            advanceToFirstAttemptableTextInstance(),
+          (Component = nextHydratableInstance),
+          Component && renderLanes)
+            ? tryHydrateText(workInProgress, Component) ||
+              (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              (nextHydratableInstance = getNextHydratable(
+                Component.nextSibling
+              )),
+              (init = hydrationParentFiber),
+              rootOrSingletonContext &&
+                renderLanes &&
+                advanceToFirstAttemptableTextInstance(),
+              nextHydratableInstance &&
+              tryHydrateText(workInProgress, nextHydratableInstance)
+                ? deleteHydratableInstance(init, Component)
+                : (insertNonHydratedInstance(
+                    hydrationParentFiber,
+                    workInProgress
+                  ),
+                  (isHydrating = !1),
+                  (hydrationParentFiber = workInProgress),
+                  (nextHydratableInstance = current)))
+            : (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress),
+              (nextHydratableInstance = current))),
+        null
+      );
+    case 13:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+    case 4:
+      return (
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        ),
+        (Component = workInProgress.pendingProps),
+        null === current
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            ))
+          : reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 11:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateForwardRef(current, workInProgress, Component, init, renderLanes)
+      );
+    case 7:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 8:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 12:
+      return (
+        (workInProgress.flags |= 4),
+        (Component = workInProgress.stateNode),
+        (Component.effectDuration = 0),
+        (Component.passiveEffectDuration = 0),
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 10:
+      a: {
+        Component = workInProgress.type._context;
+        init = workInProgress.pendingProps;
+        prevState = workInProgress.memoizedProps;
+        root = init.value;
+        pushProvider(workInProgress, Component, root);
+        if (!enableLazyContextPropagation && null !== prevState)
+          if (objectIs(prevState.value, root)) {
+            if (prevState.children === init.children) {
+              workInProgress = bailoutOnAlreadyFinishedWork(
+                current,
+                workInProgress,
+                renderLanes
+              );
+              break a;
+            }
+          } else propagateContextChange(workInProgress, Component, renderLanes);
+        reconcileChildren(current, workInProgress, init.children, renderLanes);
+        workInProgress = workInProgress.child;
+      }
+      return workInProgress;
+    case 9:
+      return (
+        (init = workInProgress.type),
+        (Component = workInProgress.pendingProps.children),
+        prepareToReadContext(workInProgress, renderLanes),
+        (init = readContext(init)),
+        enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
+        (Component = Component(init)),
+        enableSchedulingProfiler && markComponentRenderStopped(),
+        (workInProgress.flags |= 1),
+        reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 14:
+      return (
+        (Component = workInProgress.type),
+        (init = resolveDefaultProps(Component, workInProgress.pendingProps)),
+        (init = resolveDefaultProps(Component.type, init)),
+        updateMemoComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 15:
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        workInProgress.pendingProps,
+        renderLanes
+      );
+    case 17:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+        (workInProgress.tag = 1),
+        prepareToReadContext(workInProgress, renderLanes),
+        constructClassInstance(workInProgress, Component, init),
+        mountClassInstance(workInProgress, Component, init, renderLanes),
+        finishClassComponent(
+          null,
+          workInProgress,
+          Component,
+          !0,
+          !1,
+          renderLanes
+        )
+      );
+    case 19:
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    case 21:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 22:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 23:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 24:
+      return (
+        prepareToReadContext(workInProgress, renderLanes),
+        (Component = readContext(CacheContext)),
+        null === current
+          ? ((init = peekCacheFromPool()),
+            null === init &&
+              ((init = workInProgressRoot),
+              (prevState = createCache()),
+              (init.pooledCache = prevState),
+              prevState.refCount++,
+              null !== prevState && (init.pooledCacheLanes |= renderLanes),
+              (init = prevState)),
+            (workInProgress.memoizedState = { parent: Component, cache: init }),
+            initializeUpdateQueue(workInProgress),
+            pushProvider(workInProgress, CacheContext, init))
+          : (0 !== (current.lanes & renderLanes) &&
+              (cloneUpdateQueue(current, workInProgress),
+              processUpdateQueue(workInProgress, null, null, renderLanes)),
+            (init = current.memoizedState),
+            (prevState = workInProgress.memoizedState),
+            init.parent !== Component
+              ? ((init = { parent: Component, cache: Component }),
+                (workInProgress.memoizedState = init),
+                0 === workInProgress.lanes &&
+                  (workInProgress.memoizedState =
+                    workInProgress.updateQueue.baseState =
+                      init),
+                pushProvider(workInProgress, CacheContext, Component))
+              : ((Component = prevState.cache),
+                pushProvider(workInProgress, CacheContext, Component),
+                Component !== init.cache &&
+                  propagateContextChange(
+                    workInProgress,
+                    CacheContext,
+                    renderLanes
+                  ))),
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 25:
+      if (enableTransitionTracing)
+        return (
+          enableTransitionTracing
+            ? (null === current &&
+                ((Component = enableTransitionTracing
+                  ? transitionStack.current
+                  : null),
+                null !== Component &&
+                  ((Component = {
+                    tag: 1,
+                    transitions: new Set(Component),
+                    pendingBoundaries: null,
+                    name: workInProgress.pendingProps.name,
+                    aborts: null
+                  }),
+                  (workInProgress.stateNode = Component),
+                  (workInProgress.flags |= 2048))),
+              (Component = workInProgress.stateNode),
+              null !== Component &&
+                pushMarkerInstance(workInProgress, Component),
+              reconcileChildren(
+                current,
+                workInProgress,
+                workInProgress.pendingProps.children,
+                renderLanes
+              ),
+              (workInProgress = workInProgress.child))
+            : (workInProgress = null),
+          workInProgress
+        );
+  }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+};
+function restorePendingUpdaters(root, lanes) {
+  isDevToolsPresent &&
+    root.memoizedUpdaters.forEach(function (schedulingFiber) {
+      addFiberToLanesMap(root, schedulingFiber, lanes);
+    });
+}
+function scheduleCallback(priorityLevel, callback) {
+  return scheduleCallback$2(priorityLevel, callback);
+}
+function FiberNode(tag, pendingProps, key, mode) {
+  this.tag = tag;
+  this.key = key;
+  this.sibling =
+    this.child =
+    this.return =
+    this.stateNode =
+    this.type =
+    this.elementType =
+      null;
+  this.index = 0;
+  this.refCleanup = this.ref = null;
+  this.pendingProps = pendingProps;
+  this.dependencies =
+    this.memoizedState =
+    this.updateQueue =
+    this.memoizedProps =
+      null;
+  this.mode = mode;
+  this.subtreeFlags = this.flags = 0;
+  this.deletions = null;
+  this.childLanes = this.lanes = 0;
+  this.alternate = null;
+  this.actualDuration = 0;
+  this.actualStartTime = -1;
+  this.treeBaseDuration = this.selfBaseDuration = 0;
+}
+function createFiber(tag, pendingProps, key, mode) {
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+function shouldConstruct(Component) {
+  Component = Component.prototype;
+  return !(!Component || !Component.isReactComponent);
+}
+function resolveLazyComponentTag(Component) {
+  if ("function" === typeof Component)
+    return shouldConstruct(Component) ? 1 : 0;
+  if (void 0 !== Component && null !== Component) {
+    Component = Component.$$typeof;
+    if (Component === REACT_FORWARD_REF_TYPE) return 11;
+    if (Component === REACT_MEMO_TYPE) return 14;
+  }
+  return 2;
+}
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
+  null === workInProgress
+    ? ((workInProgress = createFiber(
+        current.tag,
+        pendingProps,
+        current.key,
+        current.mode
+      )),
+      (workInProgress.elementType = current.elementType),
+      (workInProgress.type = current.type),
+      (workInProgress.stateNode = current.stateNode),
+      (workInProgress.alternate = current),
+      (current.alternate = workInProgress))
+    : ((workInProgress.pendingProps = pendingProps),
+      (workInProgress.type = current.type),
+      (workInProgress.flags = 0),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null),
+      (workInProgress.actualDuration = 0),
+      (workInProgress.actualStartTime = -1));
+  workInProgress.flags = current.flags & 14680064;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue;
+  pendingProps = current.dependencies;
+  workInProgress.dependencies =
+    null === pendingProps
+      ? null
+      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+  workInProgress.selfBaseDuration = current.selfBaseDuration;
+  workInProgress.treeBaseDuration = current.treeBaseDuration;
+  return workInProgress;
+}
+function resetWorkInProgress(workInProgress, renderLanes) {
+  workInProgress.flags &= 14680066;
+  var current = workInProgress.alternate;
+  null === current
+    ? ((workInProgress.childLanes = 0),
+      (workInProgress.lanes = renderLanes),
+      (workInProgress.child = null),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.memoizedProps = null),
+      (workInProgress.memoizedState = null),
+      (workInProgress.updateQueue = null),
+      (workInProgress.dependencies = null),
+      (workInProgress.stateNode = null),
+      (workInProgress.selfBaseDuration = 0),
+      (workInProgress.treeBaseDuration = 0))
+    : ((workInProgress.childLanes = current.childLanes),
+      (workInProgress.lanes = current.lanes),
+      (workInProgress.child = current.child),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null),
+      (workInProgress.memoizedProps = current.memoizedProps),
+      (workInProgress.memoizedState = current.memoizedState),
+      (workInProgress.updateQueue = current.updateQueue),
+      (workInProgress.type = current.type),
+      (renderLanes = current.dependencies),
+      (workInProgress.dependencies =
+        null === renderLanes
+          ? null
+          : {
+              lanes: renderLanes.lanes,
+              firstContext: renderLanes.firstContext
+            }),
+      (workInProgress.selfBaseDuration = current.selfBaseDuration),
+      (workInProgress.treeBaseDuration = current.treeBaseDuration));
+  return workInProgress;
+}
+function createFiberFromTypeAndProps(
+  type,
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
+) {
+  var fiberTag = 2;
+  owner = type;
+  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
+  else if ("string" === typeof type)
+    fiberTag = isHostHoistableType(
+      type,
+      pendingProps,
+      contextStackCursor.current
+    )
+      ? 26
+      : "html" === type || "head" === type || "body" === type
+      ? 27
+      : 5;
+  else
+    a: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = 8;
+        mode |= 8;
+        0 !== (mode & 1) && (mode |= 16);
+        break;
+      case REACT_PROFILER_TYPE:
+        return (
+          (type = createFiber(12, pendingProps, key, mode | 2)),
+          (type.elementType = REACT_PROFILER_TYPE),
+          (type.lanes = lanes),
+          (type.stateNode = { effectDuration: 0, passiveEffectDuration: 0 }),
+          type
+        );
+      case REACT_SUSPENSE_TYPE:
+        return (
+          (type = createFiber(13, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_SUSPENSE_LIST_TYPE:
+        return (
+          (type = createFiber(19, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+      case REACT_LEGACY_HIDDEN_TYPE:
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      case REACT_SCOPE_TYPE:
+        return (
+          (pendingProps = createFiber(21, pendingProps, key, mode)),
+          (pendingProps.type = type),
+          (pendingProps.elementType = type),
+          (pendingProps.lanes = lanes),
+          pendingProps
+        );
+      case REACT_CACHE_TYPE:
+        return (
+          (type = createFiber(24, pendingProps, key, mode)),
+          (type.elementType = REACT_CACHE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing)
+          return (
+            (type = createFiber(25, pendingProps, key, mode)),
+            (type.elementType = REACT_TRACING_MARKER_TYPE),
+            (type.lanes = lanes),
+            (type.stateNode = {
+              tag: 1,
+              transitions: null,
+              pendingBoundaries: null,
+              aborts: null,
+              name: pendingProps.name
+            }),
+            type
+          );
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = 8;
+          mode |= 4;
+          break;
+        }
+      default:
+        if ("object" === typeof type && null !== type)
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = 10;
+              break a;
+            case REACT_CONTEXT_TYPE:
+              fiberTag = 9;
+              break a;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = 11;
+              break a;
+            case REACT_MEMO_TYPE:
+              fiberTag = 14;
+              break a;
+            case REACT_LAZY_TYPE:
+              fiberTag = 16;
+              owner = null;
+              break a;
+          }
+        throw Error(
+          formatProdErrorMessage(130, null == type ? type : typeof type, "")
+        );
+    }
+  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
+  pendingProps.elementType = type;
+  pendingProps.type = owner;
+  pendingProps.lanes = lanes;
+  return pendingProps;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  elements = createFiber(7, elements, key, mode);
+  elements.lanes = lanes;
+  return elements;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(22, pendingProps, key, mode);
+  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
+  pendingProps.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
+    }
+  };
+  pendingProps.stateNode = primaryChildInstance;
+  return pendingProps;
+}
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(23, pendingProps, key, mode);
+  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  pendingProps.lanes = lanes;
+  var instance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
+    }
+  };
+  pendingProps.stateNode = instance;
+  return pendingProps;
+}
+function createFiberFromText(content, mode, lanes) {
+  content = createFiber(6, content, null, mode);
+  content.lanes = lanes;
+  return content;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  mode = createFiber(
+    4,
+    null !== portal.children ? portal.children : [],
+    portal.key,
+    mode
+  );
+  mode.lanes = lanes;
+  mode.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    implementation: portal.implementation
+  };
+  return mode;
+}
+function FiberRootNode(
+  containerInfo,
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
+) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.finishedWork =
+    this.pingCache =
+    this.current =
+    this.pendingChildren =
+      null;
+  this.timeoutHandle = -1;
+  this.callbackNode = this.pendingContext = this.context = null;
+  this.callbackPriority = 0;
+  this.eventTimes = createLaneMap(0);
+  this.expirationTimes = createLaneMap(-1);
+  this.entangledLanes =
+    this.errorRecoveryDisabledLanes =
+    this.finishedLanes =
+    this.mutableReadLanes =
+    this.expiredLanes =
+    this.pingedLanes =
+    this.suspendedLanes =
+    this.pendingLanes =
+      0;
+  this.entanglements = createLaneMap(0);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+  this.pooledCache = null;
+  this.pooledCacheLanes = 0;
+  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
+  this.incompleteTransitions = new Map();
+  if (enableTransitionTracing)
+    for (
+      this.transitionCallbacks = null,
+        containerInfo = this.transitionLanes = [],
+        tag = 0;
+      31 > tag;
+      tag++
+    )
+      containerInfo.push(null);
+  this.passiveEffectDuration = this.effectDuration = 0;
+  this.memoizedUpdaters = new Set();
+  containerInfo = this.pendingUpdatersLaneMap = [];
+  for (tag = 0; 31 > tag; tag++) containerInfo.push(new Set());
+}
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  containerInfo = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
+  );
+  containerInfo.hydrationCallbacks = hydrationCallbacks;
+  enableTransitionTracing &&
+    (containerInfo.transitionCallbacks = transitionCallbacks);
+  1 === tag
+    ? ((tag = 1),
+      !0 === isStrictMode && (tag |= 24),
+      concurrentUpdatesByDefaultOverride && (tag |= 32))
+    : (tag = 0);
+  isDevToolsPresent && (tag |= 2);
+  isStrictMode = createFiber(3, null, null, tag);
+  containerInfo.current = isStrictMode;
+  isStrictMode.stateNode = containerInfo;
+  concurrentUpdatesByDefaultOverride = createCache();
+  concurrentUpdatesByDefaultOverride.refCount++;
+  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
+  concurrentUpdatesByDefaultOverride.refCount++;
+  isStrictMode.memoizedState = {
+    element: initialChildren,
+    isDehydrated: hydrate,
+    cache: concurrentUpdatesByDefaultOverride
+  };
+  initializeUpdateQueue(isStrictMode);
+  return containerInfo;
+}
+function createPortal$1(children, containerInfo, implementation) {
+  var key =
+    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+  return {
+    $$typeof: REACT_PORTAL_TYPE,
+    key: null == key ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
+}
+function updateContainer(element, container, parentComponent, callback) {
+  parentComponent = container.current;
+  var lane = requestUpdateLane(parentComponent);
+  enableSchedulingProfiler &&
+    enableSchedulingProfiler &&
+    null !== injectedProfilingHooks &&
+    "function" === typeof injectedProfilingHooks.markRenderScheduled &&
+    injectedProfilingHooks.markRenderScheduled(lane);
+  null === container.context
+    ? (container.context = emptyContextObject)
+    : (container.pendingContext = emptyContextObject);
+  container = createUpdate(lane);
+  container.payload = { element: element };
+  callback = void 0 === callback ? null : callback;
+  null !== callback && (container.callback = callback);
+  element = enqueueUpdate(parentComponent, container, lane);
+  null !== element &&
+    ((callback = requestEventTime()),
+    scheduleUpdateOnFiber(element, parentComponent, lane, callback),
+    entangleTransitions(element, parentComponent, lane));
+  return lane;
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case 3:
+      var root$200 = fiber.stateNode;
+      if (root$200.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$200.pendingLanes);
+        0 !== lanes &&
+          (markRootEntangled(root$200, lanes | 2),
+          ensureRootIsScheduled(root$200, now$1()),
+          0 === (executionContext & 6) &&
+            (resetRenderTimer(), flushSyncCallbacks()));
+      }
+      break;
+    case 13:
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, 2);
+        if (null !== root) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
+        }
+      }),
+        markRetryLaneIfNotHydrated(fiber, 2);
+  }
+}
+function markRetryLaneImpl(fiber, retryLane) {
+  fiber = fiber.memoizedState;
+  if (null !== fiber && null !== fiber.dehydrated) {
+    var a = fiber.retryLane;
+    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+  }
+}
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
+}
+function attemptContinuousHydration(fiber) {
+  if (13 === fiber.tag) {
+    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
+    if (null !== root) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
+    }
+    markRetryLaneIfNotHydrated(fiber, 134217728);
+  }
+}
+function emptyFindFiberByHostInstance() {
+  return null;
+}
+var isInsideEventHandler = !1;
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) return fn(a, b);
+  isInsideEventHandler = !0;
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    if (
+      ((isInsideEventHandler = !1),
+      null !== restoreTarget || null !== restoreQueue)
+    )
+      flushSync$1(), restoreStateIfNeeded();
+  }
+}
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
+  if (null === stateNode) return null;
+  var props = getFiberCurrentPropsFromNode(stateNode);
+  if (null === props) return null;
+  stateNode = props[registrationName];
+  a: switch (registrationName) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      (props = !props.disabled) ||
+        ((inst = inst.type),
+        (props = !(
+          "button" === inst ||
+          "input" === inst ||
+          "select" === inst ||
+          "textarea" === inst
+        )));
+      inst = !props;
+      break a;
+    default:
+      inst = !1;
+  }
+  if (inst) return null;
+  if (stateNode && "function" !== typeof stateNode)
+    throw Error(
+      formatProdErrorMessage(231, registrationName, typeof stateNode)
+    );
+  return stateNode;
+}
+var passiveBrowserEventsSupported = !1;
+if (canUseDOM)
+  try {
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = !0;
+      }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = !1;
+  }
+var hasScheduledReplayAttempt = !1,
+  queuedDiscreteEvents = [],
+  queuedFocus = null,
+  queuedDrag = null,
+  queuedMouse = null,
+  queuedPointers = new Map(),
+  queuedPointerCaptures = new Map(),
+  queuedExplicitHydrationTargets = [],
+  discreteReplayableEvents =
+    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
+      " "
+    );
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return {
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
+  };
+}
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
+    ((blockedOn = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )),
+    queuedDiscreteEvents.push(blockedOn),
+    1 === queuedDiscreteEvents.length)
+  )
+    for (; null !== blockedOn.blockedOn; ) {
+      domEventName = getInstanceFromNode$1(blockedOn.blockedOn);
+      if (null === domEventName) break;
+      attemptSynchronousHydration(domEventName);
+      if (null === blockedOn.blockedOn) replayUnblockedEvents();
+      else break;
+    }
+}
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
+    case "pointerover":
+    case "pointerout":
+      queuedPointers.delete(nativeEvent.pointerId);
+      break;
+    case "gotpointercapture":
+    case "lostpointercapture":
+      queuedPointerCaptures.delete(nativeEvent.pointerId);
+  }
+}
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    null === existingQueuedEvent ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
+  )
+    return (
+      (existingQueuedEvent = createQueuedReplayableEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )),
+      null !== blockedOn &&
+        ((blockedOn = getInstanceFromNode$1(blockedOn)),
+        null !== blockedOn && attemptContinuousHydration(blockedOn)),
+      existingQueuedEvent
+    );
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  blockedOn = existingQueuedEvent.targetContainers;
+  null !== targetContainer &&
+    -1 === blockedOn.indexOf(targetContainer) &&
+    blockedOn.push(targetContainer);
+  return existingQueuedEvent;
+}
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  switch (domEventName) {
+    case "focusin":
+      return (
+        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedFocus,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "dragenter":
+      return (
+        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedDrag,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "mouseover":
+      return (
+        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedMouse,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "pointerover":
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
+      );
+      return !0;
+    case "gotpointercapture":
+      return (
+        (pointerId = nativeEvent.pointerId),
+        queuedPointerCaptures.set(
+          pointerId,
+          accumulateOrCreateContinuousQueuedReplayableEvent(
+            queuedPointerCaptures.get(pointerId) || null,
+            blockedOn,
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          )
+        ),
+        !0
+      );
+  }
+  return !1;
+}
+function attemptExplicitHydrationTarget(queuedTarget) {
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
+  if (null !== targetInst) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
+    if (null !== nearestMounted)
+      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
+        if (
+          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
+          null !== targetInst)
+        ) {
+          queuedTarget.blockedOn = targetInst;
+          runWithPriority(queuedTarget.priority, function () {
+            if (13 === nearestMounted.tag) {
+              var lane = requestUpdateLane(nearestMounted),
+                root = enqueueConcurrentRenderForLane(nearestMounted, lane);
+              if (null !== root) {
+                var eventTime = requestEventTime();
+                scheduleUpdateOnFiber(root, nearestMounted, lane, eventTime);
+              }
+              markRetryLaneIfNotHydrated(nearestMounted, lane);
+            }
+          });
+          return;
+        }
+      } else if (
+        3 === targetInst &&
+        nearestMounted.stateNode.current.memoizedState.isDehydrated
+      ) {
+        queuedTarget.blockedOn =
+          3 === nearestMounted.tag
+            ? nearestMounted.stateNode.containerInfo
+            : null;
+        return;
+      }
+  }
+  queuedTarget.blockedOn = null;
+}
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (null !== queuedEvent.blockedOn) return !1;
+  for (
+    var targetContainers = queuedEvent.targetContainers;
+    0 < targetContainers.length;
+
+  ) {
+    var targetContainer = targetContainers[0],
+      nextBlockedOn = findInstanceBlockingEvent(
+        queuedEvent.domEventName,
+        queuedEvent.eventSystemFlags,
+        targetContainer,
+        queuedEvent.nativeEvent
+      );
+    if (null === nextBlockedOn)
+      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
+        ? ((nextBlockedOn = queuedEvent.nativeEvent),
+          (currentReplayingEvent = targetContainer =
+            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
+          nextBlockedOn.target.dispatchEvent(targetContainer))
+        : ((currentReplayingEvent = queuedEvent.nativeEvent),
+          dispatchEventForPluginEventSystem(
+            queuedEvent.domEventName,
+            queuedEvent.eventSystemFlags,
+            queuedEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          )),
+        (currentReplayingEvent = null);
+    else
+      return (
+        (targetContainers = getInstanceFromNode$1(nextBlockedOn)),
+        null !== targetContainers &&
+          attemptContinuousHydration(targetContainers),
+        (queuedEvent.blockedOn = nextBlockedOn),
+        !1
+      );
+    targetContainers.shift();
+  }
+  return !0;
+}
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+}
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = !1;
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
+    for (; 0 < queuedDiscreteEvents.length; ) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
+      if (null !== nextDiscreteEvent.blockedOn) {
+        nextDiscreteEvent = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
+        if (null !== nextDiscreteEvent && 13 === nextDiscreteEvent.tag) {
+          var root = enqueueConcurrentRenderForLane(nextDiscreteEvent, 2);
+          if (null !== root) {
+            var eventTime = requestEventTime();
+            scheduleUpdateOnFiber(root, nextDiscreteEvent, 2, eventTime);
+          }
+          markRetryLaneIfNotHydrated(nextDiscreteEvent, 2);
+        }
+        break;
+      }
+      for (root = nextDiscreteEvent.targetContainers; 0 < root.length; ) {
+        eventTime = root[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          eventTime,
+          nextDiscreteEvent.nativeEvent
+        );
+        if (null === nextBlockedOn)
+          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
+            dispatchEventForPluginEventSystem(
+              nextDiscreteEvent.domEventName,
+              nextDiscreteEvent.eventSystemFlags,
+              nextDiscreteEvent.nativeEvent,
+              return_targetInst,
+              eventTime
+            ),
+            (currentReplayingEvent = null);
+        else {
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
+          break;
+        }
+        root.shift();
+      }
+      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
+    }
+  null !== queuedFocus &&
+    attemptReplayContinuousQueuedEvent(queuedFocus) &&
+    (queuedFocus = null);
+  null !== queuedDrag &&
+    attemptReplayContinuousQueuedEvent(queuedDrag) &&
+    (queuedDrag = null);
+  null !== queuedMouse &&
+    attemptReplayContinuousQueuedEvent(queuedMouse) &&
+    (queuedMouse = null);
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  queuedEvent.blockedOn === unblocked &&
+    ((queuedEvent.blockedOn = null),
+    hasScheduledReplayAttempt ||
+      ((hasScheduledReplayAttempt = !0),
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      )));
+}
+function retryIfBlockedOn(unblocked) {
+  function unblock(queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  }
+  if (0 < queuedDiscreteEvents.length) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
+    }
+  }
+  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
+    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
+  for (
+    ;
+    0 < queuedExplicitHydrationTargets.length &&
+    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
+
+  )
+    attemptExplicitHydrationTarget(i),
+      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
+}
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
+  _enabled = !0;
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
+) {
+  switch (getEventPriority(domEventName)) {
+    case 2:
+      var listenerWrapper = dispatchDiscreteEvent;
+      break;
+    case 8:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+    default:
+      listenerWrapper = dispatchEvent;
+  }
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
+  );
+}
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 2),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
+  }
+}
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 8),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
+  }
+}
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (_enabled)
+    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+      var blockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
+      if (null === blockedOn)
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          clearIfContinuousEvent(domEventName, nativeEvent);
+      else if (
+        queueIfContinuousEvent(
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
+      )
+        nativeEvent.stopPropagation();
+      else if (
+        (clearIfContinuousEvent(domEventName, nativeEvent),
+        eventSystemFlags & 4 &&
+          -1 < discreteReplayableEvents.indexOf(domEventName))
+      ) {
+        for (; null !== blockedOn; ) {
+          var fiber = getInstanceFromNode$1(blockedOn);
+          null !== fiber && attemptSynchronousHydration(fiber);
+          fiber = findInstanceBlockingEvent(
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          );
+          null === fiber &&
+            dispatchEventForPluginEventSystem(
+              domEventName,
+              eventSystemFlags,
+              nativeEvent,
+              return_targetInst,
+              targetContainer
+            );
+          if (fiber === blockedOn) break;
+          blockedOn = fiber;
+        }
+        null !== blockedOn && nativeEvent.stopPropagation();
+      } else
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+    } else
+      a: if (
+        (blockedOn = 0 === (eventSystemFlags & 4)) &&
+        0 < queuedDiscreteEvents.length &&
+        -1 < discreteReplayableEvents.indexOf(domEventName)
+      )
+        queueDiscreteEvent(
+          null,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        );
+      else if (
+        ((fiber = findInstanceBlockingEvent(
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        null === fiber)
+      )
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
+      else {
+        if (blockedOn) {
+          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
+            queueDiscreteEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            );
+            break a;
+          }
+          if (
+            queueIfContinuousEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            )
+          )
+            break a;
+          clearIfContinuousEvent(domEventName, nativeEvent);
+        }
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+      }
+}
+var return_targetInst = null;
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return_targetInst = null;
+  domEventName = getEventTarget(nativeEvent);
+  domEventName = getClosestInstanceFromNode(domEventName);
+  if (null !== domEventName)
+    if (
+      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
+      null === eventSystemFlags)
+    )
+      domEventName = null;
+    else if (
+      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
+    ) {
+      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
+      if (null !== domEventName) return domEventName;
+      domEventName = null;
+    } else if (3 === targetContainer) {
+      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
+        return 3 === eventSystemFlags.tag
+          ? eventSystemFlags.stateNode.containerInfo
+          : null;
+      domEventName = null;
+    } else eventSystemFlags !== domEventName && (domEventName = null);
+  return_targetInst = domEventName;
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange":
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate":
+    case "beforeblur":
+    case "afterblur":
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return 2;
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel":
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return 8;
+    case "message":
+      switch (getCurrentPriorityLevel()) {
+        case ImmediatePriority:
+          return 2;
+        case UserBlockingPriority:
+          return 8;
+        case NormalPriority$1:
+        case LowPriority:
+          return 32;
+        case IdlePriority:
+          return 536870912;
+        default:
+          return 32;
+      }
+    default:
+      return 32;
+  }
+}
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, !1);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, !0);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, {
+    capture: !0,
+    passive: passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, { passive: passive });
+  return listener;
+}
+var root = null,
+  startText = null,
+  fallbackText = null;
+function getData() {
+  if (fallbackText) return fallbackText;
+  var start,
+    startValue = startText,
+    startLength = startValue.length,
+    end,
+    endValue = "value" in root ? root.value : root.textContent,
+    endLength = endValue.length;
+  for (
+    start = 0;
+    start < startLength && startValue[start] === endValue[start];
+    start++
+  );
+  var minEnd = startLength - start;
+  for (
+    end = 1;
+    end <= minEnd &&
+    startValue[startLength - end] === endValue[endLength - end];
+    end++
+  );
+  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
+}
+function getEventCharCode(nativeEvent) {
+  var keyCode = nativeEvent.keyCode;
+  "charCode" in nativeEvent
+    ? ((nativeEvent = nativeEvent.charCode),
+      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
+    : (nativeEvent = keyCode);
+  10 === nativeEvent && (nativeEvent = 13);
+  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
+}
+function functionThatReturnsTrue() {
+  return !0;
+}
+function functionThatReturnsFalse() {
+  return !1;
+}
+function createSyntheticEvent(Interface) {
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  ) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+    for (var propName in Interface)
+      Interface.hasOwnProperty(propName) &&
+        ((reactName = Interface[propName]),
+        (this[propName] = reactName
+          ? reactName(nativeEvent)
+          : nativeEvent[propName]));
+    this.isDefaultPrevented = (
+      null != nativeEvent.defaultPrevented
+        ? nativeEvent.defaultPrevented
+        : !1 === nativeEvent.returnValue
+    )
+      ? functionThatReturnsTrue
+      : functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  }
+  assign(SyntheticBaseEvent.prototype, {
+    preventDefault: function () {
+      this.defaultPrevented = !0;
+      var event = this.nativeEvent;
+      event &&
+        (event.preventDefault
+          ? event.preventDefault()
+          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
+        (this.isDefaultPrevented = functionThatReturnsTrue));
+    },
+    stopPropagation: function () {
+      var event = this.nativeEvent;
+      event &&
+        (event.stopPropagation
+          ? event.stopPropagation()
+          : "unknown" !== typeof event.cancelBubble &&
+            (event.cancelBubble = !0),
+        (this.isPropagationStopped = functionThatReturnsTrue));
+    },
+    persist: function () {},
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+var EventInterface = {
+    eventPhase: 0,
+    bubbles: 0,
+    cancelable: 0,
+    timeStamp: function (event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: 0,
+    isTrusted: 0
+  },
+  SyntheticEvent = createSyntheticEvent(EventInterface),
+  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
+  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
+  lastMovementX,
+  lastMovementY,
+  lastMouseEvent,
+  MouseEventInterface = assign({}, UIEventInterface, {
+    screenX: 0,
+    screenY: 0,
+    clientX: 0,
+    clientY: 0,
+    pageX: 0,
+    pageY: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    getModifierState: getEventModifierState,
+    button: 0,
+    buttons: 0,
+    relatedTarget: function (event) {
+      return void 0 === event.relatedTarget
+        ? event.fromElement === event.srcElement
+          ? event.toElement
+          : event.fromElement
+        : event.relatedTarget;
+    },
+    movementX: function (event) {
+      if ("movementX" in event) return event.movementX;
+      event !== lastMouseEvent &&
+        (lastMouseEvent && "mousemove" === event.type
+          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
+            (lastMovementY = event.screenY - lastMouseEvent.screenY))
+          : (lastMovementY = lastMovementX = 0),
+        (lastMouseEvent = event));
+      return lastMovementX;
+    },
+    movementY: function (event) {
+      return "movementY" in event ? event.movementY : lastMovementY;
+    }
+  }),
+  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
+  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
+  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
+  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
+  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
+  AnimationEventInterface = assign({}, EventInterface, {
+    animationName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
+  ClipboardEventInterface = assign({}, EventInterface, {
+    clipboardData: function (event) {
+      return "clipboardData" in event
+        ? event.clipboardData
+        : window.clipboardData;
+    }
+  }),
+  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
+  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
+  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
+  normalizeKey = {
+    Esc: "Escape",
+    Spacebar: " ",
+    Left: "ArrowLeft",
+    Up: "ArrowUp",
+    Right: "ArrowRight",
+    Down: "ArrowDown",
+    Del: "Delete",
+    Win: "OS",
+    Menu: "ContextMenu",
+    Apps: "ContextMenu",
+    Scroll: "ScrollLock",
+    MozPrintableKey: "Unidentified"
+  },
+  translateToKey = {
+    8: "Backspace",
+    9: "Tab",
+    12: "Clear",
+    13: "Enter",
+    16: "Shift",
+    17: "Control",
+    18: "Alt",
+    19: "Pause",
+    20: "CapsLock",
+    27: "Escape",
+    32: " ",
+    33: "PageUp",
+    34: "PageDown",
+    35: "End",
+    36: "Home",
+    37: "ArrowLeft",
+    38: "ArrowUp",
+    39: "ArrowRight",
+    40: "ArrowDown",
+    45: "Insert",
+    46: "Delete",
+    112: "F1",
+    113: "F2",
+    114: "F3",
+    115: "F4",
+    116: "F5",
+    117: "F6",
+    118: "F7",
+    119: "F8",
+    120: "F9",
+    121: "F10",
+    122: "F11",
+    123: "F12",
+    144: "NumLock",
+    145: "ScrollLock",
+    224: "Meta"
+  },
+  modifierKeyToProp = {
+    Alt: "altKey",
+    Control: "ctrlKey",
+    Meta: "metaKey",
+    Shift: "shiftKey"
+  };
+function modifierStateGetter(keyArg) {
+  var nativeEvent = this.nativeEvent;
+  return nativeEvent.getModifierState
+    ? nativeEvent.getModifierState(keyArg)
+    : (keyArg = modifierKeyToProp[keyArg])
+    ? !!nativeEvent[keyArg]
+    : !1;
+}
+function getEventModifierState() {
+  return modifierStateGetter;
+}
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+    key: function (nativeEvent) {
+      if (nativeEvent.key) {
+        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+        if ("Unidentified" !== key) return key;
+      }
+      return "keypress" === nativeEvent.type
+        ? ((nativeEvent = getEventCharCode(nativeEvent)),
+          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
+        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
+        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
+        : "";
+    },
+    code: 0,
+    location: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    repeat: 0,
+    locale: 0,
+    getModifierState: getEventModifierState,
+    charCode: function (event) {
+      return "keypress" === event.type ? getEventCharCode(event) : 0;
+    },
+    keyCode: function (event) {
+      return "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
+    },
+    which: function (event) {
+      return "keypress" === event.type
+        ? getEventCharCode(event)
+        : "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
     }
-    completeUnitOfWork(unitOfWork);
+  }),
+  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
+  PointerEventInterface = assign({}, MouseEventInterface, {
+    pointerId: 0,
+    width: 0,
+    height: 0,
+    pressure: 0,
+    tangentialPressure: 0,
+    tiltX: 0,
+    tiltY: 0,
+    twist: 0,
+    pointerType: 0,
+    isPrimary: 0
+  }),
+  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
+  TouchEventInterface = assign({}, UIEventInterface, {
+    touches: 0,
+    targetTouches: 0,
+    changedTouches: 0,
+    altKey: 0,
+    metaKey: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    getModifierState: getEventModifierState
+  }),
+  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
+  TransitionEventInterface = assign({}, EventInterface, {
+    propertyName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
+  WheelEventInterface = assign({}, MouseEventInterface, {
+    deltaX: function (event) {
+      return "deltaX" in event
+        ? event.deltaX
+        : "wheelDeltaX" in event
+        ? -event.wheelDeltaX
+        : 0;
+    },
+    deltaY: function (event) {
+      return "deltaY" in event
+        ? event.deltaY
+        : "wheelDeltaY" in event
+        ? -event.wheelDeltaY
+        : "wheelDelta" in event
+        ? -event.wheelDelta
+        : 0;
+    },
+    deltaZ: 0,
+    deltaMode: 0
+  }),
+  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
+  END_KEYCODES = [9, 13, 27, 32],
+  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
+  documentMode = null;
+canUseDOM &&
+  "documentMode" in document &&
+  (documentMode = document.documentMode);
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
+  useFallbackCompositionData =
+    canUseDOM &&
+    (!canUseCompositionEvent ||
+      (documentMode && 8 < documentMode && 11 >= documentMode)),
+  SPACEBAR_CHAR = String.fromCharCode(32),
+  hasSpaceKeypress = !1;
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
+    case "keydown":
+      return 229 !== nativeEvent.keyCode;
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      return !0;
+    default:
+      return !1;
   }
 }
-function completeUnitOfWork(unitOfWork) {
-  var completedWork = unitOfWork;
-  do {
-    var current = completedWork.alternate;
-    unitOfWork = completedWork.return;
-    if (0 === (completedWork.flags & 32768)) {
+function getDataFromCustomEvent(nativeEvent) {
+  nativeEvent = nativeEvent.detail;
+  return "object" === typeof nativeEvent && "data" in nativeEvent
+    ? nativeEvent.data
+    : null;
+}
+var isComposing = !1;
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
+    case "keypress":
+      if (32 !== nativeEvent.which) return null;
+      hasSpaceKeypress = !0;
+      return SPACEBAR_CHAR;
+    case "textInput":
+      return (
+        (domEventName = nativeEvent.data),
+        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
+      );
+    default:
+      return null;
+  }
+}
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  if (isComposing)
+    return "compositionend" === domEventName ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+      ? ((domEventName = getData()),
+        (fallbackText = startText = root = null),
+        (isComposing = !1),
+        domEventName)
+      : null;
+  switch (domEventName) {
+    case "paste":
+      return null;
+    case "keypress":
       if (
-        (0 === (completedWork.mode & 2)
-          ? (current = completeWork(current, completedWork, renderLanes))
-          : (startProfilerTimer(completedWork),
-            (current = completeWork(current, completedWork, renderLanes)),
-            stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1)),
-        null !== current)
+        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
+        (nativeEvent.ctrlKey && nativeEvent.altKey)
       ) {
-        workInProgress = current;
-        return;
-      }
-    } else {
-      current = unwindWork(current, completedWork);
-      if (null !== current) {
-        current.flags &= 16383;
-        workInProgress = current;
-        return;
-      }
-      if (0 !== (completedWork.mode & 2)) {
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, !1);
-        current = completedWork.actualDuration;
-        for (var child = completedWork.child; null !== child; )
-          (current += child.actualDuration), (child = child.sibling);
-        completedWork.actualDuration = current;
-      }
-      if (null !== unitOfWork)
-        (unitOfWork.flags |= 32768),
-          (unitOfWork.subtreeFlags = 0),
-          (unitOfWork.deletions = null);
-      else {
-        workInProgressRootExitStatus = 6;
-        workInProgress = null;
-        return;
+        if (nativeEvent.char && 1 < nativeEvent.char.length)
+          return nativeEvent.char;
+        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
       }
-    }
-    completedWork = completedWork.sibling;
-    if (null !== completedWork) {
-      workInProgress = completedWork;
-      return;
-    }
-    workInProgress = completedWork = unitOfWork;
-  } while (null !== completedWork);
-  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
-}
-function commitRoot(root, recoverableErrors, transitions) {
-  var previousUpdateLanePriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig.transition;
-  try {
-    (ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      commitRootImpl(
-        root,
-        recoverableErrors,
-        transitions,
-        previousUpdateLanePriority
-      );
-  } finally {
-    (ReactCurrentBatchConfig.transition = prevTransition),
-      (currentUpdatePriority = previousUpdateLanePriority);
+      return null;
+    case "compositionend":
+      return useFallbackCompositionData && "ko" !== nativeEvent.locale
+        ? null
+        : nativeEvent.data;
+    default:
+      return null;
   }
-  return null;
 }
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
+var supportedInputTypes = {
+  color: !0,
+  date: !0,
+  datetime: !0,
+  "datetime-local": !0,
+  email: !0,
+  month: !0,
+  number: !0,
+  password: !0,
+  range: !0,
+  search: !0,
+  tel: !0,
+  text: !0,
+  time: !0,
+  url: !0,
+  week: !0
+};
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return "input" === nodeName
+    ? !!supportedInputTypes[elem.type]
+    : "textarea" === nodeName
+    ? !0
+    : !1;
+}
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
 ) {
-  do flushPassiveEffects();
-  while (null !== rootWithPendingPassiveEffects);
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var finishedWork = root.finishedWork,
-    lanes = root.finishedLanes;
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markCommitStarted &&
-    injectedProfilingHooks.markCommitStarted(lanes);
-  if (null === finishedWork)
-    return enableSchedulingProfiler && markCommitStopped(), null;
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
-  root.callbackNode = null;
-  root.callbackPriority = 0;
-  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
-  remainingLanes |= concurrentlyUpdatedLanes;
-  markRootFinished(root, remainingLanes);
-  root === workInProgressRoot &&
-    ((workInProgress = workInProgressRoot = null),
-    (workInProgressRootRenderLanes = 0));
-  (0 === (finishedWork.subtreeFlags & 10256) &&
-    0 === (finishedWork.flags & 10256)) ||
-    rootDoesHavePassiveEffects ||
-    ((rootDoesHavePassiveEffects = !0),
-    (pendingPassiveEffectsRemainingLanes = remainingLanes),
-    (pendingPassiveTransitions = transitions),
-    scheduleCallback(NormalPriority$1, function () {
-      flushPassiveEffects();
-      return null;
-    }));
-  transitions = 0 !== (finishedWork.flags & 15990);
-  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
-    transitions = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    var prevExecutionContext = executionContext;
-    executionContext |= 4;
-    ReactCurrentOwner.current = null;
-    var shouldFireAfterActiveInstanceBlur$240 = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
-    commitTime = now();
-    enableProfilerNestedUpdateScheduledHook &&
-      (rootCommittingMutationOrLayoutEffects = root);
-    commitMutationEffects(root, finishedWork, lanes);
-    shouldFireAfterActiveInstanceBlur$240 &&
-      ((_enabled = !0),
-      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
-      (_enabled = !1));
-    restoreSelection(selectionInformation);
-    _enabled = !!eventsEnabled;
-    selectionInformation = eventsEnabled = null;
-    root.current = finishedWork;
-    enableSchedulingProfiler &&
-      enableSchedulingProfiler &&
-      null !== injectedProfilingHooks &&
-      "function" === typeof injectedProfilingHooks.markLayoutEffectsStarted &&
-      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
-    commitLayoutEffects(finishedWork, root, lanes);
-    enableSchedulingProfiler &&
-      enableSchedulingProfiler &&
-      null !== injectedProfilingHooks &&
-      "function" === typeof injectedProfilingHooks.markLayoutEffectsStopped &&
-      injectedProfilingHooks.markLayoutEffectsStopped();
-    enableProfilerNestedUpdateScheduledHook &&
-      (rootCommittingMutationOrLayoutEffects = null);
-    requestPaint();
-    executionContext = prevExecutionContext;
-    currentUpdatePriority = previousPriority;
-    ReactCurrentBatchConfig.transition = transitions;
-  } else (root.current = finishedWork), (commitTime = now());
-  rootDoesHavePassiveEffects
-    ? ((rootDoesHavePassiveEffects = !1),
-      (rootWithPendingPassiveEffects = root),
-      (pendingPassiveEffectsLanes = lanes))
-    : releaseRootPooledCache(root, remainingLanes);
-  remainingLanes = root.pendingLanes;
-  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
-  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
-  isDevToolsPresent && root.memoizedUpdaters.clear();
-  ensureRootIsScheduled(root, now$1());
-  if (null !== recoverableErrors)
-    for (
-      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
-      finishedWork < recoverableErrors.length;
-      finishedWork++
-    )
-      (lanes = recoverableErrors[finishedWork]),
-        (remainingLanes = {
-          digest: lanes.digest,
-          componentStack: lanes.stack
-        }),
-        renderPriorityLevel(lanes.value, remainingLanes);
-  if (hasUncaughtError)
-    throw (
-      ((hasUncaughtError = !1),
-      (root = firstUncaughtError),
-      (firstUncaughtError = null),
-      root)
+  enqueueStateRestore(target);
+  inst = accumulateTwoPhaseListeners(inst, "onChange");
+  0 < inst.length &&
+    ((nativeEvent = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    )),
+    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+}
+var activeElement$1 = null,
+  activeElementInst$1 = null;
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
+  if (updateValueIfChanged(targetNode)) return targetInst;
+}
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if ("change" === domEventName) return targetInst;
+}
+var isInputEventSupported = !1;
+if (canUseDOM) {
+  var JSCompiler_inline_result$jscomp$313;
+  if (canUseDOM) {
+    var isSupported$jscomp$inline_1569 = "oninput" in document;
+    if (!isSupported$jscomp$inline_1569) {
+      var element$jscomp$inline_1570 = document.createElement("div");
+      element$jscomp$inline_1570.setAttribute("oninput", "return;");
+      isSupported$jscomp$inline_1569 =
+        "function" === typeof element$jscomp$inline_1570.oninput;
+    }
+    JSCompiler_inline_result$jscomp$313 = isSupported$jscomp$inline_1569;
+  } else JSCompiler_inline_result$jscomp$313 = !1;
+  isInputEventSupported =
+    JSCompiler_inline_result$jscomp$313 &&
+    (!document.documentMode || 9 < document.documentMode);
+}
+function stopWatchingForValueChange() {
+  activeElement$1 &&
+    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
+    (activeElementInst$1 = activeElement$1 = null));
+}
+function handlePropertyChange(nativeEvent) {
+  if (
+    "value" === nativeEvent.propertyName &&
+    getInstIfValueChanged(activeElementInst$1)
+  ) {
+    var dispatchQueue = [];
+    createAndAccumulateChangeEvent(
+      dispatchQueue,
+      activeElementInst$1,
+      nativeEvent,
+      getEventTarget(nativeEvent)
     );
-  0 !== (pendingPassiveEffectsLanes & 3) &&
-    0 !== root.tag &&
-    flushPassiveEffects();
-  remainingLanes = root.pendingLanes;
-  0 !== (remainingLanes & 3)
-    ? ((nestedUpdateScheduled = !0),
-      root === rootWithNestedUpdates
-        ? nestedUpdateCount++
-        : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root)))
-    : (nestedUpdateCount = 0);
-  flushSyncCallbacks();
-  enableSchedulingProfiler && markCommitStopped();
-  if (enableTransitionTracing) {
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    null !== prevRootTransitionCallbacks &&
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-        null !== prevPendingTransitionCallbacks
-          ? ((currentPendingTransitionCallbacks = null),
-            scheduleCallback(IdlePriority, function () {
-              processTransitionCallbacks(
-                prevPendingTransitionCallbacks,
-                endTime,
-                prevRootTransitionCallbacks
-              );
-            }))
-          : (currentEndTime = endTime);
-      });
+    batchedUpdates(runEventInBatch, dispatchQueue);
   }
-  return null;
 }
-function releaseRootPooledCache(root, remainingLanes) {
-  0 === (root.pooledCacheLanes &= remainingLanes) &&
-    ((remainingLanes = root.pooledCache),
-    null != remainingLanes &&
-      ((root.pooledCache = null), releaseCache(remainingLanes)));
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  "focusin" === domEventName
+    ? (stopWatchingForValueChange(),
+      (activeElement$1 = target),
+      (activeElementInst$1 = targetInst),
+      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
+    : "focusout" === domEventName && stopWatchingForValueChange();
+}
+function getTargetInstForInputEventPolyfill(domEventName) {
+  if (
+    "selectionchange" === domEventName ||
+    "keyup" === domEventName ||
+    "keydown" === domEventName
+  )
+    return getInstIfValueChanged(activeElementInst$1);
+}
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
+}
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if ("input" === domEventName || "change" === domEventName)
+    return getInstIfValueChanged(targetInst);
+}
+function getLeafNode(node) {
+  for (; node && node.firstChild; ) node = node.firstChild;
+  return node;
+}
+function getNodeForCharacterOffset(root, offset) {
+  var node = getLeafNode(root);
+  root = 0;
+  for (var nodeEnd; node; ) {
+    if (3 === node.nodeType) {
+      nodeEnd = root + node.textContent.length;
+      if (root <= offset && nodeEnd >= offset)
+        return { node: node, offset: offset - root };
+      root = nodeEnd;
+    }
+    a: {
+      for (; node; ) {
+        if (node.nextSibling) {
+          node = node.nextSibling;
+          break a;
+        }
+        node = node.parentNode;
+      }
+      node = void 0;
+    }
+    node = getLeafNode(node);
+  }
+}
+function containsNode(outerNode, innerNode) {
+  return outerNode && innerNode
+    ? outerNode === innerNode
+      ? !0
+      : outerNode && 3 === outerNode.nodeType
+      ? !1
+      : innerNode && 3 === innerNode.nodeType
+      ? containsNode(outerNode, innerNode.parentNode)
+      : "contains" in outerNode
+      ? outerNode.contains(innerNode)
+      : outerNode.compareDocumentPosition
+      ? !!(outerNode.compareDocumentPosition(innerNode) & 16)
+      : !1
+    : !1;
 }
-function flushPassiveEffects() {
-  if (null !== rootWithPendingPassiveEffects) {
-    var root$241 = rootWithPendingPassiveEffects,
-      remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = 0;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    renderPriority = 32 > renderPriority ? 32 : renderPriority;
-    var prevTransition = ReactCurrentBatchConfig.transition,
-      previousPriority = currentUpdatePriority;
+function getActiveElementDeep() {
+  for (
+    var win = window, element = getActiveElement();
+    element instanceof win.HTMLIFrameElement;
+
+  ) {
     try {
-      return (
-        (ReactCurrentBatchConfig.transition = null),
-        (currentUpdatePriority = renderPriority),
-        flushPassiveEffectsImpl()
-      );
-    } finally {
-      (currentUpdatePriority = previousPriority),
-        (ReactCurrentBatchConfig.transition = prevTransition),
-        releaseRootPooledCache(root$241, remainingLanes);
+      var JSCompiler_inline_result =
+        "string" === typeof element.contentWindow.location.href;
+    } catch (err) {
+      JSCompiler_inline_result = !1;
     }
+    if (JSCompiler_inline_result) win = element.contentWindow;
+    else break;
+    element = getActiveElement(win.document);
   }
-  return !1;
+  return element;
 }
-function enqueuePendingPassiveProfilerEffect(fiber) {
-  pendingPassiveProfilerEffects.push(fiber);
-  rootDoesHavePassiveEffects ||
-    ((rootDoesHavePassiveEffects = !0),
-    scheduleCallback(NormalPriority$1, function () {
-      flushPassiveEffects();
-      return null;
-    }));
+function hasSelectionCapabilities(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName &&
+    (("input" === nodeName &&
+      ("text" === elem.type ||
+        "search" === elem.type ||
+        "tel" === elem.type ||
+        "url" === elem.type ||
+        "password" === elem.type)) ||
+      "textarea" === nodeName ||
+      "true" === elem.contentEditable)
+  );
 }
-function flushPassiveEffectsImpl() {
-  if (null === rootWithPendingPassiveEffects) return !1;
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects,
-    lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null;
-  pendingPassiveEffectsLanes = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markPassiveEffectsStarted &&
-    injectedProfilingHooks.markPassiveEffectsStarted(lanes);
-  var prevExecutionContext = executionContext;
-  executionContext |= 4;
-  commitPassiveUnmountOnFiber(root.current);
-  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
-  transitions = pendingPassiveProfilerEffects;
-  pendingPassiveProfilerEffects = [];
-  for (lanes = 0; lanes < transitions.length; lanes++)
-    commitPassiveEffectDurations(root, transitions[lanes]);
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markPassiveEffectsStopped &&
-    injectedProfilingHooks.markPassiveEffectsStopped();
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
-      prevRootTransitionCallbacks = root.transitionCallbacks,
-      prevEndTime = currentEndTime;
-    null !== prevPendingTransitionCallbacks &&
-      null !== prevRootTransitionCallbacks &&
-      null !== prevEndTime &&
-      ((currentEndTime = currentPendingTransitionCallbacks = null),
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
+function restoreSelection(priorSelectionInformation) {
+  var curFocusedElem = getActiveElementDeep(),
+    priorFocusedElem = priorSelectionInformation.focusedElem,
+    priorSelectionRange = priorSelectionInformation.selectionRange;
+  if (
+    curFocusedElem !== priorFocusedElem &&
+    priorFocusedElem &&
+    priorFocusedElem.ownerDocument &&
+    containsNode(
+      priorFocusedElem.ownerDocument.documentElement,
+      priorFocusedElem
+    )
+  ) {
+    if (
+      null !== priorSelectionRange &&
+      hasSelectionCapabilities(priorFocusedElem)
+    )
+      if (
+        ((curFocusedElem = priorSelectionRange.start),
+        (priorSelectionInformation = priorSelectionRange.end),
+        void 0 === priorSelectionInformation &&
+          (priorSelectionInformation = curFocusedElem),
+        "selectionStart" in priorFocusedElem)
+      )
+        (priorFocusedElem.selectionStart = curFocusedElem),
+          (priorFocusedElem.selectionEnd = Math.min(
+            priorSelectionInformation,
+            priorFocusedElem.value.length
+          ));
+      else if (
+        ((priorSelectionInformation =
+          ((curFocusedElem = priorFocusedElem.ownerDocument || document) &&
+            curFocusedElem.defaultView) ||
+          window),
+        priorSelectionInformation.getSelection)
+      ) {
+        priorSelectionInformation = priorSelectionInformation.getSelection();
+        var length = priorFocusedElem.textContent.length,
+          start = Math.min(priorSelectionRange.start, length);
+        priorSelectionRange =
+          void 0 === priorSelectionRange.end
+            ? start
+            : Math.min(priorSelectionRange.end, length);
+        !priorSelectionInformation.extend &&
+          start > priorSelectionRange &&
+          ((length = priorSelectionRange),
+          (priorSelectionRange = start),
+          (start = length));
+        length = getNodeForCharacterOffset(priorFocusedElem, start);
+        var endMarker = getNodeForCharacterOffset(
+          priorFocusedElem,
+          priorSelectionRange
         );
-      }));
+        length &&
+          endMarker &&
+          (1 !== priorSelectionInformation.rangeCount ||
+            priorSelectionInformation.anchorNode !== length.node ||
+            priorSelectionInformation.anchorOffset !== length.offset ||
+            priorSelectionInformation.focusNode !== endMarker.node ||
+            priorSelectionInformation.focusOffset !== endMarker.offset) &&
+          ((curFocusedElem = curFocusedElem.createRange()),
+          curFocusedElem.setStart(length.node, length.offset),
+          priorSelectionInformation.removeAllRanges(),
+          start > priorSelectionRange
+            ? (priorSelectionInformation.addRange(curFocusedElem),
+              priorSelectionInformation.extend(
+                endMarker.node,
+                endMarker.offset
+              ))
+            : (curFocusedElem.setEnd(endMarker.node, endMarker.offset),
+              priorSelectionInformation.addRange(curFocusedElem)));
+      }
+    curFocusedElem = [];
+    for (
+      priorSelectionInformation = priorFocusedElem;
+      (priorSelectionInformation = priorSelectionInformation.parentNode);
+
+    )
+      1 === priorSelectionInformation.nodeType &&
+        curFocusedElem.push({
+          element: priorSelectionInformation,
+          left: priorSelectionInformation.scrollLeft,
+          top: priorSelectionInformation.scrollTop
+        });
+    "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
+    for (
+      priorFocusedElem = 0;
+      priorFocusedElem < curFocusedElem.length;
+      priorFocusedElem++
+    )
+      (priorSelectionInformation = curFocusedElem[priorFocusedElem]),
+        (priorSelectionInformation.element.scrollLeft =
+          priorSelectionInformation.left),
+        (priorSelectionInformation.element.scrollTop =
+          priorSelectionInformation.top);
   }
-  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
-    try {
-      injectedHook.onPostCommitFiberRoot(rendererID, root);
-    } catch (err) {}
-  root = root.current.stateNode;
-  root.effectDuration = 0;
-  root.passiveEffectDuration = 0;
-  return !0;
 }
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
-  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
-  sourceFiber = requestEventTime();
-  null !== rootFiber &&
-    (markRootUpdated(rootFiber, 2, sourceFiber),
-    ensureRootIsScheduled(rootFiber, sourceFiber));
+var skipSelectionChangeEvent =
+    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
+  activeElement = null,
+  activeElementInst = null,
+  lastSelection = null,
+  mouseDown = !1;
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  var doc =
+    nativeEventTarget.window === nativeEventTarget
+      ? nativeEventTarget.document
+      : 9 === nativeEventTarget.nodeType
+      ? nativeEventTarget
+      : nativeEventTarget.ownerDocument;
+  mouseDown ||
+    null == activeElement ||
+    activeElement !== getActiveElement(doc) ||
+    ((doc = activeElement),
+    "selectionStart" in doc && hasSelectionCapabilities(doc)
+      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
+      : ((doc = (
+          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
+          window
+        ).getSelection()),
+        (doc = {
+          anchorNode: doc.anchorNode,
+          anchorOffset: doc.anchorOffset,
+          focusNode: doc.focusNode,
+          focusOffset: doc.focusOffset
+        })),
+    (lastSelection && shallowEqual(lastSelection, doc)) ||
+      ((lastSelection = doc),
+      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
+      0 < doc.length &&
+        ((nativeEvent = new SyntheticEvent(
+          "onSelect",
+          "select",
+          null,
+          nativeEvent,
+          nativeEventTarget
+        )),
+        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
+        (nativeEvent.target = activeElement))));
+}
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
+}
+var vendorPrefixes = {
+    animationend: makePrefixMap("Animation", "AnimationEnd"),
+    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+    animationstart: makePrefixMap("Animation", "AnimationStart"),
+    transitionend: makePrefixMap("Transition", "TransitionEnd")
+  },
+  prefixedEventNames = {},
+  style = {};
+canUseDOM &&
+  ((style = document.createElement("div").style),
+  "AnimationEvent" in window ||
+    (delete vendorPrefixes.animationend.animation,
+    delete vendorPrefixes.animationiteration.animation,
+    delete vendorPrefixes.animationstart.animation),
+  "TransitionEvent" in window ||
+    delete vendorPrefixes.transitionend.transition);
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
+  if (!vendorPrefixes[eventName]) return eventName;
+  var prefixMap = vendorPrefixes[eventName],
+    styleProp;
+  for (styleProp in prefixMap)
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
+  return eventName;
+}
+var ANIMATION_END = getVendorPrefixedEventName("animationend"),
+  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
+  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
+  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
+  topLevelEventsToReactNames = new Map(),
+  simpleEventPluginEvents =
+    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
+      " "
+    );
+topLevelEventsToReactNames.set("beforeblur", null);
+topLevelEventsToReactNames.set("afterblur", null);
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
 }
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
-  if (3 === sourceFiber.tag)
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
-  else
-    for (
-      nearestMountedAncestor = skipUnmountedBoundaries
-        ? nearestMountedAncestor
-        : sourceFiber.return;
-      null !== nearestMountedAncestor;
-
-    ) {
-      if (3 === nearestMountedAncestor.tag) {
-        captureCommitPhaseErrorOnRoot(
-          nearestMountedAncestor,
-          sourceFiber,
-          error
-        );
-        break;
-      } else if (1 === nearestMountedAncestor.tag) {
-        var instance = nearestMountedAncestor.stateNode;
-        if (
-          "function" ===
-            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
-          ("function" === typeof instance.componentDidCatch &&
-            (null === legacyErrorBoundariesThatAlreadyFailed ||
-              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
+for (
+  var i$jscomp$inline_1610 = 0;
+  i$jscomp$inline_1610 < simpleEventPluginEvents.length;
+  i$jscomp$inline_1610++
+) {
+  var eventName$jscomp$inline_1611 =
+      simpleEventPluginEvents[i$jscomp$inline_1610],
+    domEventName$jscomp$inline_1612 =
+      eventName$jscomp$inline_1611.toLowerCase(),
+    capitalizedEvent$jscomp$inline_1613 =
+      eventName$jscomp$inline_1611[0].toUpperCase() +
+      eventName$jscomp$inline_1611.slice(1);
+  registerSimpleEvent(
+    domEventName$jscomp$inline_1612,
+    "on" + capitalizedEvent$jscomp$inline_1613
+  );
+}
+registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+registerSimpleEvent("dblclick", "onDoubleClick");
+registerSimpleEvent("focusin", "onFocus");
+registerSimpleEvent("focusout", "onBlur");
+registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+registerTwoPhaseEvent(
+  "onChange",
+  "change click focusin focusout input keydown keyup selectionchange".split(" ")
+);
+registerTwoPhaseEvent(
+  "onSelect",
+  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
+    " "
+  )
+);
+registerTwoPhaseEvent("onBeforeInput", [
+  "compositionend",
+  "keypress",
+  "textInput",
+  "paste"
+]);
+registerTwoPhaseEvent(
+  "onCompositionEnd",
+  "compositionend focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionStart",
+  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionUpdate",
+  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
+);
+var mediaEventTypes =
+    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
+      " "
+    ),
+  nonDelegatedEvents = new Set(
+    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
+  );
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+  event.currentTarget = null;
+}
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  eventSystemFlags = 0 !== (eventSystemFlags & 4);
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event;
+    _dispatchQueue$i = _dispatchQueue$i.listeners;
+    a: {
+      var previousInstance = void 0;
+      if (eventSystemFlags)
+        for (
+          var i$jscomp$0 = _dispatchQueue$i.length - 1;
+          0 <= i$jscomp$0;
+          i$jscomp$0--
         ) {
-          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-          sourceFiber = createClassErrorUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          nearestMountedAncestor = enqueueUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          sourceFiber = requestEventTime();
-          null !== nearestMountedAncestor &&
-            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
-            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
-          break;
+          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
+        }
+      else
+        for (
+          i$jscomp$0 = 0;
+          i$jscomp$0 < _dispatchQueue$i.length;
+          i$jscomp$0++
+        ) {
+          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
+          instance = _dispatchListeners$i.instance;
+          currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
+            break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
         }
-      }
-      nearestMountedAncestor = nearestMountedAncestor.return;
     }
+  }
+  if (hasRethrowError)
+    throw (
+      ((dispatchQueue = rethrowError),
+      (hasRethrowError = !1),
+      (rethrowError = null),
+      dispatchQueue)
+    );
 }
-function attachPingListener(root, wakeable, lanes) {
-  var pingCache = root.pingCache;
-  if (null === pingCache) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    var threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else
-    (threadIDs = pingCache.get(wakeable)),
-      void 0 === threadIDs &&
-        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
-  threadIDs.has(lanes) ||
-    ((workInProgressRootDidAttachPingListener = !0),
-    threadIDs.add(lanes),
-    (pingCache = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
-    isDevToolsPresent && restorePendingUpdaters(root, lanes),
-    wakeable.then(pingCache, pingCache));
-}
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
-  null !== pingCache && pingCache.delete(wakeable);
-  wakeable = requestEventTime();
-  root.pingedLanes |= root.suspendedLanes & pingedLanes;
-  workInProgressRoot === root &&
-    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
-    (4 === workInProgressRootExitStatus ||
-    (3 === workInProgressRootExitStatus &&
-      (workInProgressRootRenderLanes & 125829120) ===
-        workInProgressRootRenderLanes &&
-      500 > now$1() - globalMostRecentFallbackTime)
-      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
-      : (workInProgressRootPingedLanes |= pingedLanes));
-  ensureRootIsScheduled(root, wakeable);
-}
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  0 === retryLane &&
-    (0 === (boundaryFiber.mode & 1)
-      ? (retryLane = 2)
-      : ((retryLane = nextRetryLane),
-        (nextRetryLane <<= 1),
-        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
-  var eventTime = requestEventTime();
-  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
-  null !== boundaryFiber &&
-    (markRootUpdated(boundaryFiber, retryLane, eventTime),
-    ensureRootIsScheduled(boundaryFiber, eventTime));
-}
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState,
-    retryLane = 0;
-  null !== suspenseState && (retryLane = suspenseState.retryLane);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+  var listenerSet = getEventListenerSet(targetElement),
+    listenerSetKey = domEventName + "__bubble";
+  listenerSet.has(listenerSetKey) ||
+    (addTrappedEventListener(targetElement, domEventName, 2, !1),
+    listenerSet.add(listenerSetKey));
 }
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = 0;
-  switch (boundaryFiber.tag) {
-    case 13:
-      var retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
-      null !== suspenseState && (retryLane = suspenseState.retryLane);
-      break;
-    case 19:
-      retryCache = boundaryFiber.stateNode;
-      break;
-    case 22:
-      retryCache = boundaryFiber.stateNode._retryCache;
-      break;
-    default:
-      throw Error(formatProdErrorMessage(314));
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+  var eventSystemFlags = 0;
+  isCapturePhaseListener && (eventSystemFlags |= 4);
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
+}
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = !0;
+    allNativeEvents.forEach(function (domEventName) {
+      "selectionchange" !== domEventName &&
+        (nonDelegatedEvents.has(domEventName) ||
+          listenToNativeEvent(domEventName, !1, rootContainerElement),
+        listenToNativeEvent(domEventName, !0, rootContainerElement));
+    });
+    var ownerDocument =
+      9 === rootContainerElement.nodeType
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
+    null === ownerDocument ||
+      ownerDocument[listeningMarker] ||
+      ((ownerDocument[listeningMarker] = !0),
+      listenToNativeEvent("selectionchange", !1, ownerDocument));
   }
-  null !== retryCache && retryCache.delete(wakeable);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
 }
-var beginWork;
-beginWork = function (current, workInProgress, renderLanes) {
-  if (null !== current)
-    if (current.memoizedProps !== workInProgress.pendingProps)
-      didReceiveUpdate = !0;
-    else {
-      if (
-        !checkScheduledUpdateOrContext(current, renderLanes) &&
-        0 === (workInProgress.flags & 128)
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  eventSystemFlags = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  );
+  var isPassiveListener = void 0;
+  !passiveBrowserEventsSupported ||
+    ("touchstart" !== domEventName &&
+      "touchmove" !== domEventName &&
+      "wheel" !== domEventName) ||
+    (isPassiveListener = !0);
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = eventSystemFlags;
+    eventSystemFlags = function () {
+      targetContainer.removeEventListener(
+        domEventName,
+        unsubscribeListener,
+        isCapturePhaseListener
+      );
+      for (
+        var _len = arguments.length, p = Array(_len), _key = 0;
+        _key < _len;
+        _key++
       )
-        return (
-          (didReceiveUpdate = !1),
-          attemptEarlyBailoutIfNoScheduledUpdate(
-            current,
-            workInProgress,
-            renderLanes
-          )
-        );
-      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+        p[_key] = arguments[_key];
+      return originalListener.apply(this, p);
+    };
+  }
+  var unsubscribeListener = isCapturePhaseListener
+    ? void 0 !== isPassiveListener
+      ? addEventCaptureListenerWithPassiveFlag(
+          targetContainer,
+          domEventName,
+          eventSystemFlags,
+          isPassiveListener
+        )
+      : addEventCaptureListener(targetContainer, domEventName, eventSystemFlags)
+    : void 0 !== isPassiveListener
+    ? addEventBubbleListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        eventSystemFlags,
+        isPassiveListener
+      )
+    : addEventBubbleListener(targetContainer, domEventName, eventSystemFlags);
+}
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst$jscomp$0,
+  targetContainer
+) {
+  var ancestorInst = targetInst$jscomp$0;
+  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+    if (
+      enableLegacyFBSupport &&
+      "click" === domEventName &&
+      0 === (eventSystemFlags & 20) &&
+      nativeEvent !== currentReplayingEvent
+    ) {
+      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
+      return;
     }
-  else
-    (didReceiveUpdate = !1),
-      isHydrating &&
-        0 !== (workInProgress.flags & 1048576) &&
-        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
-  workInProgress.lanes = 0;
-  switch (workInProgress.tag) {
-    case 2:
-      var Component = workInProgress.type;
-      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-      current = workInProgress.pendingProps;
-      prepareToReadContext(workInProgress, renderLanes);
-      enableSchedulingProfiler && markComponentRenderStarted(workInProgress);
-      current = renderWithHooks(
-        null,
-        workInProgress,
-        Component,
-        current,
-        void 0,
-        renderLanes
-      );
-      Component = checkDidRenderIdHook();
-      enableSchedulingProfiler && markComponentRenderStopped();
-      workInProgress.flags |= 1;
-      workInProgress.tag = 0;
-      isHydrating && Component && pushMaterializedTreeId(workInProgress);
-      reconcileChildren(null, workInProgress, current, renderLanes);
-      workInProgress = workInProgress.child;
-      return workInProgress;
-    case 16:
-      Component = workInProgress.elementType;
-      a: {
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-        current = workInProgress.pendingProps;
-        var init = Component._init;
-        Component = init(Component._payload);
-        workInProgress.type = Component;
-        init = workInProgress.tag = resolveLazyComponentTag(Component);
-        current = resolveDefaultProps(Component, current);
-        switch (init) {
-          case 0:
-            workInProgress = updateFunctionComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 1:
-            workInProgress = updateClassComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 11:
-            workInProgress = updateForwardRef(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 14:
-            workInProgress = updateMemoComponent(
-              null,
-              workInProgress,
-              Component,
-              resolveDefaultProps(Component.type, current),
-              renderLanes
-            );
-            break a;
+    if (null !== targetInst$jscomp$0)
+      a: for (;;) {
+        if (null === targetInst$jscomp$0) return;
+        var nodeTag = targetInst$jscomp$0.tag;
+        if (3 === nodeTag || 4 === nodeTag) {
+          var container = targetInst$jscomp$0.stateNode.containerInfo;
+          if (
+            container === targetContainer ||
+            (8 === container.nodeType &&
+              container.parentNode === targetContainer)
+          )
+            break;
+          if (4 === nodeTag)
+            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
+              var grandTag = nodeTag.tag;
+              if (3 === grandTag || 4 === grandTag)
+                if (
+                  ((grandTag = nodeTag.stateNode.containerInfo),
+                  grandTag === targetContainer ||
+                    (8 === grandTag.nodeType &&
+                      grandTag.parentNode === targetContainer))
+                )
+                  return;
+              nodeTag = nodeTag.return;
+            }
+          for (; null !== container; ) {
+            nodeTag = getClosestInstanceFromNode(container);
+            if (null === nodeTag) return;
+            grandTag = nodeTag.tag;
+            if (
+              5 === grandTag ||
+              6 === grandTag ||
+              26 === grandTag ||
+              27 === grandTag
+            ) {
+              targetInst$jscomp$0 = ancestorInst = nodeTag;
+              continue a;
+            }
+            container = container.parentNode;
+          }
+        }
+        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+      }
+  }
+  batchedUpdates(function () {
+    var targetInst = ancestorInst,
+      nativeEventTarget = getEventTarget(nativeEvent),
+      dispatchQueue = [];
+    a: {
+      var reactName = topLevelEventsToReactNames.get(domEventName);
+      if (void 0 !== reactName) {
+        var SyntheticEventCtor = SyntheticEvent,
+          reactEventType = domEventName;
+        switch (domEventName) {
+          case "keypress":
+            if (0 === getEventCharCode(nativeEvent)) break a;
+          case "keydown":
+          case "keyup":
+            SyntheticEventCtor = SyntheticKeyboardEvent;
+            break;
+          case "focusin":
+            reactEventType = "focus";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "focusout":
+            reactEventType = "blur";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "beforeblur":
+          case "afterblur":
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "click":
+            if (2 === nativeEvent.button) break a;
+          case "auxclick":
+          case "dblclick":
+          case "mousedown":
+          case "mousemove":
+          case "mouseup":
+          case "mouseout":
+          case "mouseover":
+          case "contextmenu":
+            SyntheticEventCtor = SyntheticMouseEvent;
+            break;
+          case "drag":
+          case "dragend":
+          case "dragenter":
+          case "dragexit":
+          case "dragleave":
+          case "dragover":
+          case "dragstart":
+          case "drop":
+            SyntheticEventCtor = SyntheticDragEvent;
+            break;
+          case "touchcancel":
+          case "touchend":
+          case "touchmove":
+          case "touchstart":
+            SyntheticEventCtor = SyntheticTouchEvent;
+            break;
+          case ANIMATION_END:
+          case ANIMATION_ITERATION:
+          case ANIMATION_START:
+            SyntheticEventCtor = SyntheticAnimationEvent;
+            break;
+          case TRANSITION_END:
+            SyntheticEventCtor = SyntheticTransitionEvent;
+            break;
+          case "scroll":
+            SyntheticEventCtor = SyntheticUIEvent;
+            break;
+          case "wheel":
+            SyntheticEventCtor = SyntheticWheelEvent;
+            break;
+          case "copy":
+          case "cut":
+          case "paste":
+            SyntheticEventCtor = SyntheticClipboardEvent;
+            break;
+          case "gotpointercapture":
+          case "lostpointercapture":
+          case "pointercancel":
+          case "pointerdown":
+          case "pointermove":
+          case "pointerout":
+          case "pointerover":
+          case "pointerup":
+            SyntheticEventCtor = SyntheticPointerEvent;
         }
-        throw Error(formatProdErrorMessage(306, Component, ""));
+        var inCapturePhase = 0 !== (eventSystemFlags & 4);
+        eventSystemFlags & 1
+          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
+              reactEventType,
+              targetContainer,
+              inCapturePhase
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })))
+          : ((inCapturePhase = accumulateSinglePhaseListeners(
+              targetInst,
+              reactName,
+              nativeEvent.type,
+              inCapturePhase,
+              !inCapturePhase && "scroll" === domEventName,
+              nativeEvent
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })));
       }
-      return workInProgress;
-    case 0:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateFunctionComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 1:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateClassComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 3:
+    }
+    if (0 === (eventSystemFlags & 7)) {
       a: {
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
-        );
-        if (null === current) throw Error(formatProdErrorMessage(387));
-        Component = workInProgress.pendingProps;
-        var prevState = workInProgress.memoizedState;
-        init = prevState.element;
-        cloneUpdateQueue(current, workInProgress);
-        processUpdateQueue(workInProgress, Component, null, renderLanes);
-        var nextState = workInProgress.memoizedState,
-          root = workInProgress.stateNode;
-        enableTransitionTracing &&
-          push(transitionStack, workInProgressTransitions);
-        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-        Component = nextState.cache;
-        pushProvider(workInProgress, CacheContext, Component);
-        Component !== prevState.cache &&
-          propagateContextChange(workInProgress, CacheContext, renderLanes);
-        Component = nextState.element;
-        if (prevState.isDehydrated)
-          if (
-            ((prevState = {
-              element: Component,
-              isDehydrated: !1,
-              cache: nextState.cache
-            }),
-            (workInProgress.updateQueue.baseState = prevState),
-            (workInProgress.memoizedState = prevState),
-            workInProgress.flags & 256)
-          ) {
-            init = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(423)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              init
-            );
-            break a;
-          } else if (Component !== init) {
-            init = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(424)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              init
-            );
-            break a;
-          } else {
-            nextHydratableInstance = getNextHydratable(
-              workInProgress.stateNode.containerInfo.firstChild
-            );
-            hydrationParentFiber = workInProgress;
-            isHydrating = !0;
-            hydrationErrors = null;
-            rootOrSingletonContext = !0;
-            current = root.mutableSourceEagerHydrationData;
-            if (null != current)
-              for (init = 0; init < current.length; init += 2)
-                (prevState = current[init]),
-                  (prevState._workInProgressVersionPrimary = current[init + 1]),
-                  workInProgressSources.push(prevState);
-            renderLanes = mountChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
+        reactName =
+          "mouseover" === domEventName || "pointerover" === domEventName;
+        SyntheticEventCtor =
+          "mouseout" === domEventName || "pointerout" === domEventName;
+        if (
+          reactName &&
+          nativeEvent !== currentReplayingEvent &&
+          (reactEventType =
+            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
+          (getClosestInstanceFromNode(reactEventType) ||
+            reactEventType[internalContainerInstanceKey])
+        )
+          break a;
+        if (SyntheticEventCtor || reactName) {
+          reactName =
+            nativeEventTarget.window === nativeEventTarget
+              ? nativeEventTarget
+              : (reactName = nativeEventTarget.ownerDocument)
+              ? reactName.defaultView || reactName.parentWindow
+              : window;
+          if (SyntheticEventCtor) {
+            if (
+              ((reactEventType =
+                nativeEvent.relatedTarget || nativeEvent.toElement),
+              (SyntheticEventCtor = targetInst),
+              (reactEventType = reactEventType
+                ? getClosestInstanceFromNode(reactEventType)
+                : null),
+              null !== reactEventType)
+            ) {
+              inCapturePhase = getNearestMountedFiber(reactEventType);
+              var tag = reactEventType.tag;
+              if (
+                reactEventType !== inCapturePhase ||
+                (5 !== tag && 27 !== tag && 6 !== tag)
+              )
+                reactEventType = null;
+            }
+          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
+          if (SyntheticEventCtor !== reactEventType) {
+            tag = SyntheticMouseEvent;
+            var leaveEventType = "onMouseLeave",
+              enterEventType = "onMouseEnter",
+              eventTypePrefix = "mouse";
+            if ("pointerout" === domEventName || "pointerover" === domEventName)
+              (tag = SyntheticPointerEvent),
+                (leaveEventType = "onPointerLeave"),
+                (enterEventType = "onPointerEnter"),
+                (eventTypePrefix = "pointer");
+            inCapturePhase =
+              null == SyntheticEventCtor
+                ? reactName
+                : getNodeFromInstance(SyntheticEventCtor);
+            var toNode =
+              null == reactEventType
+                ? reactName
+                : getNodeFromInstance(reactEventType);
+            reactName = new tag(
+              leaveEventType,
+              eventTypePrefix + "leave",
+              SyntheticEventCtor,
+              nativeEvent,
+              nativeEventTarget
             );
-            for (workInProgress.child = renderLanes; renderLanes; )
-              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
-                (renderLanes = renderLanes.sibling);
+            reactName.target = inCapturePhase;
+            reactName.relatedTarget = toNode;
+            leaveEventType = null;
+            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
+              ((tag = new tag(
+                enterEventType,
+                eventTypePrefix + "enter",
+                reactEventType,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              (tag.target = toNode),
+              (tag.relatedTarget = inCapturePhase),
+              (leaveEventType = tag));
+            inCapturePhase = leaveEventType;
+            if (SyntheticEventCtor && reactEventType)
+              b: {
+                tag = SyntheticEventCtor;
+                enterEventType = reactEventType;
+                eventTypePrefix = 0;
+                for (toNode = tag; toNode; toNode = getParent(toNode))
+                  eventTypePrefix++;
+                toNode = 0;
+                for (
+                  leaveEventType = enterEventType;
+                  leaveEventType;
+                  leaveEventType = getParent(leaveEventType)
+                )
+                  toNode++;
+                for (; 0 < eventTypePrefix - toNode; )
+                  (tag = getParent(tag)), eventTypePrefix--;
+                for (; 0 < toNode - eventTypePrefix; )
+                  (enterEventType = getParent(enterEventType)), toNode--;
+                for (; eventTypePrefix--; ) {
+                  if (
+                    tag === enterEventType ||
+                    (null !== enterEventType &&
+                      tag === enterEventType.alternate)
+                  )
+                    break b;
+                  tag = getParent(tag);
+                  enterEventType = getParent(enterEventType);
+                }
+                tag = null;
+              }
+            else tag = null;
+            null !== SyntheticEventCtor &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                reactName,
+                SyntheticEventCtor,
+                tag,
+                !1
+              );
+            null !== reactEventType &&
+              null !== inCapturePhase &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                inCapturePhase,
+                reactEventType,
+                tag,
+                !0
+              );
           }
-        else {
-          resetHydrationState();
-          if (Component === init) {
-            workInProgress = bailoutOnAlreadyFinishedWork(
-              current,
-              workInProgress,
-              renderLanes
-            );
-            break a;
+        }
+      }
+      a: {
+        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
+        SyntheticEventCtor =
+          reactName.nodeName && reactName.nodeName.toLowerCase();
+        if (
+          "select" === SyntheticEventCtor ||
+          ("input" === SyntheticEventCtor && "file" === reactName.type)
+        )
+          var getTargetInstFunc = getTargetInstForChangeEvent;
+        else if (isTextInputElement(reactName))
+          if (isInputEventSupported)
+            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+          else {
+            getTargetInstFunc = getTargetInstForInputEventPolyfill;
+            var handleEventFunc = handleEventsForInputEventPolyfill;
           }
-          reconcileChildren(current, workInProgress, Component, renderLanes);
+        else
+          (SyntheticEventCtor = reactName.nodeName),
+            !SyntheticEventCtor ||
+            "input" !== SyntheticEventCtor.toLowerCase() ||
+            ("checkbox" !== reactName.type && "radio" !== reactName.type)
+              ? enableCustomElementPropertySupport &&
+                targetInst &&
+                isCustomComponent(
+                  targetInst.elementType,
+                  targetInst.memoizedProps
+                ) &&
+                (getTargetInstFunc = getTargetInstForChangeEvent)
+              : (getTargetInstFunc = getTargetInstForClickEvent);
+        if (
+          getTargetInstFunc &&
+          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
+        ) {
+          createAndAccumulateChangeEvent(
+            dispatchQueue,
+            getTargetInstFunc,
+            nativeEvent,
+            nativeEventTarget
+          );
+          break a;
         }
-        workInProgress = workInProgress.child;
+        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
+        "focusout" === domEventName &&
+          (handleEventFunc = reactName._wrapperState) &&
+          handleEventFunc.controlled &&
+          "number" === reactName.type &&
+          (disableInputAttributeSyncing ||
+            setDefaultValue(reactName, "number", reactName.value));
       }
-      return workInProgress;
-    case 26:
-      return (
-        markRef$1(current, workInProgress),
-        (renderLanes = workInProgress.memoizedState =
-          getResource(
-            workInProgress.type,
-            null === current ? null : current.memoizedProps,
-            workInProgress.pendingProps
-          )),
-        null !== current ||
-          isHydrating ||
-          null !== renderLanes ||
-          ((renderLanes = workInProgress.type),
-          (current = workInProgress.pendingProps),
-          (Component = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
-          )),
-          (Component = createHTMLElement(renderLanes, current, Component)),
-          (Component[internalInstanceKey] = workInProgress),
-          (Component[internalPropsKey] = current),
-          setInitialProperties(Component, renderLanes, current),
-          markNodeAsHoistable(Component),
-          (workInProgress.stateNode = Component)),
-        null
-      );
-    case 27:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          ((Component = workInProgress.stateNode =
-            resolveSingletonInstance(
-              workInProgress.type,
-              workInProgress.pendingProps,
-              rootInstanceStackCursor.current
-            )),
-          (hydrationParentFiber = workInProgress),
-          (rootOrSingletonContext = !0),
-          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
-        (Component = workInProgress.pendingProps.children),
-        null !== current || isHydrating
-          ? reconcileChildren(current, workInProgress, Component, renderLanes)
-          : (workInProgress.child = reconcileChildFibers(
-              workInProgress,
+      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
+      switch (domEventName) {
+        case "focusin":
+          if (
+            isTextInputElement(handleEventFunc) ||
+            "true" === handleEventFunc.contentEditable
+          )
+            (activeElement = handleEventFunc),
+              (activeElementInst = targetInst),
+              (lastSelection = null);
+          break;
+        case "focusout":
+          lastSelection = activeElementInst = activeElement = null;
+          break;
+        case "mousedown":
+          mouseDown = !0;
+          break;
+        case "contextmenu":
+        case "mouseup":
+        case "dragend":
+          mouseDown = !1;
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+          break;
+        case "selectionchange":
+          if (skipSelectionChangeEvent) break;
+        case "keydown":
+        case "keyup":
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      }
+      var fallbackData;
+      if (canUseCompositionEvent)
+        b: {
+          switch (domEventName) {
+            case "compositionstart":
+              var eventType = "onCompositionStart";
+              break b;
+            case "compositionend":
+              eventType = "onCompositionEnd";
+              break b;
+            case "compositionupdate":
+              eventType = "onCompositionUpdate";
+              break b;
+          }
+          eventType = void 0;
+        }
+      else
+        isComposing
+          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
+            (eventType = "onCompositionEnd")
+          : "keydown" === domEventName &&
+            229 === nativeEvent.keyCode &&
+            (eventType = "onCompositionStart");
+      eventType &&
+        (useFallbackCompositionData &&
+          "ko" !== nativeEvent.locale &&
+          (isComposing || "onCompositionStart" !== eventType
+            ? "onCompositionEnd" === eventType &&
+              isComposing &&
+              (fallbackData = getData())
+            : ((root = nativeEventTarget),
+              (startText = "value" in root ? root.value : root.textContent),
+              (isComposing = !0))),
+        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
+        0 < handleEventFunc.length &&
+          ((eventType = new SyntheticCompositionEvent(
+            eventType,
+            domEventName,
+            null,
+            nativeEvent,
+            nativeEventTarget
+          )),
+          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
+          fallbackData
+            ? (eventType.data = fallbackData)
+            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
+              null !== fallbackData && (eventType.data = fallbackData))));
+      if (
+        (fallbackData = canUseTextInputEvent
+          ? getNativeBeforeInputChars(domEventName, nativeEvent)
+          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+      )
+        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
+          0 < targetInst.length &&
+            ((nativeEventTarget = new SyntheticCompositionEvent(
+              "onBeforeInput",
+              "beforeinput",
               null,
-              Component,
-              renderLanes
+              nativeEvent,
+              nativeEventTarget
             )),
-        markRef$1(current, workInProgress),
-        workInProgress.child
-      );
-    case 5:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          (((Component = workInProgress.pendingProps),
-          "script" === workInProgress.type
-            ? ((init = Component.onLoad),
-              (prevState = Component.onError),
-              (Component = !(Component.async && (init || prevState))))
-            : (Component = !0),
-          Component)
-            ? ((Component = nextHydratableInstance),
-              rootOrSingletonContext &&
-                advanceToFirstAttemptableInstance(workInProgress),
-              (init = nextHydratableInstance),
-              init)
-              ? tryHydrateInstance(workInProgress, init) ||
-                (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                (nextHydratableInstance = getNextHydratable(init.nextSibling)),
-                (prevState = hydrationParentFiber),
-                rootOrSingletonContext &&
-                  advanceToFirstAttemptableInstance(workInProgress),
-                nextHydratableInstance &&
-                tryHydrateInstance(workInProgress, nextHydratableInstance)
-                  ? deleteHydratableInstance(prevState, init)
-                  : (insertNonHydratedInstance(
-                      hydrationParentFiber,
-                      workInProgress
-                    ),
-                    (isHydrating = !1),
-                    (hydrationParentFiber = workInProgress),
-                    (nextHydratableInstance = Component)))
-              : (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = Component))
-            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress))),
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (prevState = null !== current ? current.memoizedProps : null),
-        (root = init.children),
-        shouldSetTextContent(Component, init)
-          ? (root = null)
-          : null !== prevState &&
-            shouldSetTextContent(Component, prevState) &&
-            (workInProgress.flags |= 32),
-        markRef$1(current, workInProgress),
-        reconcileChildren(current, workInProgress, root, renderLanes),
-        workInProgress.child
-      );
-    case 6:
-      return (
-        null === current &&
-          isHydrating &&
-          (((renderLanes = "" !== workInProgress.pendingProps),
-          (current = nextHydratableInstance),
-          rootOrSingletonContext &&
-            renderLanes &&
-            advanceToFirstAttemptableTextInstance(),
-          (Component = nextHydratableInstance),
-          Component && renderLanes)
-            ? tryHydrateText(workInProgress, Component) ||
-              (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              (nextHydratableInstance = getNextHydratable(
-                Component.nextSibling
-              )),
-              (init = hydrationParentFiber),
-              rootOrSingletonContext &&
-                renderLanes &&
-                advanceToFirstAttemptableTextInstance(),
-              nextHydratableInstance &&
-              tryHydrateText(workInProgress, nextHydratableInstance)
-                ? deleteHydratableInstance(init, Component)
-                : (insertNonHydratedInstance(
-                    hydrationParentFiber,
-                    workInProgress
-                  ),
-                  (isHydrating = !1),
-                  (hydrationParentFiber = workInProgress),
-                  (nextHydratableInstance = current)))
-            : (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress),
-              (nextHydratableInstance = current))),
-        null
-      );
-    case 13:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
-    case 4:
-      return (
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
-        ),
-        (Component = workInProgress.pendingProps),
-        null === current
-          ? (workInProgress.child = reconcileChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            ))
-          : reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 11:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateForwardRef(current, workInProgress, Component, init, renderLanes)
-      );
-    case 7:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 8:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 12:
-      return (
-        (workInProgress.flags |= 4),
-        (Component = workInProgress.stateNode),
-        (Component.effectDuration = 0),
-        (Component.passiveEffectDuration = 0),
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 10:
-      a: {
-        Component = workInProgress.type._context;
-        init = workInProgress.pendingProps;
-        prevState = workInProgress.memoizedProps;
-        root = init.value;
-        pushProvider(workInProgress, Component, root);
-        if (!enableLazyContextPropagation && null !== prevState)
-          if (objectIs(prevState.value, root)) {
-            if (prevState.children === init.children) {
-              workInProgress = bailoutOnAlreadyFinishedWork(
-                current,
-                workInProgress,
-                renderLanes
+            dispatchQueue.push({
+              event: nativeEventTarget,
+              listeners: targetInst
+            }),
+            (nativeEventTarget.data = fallbackData));
+    }
+    processDispatchQueue(dispatchQueue, eventSystemFlags);
+  });
+}
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  reactName = inCapturePhase
+    ? null !== reactName
+      ? reactName + "Capture"
+      : null
+    : reactName;
+  for (
+    var listeners = [], instance = targetFiber, lastHostComponent = null;
+    null !== instance;
+
+  ) {
+    var _instance = instance;
+    targetFiber = _instance.stateNode;
+    _instance = _instance.tag;
+    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
+    null === targetFiber
+      ? 21 === _instance &&
+        null !== lastHostComponent &&
+        null !== targetFiber &&
+        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
               );
-              break a;
-            }
-          } else propagateContextChange(workInProgress, Component, renderLanes);
-        reconcileChildren(current, workInProgress, init.children, renderLanes);
-        workInProgress = workInProgress.child;
-      }
-      return workInProgress;
-    case 9:
-      return (
-        (init = workInProgress.type),
-        (Component = workInProgress.pendingProps.children),
-        prepareToReadContext(workInProgress, renderLanes),
-        (init = readContext(init)),
-        enableSchedulingProfiler && markComponentRenderStarted(workInProgress),
-        (Component = Component(init)),
-        enableSchedulingProfiler && markComponentRenderStopped(),
-        (workInProgress.flags |= 1),
-        reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 14:
-      return (
-        (Component = workInProgress.type),
-        (init = resolveDefaultProps(Component, workInProgress.pendingProps)),
-        (init = resolveDefaultProps(Component.type, init)),
-        updateMemoComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 15:
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
-      );
-    case 17:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-        (workInProgress.tag = 1),
-        prepareToReadContext(workInProgress, renderLanes),
-        constructClassInstance(workInProgress, Component, init),
-        mountClassInstance(workInProgress, Component, init, renderLanes),
-        finishClassComponent(
-          null,
-          workInProgress,
-          Component,
-          !0,
-          !1,
-          renderLanes
-        )
-      );
-    case 19:
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    case 21:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 22:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 23:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 24:
-      return (
-        prepareToReadContext(workInProgress, renderLanes),
-        (Component = readContext(CacheContext)),
-        null === current
-          ? ((init = peekCacheFromPool()),
-            null === init &&
-              ((init = workInProgressRoot),
-              (prevState = createCache()),
-              (init.pooledCache = prevState),
-              prevState.refCount++,
-              null !== prevState && (init.pooledCacheLanes |= renderLanes),
-              (init = prevState)),
-            (workInProgress.memoizedState = { parent: Component, cache: init }),
-            initializeUpdateQueue(workInProgress),
-            pushProvider(workInProgress, CacheContext, init))
-          : (0 !== (current.lanes & renderLanes) &&
-              (cloneUpdateQueue(current, workInProgress),
-              processUpdateQueue(workInProgress, null, null, renderLanes)),
-            (init = current.memoizedState),
-            (prevState = workInProgress.memoizedState),
-            init.parent !== Component
-              ? ((init = { parent: Component, cache: Component }),
-                (workInProgress.memoizedState = init),
-                0 === workInProgress.lanes &&
-                  (workInProgress.memoizedState =
-                    workInProgress.updateQueue.baseState =
-                      init),
-                pushProvider(workInProgress, CacheContext, Component))
-              : ((Component = prevState.cache),
-                pushProvider(workInProgress, CacheContext, Component),
-                Component !== init.cache &&
-                  propagateContextChange(
-                    workInProgress,
-                    CacheContext,
-                    renderLanes
-                  ))),
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
+          }))
+      : ((lastHostComponent = targetFiber),
+        (targetFiber =
+          lastHostComponent[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }),
+        null !== reactName &&
+          ((targetFiber = getListener(instance, reactName)),
+          null != targetFiber &&
+            listeners.push(
+              createDispatchListener(instance, targetFiber, lastHostComponent)
+            )));
+    if (accumulateTargetOnly) break;
+    "beforeblur" === nativeEvent.type &&
+      ((targetFiber = nativeEvent._detachedInterceptFiber),
+      null === targetFiber ||
+        (targetFiber !== instance && targetFiber !== instance.alternate) ||
+        (listeners = []));
+    instance = instance.return;
+  }
+  return listeners;
+}
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  for (
+    var captureName = reactName + "Capture", listeners = [];
+    null !== targetFiber;
+
+  ) {
+    var _instance2 = targetFiber,
+      stateNode = _instance2.stateNode;
+    _instance2 = _instance2.tag;
+    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
+      null === stateNode ||
+      ((_instance2 = getListener(targetFiber, captureName)),
+      null != _instance2 &&
+        listeners.unshift(
+          createDispatchListener(targetFiber, _instance2, stateNode)
         ),
-        workInProgress.child
-      );
-    case 25:
-      if (enableTransitionTracing)
-        return (
-          enableTransitionTracing
-            ? (null === current &&
-                ((Component = enableTransitionTracing
-                  ? transitionStack.current
-                  : null),
-                null !== Component &&
-                  ((Component = {
-                    tag: 1,
-                    transitions: new Set(Component),
-                    pendingBoundaries: null,
-                    name: workInProgress.pendingProps.name,
-                    aborts: null
-                  }),
-                  (workInProgress.stateNode = Component),
-                  (workInProgress.flags |= 2048))),
-              (Component = workInProgress.stateNode),
-              null !== Component &&
-                pushMarkerInstance(workInProgress, Component),
-              reconcileChildren(
-                current,
-                workInProgress,
-                workInProgress.pendingProps.children,
-                renderLanes
-              ),
-              (workInProgress = workInProgress.child))
-            : (workInProgress = null),
-          workInProgress
+      (_instance2 = getListener(targetFiber, reactName)),
+      null != _instance2 &&
+        listeners.push(
+          createDispatchListener(targetFiber, _instance2, stateNode)
+        ));
+    targetFiber = targetFiber.return;
+  }
+  return listeners;
+}
+function getParent(inst) {
+  if (null === inst) return null;
+  do inst = inst.return;
+  while (inst && 5 !== inst.tag && 27 !== inst.tag);
+  return inst ? inst : null;
+}
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
+) {
+  for (
+    var registrationName = event._reactName, listeners = [];
+    null !== target && target !== common;
+
+  ) {
+    var _instance3 = target,
+      alternate = _instance3.alternate,
+      stateNode = _instance3.stateNode;
+    _instance3 = _instance3.tag;
+    if (null !== alternate && alternate === common) break;
+    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
+      null === stateNode ||
+      ((alternate = stateNode),
+      inCapturePhase
+        ? ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.unshift(
+              createDispatchListener(target, stateNode, alternate)
+            ))
+        : inCapturePhase ||
+          ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.push(
+              createDispatchListener(target, stateNode, alternate)
+            )));
+    target = target.return;
+  }
+  0 !== listeners.length &&
+    dispatchQueue.push({ event: event, listeners: listeners });
+}
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
+) {
+  var listeners = [],
+    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
+  null !== eventListeners &&
+    eventListeners.forEach(function (entry) {
+      entry.type === reactEventType &&
+        entry.capture === inCapturePhase &&
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
         );
-  }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
-};
-function restorePendingUpdaters(root, lanes) {
-  isDevToolsPresent &&
-    root.memoizedUpdaters.forEach(function (schedulingFiber) {
-      addFiberToLanesMap(root, schedulingFiber, lanes);
     });
+  return listeners;
 }
-function scheduleCallback(priorityLevel, callback) {
-  return scheduleCallback$2(priorityLevel, callback);
+var NORMALIZE_NEWLINES_REGEX = /\r\n?/g,
+  NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+function normalizeMarkupForTextOrAttribute(markup) {
+  return ("string" === typeof markup ? markup : "" + markup)
+    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
+    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
 }
-function FiberNode(tag, pendingProps, key, mode) {
-  this.tag = tag;
-  this.key = key;
-  this.sibling =
-    this.child =
-    this.return =
-    this.stateNode =
-    this.type =
-    this.elementType =
-      null;
-  this.index = 0;
-  this.refCleanup = this.ref = null;
-  this.pendingProps = pendingProps;
-  this.dependencies =
-    this.memoizedState =
-    this.updateQueue =
-    this.memoizedProps =
-      null;
-  this.mode = mode;
-  this.subtreeFlags = this.flags = 0;
-  this.deletions = null;
-  this.childLanes = this.lanes = 0;
-  this.alternate = null;
-  this.actualDuration = 0;
-  this.actualStartTime = -1;
-  this.treeBaseDuration = this.selfBaseDuration = 0;
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return 9 === rootContainerElement.nodeType
+    ? rootContainerElement
+    : rootContainerElement.ownerDocument;
+}
+function noop() {}
+function createHTMLElement(type, props, ownerDocument) {
+  return "string" === typeof props.is
+    ? ownerDocument.createElement(type, { is: props.is })
+    : ownerDocument.createElement(type);
+}
+function setInitialProperties(domElement, tag, rawProps) {
+  var isCustomComponentTag = isCustomComponent(tag, rawProps);
+  switch (tag) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", domElement);
+      listenToNonDelegatedEvent("close", domElement);
+      var props = rawProps;
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
+    case "video":
+    case "audio":
+      for (props = 0; props < mediaEventTypes.length; props++)
+        listenToNonDelegatedEvent(mediaEventTypes[props], domElement);
+      props = rawProps;
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", domElement);
+      props = rawProps;
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", domElement);
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", domElement);
+      props = rawProps;
+      break;
+    case "input":
+      initWrapperState$2(domElement, rawProps);
+      props = getHostProps$2(domElement, rawProps);
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    case "option":
+      props = rawProps;
+      break;
+    case "select":
+      domElement._wrapperState = { wasMultiple: !!rawProps.multiple };
+      props = assign({}, rawProps, { value: void 0 });
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    case "textarea":
+      initWrapperState(domElement, rawProps);
+      props = getHostProps(domElement, rawProps);
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    default:
+      props = rawProps;
+  }
+  assertValidProps(tag, props);
+  var nextProps = props,
+    propKey;
+  for (propKey in nextProps)
+    if (nextProps.hasOwnProperty(propKey)) {
+      var nextProp = nextProps[propKey];
+      "style" === propKey
+        ? setValueForStyles(domElement, nextProp)
+        : "dangerouslySetInnerHTML" === propKey
+        ? ((nextProp = nextProp ? nextProp.__html : void 0),
+          null != nextProp &&
+            (disableIEWorkarounds
+              ? (domElement.innerHTML = nextProp)
+              : setInnerHTML$1(domElement, nextProp)))
+        : "children" === propKey
+        ? "string" === typeof nextProp
+          ? "body" === tag ||
+            ("textarea" === tag && "" === nextProp) ||
+            setTextContent(domElement, nextProp)
+          : "number" === typeof nextProp &&
+            "body" !== tag &&
+            setTextContent(domElement, "" + nextProp)
+        : "suppressContentEditableWarning" !== propKey &&
+          "suppressHydrationWarning" !== propKey &&
+          "autoFocus" !== propKey &&
+          (registrationNameDependencies.hasOwnProperty(propKey)
+            ? null != nextProp &&
+              "onScroll" === propKey &&
+              listenToNonDelegatedEvent("scroll", domElement)
+            : null != nextProp &&
+              setValueForProperty(
+                domElement,
+                propKey,
+                nextProp,
+                isCustomComponentTag
+              ));
+    }
+  switch (tag) {
+    case "input":
+      track(domElement);
+      postMountWrapper$3(domElement, rawProps, !1);
+      break;
+    case "textarea":
+      track(domElement);
+      postMountWrapper(domElement);
+      break;
+    case "option":
+      null != rawProps.value &&
+        domElement.setAttribute("value", "" + getToStringValue(rawProps.value));
+      break;
+    case "select":
+      domElement.multiple = !!rawProps.multiple;
+      tag = rawProps.value;
+      null != tag
+        ? updateOptions(domElement, !!rawProps.multiple, tag, !1)
+        : null != rawProps.defaultValue &&
+          updateOptions(
+            domElement,
+            !!rawProps.multiple,
+            rawProps.defaultValue,
+            !0
+          );
+      break;
+    default:
+      "function" === typeof props.onClick && (domElement.onclick = noop);
+  }
+}
+function updateProperties(
+  domElement,
+  updatePayload,
+  tag,
+  lastRawProps,
+  nextRawProps
+) {
+  "input" === tag &&
+    "radio" === nextRawProps.type &&
+    null != nextRawProps.name &&
+    updateChecked(domElement, nextRawProps);
+  isCustomComponent(tag, lastRawProps);
+  lastRawProps = isCustomComponent(tag, nextRawProps);
+  for (var i = 0; i < updatePayload.length; i += 2) {
+    var propKey = updatePayload[i],
+      propValue = updatePayload[i + 1];
+    "style" === propKey
+      ? setValueForStyles(domElement, propValue)
+      : "dangerouslySetInnerHTML" === propKey
+      ? disableIEWorkarounds
+        ? (domElement.innerHTML = propValue)
+        : setInnerHTML$1(domElement, propValue)
+      : "children" === propKey
+      ? setTextContent(domElement, propValue)
+      : setValueForProperty(domElement, propKey, propValue, lastRawProps);
+  }
+  switch (tag) {
+    case "input":
+      updateWrapper$1(domElement, nextRawProps);
+      break;
+    case "textarea":
+      updateWrapper(domElement, nextRawProps);
+      break;
+    case "select":
+      (updatePayload = domElement._wrapperState.wasMultiple),
+        (domElement._wrapperState.wasMultiple = !!nextRawProps.multiple),
+        (tag = nextRawProps.value),
+        null != tag
+          ? updateOptions(domElement, !!nextRawProps.multiple, tag, !1)
+          : updatePayload !== !!nextRawProps.multiple &&
+            (null != nextRawProps.defaultValue
+              ? updateOptions(
+                  domElement,
+                  !!nextRawProps.multiple,
+                  nextRawProps.defaultValue,
+                  !0
+                )
+              : updateOptions(
+                  domElement,
+                  !!nextRawProps.multiple,
+                  nextRawProps.multiple ? [] : "",
+                  !1
+                ));
+  }
+}
+var Dispatcher$1 = Internals.Dispatcher,
+  lastCurrentDocument = null,
+  previousDispatcher = null,
+  ReactDOMClientDispatcher = {
+    prefetchDNS: prefetchDNS$1,
+    preconnect: preconnect$1,
+    preload: preload$1,
+    preinit: preinit$1
+  },
+  preloadPropsMap = new Map(),
+  preconnectsSet = new Set();
+function getHoistableRoot(container) {
+  return "function" === typeof container.getRootNode
+    ? container.getRootNode()
+    : container.ownerDocument;
+}
+function getCurrentResourceRoot() {
+  var currentContainer = rootInstanceStackCursor.current;
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+function getDocumentForPreloads() {
+  var root = getCurrentResourceRoot();
+  if (root) return root.ownerDocument || root;
+  try {
+    return lastCurrentDocument || window.document;
+  } catch (error) {
+    return null;
+  }
 }
-function createFiber(tag, pendingProps, key, mode) {
-  return new FiberNode(tag, pendingProps, key, mode);
+function preconnectAs(rel, crossOrigin, href) {
+  var ownerDocument = getDocumentForPreloads();
+  if ("string" === typeof href && href && ownerDocument) {
+    var limitedEscapedHref =
+      escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    limitedEscapedHref =
+      'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
+    "string" === typeof crossOrigin &&
+      (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
+    preconnectsSet.has(limitedEscapedHref) ||
+      (preconnectsSet.add(limitedEscapedHref),
+      (rel = { rel: rel, crossOrigin: crossOrigin, href: href }),
+      null === ownerDocument.querySelector(limitedEscapedHref) &&
+        ((crossOrigin = ownerDocument.createElement("link")),
+        setInitialProperties(crossOrigin, "link", rel),
+        markNodeAsHoistable(crossOrigin),
+        ownerDocument.head.appendChild(crossOrigin)));
+  }
 }
-function shouldConstruct(Component) {
-  Component = Component.prototype;
-  return !(!Component || !Component.isReactComponent);
+function prefetchDNS$1(href) {
+  preconnectAs("dns-prefetch", null, href);
 }
-function resolveLazyComponentTag(Component) {
-  if ("function" === typeof Component)
-    return shouldConstruct(Component) ? 1 : 0;
-  if (void 0 !== Component && null !== Component) {
-    Component = Component.$$typeof;
-    if (Component === REACT_FORWARD_REF_TYPE) return 11;
-    if (Component === REACT_MEMO_TYPE) return 14;
+function preconnect$1(href, options) {
+  preconnectAs(
+    "preconnect",
+    null == options || "string" !== typeof options.crossOrigin
+      ? null
+      : "use-credentials" === options.crossOrigin
+      ? "use-credentials"
+      : "",
+    href
+  );
+}
+function preload$1(href, options) {
+  var ownerDocument = getDocumentForPreloads();
+  if (
+    "string" === typeof href &&
+    href &&
+    "object" === typeof options &&
+    null !== options &&
+    ownerDocument
+  ) {
+    var as = options.as,
+      limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href),
+      key = (limitedEscapedHref =
+        'link[rel="preload"][as="' +
+        as +
+        '"][href="' +
+        limitedEscapedHref +
+        '"]');
+    switch (as) {
+      case "style":
+        key = getStyleKey(href);
+        break;
+      case "script":
+        key = getScriptKey(href);
+    }
+    preloadPropsMap.has(key) ||
+      ((href = {
+        href: href,
+        rel: "preload",
+        as: as,
+        crossOrigin: "font" === as ? "" : options.crossOrigin,
+        integrity: options.integrity,
+        type: options.type
+      }),
+      preloadPropsMap.set(key, href),
+      null === ownerDocument.querySelector(limitedEscapedHref) &&
+        ((options = ownerDocument.createElement("link")),
+        setInitialProperties(options, "link", href),
+        markNodeAsHoistable(options),
+        ownerDocument.head.appendChild(options)));
   }
-  return 2;
 }
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
-  null === workInProgress
-    ? ((workInProgress = createFiber(
-        current.tag,
-        pendingProps,
-        current.key,
-        current.mode
-      )),
-      (workInProgress.elementType = current.elementType),
-      (workInProgress.type = current.type),
-      (workInProgress.stateNode = current.stateNode),
-      (workInProgress.alternate = current),
-      (current.alternate = workInProgress))
-    : ((workInProgress.pendingProps = pendingProps),
-      (workInProgress.type = current.type),
-      (workInProgress.flags = 0),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null),
-      (workInProgress.actualDuration = 0),
-      (workInProgress.actualStartTime = -1));
-  workInProgress.flags = current.flags & 14680064;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue;
-  pendingProps = current.dependencies;
-  workInProgress.dependencies =
-    null === pendingProps
-      ? null
-      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
-  workInProgress.selfBaseDuration = current.selfBaseDuration;
-  workInProgress.treeBaseDuration = current.treeBaseDuration;
-  return workInProgress;
+function preinit$1(href, options) {
+  if (
+    "string" === typeof href &&
+    href &&
+    "object" === typeof options &&
+    null !== options
+  ) {
+    var resourceRoot = getCurrentResourceRoot(),
+      as = options.as;
+    if (resourceRoot)
+      switch (as) {
+        case "style":
+          as = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          var key$217 = getStyleKey(href),
+            precedence = options.precedence || "default",
+            resource = as.get(key$217);
+          if (resource) break;
+          resource = resourceRoot.querySelector(
+            getStylesheetSelectorFromKey(key$217)
+          );
+          resource ||
+            ((href = {
+              rel: "stylesheet",
+              href: href,
+              "data-precedence": precedence,
+              crossOrigin: options.crossOrigin
+            }),
+            (options = preloadPropsMap.get(key$217)) &&
+              adoptPreloadPropsForStylesheet(href, options),
+            (resource = (
+              resourceRoot.ownerDocument || resourceRoot
+            ).createElement("link")),
+            markNodeAsHoistable(resource),
+            setInitialProperties(resource, "link", href),
+            insertStylesheet(resource, precedence, resourceRoot));
+          resource = { type: "stylesheet", instance: resource, count: 1 };
+          as.set(key$217, resource);
+          break;
+        case "script":
+          (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
+            (key$217 = getScriptKey(href)),
+            (precedence = as.get(key$217)),
+            precedence ||
+              ((precedence = resourceRoot.querySelector(
+                "script[async]" + key$217
+              )),
+              precedence ||
+                ((href = {
+                  src: href,
+                  async: !0,
+                  crossOrigin: options.crossOrigin,
+                  integrity: options.integrity
+                }),
+                (options = preloadPropsMap.get(key$217)) &&
+                  adoptPreloadPropsForScript(href, options),
+                (options = resourceRoot.ownerDocument || resourceRoot),
+                (precedence = options.createElement("script")),
+                markNodeAsHoistable(precedence),
+                setInitialProperties(precedence, "link", href),
+                options.head.appendChild(precedence)),
+              (precedence = { type: "script", instance: precedence, count: 1 }),
+              as.set(key$217, precedence));
+      }
+    else if ("style" === as || "script" === as)
+      if ((resourceRoot = getDocumentForPreloads())) {
+        key$217 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+        precedence = key$217 =
+          'link[rel="preload"][as="' + as + '"][href="' + key$217 + '"]';
+        switch (as) {
+          case "style":
+            precedence = getStyleKey(href);
+            break;
+          case "script":
+            precedence = getScriptKey(href);
+        }
+        preloadPropsMap.has(precedence) ||
+          ((href = {
+            href: href,
+            rel: "preload",
+            as: as,
+            crossOrigin: "font" === as ? "" : options.crossOrigin,
+            integrity: options.integrity
+          }),
+          preloadPropsMap.set(precedence, href),
+          null === resourceRoot.querySelector(key$217) &&
+            ((options = resourceRoot.createElement("link")),
+            setInitialProperties(options, "link", href),
+            markNodeAsHoistable(options),
+            resourceRoot.head.appendChild(options)));
+      }
+  }
 }
-function resetWorkInProgress(workInProgress, renderLanes) {
-  workInProgress.flags &= 14680066;
-  var current = workInProgress.alternate;
-  null === current
-    ? ((workInProgress.childLanes = 0),
-      (workInProgress.lanes = renderLanes),
-      (workInProgress.child = null),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.memoizedProps = null),
-      (workInProgress.memoizedState = null),
-      (workInProgress.updateQueue = null),
-      (workInProgress.dependencies = null),
-      (workInProgress.stateNode = null),
-      (workInProgress.selfBaseDuration = 0),
-      (workInProgress.treeBaseDuration = 0))
-    : ((workInProgress.childLanes = current.childLanes),
-      (workInProgress.lanes = current.lanes),
-      (workInProgress.child = current.child),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null),
-      (workInProgress.memoizedProps = current.memoizedProps),
-      (workInProgress.memoizedState = current.memoizedState),
-      (workInProgress.updateQueue = current.updateQueue),
-      (workInProgress.type = current.type),
-      (renderLanes = current.dependencies),
-      (workInProgress.dependencies =
-        null === renderLanes
-          ? null
-          : {
-              lanes: renderLanes.lanes,
-              firstContext: renderLanes.firstContext
+function getResource(type, currentProps, pendingProps) {
+  currentProps = getCurrentResourceRoot();
+  if (!currentProps) throw Error(formatProdErrorMessage(446));
+  switch (type) {
+    case "meta":
+    case "title":
+      return null;
+    case "style":
+      return "string" === typeof pendingProps.precedence &&
+        "string" === typeof pendingProps.href
+        ? ((pendingProps = getStyleKey(pendingProps.href)),
+          (currentProps = getResourcesFromRoot(currentProps).hoistableStyles),
+          (type = currentProps.get(pendingProps)),
+          type ||
+            ((type = { type: "style", instance: null, count: 0 }),
+            currentProps.set(pendingProps, type)),
+          type)
+        : { type: "void", instance: null, count: 0 };
+    case "link":
+      if (
+        "stylesheet" === pendingProps.rel &&
+        "string" === typeof pendingProps.href &&
+        "string" === typeof pendingProps.precedence
+      ) {
+        var key$224 = getStyleKey(pendingProps.href),
+          styles$225 = getResourcesFromRoot(currentProps).hoistableStyles;
+        type = styles$225.get(key$224);
+        type ||
+          ((currentProps = currentProps.ownerDocument || currentProps),
+          (type = { type: "stylesheet", instance: null, count: 0 }),
+          styles$225.set(key$224, type),
+          preloadPropsMap.has(key$224) ||
+            ((pendingProps = {
+              rel: "preload",
+              as: "style",
+              href: pendingProps.href,
+              crossOrigin: pendingProps.crossOrigin,
+              integrity: pendingProps.integrity,
+              media: pendingProps.media,
+              hrefLang: pendingProps.hrefLang,
+              referrerPolicy: pendingProps.referrerPolicy
             }),
-      (workInProgress.selfBaseDuration = current.selfBaseDuration),
-      (workInProgress.treeBaseDuration = current.treeBaseDuration));
-  return workInProgress;
+            preloadPropsMap.set(key$224, pendingProps),
+            currentProps.querySelector(getStylesheetSelectorFromKey(key$224)) ||
+              null !==
+                currentProps.querySelector(
+                  'link[rel="preload"][as="style"][' + key$224 + "]"
+                ) ||
+              ((key$224 = currentProps.createElement("link")),
+              setInitialProperties(key$224, "link", pendingProps),
+              markNodeAsHoistable(key$224),
+              currentProps.head.appendChild(key$224))));
+        return type;
+      }
+      return null;
+    case "script":
+      return "string" === typeof pendingProps.src && !0 === pendingProps.async
+        ? ((pendingProps = getScriptKey(pendingProps.src)),
+          (currentProps = getResourcesFromRoot(currentProps).hoistableScripts),
+          (type = currentProps.get(pendingProps)),
+          type ||
+            ((type = { type: "script", instance: null, count: 0 }),
+            currentProps.set(pendingProps, type)),
+          type)
+        : { type: "void", instance: null, count: 0 };
+    default:
+      throw Error(formatProdErrorMessage(444, type));
+  }
 }
-function createFiberFromTypeAndProps(
-  type,
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = 2;
-  owner = type;
-  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
-  else if ("string" === typeof type)
-    fiberTag = isHostHoistableType(
-      type,
-      pendingProps,
-      contextStackCursor.current
-    )
-      ? 26
-      : "html" === type || "head" === type || "body" === type
-      ? 27
-      : 5;
-  else
-    a: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = 8;
-        mode |= 8;
-        0 !== (mode & 1) && (mode |= 16);
-        break;
-      case REACT_PROFILER_TYPE:
-        return (
-          (type = createFiber(12, pendingProps, key, mode | 2)),
-          (type.elementType = REACT_PROFILER_TYPE),
-          (type.lanes = lanes),
-          (type.stateNode = { effectDuration: 0, passiveEffectDuration: 0 }),
-          type
-        );
-      case REACT_SUSPENSE_TYPE:
-        return (
-          (type = createFiber(13, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_LIST_TYPE:
-        return (
-          (type = createFiber(19, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
-      case REACT_LEGACY_HIDDEN_TYPE:
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      case REACT_SCOPE_TYPE:
-        return (
-          (pendingProps = createFiber(21, pendingProps, key, mode)),
-          (pendingProps.type = type),
-          (pendingProps.elementType = type),
-          (pendingProps.lanes = lanes),
-          pendingProps
+function getStyleKey(href) {
+  return 'href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
+}
+function getStylesheetSelectorFromKey(key) {
+  return 'link[rel="stylesheet"][' + key + "]";
+}
+function getScriptKey(src) {
+  return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
+}
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+  if (null === resource.instance)
+    switch (resource.type) {
+      case "style":
+        var key = getStyleKey(props.href);
+        if ((key = hoistableRoot.querySelector("style[data-" + key + "]")))
+          return (resource.instance = key), markNodeAsHoistable(key), key;
+        var styleProps = assign({}, props, {
+          "data-href": props.href,
+          "data-precedence": props.precedence,
+          href: null,
+          precedence: null
+        });
+        key = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
+          "style"
         );
-      case REACT_CACHE_TYPE:
-        return (
-          (type = createFiber(24, pendingProps, key, mode)),
-          (type.elementType = REACT_CACHE_TYPE),
-          (type.lanes = lanes),
-          type
+        markNodeAsHoistable(key);
+        setInitialProperties(key, "style", styleProps);
+        insertStylesheet(key, props.precedence, hoistableRoot);
+        return (resource.instance = key);
+      case "stylesheet":
+        styleProps = getStyleKey(props.href);
+        var instance$231 = hoistableRoot.querySelector(
+          getStylesheetSelectorFromKey(styleProps)
         );
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing)
+        if (instance$231)
           return (
-            (type = createFiber(25, pendingProps, key, mode)),
-            (type.elementType = REACT_TRACING_MARKER_TYPE),
-            (type.lanes = lanes),
-            (type.stateNode = {
-              tag: 1,
-              transitions: null,
-              pendingBoundaries: null,
-              aborts: null,
-              name: pendingProps.name
-            }),
-            type
+            (resource.instance = instance$231),
+            markNodeAsHoistable(instance$231),
+            instance$231
           );
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = 8;
-          mode |= 4;
-          break;
-        }
-      default:
-        if ("object" === typeof type && null !== type)
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = 10;
-              break a;
-            case REACT_CONTEXT_TYPE:
-              fiberTag = 9;
-              break a;
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = 11;
-              break a;
-            case REACT_MEMO_TYPE:
-              fiberTag = 14;
-              break a;
-            case REACT_LAZY_TYPE:
-              fiberTag = 16;
-              owner = null;
-              break a;
+        key = assign({}, props, {
+          "data-precedence": props.precedence,
+          precedence: null
+        });
+        (styleProps = preloadPropsMap.get(styleProps)) &&
+          adoptPreloadPropsForStylesheet(key, styleProps);
+        instance$231 = (
+          hoistableRoot.ownerDocument || hoistableRoot
+        ).createElement("link");
+        markNodeAsHoistable(instance$231);
+        var linkInstance = instance$231;
+        linkInstance._p = new Promise(function (resolve, reject) {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        }).then(
+          function () {
+            return (linkInstance._p.s = "l");
+          },
+          function () {
+            return (linkInstance._p.s = "e");
           }
-        throw Error(
-          formatProdErrorMessage(130, null == type ? type : typeof type, "")
         );
+        setInitialProperties(instance$231, "link", key);
+        insertStylesheet(instance$231, props.precedence, hoistableRoot);
+        return (resource.instance = instance$231);
+      case "script":
+        instance$231 = getScriptKey(props.src);
+        if (
+          (styleProps = hoistableRoot.querySelector(
+            "script[async]" + instance$231
+          ))
+        )
+          return (
+            (resource.instance = styleProps),
+            markNodeAsHoistable(styleProps),
+            styleProps
+          );
+        key = props;
+        if ((styleProps = preloadPropsMap.get(instance$231)))
+          (key = assign({}, props)),
+            adoptPreloadPropsForScript(key, styleProps);
+        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+        styleProps = hoistableRoot.createElement("script");
+        markNodeAsHoistable(styleProps);
+        setInitialProperties(styleProps, "link", key);
+        hoistableRoot.head.appendChild(styleProps);
+        return (resource.instance = styleProps);
+      case "void":
+        return null;
+      default:
+        throw Error(formatProdErrorMessage(443, resource.type));
     }
-  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
-  pendingProps.elementType = type;
-  pendingProps.type = owner;
-  pendingProps.lanes = lanes;
-  return pendingProps;
+  return resource.instance;
 }
-function createFiberFromFragment(elements, mode, lanes, key) {
-  elements = createFiber(7, elements, key, mode);
-  elements.lanes = lanes;
-  return elements;
+function insertStylesheet(instance, precedence, root) {
+  for (
+    var nodes = root.querySelectorAll(
+        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
+      ),
+      last = nodes.length ? nodes[nodes.length - 1] : null,
+      prior = last,
+      i = 0;
+    i < nodes.length;
+    i++
+  ) {
+    var node = nodes[i];
+    if (node.dataset.precedence === precedence) prior = node;
+    else if (prior !== last) break;
+  }
+  prior
+    ? prior.parentNode.insertBefore(instance, prior.nextSibling)
+    : ((precedence = 9 === root.nodeType ? root.head : root),
+      precedence.insertBefore(instance, precedence.firstChild));
+}
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  null == stylesheetProps.crossOrigin &&
+    (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
+  null == stylesheetProps.referrerPolicy &&
+    (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
+  null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
+}
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  null == scriptProps.crossOrigin &&
+    (scriptProps.crossOrigin = preloadProps.crossOrigin);
+  null == scriptProps.referrerPolicy &&
+    (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
+  null == scriptProps.integrity &&
+    (scriptProps.referrerPolicy = preloadProps.integrity);
 }
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(22, pendingProps, key, mode);
-  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
-  pendingProps.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
+var tagCaches = null;
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  if (null === tagCaches) {
+    var cache = new Map();
+    var caches = (tagCaches = new Map());
+    caches.set(ownerDocument, cache);
+  } else
+    (caches = tagCaches),
+      (cache = caches.get(ownerDocument)),
+      cache || ((cache = new Map()), caches.set(ownerDocument, cache));
+  if (cache.has(type)) return cache;
+  cache.set(type, null);
+  ownerDocument = ownerDocument.getElementsByTagName(type);
+  for (caches = 0; caches < ownerDocument.length; caches++) {
+    var node = ownerDocument[caches];
+    if (
+      !(
+        node[internalHoistableMarker] ||
+        node[internalInstanceKey] ||
+        ("link" === type && "stylesheet" === node.getAttribute("rel"))
+      ) &&
+      "http://www.w3.org/2000/svg" !== node.namespaceURI
+    ) {
+      var nodeKey = node.getAttribute(keyAttribute) || "";
+      nodeKey = type + nodeKey;
+      var existing = cache.get(nodeKey);
+      existing ? existing.push(node) : cache.set(nodeKey, [node]);
     }
-  };
-  pendingProps.stateNode = primaryChildInstance;
-  return pendingProps;
+  }
+  return cache;
 }
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(23, pendingProps, key, mode);
-  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  pendingProps.lanes = lanes;
-  var instance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
+function mountHoistable(hoistableRoot, type, instance) {
+  hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+  hoistableRoot.head.insertBefore(
+    instance,
+    "title" === type ? hoistableRoot.querySelector("head > title") : null
+  );
+}
+var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(
+    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
+    function (ch) {
+      return "\\" + ch.charCodeAt(0).toString(16);
     }
-  };
-  pendingProps.stateNode = instance;
-  return pendingProps;
+  );
 }
-function createFiberFromText(content, mode, lanes) {
-  content = createFiber(6, content, null, mode);
-  content.lanes = lanes;
-  return content;
+var eventsEnabled = null,
+  selectionInformation = null;
+function beforeActiveInstanceBlur(internalInstanceHandle) {
+  _enabled = !0;
+  var target = selectionInformation.focusedElem,
+    event = createEvent("beforeblur", !0);
+  event._detachedInterceptFiber = internalInstanceHandle;
+  target.dispatchEvent(event);
+  _enabled = !1;
 }
-function createFiberFromPortal(portal, mode, lanes) {
-  mode = createFiber(
-    4,
-    null !== portal.children ? portal.children : [],
-    portal.key,
-    mode
+function shouldSetTextContent(type, props) {
+  return (
+    "textarea" === type ||
+    "noscript" === type ||
+    "string" === typeof props.children ||
+    "number" === typeof props.children ||
+    ("object" === typeof props.dangerouslySetInnerHTML &&
+      null !== props.dangerouslySetInnerHTML &&
+      null != props.dangerouslySetInnerHTML.__html)
   );
-  mode.lanes = lanes;
-  mode.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    implementation: portal.implementation
-  };
-  return mode;
 }
-function FiberRootNode(
-  containerInfo,
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
-) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.finishedWork =
-    this.pingCache =
-    this.current =
-    this.pendingChildren =
-      null;
-  this.timeoutHandle = -1;
-  this.callbackNode = this.pendingContext = this.context = null;
-  this.callbackPriority = 0;
-  this.eventTimes = createLaneMap(0);
-  this.expirationTimes = createLaneMap(-1);
-  this.entangledLanes =
-    this.errorRecoveryDisabledLanes =
-    this.finishedLanes =
-    this.mutableReadLanes =
-    this.expiredLanes =
-    this.pingedLanes =
-    this.suspendedLanes =
-    this.pendingLanes =
-      0;
-  this.entanglements = createLaneMap(0);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
-  this.pooledCache = null;
-  this.pooledCacheLanes = 0;
-  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
-  this.incompleteTransitions = new Map();
-  if (enableTransitionTracing)
-    for (
-      this.transitionCallbacks = null,
-        containerInfo = this.transitionLanes = [],
-        tag = 0;
-      31 > tag;
-      tag++
-    )
-      containerInfo.push(null);
-  this.passiveEffectDuration = this.effectDuration = 0;
-  this.memoizedUpdaters = new Set();
-  containerInfo = this.pendingUpdatersLaneMap = [];
-  for (tag = 0; 31 > tag; tag++) containerInfo.push(new Set());
+var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
+  cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
+  localPromise = "function" === typeof Promise ? Promise : void 0,
+  localRequestAnimationFrame =
+    "function" === typeof requestAnimationFrame
+      ? requestAnimationFrame
+      : scheduleTimeout;
+function getInstanceFromScope(scopeInstance) {
+  scopeInstance = scopeInstance[internalInstanceKey] || null;
+  return scopeInstance;
 }
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
-) {
-  containerInfo = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
-  );
-  containerInfo.hydrationCallbacks = hydrationCallbacks;
-  enableTransitionTracing &&
-    (containerInfo.transitionCallbacks = transitionCallbacks);
-  1 === tag
-    ? ((tag = 1),
-      !0 === isStrictMode && (tag |= 24),
-      concurrentUpdatesByDefaultOverride && (tag |= 32))
-    : (tag = 0);
-  isDevToolsPresent && (tag |= 2);
-  isStrictMode = createFiber(3, null, null, tag);
-  containerInfo.current = isStrictMode;
-  isStrictMode.stateNode = containerInfo;
-  concurrentUpdatesByDefaultOverride = createCache();
-  concurrentUpdatesByDefaultOverride.refCount++;
-  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
-  concurrentUpdatesByDefaultOverride.refCount++;
-  isStrictMode.memoizedState = {
-    element: initialChildren,
-    isDehydrated: hydrate,
-    cache: concurrentUpdatesByDefaultOverride
-  };
-  initializeUpdateQueue(isStrictMode);
-  return containerInfo;
+var scheduleMicrotask =
+  "function" === typeof queueMicrotask
+    ? queueMicrotask
+    : "undefined" !== typeof localPromise
+    ? function (callback) {
+        return localPromise
+          .resolve(null)
+          .then(callback)
+          .catch(handleErrorInNextTick);
+      }
+    : scheduleTimeout;
+function handleErrorInNextTick(error) {
+  setTimeout(function () {
+    throw error;
+  });
 }
-function createPortal$1(children, containerInfo, implementation) {
-  var key =
-    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
-  return {
-    $$typeof: REACT_PORTAL_TYPE,
-    key: null == key ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
-  };
+function createEvent(type, bubbles) {
+  var event = document.createEvent("Event");
+  event.initEvent(type, bubbles, !1);
+  return event;
+}
+function dispatchAfterDetachedBlur(target) {
+  var event = createEvent("afterblur", !1);
+  event.relatedTarget = target;
+  document.dispatchEvent(event);
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  var node = suspenseInstance,
+    depth = 0;
+  do {
+    var nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+    if (nextNode && 8 === nextNode.nodeType)
+      if (((node = nextNode.data), "/$" === node)) {
+        if (0 === depth) {
+          parentInstance.removeChild(nextNode);
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        }
+        depth--;
+      } else ("$" !== node && "$?" !== node && "$!" !== node) || depth++;
+    node = nextNode;
+  } while (node);
+  retryIfBlockedOn(suspenseInstance);
 }
-function updateContainer(element, container, parentComponent, callback) {
-  parentComponent = container.current;
-  var lane = requestUpdateLane(parentComponent);
-  enableSchedulingProfiler &&
-    enableSchedulingProfiler &&
-    null !== injectedProfilingHooks &&
-    "function" === typeof injectedProfilingHooks.markRenderScheduled &&
-    injectedProfilingHooks.markRenderScheduled(lane);
-  null === container.context
-    ? (container.context = emptyContextObject)
-    : (container.pendingContext = emptyContextObject);
-  container = createUpdate(lane);
-  container.payload = { element: element };
-  callback = void 0 === callback ? null : callback;
-  null !== callback && (container.callback = callback);
-  element = enqueueUpdate(parentComponent, container, lane);
-  null !== element &&
-    ((callback = requestEventTime()),
-    scheduleUpdateOnFiber(element, parentComponent, lane, callback),
-    entangleTransitions(element, parentComponent, lane));
-  return lane;
+function clearContainerSparingly(container) {
+  var nextNode = container.firstChild;
+  nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
+  for (; nextNode; ) {
+    var node = nextNode;
+    nextNode = nextNode.nextSibling;
+    switch (node.nodeName) {
+      case "HTML":
+      case "HEAD":
+      case "BODY":
+        clearContainerSparingly(node);
+        detachDeletedInstance(node);
+        continue;
+      case "STYLE":
+        continue;
+      case "LINK":
+        if ("stylesheet" === node.rel.toLowerCase()) continue;
+    }
+    container.removeChild(node);
+  }
 }
-function markRetryLaneImpl(fiber, retryLane) {
-  fiber = fiber.memoizedState;
-  if (null !== fiber && null !== fiber.dehydrated) {
-    var a = fiber.retryLane;
-    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+function shouldSkipHydratableForInstance(instance, type, props) {
+  if (1 !== instance.nodeType) return !1;
+  if (
+    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
+    instance[internalHoistableMarker]
+  )
+    return !0;
+  switch (type) {
+    case "meta":
+      if (!instance.hasAttribute("itemprop")) return !0;
+      break;
+    case "link":
+      type = instance.getAttribute("rel");
+      if (
+        ("stylesheet" === type && instance.hasAttribute("data-precedence")) ||
+        type !== props.rel ||
+        instance.getAttribute("href") !==
+          (null == props.href ? null : props.href) ||
+        instance.getAttribute("crossorigin") !==
+          (null == props.crossOrigin ? null : props.crossOrigin) ||
+        instance.getAttribute("title") !==
+          (null == props.title ? null : props.title)
+      )
+        return !0;
+      break;
+    case "style":
+      if (instance.hasAttribute("data-precedence")) return !0;
+      break;
+    case "script":
+      if (
+        ((type = instance.getAttribute("src")) &&
+          instance.hasAttribute("async") &&
+          !instance.hasAttribute("itemprop")) ||
+        type !== (null == props.src ? null : props.src) ||
+        instance.getAttribute("type") !==
+          (null == props.type ? null : props.type) ||
+        instance.getAttribute("crossorigin") !==
+          (null == props.crossOrigin ? null : props.crossOrigin)
+      )
+        return !0;
   }
+  return !1;
 }
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
+function getNextHydratable(node) {
+  for (; null != node; node = node.nextSibling) {
+    var nodeType = node.nodeType;
+    if (1 === nodeType || 3 === nodeType) break;
+    if (8 === nodeType) {
+      nodeType = node.data;
+      if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType) break;
+      if ("/$" === nodeType) return null;
+    }
+  }
+  return node;
 }
-function emptyFindFiberByHostInstance() {
+function getParentSuspenseInstance(targetInstance) {
+  targetInstance = targetInstance.previousSibling;
+  for (var depth = 0; targetInstance; ) {
+    if (8 === targetInstance.nodeType) {
+      var data = targetInstance.data;
+      if ("$" === data || "$!" === data || "$?" === data) {
+        if (0 === depth) return targetInstance;
+        depth--;
+      } else "/$" === data && depth++;
+    }
+    targetInstance = targetInstance.previousSibling;
+  }
   return null;
 }
+function requestPostPaintCallback(callback) {
+  localRequestAnimationFrame(function () {
+    localRequestAnimationFrame(function (time) {
+      return callback(time);
+    });
+  });
+}
+function isHostHoistableType(type, props, hostContext) {
+  if ("http://www.w3.org/2000/svg" === hostContext || null != props.itemProp)
+    return !1;
+  switch (type) {
+    case "meta":
+    case "title":
+      return !0;
+    case "style":
+      if (
+        "string" !== typeof props.precedence ||
+        "string" !== typeof props.href ||
+        "" === props.href
+      )
+        break;
+      return !0;
+    case "link":
+      if (
+        "string" !== typeof props.rel ||
+        "string" !== typeof props.href ||
+        "" === props.href ||
+        props.onLoad ||
+        props.onError
+      )
+        break;
+      switch (props.rel) {
+        case "stylesheet":
+          return (
+            (type = props.disabled),
+            "string" === typeof props.precedence && null == type
+          );
+        default:
+          return !0;
+      }
+    case "script":
+      if (
+        !0 === props.async &&
+        !props.onLoad &&
+        !props.onError &&
+        "string" === typeof props.src &&
+        props.src
+      )
+        return !0;
+  }
+  return !1;
+}
+function resolveSingletonInstance(type, props, rootContainerInstance) {
+  props = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  switch (type) {
+    case "html":
+      type = props.documentElement;
+      if (!type) throw Error(formatProdErrorMessage(452));
+      return type;
+    case "head":
+      type = props.head;
+      if (!type) throw Error(formatProdErrorMessage(453));
+      return type;
+    case "body":
+      type = props.body;
+      if (!type) throw Error(formatProdErrorMessage(454));
+      return type;
+    default:
+      throw Error(formatProdErrorMessage(451));
+  }
+}
 var Dispatcher = Internals.Dispatcher,
   defaultOnRecoverableError =
     "function" === typeof reportError
@@ -15872,7 +15942,7 @@ function ReactDOMHydrationRoot(internalRoot) {
 }
 ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
   if (target) {
-    var updatePriority = getCurrentUpdatePriority();
+    var updatePriority = currentUpdatePriority;
     target = { blockedOn: null, target: target, priority: updatePriority };
     for (
       var i = 0;
@@ -15916,108 +15986,18 @@ function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
         listenerSet.add(listenerSetKey));
     } else throw Error(formatProdErrorMessage(369));
 }
-_attemptSynchronousHydration = function (fiber) {
-  switch (fiber.tag) {
-    case 3:
-      var root$244 = fiber.stateNode;
-      if (root$244.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$244.pendingLanes);
-        0 !== lanes &&
-          (markRootEntangled(root$244, lanes | 2),
-          ensureRootIsScheduled(root$244, now$1()),
-          0 === (executionContext & 6) &&
-            (resetRenderTimer(), flushSyncCallbacks()));
-      }
-      break;
-    case 13:
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        if (null !== root) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-        }
-      }),
-        markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptDiscreteHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptContinuousHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 134217728);
-  }
-};
-attemptHydrationAtCurrentPriority$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var lane = requestUpdateLane(fiber),
-      root = enqueueConcurrentRenderForLane(fiber, lane);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, lane);
-  }
-};
-getCurrentUpdatePriority = function () {
-  return currentUpdatePriority;
-};
-attemptHydrationAtPriority = runWithPriority;
-restoreImpl = function (domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, props);
-      tag = props.name;
-      if ("radio" === props.type && null != tag) {
-        for (props = domElement; props.parentNode; ) props = props.parentNode;
-        props = props.querySelectorAll(
-          "input[name=" + JSON.stringify("" + tag) + '][type="radio"]'
-        );
-        for (tag = 0; tag < props.length; tag++) {
-          var otherNode = props[tag];
-          if (otherNode !== domElement && otherNode.form === domElement.form) {
-            var otherProps = getFiberCurrentPropsFromNode(otherNode);
-            if (!otherProps) throw Error(formatProdErrorMessage(90));
-            updateValueIfChanged(otherNode);
-            updateWrapper$1(otherNode, otherProps);
-          }
-        }
-      }
-      break;
-    case "textarea":
-      updateWrapper(domElement, props);
-      break;
-    case "select":
-      (tag = props.value),
-        null != tag && updateOptions(domElement, !!props.multiple, tag, !1);
-  }
-};
-batchedUpdatesImpl = batchedUpdates;
-flushSyncImpl = flushSync$1;
 Internals.Events = [
   getInstanceFromNode$1,
   getNodeFromInstance,
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
-var devToolsConfig$jscomp$inline_1800 = {
+var devToolsConfig$jscomp$inline_1789 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-modern-f405ae4d",
+  version: "18.3.0-www-modern-e0363ff4",
   rendererPackageName: "react-dom"
 };
 (function (internals) {
@@ -16035,10 +16015,10 @@ var devToolsConfig$jscomp$inline_1800 = {
   } catch (err) {}
   return hook.checkDCE ? !0 : !1;
 })({
-  bundleType: devToolsConfig$jscomp$inline_1800.bundleType,
-  version: devToolsConfig$jscomp$inline_1800.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1800.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1800.rendererConfig,
+  bundleType: devToolsConfig$jscomp$inline_1789.bundleType,
+  version: devToolsConfig$jscomp$inline_1789.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1789.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1789.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -16055,14 +16035,14 @@ var devToolsConfig$jscomp$inline_1800 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1800.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1789.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-modern-f405ae4d"
+  reconcilerVersion: "18.3.0-www-modern-e0363ff4"
 });
 exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
 exports.createPortal = function (children, container) {
@@ -16187,7 +16167,7 @@ exports.preload = function () {
   var dispatcher = Internals.Dispatcher.current;
   dispatcher && dispatcher.preload.apply(this, arguments);
 };
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = function (type, options) {
   function eventHandle(target, callback) {
     if ("function" !== typeof callback)
@@ -16220,21 +16200,21 @@ exports.unstable_createEventHandle = function (type, options) {
 exports.unstable_flushControlled = function (fn) {
   var prevExecutionContext = executionContext;
   executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
     previousPriority = currentUpdatePriority;
   try {
-    (ReactCurrentBatchConfig.transition = null),
+    (ReactCurrentBatchConfig$1.transition = null),
       (currentUpdatePriority = 2),
       fn();
   } finally {
     (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
       (executionContext = prevExecutionContext),
       0 === executionContext && (resetRenderTimer(), flushSyncCallbacks());
   }
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-modern-f405ae4d";
+exports.version = "18.3.0-www-modern-e0363ff4";
 
           /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
 if (
diff --git a/compiled/facebook-www/ReactDOMTesting-dev.classic.js b/compiled/facebook-www/ReactDOMTesting-dev.classic.js
index 6ee2b90e4174e..26f5736d2c601 100644
--- a/compiled/facebook-www/ReactDOMTesting-dev.classic.js
+++ b/compiled/facebook-www/ReactDOMTesting-dev.classic.js
@@ -26,6 +26,7 @@ var dynamicFeatureFlags = require("ReactFeatureFlags");
 
 var disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   replayFailedUnitOfWorkWithInvokeGuardedCallback =
@@ -5546,7 +5547,8 @@ var canDiffStyleForHydrationWarning;
   // in that browser completely in favor of doing all that work.
   // See https://github.com/facebook/react/issues/11807
 
-  canDiffStyleForHydrationWarning = canUseDOM && !document.documentMode;
+  canDiffStyleForHydrationWarning =
+    disableIEWorkarounds || (canUseDOM && !document.documentMode);
 }
 
 function validatePropertiesInDevelopment(type, props) {
@@ -5739,7 +5741,11 @@ function setInitialDOMProperties(
       var nextHtml = nextProp ? nextProp[HTML] : undefined;
 
       if (nextHtml != null) {
-        setInnerHTML$1(domElement, nextHtml);
+        if (disableIEWorkarounds) {
+          domElement.innerHTML = nextHtml;
+        } else {
+          setInnerHTML$1(domElement, nextHtml);
+        }
       }
     } else if (propKey === CHILDREN) {
       if (typeof nextProp === "string") {
@@ -5795,7 +5801,11 @@ function updateDOMProperties(
     if (propKey === STYLE$1) {
       setValueForStyles(domElement, propValue);
     } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      setInnerHTML$1(domElement, propValue);
+      if (disableIEWorkarounds) {
+        domElement.innerHTML = propValue;
+      } else {
+        setInnerHTML$1(domElement, propValue);
+      }
     } else if (propKey === CHILDREN) {
       setTextContent(domElement, propValue);
     } else {
@@ -9162,7 +9172,7 @@ var ContinuousEventPriority = InputContinuousLane;
 var DefaultEventPriority = DefaultLane;
 var IdleEventPriority = IdleLane;
 var currentUpdatePriority = NoLane;
-function getCurrentUpdatePriority$1() {
+function getCurrentUpdatePriority() {
   return currentUpdatePriority;
 }
 function setCurrentUpdatePriority(newPriority) {
@@ -9784,7 +9794,7 @@ function flushSyncCallbacks() {
     // queue is in the render or commit phases, which already set the
     // event priority. Should be able to remove.
 
-    var previousUpdatePriority = getCurrentUpdatePriority$1();
+    var previousUpdatePriority = getCurrentUpdatePriority();
     setCurrentUpdatePriority(DiscreteEventPriority);
     var errors = null;
     var queue = syncQueue; // $FlowFixMe[incompatible-use] found when upgrading Flow
@@ -16218,7 +16228,7 @@ function updateDeferredValueImpl(hook, prevValue, value) {
 }
 
 function startTransition(setPending, callback, options) {
-  var previousPriority = getCurrentUpdatePriority$1();
+  var previousPriority = getCurrentUpdatePriority();
   setCurrentUpdatePriority(
     higherEventPriority(previousPriority, ContinuousEventPriority)
   );
@@ -31568,7 +31578,7 @@ function requestUpdateLane(fiber) {
   // use that directly.
   // TODO: Move this type conversion to the event priority module.
 
-  var updateLane = getCurrentUpdatePriority$1();
+  var updateLane = getCurrentUpdatePriority();
 
   if (updateLane !== NoLane) {
     return updateLane;
@@ -32451,23 +32461,6 @@ function batchedUpdates$1(fn, a) {
     }
   }
 }
-function discreteUpdates(fn, a, b, c, d) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig$1.transition;
-
-  try {
-    ReactCurrentBatchConfig$1.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    return fn(a, b, c, d);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$1.transition = prevTransition;
-
-    if (executionContext === NoContext) {
-      resetRenderTimer();
-    }
-  }
-} // Overload the definition to the two valid signatures.
 // Warning, this opts-out of checking the function body.
 // eslint-disable-next-line no-unused-vars
 // eslint-disable-next-line no-redeclare
@@ -32487,7 +32480,7 @@ function flushSync$1(fn) {
   var prevExecutionContext = executionContext;
   executionContext |= BatchedContext;
   var prevTransition = ReactCurrentBatchConfig$1.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
+  var previousPriority = getCurrentUpdatePriority();
 
   try {
     ReactCurrentBatchConfig$1.transition = null;
@@ -32523,7 +32516,7 @@ function flushControlled(fn) {
   var prevExecutionContext = executionContext;
   executionContext |= BatchedContext;
   var prevTransition = ReactCurrentBatchConfig$1.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
+  var previousPriority = getCurrentUpdatePriority();
 
   try {
     ReactCurrentBatchConfig$1.transition = null;
@@ -33448,7 +33441,7 @@ function completeUnitOfWork(unitOfWork) {
 function commitRoot(root, recoverableErrors, transitions) {
   // TODO: This no longer makes any sense. We already wrap the mutation and
   // layout phases. Should be able to remove.
-  var previousUpdateLanePriority = getCurrentUpdatePriority$1();
+  var previousUpdateLanePriority = getCurrentUpdatePriority();
   var prevTransition = ReactCurrentBatchConfig$1.transition;
 
   try {
@@ -33599,7 +33592,7 @@ function commitRootImpl(
   if (subtreeHasEffects || rootHasEffect) {
     var prevTransition = ReactCurrentBatchConfig$1.transition;
     ReactCurrentBatchConfig$1.transition = null;
-    var previousPriority = getCurrentUpdatePriority$1();
+    var previousPriority = getCurrentUpdatePriority();
     setCurrentUpdatePriority(DiscreteEventPriority);
     var prevExecutionContext = executionContext;
     executionContext |= CommitContext; // Reset this to null before calling lifecycles
@@ -33902,7 +33895,7 @@ function flushPassiveEffects() {
     var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
     var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
     var prevTransition = ReactCurrentBatchConfig$1.transition;
-    var previousPriority = getCurrentUpdatePriority$1();
+    var previousPriority = getCurrentUpdatePriority();
 
     try {
       ReactCurrentBatchConfig$1.transition = null;
@@ -36069,7 +36062,7 @@ function createFiberRoot(
   return root;
 }
 
-var ReactVersion = "18.3.0-www-classic-31d2202b";
+var ReactVersion = "18.3.0-www-classic-7b9fdab9";
 
 function createPortal$1(
   children,
@@ -36342,7 +36335,7 @@ function getPublicRootInstance(container) {
       return containerFiber.child.stateNode;
   }
 }
-function attemptSynchronousHydration$1(fiber) {
+function attemptSynchronousHydration(fiber) {
   switch (fiber.tag) {
     case HostRoot: {
       var root = fiber.stateNode;
@@ -36395,7 +36388,7 @@ function markRetryLaneIfNotHydrated(fiber, retryLane) {
   }
 }
 
-function attemptDiscreteHydration$1(fiber) {
+function attemptDiscreteHydration(fiber) {
   if (fiber.tag !== SuspenseComponent) {
     // We ignore HostRoots here because we can't increase
     // their priority and they should not suspend on I/O,
@@ -36414,7 +36407,7 @@ function attemptDiscreteHydration$1(fiber) {
 
   markRetryLaneIfNotHydrated(fiber, lane);
 }
-function attemptContinuousHydration$1(fiber) {
+function attemptContinuousHydration(fiber) {
   if (fiber.tag !== SuspenseComponent) {
     // We ignore HostRoots here because we can't increase
     // their priority and they should not suspend on I/O,
@@ -36433,7 +36426,7 @@ function attemptContinuousHydration$1(fiber) {
 
   markRetryLaneIfNotHydrated(fiber, lane);
 }
-function attemptHydrationAtCurrentPriority$1(fiber) {
+function attemptHydrationAtCurrentPriority(fiber) {
   if (fiber.tag !== SuspenseComponent) {
     // We ignore HostRoots here because we can't increase
     // their priority other than synchronously flush it.
@@ -37553,7 +37546,6 @@ function createEventHandle(type, options) {
   }
 }
 
-var restoreImpl = null;
 var restoreTarget = null;
 var restoreQueue = null;
 
@@ -37567,24 +37559,18 @@ function restoreStateOfTarget(target) {
     return;
   }
 
-  if (typeof restoreImpl !== "function") {
-    throw new Error(
-      "setRestoreImplementation() needs to be called to handle a target for controlled " +
-        "events. This error is likely caused by a bug in React. Please file an issue."
-    );
-  }
-
   var stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
 
   if (stateNode) {
     var props = getFiberCurrentPropsFromNode(stateNode);
-    restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+    restoreControlledState(
+      internalInstance.stateNode,
+      internalInstance.type,
+      props
+    );
   }
 }
 
-function setRestoreImplementation(impl) {
-  restoreImpl = impl;
-}
 function enqueueStateRestore(target) {
   if (restoreTarget) {
     if (restoreQueue) {
@@ -37617,63 +37603,6 @@ function restoreStateIfNeeded() {
   }
 }
 
-// the renderer. Such as when we're dispatching events or if third party
-// libraries need to call batchedUpdates. Eventually, this API will go away when
-// everything is batched by default. We'll then have a similar API to opt-out of
-// scheduled work and instead do synchronous work.
-// Defaults
-
-var batchedUpdatesImpl = function (fn, bookkeeping) {
-  return fn(bookkeeping);
-};
-
-var flushSyncImpl = function () {};
-
-var isInsideEventHandler = false;
-
-function finishEventHandler() {
-  // Here we wait until all updates have propagated, which is important
-  // when using controlled components within layers:
-  // https://github.com/facebook/react/issues/1698
-  // Then we restore state of any controlled component.
-  var controlledComponentsHavePendingUpdates = needsStateRestore();
-
-  if (controlledComponentsHavePendingUpdates) {
-    // If a controlled event was fired, we may need to restore the state of
-    // the DOM node back to the controlled value. This is necessary when React
-    // bails out of the update without touching the DOM.
-    // TODO: Restore state in the microtask, after the discrete updates flush,
-    // instead of early flushing them here.
-    flushSyncImpl();
-    restoreStateIfNeeded();
-  }
-}
-
-function batchedUpdates(fn, a, b) {
-  if (isInsideEventHandler) {
-    // If we are currently inside another batch, we need to wait until it
-    // fully completes before restoring state.
-    return fn(a, b);
-  }
-
-  isInsideEventHandler = true;
-
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    isInsideEventHandler = false;
-    finishEventHandler();
-  }
-} // TODO: Replace with flushSync
-function setBatchingImplementation(
-  _batchedUpdatesImpl,
-  _discreteUpdatesImpl,
-  _flushSyncImpl
-) {
-  batchedUpdatesImpl = _batchedUpdatesImpl;
-  flushSyncImpl = _flushSyncImpl;
-}
-
 function prefetchDNS$1() {
   var dispatcher = ReactDOMSharedInternals.Dispatcher.current;
 
@@ -37711,13 +37640,6 @@ function preinit$1() {
   // so we favor silent bailout over warning or erroring.
 }
 
-setAttemptSynchronousHydration(attemptSynchronousHydration$1);
-setAttemptDiscreteHydration(attemptDiscreteHydration$1);
-setAttemptContinuousHydration(attemptContinuousHydration$1);
-setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority$1);
-setGetCurrentUpdatePriority(getCurrentUpdatePriority$1);
-setAttemptHydrationAtPriority(runWithPriority);
-
 {
   if (
     typeof Map !== "function" || // $FlowFixMe Flow incorrectly thinks Map has no prototype
@@ -37735,9 +37657,6 @@ setAttemptHydrationAtPriority(runWithPriority);
   }
 }
 
-setRestoreImplementation(restoreControlledState);
-setBatchingImplementation(batchedUpdates$1, discreteUpdates, flushSync$1);
-
 function createPortal(children, container) {
   var key =
     arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
@@ -40832,6 +40751,48 @@ function isOwnedInstance(node) {
   return !!(node[internalHoistableMarker] || node[internalInstanceKey]);
 }
 
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
+
+var isInsideEventHandler = false;
+
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  var controlledComponentsHavePendingUpdates = needsStateRestore();
+
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
+
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
+
+  isInsideEventHandler = true;
+
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
+
 function isInteractive(tag) {
   return (
     tag === "button" ||
@@ -43941,34 +43902,6 @@ function getListenerSetKey(domEventName, capture) {
   return domEventName + "__" + (capture ? "capture" : "bubble");
 }
 
-var _attemptSynchronousHydration;
-
-function setAttemptSynchronousHydration(fn) {
-  _attemptSynchronousHydration = fn;
-}
-function attemptSynchronousHydration(fiber) {
-  _attemptSynchronousHydration(fiber);
-}
-var attemptDiscreteHydration;
-function setAttemptDiscreteHydration(fn) {
-  attemptDiscreteHydration = fn;
-}
-var attemptContinuousHydration;
-function setAttemptContinuousHydration(fn) {
-  attemptContinuousHydration = fn;
-}
-var attemptHydrationAtCurrentPriority;
-function setAttemptHydrationAtCurrentPriority(fn) {
-  attemptHydrationAtCurrentPriority = fn;
-}
-var getCurrentUpdatePriority;
-function setGetCurrentUpdatePriority(fn) {
-  getCurrentUpdatePriority = fn;
-}
-var attemptHydrationAtPriority;
-function setAttemptHydrationAtPriority(fn) {
-  attemptHydrationAtPriority = fn;
-} // TODO: Upgrade this definition once we're on a newer version of Flow that
 // has this definition built-in.
 
 var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
@@ -44272,7 +44205,7 @@ function attemptExplicitHydrationTarget(queuedTarget) {
           // We're blocked on hydrating this boundary.
           // Increase its priority.
           queuedTarget.blockedOn = instance;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
+          runWithPriority(queuedTarget.priority, function () {
             attemptHydrationAtCurrentPriority(nearestMounted);
           });
           return;
@@ -44587,7 +44520,7 @@ function dispatchDiscreteEvent(
   container,
   nativeEvent
 ) {
-  var previousPriority = getCurrentUpdatePriority$1();
+  var previousPriority = getCurrentUpdatePriority();
   var prevTransition = ReactCurrentBatchConfig.transition;
   ReactCurrentBatchConfig.transition = null;
 
@@ -44606,7 +44539,7 @@ function dispatchContinuousEvent(
   container,
   nativeEvent
 ) {
-  var previousPriority = getCurrentUpdatePriority$1();
+  var previousPriority = getCurrentUpdatePriority();
   var prevTransition = ReactCurrentBatchConfig.transition;
   ReactCurrentBatchConfig.transition = null;
 
diff --git a/compiled/facebook-www/ReactDOMTesting-dev.modern.js b/compiled/facebook-www/ReactDOMTesting-dev.modern.js
index 706b66b0880f3..db1696a2b98c9 100644
--- a/compiled/facebook-www/ReactDOMTesting-dev.modern.js
+++ b/compiled/facebook-www/ReactDOMTesting-dev.modern.js
@@ -130,6 +130,7 @@ var dynamicFeatureFlags = require("ReactFeatureFlags");
 
 var disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   replayFailedUnitOfWorkWithInvokeGuardedCallback =
@@ -5243,7 +5244,6 @@ function getEventTarget(nativeEvent) {
   return target.nodeType === TEXT_NODE ? target.parentNode : target;
 }
 
-var restoreImpl = null;
 var restoreTarget = null;
 var restoreQueue = null;
 
@@ -5257,24 +5257,18 @@ function restoreStateOfTarget(target) {
     return;
   }
 
-  if (typeof restoreImpl !== "function") {
-    throw new Error(
-      "setRestoreImplementation() needs to be called to handle a target for controlled " +
-        "events. This error is likely caused by a bug in React. Please file an issue."
-    );
-  }
-
   var stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.
 
   if (stateNode) {
     var props = getFiberCurrentPropsFromNode(stateNode);
-    restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+    restoreControlledState(
+      internalInstance.stateNode,
+      internalInstance.type,
+      props
+    );
   }
 }
 
-function setRestoreImplementation(impl) {
-  restoreImpl = impl;
-}
 function enqueueStateRestore(target) {
   if (restoreTarget) {
     if (restoreQueue) {
@@ -5307,256 +5301,6 @@ function restoreStateIfNeeded() {
   }
 }
 
-// the renderer. Such as when we're dispatching events or if third party
-// libraries need to call batchedUpdates. Eventually, this API will go away when
-// everything is batched by default. We'll then have a similar API to opt-out of
-// scheduled work and instead do synchronous work.
-// Defaults
-
-var batchedUpdatesImpl = function (fn, bookkeeping) {
-  return fn(bookkeeping);
-};
-
-var flushSyncImpl = function () {};
-
-var isInsideEventHandler = false;
-
-function finishEventHandler() {
-  // Here we wait until all updates have propagated, which is important
-  // when using controlled components within layers:
-  // https://github.com/facebook/react/issues/1698
-  // Then we restore state of any controlled component.
-  var controlledComponentsHavePendingUpdates = needsStateRestore();
-
-  if (controlledComponentsHavePendingUpdates) {
-    // If a controlled event was fired, we may need to restore the state of
-    // the DOM node back to the controlled value. This is necessary when React
-    // bails out of the update without touching the DOM.
-    // TODO: Restore state in the microtask, after the discrete updates flush,
-    // instead of early flushing them here.
-    flushSyncImpl();
-    restoreStateIfNeeded();
-  }
-}
-
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) {
-    // If we are currently inside another batch, we need to wait until it
-    // fully completes before restoring state.
-    return fn(a, b);
-  }
-
-  isInsideEventHandler = true;
-
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    isInsideEventHandler = false;
-    finishEventHandler();
-  }
-} // TODO: Replace with flushSync
-function setBatchingImplementation(
-  _batchedUpdatesImpl,
-  _discreteUpdatesImpl,
-  _flushSyncImpl
-) {
-  batchedUpdatesImpl = _batchedUpdatesImpl;
-  flushSyncImpl = _flushSyncImpl;
-}
-
-function isInteractive(tag) {
-  return (
-    tag === "button" ||
-    tag === "input" ||
-    tag === "select" ||
-    tag === "textarea"
-  );
-}
-
-function shouldPreventMouseEvent(name, type, props) {
-  switch (name) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      return !!(props.disabled && isInteractive(type));
-
-    default:
-      return false;
-  }
-}
-/**
- * @param {object} inst The instance, which is the source of events.
- * @param {string} registrationName Name of listener (e.g. `onClick`).
- * @return {?function} The stored callback.
- */
-
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-
-  if (stateNode === null) {
-    // Work in progress (ex: onload events in incremental mode).
-    return null;
-  }
-
-  var props = getFiberCurrentPropsFromNode(stateNode);
-
-  if (props === null) {
-    // Work in progress.
-    return null;
-  }
-
-  var listener = props[registrationName];
-
-  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
-    return null;
-  }
-
-  if (listener && typeof listener !== "function") {
-    throw new Error(
-      "Expected `" +
-        registrationName +
-        "` listener to be a function, instead got a value of `" +
-        typeof listener +
-        "` type."
-    );
-  }
-
-  return listener;
-}
-
-var passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
-// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
-
-if (canUseDOM) {
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = true;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = false;
-  }
-}
-
-// Provided by www
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-
-if (typeof ReactFbErrorUtils.invokeGuardedCallback !== "function") {
-  throw new Error(
-    "Expected ReactFbErrorUtils.invokeGuardedCallback to be a function."
-  );
-}
-
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  // This will call `this.onError(err)` if an error was caught.
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
-}
-
-var hasError = false;
-var caughtError = null; // Used by event system to capture/rethrow the first error.
-
-var hasRethrowError = false;
-var rethrowError = null;
-var reporter = {
-  onError: function (error) {
-    hasError = true;
-    caughtError = error;
-  }
-};
-/**
- * Call a function while guarding against errors that happens within it.
- * Returns an error if it throws, otherwise null.
- *
- * In production, this is implemented using a try-catch. The reason we don't
- * use a try-catch directly is so that we can swap out a different
- * implementation in DEV mode.
- *
- * @param {String} name of the guard to use for logging or debugging
- * @param {Function} func The function to invoke
- * @param {*} context The context to use when calling the function
- * @param {...*} args Arguments for function
- */
-
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = false;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
-}
-/**
- * Same as invokeGuardedCallback, but instead of returning an error, it stores
- * it in a global so it can be rethrown by `rethrowCaughtError` later.
- * TODO: See if caughtError and rethrowError can be unified.
- *
- * @param {String} name of the guard to use for logging or debugging
- * @param {Function} func The function to invoke
- * @param {*} context The context to use when calling the function
- * @param {...*} args Arguments for function
- */
-
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
-
-  if (hasError) {
-    var error = clearCaughtError();
-
-    if (!hasRethrowError) {
-      hasRethrowError = true;
-      rethrowError = error;
-    }
-  }
-}
-/**
- * During execution of guarded functions we will capture the first error which
- * we will rethrow to be handled by the top level error handler.
- */
-
-function rethrowCaughtError() {
-  if (hasRethrowError) {
-    var error = rethrowError;
-    hasRethrowError = false;
-    rethrowError = null;
-    throw error;
-  }
-}
-function hasCaughtError() {
-  return hasError;
-}
-function clearCaughtError() {
-  if (hasError) {
-    var error = caughtError;
-    hasError = false;
-    caughtError = null;
-    return error;
-  } else {
-    throw new Error(
-      "clearCaughtError was called but no error was captured. This error " +
-        "is likely caused by a bug in React. Please file an issue."
-    );
-  }
-}
-
 /**
  * `ReactInstanceMap` maintains a mapping from a public facing stateful
  * instance (key) and the internal representation (value). This allows public
@@ -6013,477 +5757,206 @@ function doesFiberContain(parentFiber, childFiber) {
   return false;
 }
 
-// This module only exists as an ESM wrapper around the external CommonJS
-var scheduleCallback$2 = Scheduler.unstable_scheduleCallback;
-var cancelCallback$1 = Scheduler.unstable_cancelCallback;
-var shouldYield = Scheduler.unstable_shouldYield;
-var requestPaint = Scheduler.unstable_requestPaint;
-var now$1 = Scheduler.unstable_now;
-var getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
-var ImmediatePriority = Scheduler.unstable_ImmediatePriority;
-var UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
-var NormalPriority$1 = Scheduler.unstable_NormalPriority;
-var LowPriority = Scheduler.unstable_LowPriority;
-var IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
-// on scheduler/unstable_mock, which we'll need for internal testing
-
-var log$2 = Scheduler.log;
-var unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue;
+var loggedTypeFailures = {};
+var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
 
-var rendererID = null;
-var injectedHook = null;
-var injectedProfilingHooks = null;
-var hasLoggedError = false;
-var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
-function injectInternals(internals) {
-  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
-    // No DevTools
-    return false;
+function setCurrentlyValidatingElement(element) {
+  {
+    if (element) {
+      var owner = element._owner;
+      var stack = describeUnknownElementTypeFrameInDEV(
+        element.type,
+        element._source,
+        owner ? owner.type : null
+      );
+      ReactDebugCurrentFrame.setExtraStackFrame(stack);
+    } else {
+      ReactDebugCurrentFrame.setExtraStackFrame(null);
+    }
   }
+}
 
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+function checkPropTypes(typeSpecs, values, location, componentName, element) {
+  {
+    // $FlowFixMe This is okay but Flow doesn't know it.
+    var has = Function.call.bind(hasOwnProperty);
 
-  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;
-  }
+    for (var typeSpecName in typeSpecs) {
+      if (has(typeSpecs, typeSpecName)) {
+        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
 
-  if (!hook.supportsFiber) {
-    {
-      error(
-        "The installed version of React DevTools is too old and will not work " +
-          "with the current version of React. Please update React DevTools. " +
-          "https://reactjs.org/link/react-devtools"
-      );
-    } // DevTools exists, even though it doesn't support Fiber.
+        try {
+          // This is intentionally an invariant that gets caught. It's the same
+          // behavior as without this statement except with a better message.
+          if (typeof typeSpecs[typeSpecName] !== "function") {
+            // eslint-disable-next-line react-internal/prod-error-codes
+            var err = Error(
+              (componentName || "React class") +
+                ": " +
+                location +
+                " type `" +
+                typeSpecName +
+                "` is invalid; " +
+                "it must be a function, usually from the `prop-types` package, but received `" +
+                typeof typeSpecs[typeSpecName] +
+                "`." +
+                "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+            );
+            err.name = "Invariant Violation";
+            throw err;
+          }
 
-    return true;
-  }
+          error$1 = typeSpecs[typeSpecName](
+            values,
+            typeSpecName,
+            componentName,
+            location,
+            null,
+            "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
+          );
+        } catch (ex) {
+          error$1 = ex;
+        }
 
-  try {
-    if (enableSchedulingProfiler) {
-      // Conditionally inject these hooks only if Timeline profiler is supported by this build.
-      // This gives DevTools a way to feature detect that isn't tied to version number
-      // (since profiling and timeline are controlled by different feature flags).
-      internals = assign({}, internals, {
-        getLaneLabelMap: getLaneLabelMap,
-        injectProfilingHooks: injectProfilingHooks
-      });
-    }
+        if (error$1 && !(error$1 instanceof Error)) {
+          setCurrentlyValidatingElement(element);
 
-    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
+          error(
+            "%s: type specification of %s" +
+              " `%s` is invalid; the type checker " +
+              "function must return `null` or an `Error` but returned a %s. " +
+              "You may have forgotten to pass an argument to the type checker " +
+              "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
+              "shape all require an argument).",
+            componentName || "React class",
+            location,
+            typeSpecName,
+            typeof error$1
+          );
 
-    injectedHook = hook;
-  } catch (err) {
-    // Catch all errors because it is unsafe to throw during initialization.
-    {
-      error("React instrumentation encountered an error: %s.", err);
-    }
-  }
+          setCurrentlyValidatingElement(null);
+        }
 
-  if (hook.checkDCE) {
-    // This is the real DevTools.
-    return true;
-  } else {
-    // This is likely a hook installed by Fast Refresh runtime.
-    return false;
-  }
-}
-function onScheduleRoot(root, children) {
-  {
-    if (
-      injectedHook &&
-      typeof injectedHook.onScheduleFiberRoot === "function"
-    ) {
-      try {
-        injectedHook.onScheduleFiberRoot(rendererID, root, children);
-      } catch (err) {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
+        if (
+          error$1 instanceof Error &&
+          !(error$1.message in loggedTypeFailures)
+        ) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error$1.message] = true;
+          setCurrentlyValidatingElement(element);
 
-          error("React instrumentation encountered an error: %s", err);
+          error("Failed %s type: %s", location, error$1.message);
+
+          setCurrentlyValidatingElement(null);
         }
       }
     }
   }
 }
-function onCommitRoot$1(root, eventPriority) {
-  if (injectedHook && typeof injectedHook.onCommitFiberRoot === "function") {
-    try {
-      var didError = (root.current.flags & DidCapture) === DidCapture;
-
-      if (enableProfilerTimer) {
-        var schedulerPriority;
 
-        switch (eventPriority) {
-          case DiscreteEventPriority:
-            schedulerPriority = ImmediatePriority;
-            break;
+var valueStack = [];
+var fiberStack;
 
-          case ContinuousEventPriority:
-            schedulerPriority = UserBlockingPriority;
-            break;
+{
+  fiberStack = [];
+}
 
-          case DefaultEventPriority:
-            schedulerPriority = NormalPriority$1;
-            break;
+var index = -1;
 
-          case IdleEventPriority:
-            schedulerPriority = IdlePriority;
-            break;
+function createCursor(defaultValue) {
+  return {
+    current: defaultValue
+  };
+}
 
-          default:
-            schedulerPriority = NormalPriority$1;
-            break;
-        }
+function pop(cursor, fiber) {
+  if (index < 0) {
+    {
+      error("Unexpected pop.");
+    }
 
-        injectedHook.onCommitFiberRoot(
-          rendererID,
-          root,
-          schedulerPriority,
-          didError
-        );
-      }
-    } catch (err) {
-      {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
+    return;
+  }
 
-          error("React instrumentation encountered an error: %s", err);
-        }
-      }
+  {
+    if (fiber !== fiberStack[index]) {
+      error("Unexpected Fiber popped.");
     }
   }
-}
-function onPostCommitRoot(root) {
-  if (
-    injectedHook &&
-    typeof injectedHook.onPostCommitFiberRoot === "function"
-  ) {
-    try {
-      injectedHook.onPostCommitFiberRoot(rendererID, root);
-    } catch (err) {
-      {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
 
-          error("React instrumentation encountered an error: %s", err);
-        }
-      }
-    }
+  cursor.current = valueStack[index];
+  valueStack[index] = null;
+
+  {
+    fiberStack[index] = null;
   }
+
+  index--;
 }
-function onCommitUnmount(fiber) {
-  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === "function") {
-    try {
-      injectedHook.onCommitFiberUnmount(rendererID, fiber);
-    } catch (err) {
-      {
-        if (!hasLoggedError) {
-          hasLoggedError = true;
 
-          error("React instrumentation encountered an error: %s", err);
-        }
-      }
-    }
+function push(cursor, value, fiber) {
+  index++;
+  valueStack[index] = cursor.current;
+
+  {
+    fiberStack[index] = fiber;
   }
-}
-function setIsStrictModeForDevtools(newIsStrictMode) {
-  {
-    if (typeof log$2 === "function") {
-      // We're in a test because Scheduler.log only exists
-      // in SchedulerMock. To reduce the noise in strict mode tests,
-      // suppress warnings and disable scheduler yielding during the double render
-      unstable_setDisableYieldValue(newIsStrictMode);
-      setSuppressWarning(newIsStrictMode);
-    }
-
-    if (injectedHook && typeof injectedHook.setStrictMode === "function") {
-      try {
-        injectedHook.setStrictMode(rendererID, newIsStrictMode);
-      } catch (err) {
-        {
-          if (!hasLoggedError) {
-            hasLoggedError = true;
-
-            error("React instrumentation encountered an error: %s", err);
-          }
-        }
-      }
-    }
-  }
-} // Profiler API hooks
-
-function injectProfilingHooks(profilingHooks) {
-  injectedProfilingHooks = profilingHooks;
+
+  cursor.current = value;
 }
 
-function getLaneLabelMap() {
-  if (enableSchedulingProfiler) {
-    var map = new Map();
-    var lane = 1;
+var emptyContextObject = {};
 
-    for (var index = 0; index < TotalLanes; index++) {
-      var label = getLabelForLane(lane);
-      map.set(lane, label);
-      lane *= 2;
-    }
+{
+  Object.freeze(emptyContextObject);
+} // A cursor to the current merged context object on the stack.
 
-    return map;
-  } else {
-    return null;
+function hasContextChanged() {
+  {
+    return false;
   }
 }
 
-function markCommitStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markCommitStarted === "function"
-    ) {
-      injectedProfilingHooks.markCommitStarted(lanes);
-    }
-  }
-}
-function markCommitStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markCommitStopped === "function"
-    ) {
-      injectedProfilingHooks.markCommitStopped();
-    }
-  }
-}
-function markComponentRenderStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentRenderStarted === "function"
-    ) {
-      injectedProfilingHooks.markComponentRenderStarted(fiber);
-    }
-  }
-}
-function markComponentRenderStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentRenderStopped === "function"
-    ) {
-      injectedProfilingHooks.markComponentRenderStopped();
-    }
-  }
-}
-function markComponentPassiveEffectMountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
-    }
-  }
-}
-function markComponentPassiveEffectMountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
-    }
-  }
-}
-function markComponentPassiveEffectUnmountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
-    }
-  }
-}
-function markComponentPassiveEffectUnmountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
-    }
-  }
-}
-function markComponentLayoutEffectMountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
-    }
-  }
-}
-function markComponentLayoutEffectMountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
-    }
-  }
-}
-function markComponentLayoutEffectUnmountStarted(fiber) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
-    }
-  }
-}
-function markComponentLayoutEffectUnmountStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped ===
-        "function"
-    ) {
-      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
-    }
-  }
-}
-function markComponentErrored(fiber, thrownValue, lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentErrored === "function"
-    ) {
-      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
-    }
-  }
-}
-function markComponentSuspended(fiber, wakeable, lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markComponentSuspended === "function"
-    ) {
-      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
-    }
-  }
-}
-function markLayoutEffectsStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markLayoutEffectsStarted === "function"
-    ) {
-      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
-    }
-  }
-}
-function markLayoutEffectsStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markLayoutEffectsStopped === "function"
-    ) {
-      injectedProfilingHooks.markLayoutEffectsStopped();
-    }
-  }
-}
-function markPassiveEffectsStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markPassiveEffectsStarted === "function"
-    ) {
-      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
-    }
-  }
-}
-function markPassiveEffectsStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markPassiveEffectsStopped === "function"
-    ) {
-      injectedProfilingHooks.markPassiveEffectsStopped();
-    }
-  }
-}
-function markRenderStarted(lanes) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderStarted === "function"
-    ) {
-      injectedProfilingHooks.markRenderStarted(lanes);
-    }
-  }
-}
-function markRenderYielded() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderYielded === "function"
-    ) {
-      injectedProfilingHooks.markRenderYielded();
-    }
-  }
-}
-function markRenderStopped() {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderStopped === "function"
-    ) {
-      injectedProfilingHooks.markRenderStopped();
-    }
+function isContextProvider(type) {
+  {
+    return false;
   }
 }
-function markRenderScheduled(lane) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markRenderScheduled === "function"
-    ) {
-      injectedProfilingHooks.markRenderScheduled(lane);
-    }
+
+function processChildContext(fiber, type, parentContext) {
+  {
+    return parentContext;
   }
 }
-function markForceUpdateScheduled(fiber, lane) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markForceUpdateScheduled === "function"
-    ) {
-      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
-    }
+
+function findCurrentUnmaskedContext(fiber) {
+  {
+    return emptyContextObject;
   }
 }
-function markStateUpdateScheduled(fiber, lane) {
-  if (enableSchedulingProfiler) {
-    if (
-      injectedProfilingHooks !== null &&
-      typeof injectedProfilingHooks.markStateUpdateScheduled === "function"
-    ) {
-      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
-    }
-  }
+
+var LegacyRoot = 0;
+var ConcurrentRoot = 1;
+
+// We use the existence of the state object as an indicator that the component
+// is hidden.
+var OffscreenVisible =
+  /*                     */
+  1;
+var OffscreenDetached =
+  /*                    */
+  2;
+var OffscreenPassiveEffectsConnected =
+  /*     */
+  4;
+function isOffscreenManual(offscreenFiber) {
+  return (
+    offscreenFiber.memoizedProps !== null &&
+    offscreenFiber.memoizedProps.mode === "manual"
+  );
 }
 
 var NoMode =
@@ -6514,7 +5987,7 @@ var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback; // Count leading zeros.
 // Based on:
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
 
-var log$1 = Math.log;
+var log$2 = Math.log;
 var LN2 = Math.LN2;
 
 function clz32Fallback(x) {
@@ -6524,7 +5997,7 @@ function clz32Fallback(x) {
     return 32;
   }
 
-  return (31 - ((log$1(asUint) / LN2) | 0)) | 0;
+  return (31 - ((log$2(asUint) / LN2) | 0)) | 0;
 }
 
 // If those values are changed that package should be rebuilt and redeployed.
@@ -7461,7 +6934,7 @@ var ContinuousEventPriority = InputContinuousLane;
 var DefaultEventPriority = DefaultLane;
 var IdleEventPriority = IdleLane;
 var currentUpdatePriority = NoLane;
-function getCurrentUpdatePriority$1() {
+function getCurrentUpdatePriority() {
   return currentUpdatePriority;
 }
 function setCurrentUpdatePriority(newPriority) {
@@ -7504,36043 +6977,36516 @@ function lanesToEventPriority(lanes) {
   return IdleEventPriority;
 }
 
-// This is imported by the event replaying implementation in React DOM. It's
-// in a separate file to break a circular dependency between the renderer and
-// the reconciler.
-function isRootDehydrated(root) {
-  var currentState = root.current.memoizedState;
-  return currentState.isDehydrated;
-}
+// This module only exists as an ESM wrapper around the external CommonJS
+var scheduleCallback$2 = Scheduler.unstable_scheduleCallback;
+var cancelCallback$1 = Scheduler.unstable_cancelCallback;
+var shouldYield = Scheduler.unstable_shouldYield;
+var requestPaint = Scheduler.unstable_requestPaint;
+var now$1 = Scheduler.unstable_now;
+var getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
+var ImmediatePriority = Scheduler.unstable_ImmediatePriority;
+var UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
+var NormalPriority$1 = Scheduler.unstable_NormalPriority;
+var LowPriority = Scheduler.unstable_LowPriority;
+var IdlePriority = Scheduler.unstable_IdlePriority; // this doesn't actually exist on the scheduler, but it *does*
+// on scheduler/unstable_mock, which we'll need for internal testing
 
-var _attemptSynchronousHydration;
+var log$1 = Scheduler.log;
+var unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue;
 
-function setAttemptSynchronousHydration(fn) {
-  _attemptSynchronousHydration = fn;
-}
-function attemptSynchronousHydration$1(fiber) {
-  _attemptSynchronousHydration(fiber);
-}
-var attemptDiscreteHydration$1;
-function setAttemptDiscreteHydration(fn) {
-  attemptDiscreteHydration$1 = fn;
-}
-var attemptContinuousHydration$1;
-function setAttemptContinuousHydration(fn) {
-  attemptContinuousHydration$1 = fn;
-}
-var attemptHydrationAtCurrentPriority$1;
-function setAttemptHydrationAtCurrentPriority(fn) {
-  attemptHydrationAtCurrentPriority$1 = fn;
-}
-var getCurrentUpdatePriority;
-function setGetCurrentUpdatePriority(fn) {
-  getCurrentUpdatePriority = fn;
-}
-var attemptHydrationAtPriority;
-function setAttemptHydrationAtPriority(fn) {
-  attemptHydrationAtPriority = fn;
-} // TODO: Upgrade this definition once we're on a newer version of Flow that
-// has this definition built-in.
+var rendererID = null;
+var injectedHook = null;
+var injectedProfilingHooks = null;
+var hasLoggedError = false;
+var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+    // No DevTools
+    return false;
+  }
 
-var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
 
-var queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.
-// if the last target was dehydrated.
+  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;
+  }
 
-var queuedFocus = null;
-var queuedDrag = null;
-var queuedMouse = null; // For pointer events there can be one latest event per pointerId.
+  if (!hook.supportsFiber) {
+    {
+      error(
+        "The installed version of React DevTools is too old and will not work " +
+          "with the current version of React. Please update React DevTools. " +
+          "https://reactjs.org/link/react-devtools"
+      );
+    } // DevTools exists, even though it doesn't support Fiber.
 
-var queuedPointers = new Map();
-var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
+    return true;
+  }
 
-var queuedExplicitHydrationTargets = [];
-function hasQueuedDiscreteEvents() {
-  return queuedDiscreteEvents.length > 0;
-}
-var discreteReplayableEvents = [
-  "mousedown",
-  "mouseup",
-  "touchcancel",
-  "touchend",
-  "touchstart",
-  "auxclick",
-  "dblclick",
-  "pointercancel",
-  "pointerdown",
-  "pointerup",
-  "dragend",
-  "dragstart",
-  "drop",
-  "compositionend",
-  "compositionstart",
-  "keydown",
-  "keypress",
-  "keyup",
-  "input",
-  "textInput", // Intentionally camelCase
-  "copy",
-  "cut",
-  "paste",
-  "click",
-  "change",
-  "contextmenu",
-  "reset",
-  "submit"
-];
-function isDiscreteEventThatRequiresHydration(eventType) {
-  return discreteReplayableEvents.indexOf(eventType) > -1;
-}
+  try {
+    if (enableSchedulingProfiler) {
+      // Conditionally inject these hooks only if Timeline profiler is supported by this build.
+      // This gives DevTools a way to feature detect that isn't tied to version number
+      // (since profiling and timeline are controlled by different feature flags).
+      internals = assign({}, internals, {
+        getLaneLabelMap: getLaneLabelMap,
+        injectProfilingHooks: injectProfilingHooks
+      });
+    }
 
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
-}
+    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
 
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    return;
+    injectedHook = hook;
+  } catch (err) {
+    // Catch all errors because it is unsafe to throw during initialization.
+    {
+      error("React instrumentation encountered an error: %s.", err);
+    }
   }
 
-  var queuedEvent = createQueuedReplayableEvent(
-    blockedOn,
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-  queuedDiscreteEvents.push(queuedEvent);
-
-  if (queuedDiscreteEvents.length === 1) {
-    // If this was the first discrete event, we might be able to
-    // synchronously unblock it so that preventDefault still works.
-    while (queuedEvent.blockedOn !== null) {
-      var fiber = getInstanceFromNode$1(queuedEvent.blockedOn);
+  if (hook.checkDCE) {
+    // This is the real DevTools.
+    return true;
+  } else {
+    // This is likely a hook installed by Fast Refresh runtime.
+    return false;
+  }
+}
+function onScheduleRoot(root, children) {
+  {
+    if (
+      injectedHook &&
+      typeof injectedHook.onScheduleFiberRoot === "function"
+    ) {
+      try {
+        injectedHook.onScheduleFiberRoot(rendererID, root, children);
+      } catch (err) {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-      if (fiber === null) {
-        break;
+          error("React instrumentation encountered an error: %s", err);
+        }
       }
+    }
+  }
+}
+function onCommitRoot$1(root, eventPriority) {
+  if (injectedHook && typeof injectedHook.onCommitFiberRoot === "function") {
+    try {
+      var didError = (root.current.flags & DidCapture) === DidCapture;
 
-      attemptSynchronousHydration$1(fiber);
+      if (enableProfilerTimer) {
+        var schedulerPriority;
 
-      if (queuedEvent.blockedOn === null) {
-        // We got unblocked by hydration. Let's try again.
-        replayUnblockedEvents(); // If we're reblocked, on an inner boundary, we might need
-        // to attempt hydrating that one.
+        switch (eventPriority) {
+          case DiscreteEventPriority:
+            schedulerPriority = ImmediatePriority;
+            break;
 
-        continue;
-      } else {
-        // We're still blocked from hydration, we have to give up
-        // and replay later.
-        break;
-      }
-    }
-  }
-} // Resets the replaying for this type of continuous event to no event.
+          case ContinuousEventPriority:
+            schedulerPriority = UserBlockingPriority;
+            break;
 
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
+          case DefaultEventPriority:
+            schedulerPriority = NormalPriority$1;
+            break;
 
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
+          case IdleEventPriority:
+            schedulerPriority = IdlePriority;
+            break;
 
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
+          default:
+            schedulerPriority = NormalPriority$1;
+            break;
+        }
 
-    case "pointerover":
-    case "pointerout": {
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.delete(pointerId);
-      break;
-    }
+        injectedHook.onCommitFiberRoot(
+          rendererID,
+          root,
+          schedulerPriority,
+          didError
+        );
+      }
+    } catch (err) {
+      {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-    case "gotpointercapture":
-    case "lostpointercapture": {
-      var _pointerId = nativeEvent.pointerId;
-      queuedPointerCaptures.delete(_pointerId);
-      break;
+          error("React instrumentation encountered an error: %s", err);
+        }
+      }
     }
   }
 }
-
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
+function onPostCommitRoot(root) {
   if (
-    existingQueuedEvent === null ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
+    injectedHook &&
+    typeof injectedHook.onPostCommitFiberRoot === "function"
   ) {
-    var queuedEvent = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-
-    if (blockedOn !== null) {
-      var fiber = getInstanceFromNode$1(blockedOn);
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {
+      {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-      if (fiber !== null) {
-        // Attempt to increase the priority of this target.
-        attemptContinuousHydration$1(fiber);
+          error("React instrumentation encountered an error: %s", err);
+        }
       }
     }
-
-    return queuedEvent;
-  } // If we have already queued this exact event, then it's because
-  // the different event systems have different DOM event listeners.
-  // We can accumulate the flags, and the targetContainers, and
-  // store a single event to be replayed.
-
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  var targetContainers = existingQueuedEvent.targetContainers;
-
-  if (
-    targetContainer !== null &&
-    targetContainers.indexOf(targetContainer) === -1
-  ) {
-    targetContainers.push(targetContainer);
   }
-
-  return existingQueuedEvent;
 }
+function onCommitUnmount(fiber) {
+  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === "function") {
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, fiber);
+    } catch (err) {
+      {
+        if (!hasLoggedError) {
+          hasLoggedError = true;
 
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // These set relatedTarget to null because the replayed event will be treated as if we
-  // moved from outside the window (no target) onto the target once it hydrates.
-  // Instead of mutating we could clone the event.
-  switch (domEventName) {
-    case "focusin": {
-      var focusEvent = nativeEvent;
-      queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedFocus,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        focusEvent
-      );
-      return true;
-    }
-
-    case "dragenter": {
-      var dragEvent = nativeEvent;
-      queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedDrag,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        dragEvent
-      );
-      return true;
+          error("React instrumentation encountered an error: %s", err);
+        }
+      }
     }
-
-    case "mouseover": {
-      var mouseEvent = nativeEvent;
-      queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-        queuedMouse,
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        mouseEvent
-      );
-      return true;
+  }
+}
+function setIsStrictModeForDevtools(newIsStrictMode) {
+  {
+    if (typeof log$1 === "function") {
+      // We're in a test because Scheduler.log only exists
+      // in SchedulerMock. To reduce the noise in strict mode tests,
+      // suppress warnings and disable scheduler yielding during the double render
+      unstable_setDisableYieldValue(newIsStrictMode);
+      setSuppressWarning(newIsStrictMode);
     }
 
-    case "pointerover": {
-      var pointerEvent = nativeEvent;
-      var pointerId = pointerEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          pointerEvent
-        )
-      );
-      return true;
-    }
+    if (injectedHook && typeof injectedHook.setStrictMode === "function") {
+      try {
+        injectedHook.setStrictMode(rendererID, newIsStrictMode);
+      } catch (err) {
+        {
+          if (!hasLoggedError) {
+            hasLoggedError = true;
 
-    case "gotpointercapture": {
-      var _pointerEvent = nativeEvent;
-      var _pointerId2 = _pointerEvent.pointerId;
-      queuedPointerCaptures.set(
-        _pointerId2,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointerCaptures.get(_pointerId2) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          _pointerEvent
-        )
-      );
-      return true;
+            error("React instrumentation encountered an error: %s", err);
+          }
+        }
+      }
     }
   }
+} // Profiler API hooks
 
-  return false;
-} // Check if this target is unblocked. Returns true if it's unblocked.
-
-function attemptExplicitHydrationTarget(queuedTarget) {
-  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
-  // Try to unify them. It's a bit tricky since it would require two return
-  // values.
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
-
-  if (targetInst !== null) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-
-    if (nearestMounted !== null) {
-      var tag = nearestMounted.tag;
-
-      if (tag === SuspenseComponent) {
-        var instance = getSuspenseInstanceFromFiber(nearestMounted);
-
-        if (instance !== null) {
-          // We're blocked on hydrating this boundary.
-          // Increase its priority.
-          queuedTarget.blockedOn = instance;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (tag === HostRoot) {
-        var root = nearestMounted.stateNode;
+function injectProfilingHooks(profilingHooks) {
+  injectedProfilingHooks = profilingHooks;
+}
 
-        if (isRootDehydrated(root)) {
-          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
-          // a root other than sync.
+function getLaneLabelMap() {
+  if (enableSchedulingProfiler) {
+    var map = new Map();
+    var lane = 1;
 
-          return;
-        }
-      }
+    for (var index = 0; index < TotalLanes; index++) {
+      var label = getLabelForLane(lane);
+      map.set(lane, label);
+      lane *= 2;
     }
-  }
 
-  queuedTarget.blockedOn = null;
+    return map;
+  } else {
+    return null;
+  }
 }
 
-function queueExplicitHydrationTarget(target) {
-  // TODO: This will read the priority if it's dispatched by the React
-  // event system but not native events. Should read window.event.type, like
-  // we do for updates (getCurrentEventPriority).
-  var updatePriority = getCurrentUpdatePriority();
-  var queuedTarget = {
-    blockedOn: null,
-    target: target,
-    priority: updatePriority
-  };
-  var i = 0;
-
-  for (; i < queuedExplicitHydrationTargets.length; i++) {
-    // Stop once we hit the first target with lower priority than
+function markCommitStarted(lanes) {
+  if (enableSchedulingProfiler) {
     if (
-      !isHigherEventPriority(
-        updatePriority,
-        queuedExplicitHydrationTargets[i].priority
-      )
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStarted === "function"
     ) {
-      break;
+      injectedProfilingHooks.markCommitStarted(lanes);
     }
   }
-
-  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
-
-  if (i === 0) {
-    attemptExplicitHydrationTarget(queuedTarget);
-  }
 }
-
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (queuedEvent.blockedOn !== null) {
-    return false;
+function markCommitStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markCommitStopped === "function"
+    ) {
+      injectedProfilingHooks.markCommitStopped();
+    }
   }
+}
+function markComponentRenderStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStarted === "function"
+    ) {
+      injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+  }
+}
+function markComponentRenderStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentRenderStopped === "function"
+    ) {
+      injectedProfilingHooks.markComponentRenderStopped();
+    }
+  }
+}
+function markComponentPassiveEffectMountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectMountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectMountStopped();
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentPassiveEffectUnmountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentPassiveEffectUnmountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectMountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectMountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectMountStopped();
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStarted(fiber) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(fiber);
+    }
+  }
+}
+function markComponentLayoutEffectUnmountStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped ===
+        "function"
+    ) {
+      injectedProfilingHooks.markComponentLayoutEffectUnmountStopped();
+    }
+  }
+}
+function markComponentErrored(fiber, thrownValue, lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentErrored === "function"
+    ) {
+      injectedProfilingHooks.markComponentErrored(fiber, thrownValue, lanes);
+    }
+  }
+}
+function markComponentSuspended(fiber, wakeable, lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markComponentSuspended === "function"
+    ) {
+      injectedProfilingHooks.markComponentSuspended(fiber, wakeable, lanes);
+    }
+  }
+}
+function markLayoutEffectsStarted(lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStarted === "function"
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStarted(lanes);
+    }
+  }
+}
+function markLayoutEffectsStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markLayoutEffectsStopped === "function"
+    ) {
+      injectedProfilingHooks.markLayoutEffectsStopped();
+    }
+  }
+}
+function markPassiveEffectsStarted(lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStarted === "function"
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+    }
+  }
+}
+function markPassiveEffectsStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markPassiveEffectsStopped === "function"
+    ) {
+      injectedProfilingHooks.markPassiveEffectsStopped();
+    }
+  }
+}
+function markRenderStarted(lanes) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStarted === "function"
+    ) {
+      injectedProfilingHooks.markRenderStarted(lanes);
+    }
+  }
+}
+function markRenderYielded() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderYielded === "function"
+    ) {
+      injectedProfilingHooks.markRenderYielded();
+    }
+  }
+}
+function markRenderStopped() {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderStopped === "function"
+    ) {
+      injectedProfilingHooks.markRenderStopped();
+    }
+  }
+}
+function markRenderScheduled(lane) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markRenderScheduled === "function"
+    ) {
+      injectedProfilingHooks.markRenderScheduled(lane);
+    }
+  }
+}
+function markForceUpdateScheduled(fiber, lane) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markForceUpdateScheduled === "function"
+    ) {
+      injectedProfilingHooks.markForceUpdateScheduled(fiber, lane);
+    }
+  }
+}
+function markStateUpdateScheduled(fiber, lane) {
+  if (enableSchedulingProfiler) {
+    if (
+      injectedProfilingHooks !== null &&
+      typeof injectedProfilingHooks.markStateUpdateScheduled === "function"
+    ) {
+      injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+  }
+}
 
-  var targetContainers = queuedEvent.targetContainers;
-
-  while (targetContainers.length > 0) {
-    var targetContainer = targetContainers[0];
-    var nextBlockedOn = findInstanceBlockingEvent(
-      queuedEvent.domEventName,
-      queuedEvent.eventSystemFlags,
-      targetContainer,
-      queuedEvent.nativeEvent
-    );
-
-    if (nextBlockedOn === null) {
-      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-        var nativeEvent = queuedEvent.nativeEvent;
-        var nativeEventClone = new nativeEvent.constructor(
-          nativeEvent.type,
-          nativeEvent
-        );
-        setReplayingEvent(nativeEventClone);
-        nativeEvent.target.dispatchEvent(nativeEventClone);
-        resetReplayingEvent();
-      } else {
-        setReplayingEvent(queuedEvent.nativeEvent);
-        dispatchEventForPluginEventSystem(
-          queuedEvent.domEventName,
-          queuedEvent.eventSystemFlags,
-          queuedEvent.nativeEvent,
-          return_targetInst,
-          targetContainer
-        );
-        resetReplayingEvent();
-      }
-    } else {
-      // We're still blocked. Try again later.
-      var fiber = getInstanceFromNode$1(nextBlockedOn);
-
-      if (fiber !== null) {
-        attemptContinuousHydration$1(fiber);
-      }
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return (
+    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
+  );
+}
 
-      queuedEvent.blockedOn = nextBlockedOn;
-      return false;
-    } // This target container was successfully dispatched. Try the next.
+var objectIs = typeof Object.is === "function" ? Object.is : is; // $FlowFixMe[method-unbinding]
 
-    targetContainers.shift();
+var syncQueue = null;
+var includesLegacySyncCallbacks = false;
+var isFlushingSyncQueue = false;
+function scheduleSyncCallback(callback) {
+  // Push this callback into an internal queue. We'll flush these either in
+  // the next tick, or earlier if something calls `flushSyncCallbackQueue`.
+  if (syncQueue === null) {
+    syncQueue = [callback];
+  } else {
+    // Push onto existing queue. Don't need to schedule a callback because
+    // we already scheduled one when we created the queue.
+    syncQueue.push(callback);
   }
-
-  return true;
 }
-
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
-    map.delete(key);
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = true;
+  scheduleSyncCallback(callback);
+}
+function flushSyncCallbacksOnlyInLegacyMode() {
+  // Only flushes the queue if there's a legacy sync callback scheduled.
+  // TODO: There's only a single type of callback: performSyncOnWorkOnRoot. So
+  // it might make more sense for the queue to be a list of roots instead of a
+  // list of generic callbacks. Then we can have two: one for legacy roots, one
+  // for concurrent roots. And this method would only flush the legacy ones.
+  if (includesLegacySyncCallbacks) {
+    flushSyncCallbacks();
   }
 }
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && syncQueue !== null) {
+    // Prevent re-entrance.
+    isFlushingSyncQueue = true; // Set the event priority to discrete
+    // TODO: Is this necessary anymore? The only user code that runs in this
+    // queue is in the render or commit phases, which already set the
+    // event priority. Should be able to remove.
 
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = false;
+    var previousUpdatePriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    var errors = null;
+    var queue = syncQueue; // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    // First replay discrete events.
-    while (queuedDiscreteEvents.length > 0) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
+    for (var i = 0; i < queue.length; i++) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      var callback = queue[i];
 
-      if (nextDiscreteEvent.blockedOn !== null) {
-        // We're still blocked.
-        // Increase the priority of this boundary to unblock
-        // the next discrete event.
-        var fiber = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
+      try {
+        do {
+          var isSync = true; // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-        if (fiber !== null) {
-          attemptDiscreteHydration$1(fiber);
+          callback = callback(isSync);
+        } while (callback !== null);
+      } catch (error) {
+        // Collect errors so we can rethrow them at the end
+        if (errors === null) {
+          errors = [error];
+        } else {
+          errors.push(error);
         }
-
-        break;
       }
+    }
 
-      var targetContainers = nextDiscreteEvent.targetContainers;
-
-      while (targetContainers.length > 0) {
-        var targetContainer = targetContainers[0];
-        var nextBlockedOn = findInstanceBlockingEvent(
-          nextDiscreteEvent.domEventName,
-          nextDiscreteEvent.eventSystemFlags,
-          targetContainer,
-          nextDiscreteEvent.nativeEvent
-        );
+    syncQueue = null;
+    includesLegacySyncCallbacks = false;
+    setCurrentUpdatePriority(previousUpdatePriority);
+    isFlushingSyncQueue = false;
 
-        if (nextBlockedOn === null) {
-          // This whole function is in !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
-          // so we don't need the new replay behavior code branch.
-          setReplayingEvent(nextDiscreteEvent.nativeEvent);
-          dispatchEventForPluginEventSystem(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            nextDiscreteEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          );
-          resetReplayingEvent();
+    if (errors !== null) {
+      if (errors.length > 1) {
+        if (typeof AggregateError === "function") {
+          // eslint-disable-next-line no-undef
+          throw new AggregateError(errors);
         } else {
-          // We're still blocked. Try again later.
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        } // This target container was successfully dispatched. Try the next.
-
-        targetContainers.shift();
-      }
+          for (var _i = 1; _i < errors.length; _i++) {
+            scheduleCallback$2(
+              ImmediatePriority,
+              throwError.bind(null, errors[_i])
+            );
+          }
 
-      if (nextDiscreteEvent.blockedOn === null) {
-        // We've successfully replayed the first event. Let's try the next one.
-        queuedDiscreteEvents.shift();
+          var firstError = errors[0];
+          throw firstError;
+        }
+      } else {
+        var error = errors[0];
+        throw error;
       }
     }
-  } // Next replay any continuous events.
-
-  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
-    queuedFocus = null;
-  }
-
-  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
-    queuedDrag = null;
   }
 
-  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
-    queuedMouse = null;
-  }
-
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+  return null;
 }
 
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  if (queuedEvent.blockedOn === unblocked) {
-    queuedEvent.blockedOn = null;
+function throwError(error) {
+  throw error;
+}
 
-    if (!hasScheduledReplayAttempt) {
-      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
-      // now unblocked. This first might not actually be unblocked yet.
-      // We could check it early to avoid scheduling an unnecessary callback.
+var nativeConsole = console;
+var nativeConsoleLog = null;
+var pendingGroupArgs = [];
+var printedGroupIndex = -1;
 
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      );
-    }
-  }
+function formatLanes(laneOrLanes) {
+  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
 }
 
-function retryIfBlockedOn(unblocked) {
-  // Mark anything that was blocked on this as no longer blocked
-  // and eligible for a replay.
-  if (queuedDiscreteEvents.length > 0) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
-    // worth it because we expect very few discrete events to queue up and once
-    // we are actually fully unblocked it will be fast to replay them.
+function group() {
+  for (
+    var _len = arguments.length, groupArgs = new Array(_len), _key = 0;
+    _key < _len;
+    _key++
+  ) {
+    groupArgs[_key] = arguments[_key];
+  }
 
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent = queuedDiscreteEvents[i];
+  pendingGroupArgs.push(groupArgs);
 
-      if (queuedEvent.blockedOn === unblocked) {
-        queuedEvent.blockedOn = null;
-      }
-    }
+  if (nativeConsoleLog === null) {
+    nativeConsoleLog = nativeConsole.log;
+    nativeConsole.log = log;
   }
+}
 
-  if (queuedFocus !== null) {
-    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  }
+function groupEnd() {
+  pendingGroupArgs.pop();
 
-  if (queuedDrag !== null) {
-    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  while (printedGroupIndex >= pendingGroupArgs.length) {
+    nativeConsole.groupEnd();
+    printedGroupIndex--;
   }
 
-  if (queuedMouse !== null) {
-    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  if (pendingGroupArgs.length === 0) {
+    nativeConsole.log = nativeConsoleLog;
+    nativeConsoleLog = null;
   }
+}
 
-  var unblock = function (queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
-  };
-
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
-
-  for (var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++) {
-    var queuedTarget = queuedExplicitHydrationTargets[_i];
-
-    if (queuedTarget.blockedOn === unblocked) {
-      queuedTarget.blockedOn = null;
+function log() {
+  if (printedGroupIndex < pendingGroupArgs.length - 1) {
+    for (var i = printedGroupIndex + 1; i < pendingGroupArgs.length; i++) {
+      var groupArgs = pendingGroupArgs[i];
+      nativeConsole.group.apply(nativeConsole, groupArgs);
     }
-  }
 
-  while (queuedExplicitHydrationTargets.length > 0) {
-    var nextExplicitTarget = queuedExplicitHydrationTargets[0];
+    printedGroupIndex = pendingGroupArgs.length - 1;
+  }
 
-    if (nextExplicitTarget.blockedOn !== null) {
-      // We're still blocked.
-      break;
-    } else {
-      attemptExplicitHydrationTarget(nextExplicitTarget);
+  if (typeof nativeConsoleLog === "function") {
+    nativeConsoleLog.apply(void 0, arguments);
+  } else {
+    nativeConsole.log.apply(nativeConsole, arguments);
+  }
+}
 
-      if (nextExplicitTarget.blockedOn === null) {
-        // We're unblocked.
-        queuedExplicitHydrationTargets.shift();
-      }
+var REACT_LOGO_STYLE =
+  "background-color: #20232a; color: #61dafb; padding: 0 2px;";
+function logCommitStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c commit%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
     }
   }
 }
-
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
-
-var _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
-// We'd like to remove this but it's not clear if this is safe.
-
-function setEnabled(enabled) {
-  _enabled = !!enabled;
-}
-function isEnabled() {
-  return _enabled;
+function logCommitStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
+  }
 }
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  var eventPriority = getEventPriority(domEventName);
-  var listenerWrapper;
-
-  switch (eventPriority) {
-    case DiscreteEventPriority:
-      listenerWrapper = dispatchDiscreteEvent;
-      break;
+var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
 
-    case ContinuousEventPriority:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
+var wakeableIDs = new PossiblyWeakMap$1();
+var wakeableID = 0;
 
-    case DefaultEventPriority:
-    default:
-      listenerWrapper = dispatchEvent;
-      break;
+function getWakeableID(wakeable) {
+  if (!wakeableIDs.has(wakeable)) {
+    wakeableIDs.set(wakeable, wakeableID++);
   }
 
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
+  return wakeableIDs.get(wakeable);
 }
 
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-
-  try {
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$3.transition = prevTransition;
+function logComponentSuspended(componentName, wakeable) {
+  {
+    if (enableDebugTracing) {
+      var id = getWakeableID(wakeable);
+      var display = wakeable.displayName || wakeable;
+      log(
+        "%c\u269B\uFE0F%c " + componentName + " suspended",
+        REACT_LOGO_STYLE,
+        "color: #80366d; font-weight: bold;",
+        id,
+        display
+      );
+      wakeable.then(
+        function () {
+          log(
+            "%c\u269B\uFE0F%c " + componentName + " resolved",
+            REACT_LOGO_STYLE,
+            "color: #80366d; font-weight: bold;",
+            id,
+            display
+          );
+        },
+        function () {
+          log(
+            "%c\u269B\uFE0F%c " + componentName + " rejected",
+            REACT_LOGO_STYLE,
+            "color: #80366d; font-weight: bold;",
+            id,
+            display
+          );
+        }
+      );
+    }
   }
 }
-
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-
-  try {
-    setCurrentUpdatePriority(ContinuousEventPriority);
-    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$3.transition = prevTransition;
+function logLayoutEffectsStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c layout effects%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
+    }
   }
 }
-
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (!_enabled) {
-    return;
+function logLayoutEffectsStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
   }
-
-  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-    dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-  } else {
-    dispatchEventOriginal(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
+}
+function logPassiveEffectsStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c passive effects%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
+    }
   }
 }
-
-function dispatchEventOriginal(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // TODO: replaying capture phase events is currently broken
-  // because we used to do it during top-level native bubble handlers
-  // but now we use different bubble and capture handlers.
-  // In eager mode, we attach capture listeners early, so we need
-  // to filter them out until we fix the logic to handle them correctly.
-  var allowReplay = (eventSystemFlags & IS_CAPTURE_PHASE) === 0;
-
-  if (
-    allowReplay &&
-    hasQueuedDiscreteEvents() &&
-    isDiscreteEventThatRequiresHydration(domEventName)
-  ) {
-    // If we already have a queue of discrete events, and this is another discrete
-    // event, then we can't dispatch it regardless of its target, since they
-    // need to dispatch in order.
-    queueDiscreteEvent(
-      null, // Flags that we're not actually blocked on anything as far as we know.
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-    return;
+function logPassiveEffectsStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
   }
-
-  var blockedOn = findInstanceBlockingEvent(
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-
-  if (blockedOn === null) {
-    dispatchEventForPluginEventSystem(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      return_targetInst,
-      targetContainer
-    );
-
-    if (allowReplay) {
-      clearIfContinuousEvent(domEventName, nativeEvent);
+}
+function logRenderStarted(lanes) {
+  {
+    if (enableDebugTracing) {
+      group(
+        "%c\u269B\uFE0F%c render%c (" + formatLanes(lanes) + ")",
+        REACT_LOGO_STYLE,
+        "",
+        "font-weight: normal;"
+      );
     }
-
-    return;
   }
-
-  if (allowReplay) {
-    if (isDiscreteEventThatRequiresHydration(domEventName)) {
-      // This to be replayed later once the target is available.
-      queueDiscreteEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
+}
+function logRenderStopped() {
+  {
+    if (enableDebugTracing) {
+      groupEnd();
+    }
+  }
+}
+function logForceUpdateScheduled(componentName, lane) {
+  {
+    if (enableDebugTracing) {
+      log(
+        "%c\u269B\uFE0F%c " +
+          componentName +
+          " forced update %c(" +
+          formatLanes(lane) +
+          ")",
+        REACT_LOGO_STYLE,
+        "color: #db2e1f; font-weight: bold;",
+        ""
+      );
+    }
+  }
+}
+function logStateUpdateScheduled(componentName, lane, payloadOrAction) {
+  {
+    if (enableDebugTracing) {
+      log(
+        "%c\u269B\uFE0F%c " +
+          componentName +
+          " updated state %c(" +
+          formatLanes(lane) +
+          ")",
+        REACT_LOGO_STYLE,
+        "color: #01a252; font-weight: bold;",
+        "",
+        payloadOrAction
       );
-      return;
     }
+  }
+}
 
-    if (
-      queueIfContinuousEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )
-    ) {
-      return;
-    } // We need to clear only if we didn't queue because
-    // queueing is accumulative.
+// This is imported by the event replaying implementation in React DOM. It's
+// in a separate file to break a circular dependency between the renderer and
+// the reconciler.
+function isRootDehydrated(root) {
+  var currentState = root.current.memoizedState;
+  return currentState.isDehydrated;
+}
 
-    clearIfContinuousEvent(domEventName, nativeEvent);
-  } // This is not replayable so we'll invoke it but without a target,
-  // in case the event system needs to trace it.
+// Intentionally not using it yet to derisk the initial implementation, because
+// the way we push/pop these values is a bit unusual. If there's a mistake, I'd
+// rather the ids be wrong than crash the whole reconciler.
 
-  dispatchEventForPluginEventSystem(
-    domEventName,
-    eventSystemFlags,
-    nativeEvent,
-    null,
-    targetContainer
-  );
+var forkStack = [];
+var forkStackIndex = 0;
+var treeForkProvider = null;
+var treeForkCount = 0;
+var idStack = [];
+var idStackIndex = 0;
+var treeContextProvider = null;
+var treeContextId = 1;
+var treeContextOverflow = "";
+function isForkedChild(workInProgress) {
+  warnIfNotHydrating();
+  return (workInProgress.flags & Forked) !== NoFlags$1;
 }
+function getForksAtLevel(workInProgress) {
+  warnIfNotHydrating();
+  return treeForkCount;
+}
+function getTreeId() {
+  var overflow = treeContextOverflow;
+  var idWithLeadingBit = treeContextId;
+  var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
+  return id.toString(32) + overflow;
+}
+function pushTreeFork(workInProgress, totalChildren) {
+  // This is called right after we reconcile an array (or iterator) of child
+  // fibers, because that's the only place where we know how many children in
+  // the whole set without doing extra work later, or storing addtional
+  // information on the fiber.
+  //
+  // That's why this function is separate from pushTreeId — it's called during
+  // the render phase of the fork parent, not the child, which is where we push
+  // the other context values.
+  //
+  // In the Fizz implementation this is much simpler because the child is
+  // rendered in the same callstack as the parent.
+  //
+  // It might be better to just add a `forks` field to the Fiber type. It would
+  // make this module simpler.
+  warnIfNotHydrating();
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
+}
+function pushTreeId(workInProgress, totalChildren, index) {
+  warnIfNotHydrating();
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  var baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
+  // of the id; we use it to account for leading 0s.
 
-function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  var blockedOn = findInstanceBlockingEvent(
-    domEventName,
-    eventSystemFlags,
-    targetContainer,
-    nativeEvent
-  );
-
-  if (blockedOn === null) {
-    dispatchEventForPluginEventSystem(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      return_targetInst,
-      targetContainer
-    );
-    clearIfContinuousEvent(domEventName, nativeEvent);
-    return;
-  }
+  var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
+  var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+  var slot = index + 1;
+  var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
+  // consideration the leading 1 we use to mark the end of the sequence.
 
-  if (
-    queueIfContinuousEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )
-  ) {
-    nativeEvent.stopPropagation();
-    return;
-  } // We need to clear only if we didn't queue because
-  // queueing is accumulative.
+  if (length > 30) {
+    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
+    // This branch assumes the length of the base id is greater than 5; it won't
+    // work for smaller ids, because you need 5 bits per character.
+    //
+    // We encode the id in multiple steps: first the base id, then the
+    // remaining digits.
+    //
+    // Each 5 bit sequence corresponds to a single base 32 character. So for
+    // example, if the current id is 23 bits long, we can convert 20 of those
+    // bits into a string of 4 characters, with 3 bits left over.
+    //
+    // First calculate how many bits in the base id represent a complete
+    // sequence of characters.
+    var numberOfOverflowBits = baseLength - (baseLength % 5); // Then create a bitmask that selects only those bits.
 
-  clearIfContinuousEvent(domEventName, nativeEvent);
+    var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
 
-  if (
-    eventSystemFlags & IS_CAPTURE_PHASE &&
-    isDiscreteEventThatRequiresHydration(domEventName)
-  ) {
-    while (blockedOn !== null) {
-      var fiber = getInstanceFromNode$1(blockedOn);
+    var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
 
-      if (fiber !== null) {
-        attemptSynchronousHydration$1(fiber);
-      }
+    var restOfBaseId = baseId >> numberOfOverflowBits;
+    var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
+    // we made more room, this time it won't overflow.
 
-      var nextBlockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
+    var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
+    var restOfNewBits = slot << restOfBaseLength;
+    var id = restOfNewBits | restOfBaseId;
+    var overflow = newOverflow + baseOverflow;
+    treeContextId = (1 << restOfLength) | id;
+    treeContextOverflow = overflow;
+  } else {
+    // Normal path
+    var newBits = slot << baseLength;
 
-      if (nextBlockedOn === null) {
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        );
-      }
+    var _id = newBits | baseId;
 
-      if (nextBlockedOn === blockedOn) {
-        break;
-      }
+    var _overflow = baseOverflow;
+    treeContextId = (1 << length) | _id;
+    treeContextOverflow = _overflow;
+  }
+}
+function pushMaterializedTreeId(workInProgress) {
+  warnIfNotHydrating(); // This component materialized an id. This will affect any ids that appear
+  // in its children.
 
-      blockedOn = nextBlockedOn;
-    }
+  var returnFiber = workInProgress.return;
 
-    if (blockedOn !== null) {
-      nativeEvent.stopPropagation();
-    }
+  if (returnFiber !== null) {
+    var numberOfForks = 1;
+    var slotIndex = 0;
+    pushTreeFork(workInProgress, numberOfForks);
+    pushTreeId(workInProgress, numberOfForks, slotIndex);
+  }
+}
 
-    return;
-  } // This is not replayable so we'll invoke it but without a target,
-  // in case the event system needs to trace it.
+function getBitLength(number) {
+  return 32 - clz32(number);
+}
 
-  dispatchEventForPluginEventSystem(
-    domEventName,
-    eventSystemFlags,
-    nativeEvent,
-    null,
-    targetContainer
-  );
+function getLeadingBit(id) {
+  return 1 << (getBitLength(id) - 1);
 }
 
-var return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
-// The return_targetInst field above is conceptually part of the return value.
-
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  // TODO: Warn if _enabled is false.
-  return_targetInst = null;
-  var nativeEventTarget = getEventTarget(nativeEvent);
-  var targetInst = getClosestInstanceFromNode(nativeEventTarget);
-
-  if (targetInst !== null) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-
-    if (nearestMounted === null) {
-      // This tree has been unmounted already. Dispatch without a target.
-      targetInst = null;
-    } else {
-      var tag = nearestMounted.tag;
+function popTreeContext(workInProgress) {
+  // Restore the previous values.
+  // This is a bit more complicated than other context-like modules in Fiber
+  // because the same Fiber may appear on the stack multiple times and for
+  // different reasons. We have to keep popping until the work-in-progress is
+  // no longer at the top of the stack.
+  while (workInProgress === treeForkProvider) {
+    treeForkProvider = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+    treeForkCount = forkStack[--forkStackIndex];
+    forkStack[forkStackIndex] = null;
+  }
 
-      if (tag === SuspenseComponent) {
-        var instance = getSuspenseInstanceFromFiber(nearestMounted);
+  while (workInProgress === treeContextProvider) {
+    treeContextProvider = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextOverflow = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+    treeContextId = idStack[--idStackIndex];
+    idStack[idStackIndex] = null;
+  }
+}
+function getSuspendedTreeContext() {
+  warnIfNotHydrating();
 
-        if (instance !== null) {
-          // Queue the event to be replayed later. Abort dispatching since we
-          // don't want this event dispatched twice through the event system.
-          // TODO: If this is the first discrete event in the queue. Schedule an increased
-          // priority for this boundary.
-          return instance;
-        } // This shouldn't happen, something went wrong but to avoid blocking
-        // the whole system, dispatch the event without a target.
-        // TODO: Warn.
+  if (treeContextProvider !== null) {
+    return {
+      id: treeContextId,
+      overflow: treeContextOverflow
+    };
+  } else {
+    return null;
+  }
+}
+function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
+  warnIfNotHydrating();
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextId = suspendedContext.id;
+  treeContextOverflow = suspendedContext.overflow;
+  treeContextProvider = workInProgress;
+}
 
-        targetInst = null;
-      } else if (tag === HostRoot) {
-        var root = nearestMounted.stateNode;
+function warnIfNotHydrating() {
+  {
+    if (!getIsHydrating()) {
+      error(
+        "Expected to be hydrating. This is a bug in React. Please file " +
+          "an issue."
+      );
+    }
+  }
+}
 
-        if (isRootDehydrated(root)) {
-          // If this happens during a replay something went wrong and it might block
-          // the whole system.
-          return getContainerFromFiber(nearestMounted);
-        }
+var contextStackCursor = createCursor(null);
+var contextFiberStackCursor = createCursor(null);
+var rootInstanceStackCursor = createCursor(null);
 
-        targetInst = null;
-      } else if (nearestMounted !== targetInst) {
-        // If we get an event (ex: img onload) before committing that
-        // component's mount, ignore it for now (that is, treat it as if it was an
-        // event on a non-React tree). We might also consider queueing events and
-        // dispatching them after the mount.
-        targetInst = null;
-      }
+function requiredContext(c) {
+  {
+    if (c === null) {
+      error(
+        "Expected host context to exist. This error is likely caused by a bug " +
+          "in React. Please file an issue."
+      );
     }
   }
 
-  return_targetInst = targetInst; // We're not blocked on anything.
-
-  return null;
+  return c;
 }
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    // Used by SimpleEventPlugin:
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange": // Used by polyfills:
-    // eslint-disable-next-line no-fallthrough
 
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate": // Only enableCreateEventHandleAPI:
-    // eslint-disable-next-line no-fallthrough
+function getCurrentRootHostContainer() {
+  return rootInstanceStackCursor.current;
+}
 
-    case "beforeblur":
-    case "afterblur": // Not used by React but could be by user code:
-    // eslint-disable-next-line no-fallthrough
+function getRootHostContainer() {
+  var rootInstance = requiredContext(rootInstanceStackCursor.current);
+  return rootInstance;
+}
 
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return DiscreteEventPriority;
+function pushHostContainer(fiber, nextRootInstance) {
+  // Push current root instance onto the stack;
+  // This allows us to reset root when portals are popped.
+  push(rootInstanceStackCursor, nextRootInstance, fiber); // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
 
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel": // Not used by React but could be by user code:
-    // eslint-disable-next-line no-fallthrough
+  push(contextFiberStackCursor, fiber, fiber); // Finally, we need to push the host context to the stack.
+  // However, we can't just call getRootHostContext() and push it because
+  // we'd have a different number of entries on the stack depending on
+  // whether getRootHostContext() throws somewhere in renderer code or not.
+  // So we push an empty value first. This lets us safely unwind on errors.
 
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return ContinuousEventPriority;
+  push(contextStackCursor, null, fiber);
+  var nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
 
-    case "message": {
-      // We might be in the Scheduler callback.
-      // Eventually this mechanism will be replaced by a check
-      // of the current priority on the native scheduler.
-      var schedulerPriority = getCurrentPriorityLevel();
+  pop(contextStackCursor, fiber);
+  push(contextStackCursor, nextRootContext, fiber);
+}
 
-      switch (schedulerPriority) {
-        case ImmediatePriority:
-          return DiscreteEventPriority;
+function popHostContainer(fiber) {
+  pop(contextStackCursor, fiber);
+  pop(contextFiberStackCursor, fiber);
+  pop(rootInstanceStackCursor, fiber);
+}
 
-        case UserBlockingPriority:
-          return ContinuousEventPriority;
+function getHostContext() {
+  var context = requiredContext(contextStackCursor.current);
+  return context;
+}
 
-        case NormalPriority$1:
-        case LowPriority:
-          // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
-          return DefaultEventPriority;
+function pushHostContext(fiber) {
+  var context = requiredContext(contextStackCursor.current);
+  var nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
 
-        case IdlePriority:
-          return IdleEventPriority;
+  if (context === nextContext) {
+    return;
+  } // Track the context and the Fiber that provided it.
+  // This enables us to pop only Fibers that provide unique contexts.
 
-        default:
-          return DefaultEventPriority;
-      }
-    }
+  push(contextFiberStackCursor, fiber, fiber);
+  push(contextStackCursor, nextContext, fiber);
+}
 
-    default:
-      return DefaultEventPriority;
+function popHostContext(fiber) {
+  // Do not pop unless this Fiber provided the current context.
+  // pushHostContext() only pushes Fibers that provide unique contexts.
+  if (contextFiberStackCursor.current !== fiber) {
+    return;
   }
-}
 
-function addEventBubbleListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, false);
-  return listener;
-}
-function addEventCaptureListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, true);
-  return listener;
-}
-function addEventCaptureListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, {
-    capture: true,
-    passive: passive
-  });
-  return listener;
-}
-function addEventBubbleListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, {
-    passive: passive
-  });
-  return listener;
-}
-function removeEventListener(target, eventType, listener, capture) {
-  target.removeEventListener(eventType, listener, capture);
+  pop(contextStackCursor, fiber);
+  pop(contextFiberStackCursor, fiber);
 }
 
-/**
- * These variables store information about text content of a target node,
- * allowing comparison of content before and after a given event.
- *
- * Identify the node where selection currently begins, then observe
- * both its text content and its current position in the DOM. Since the
- * browser may natively replace the target node during composition, we can
- * use its position to find its replacement.
- *
- *
- */
-var root = null;
-var startText = null;
-var fallbackText = null;
-function initialize(nativeEventTarget) {
-  root = nativeEventTarget;
-  startText = getText();
-  return true;
-}
-function reset() {
-  root = null;
-  startText = null;
-  fallbackText = null;
-}
-function getData() {
-  if (fallbackText) {
-    return fallbackText;
-  }
+// This may have been an insertion or a hydration.
 
-  var start;
-  var startValue = startText;
-  var startLength = startValue.length;
-  var end;
-  var endValue = getText();
-  var endLength = endValue.length;
+var hydrationParentFiber = null;
+var nextHydratableInstance = null;
+var isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
+// due to earlier mismatches or a suspended fiber.
 
-  for (start = 0; start < startLength; start++) {
-    if (startValue[start] !== endValue[start]) {
-      break;
-    }
-  }
+var didSuspendOrErrorDEV = false; // Hydration errors that were thrown inside this boundary
 
-  var minEnd = startLength - start;
+var hydrationErrors = null;
+var rootOrSingletonContext = false;
 
-  for (end = 1; end <= minEnd; end++) {
-    if (startValue[startLength - end] !== endValue[endLength - end]) {
-      break;
+function warnIfHydrating() {
+  {
+    if (isHydrating) {
+      error(
+        "We should not be hydrating here. This is a bug in React. Please file a bug."
+      );
     }
   }
+}
 
-  var sliceTail = end > 1 ? 1 - end : undefined;
-  fallbackText = endValue.slice(start, sliceTail);
-  return fallbackText;
+function markDidThrowWhileHydratingDEV() {
+  {
+    didSuspendOrErrorDEV = true;
+  }
 }
-function getText() {
-  if ("value" in root) {
-    return root.value;
+function didSuspendOrErrorWhileHydratingDEV() {
+  {
+    return didSuspendOrErrorDEV;
   }
-
-  return root.textContent;
 }
 
-/**
- * `charCode` represents the actual "character code" and is safe to use with
- * `String.fromCharCode`. As such, only keys that correspond to printable
- * characters produce a valid `charCode`, the only exception to this is Enter.
- * The Tab-key is considered non-printable and does not have a `charCode`,
- * presumably because it does not produce a tab-character in browsers.
- *
- * @param {object} nativeEvent Native browser event.
- * @return {number} Normalized `charCode` property.
- */
-function getEventCharCode(nativeEvent) {
-  var charCode;
-  var keyCode = nativeEvent.keyCode;
-
-  if ("charCode" in nativeEvent) {
-    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
-
-    if (charCode === 0 && keyCode === 13) {
-      charCode = 13;
-    }
-  } else {
-    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
-    charCode = keyCode;
-  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
-  // report Enter as charCode 10 when ctrl is pressed.
+function enterHydrationState(fiber) {
+  var parentInstance = fiber.stateNode.containerInfo;
+  nextHydratableInstance =
+    getFirstHydratableChildWithinContainer(parentInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  didSuspendOrErrorDEV = false;
+  rootOrSingletonContext = true;
+  return true;
+}
 
-  if (charCode === 10) {
-    charCode = 13;
-  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
-  // Must not discard the (non-)printable Enter-key.
+function reenterHydrationStateFromDehydratedSuspenseInstance(
+  fiber,
+  suspenseInstance,
+  treeContext
+) {
+  nextHydratableInstance =
+    getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
+  hydrationParentFiber = fiber;
+  isHydrating = true;
+  hydrationErrors = null;
+  didSuspendOrErrorDEV = false;
+  rootOrSingletonContext = false;
 
-  if (charCode >= 32 || charCode === 13) {
-    return charCode;
+  if (treeContext !== null) {
+    restoreSuspendedTreeContext(fiber, treeContext);
   }
 
-  return 0;
-}
-
-function functionThatReturnsTrue() {
   return true;
 }
 
-function functionThatReturnsFalse() {
-  return false;
-} // This is intentionally a factory so that we have different returned constructors.
-// If we had a single constructor, it would be megamorphic and engines would deopt.
-
-function createSyntheticEvent(Interface) {
-  /**
-   * Synthetic events are dispatched by event plugins, typically in response to a
-   * top-level event delegation handler.
-   *
-   * These systems should generally use pooling to reduce the frequency of garbage
-   * collection. The system should check `isPersistent` to determine whether the
-   * event should be released into the pool after being dispatched. Users that
-   * need a persisted event should invoke `persist`.
-   *
-   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
-   * normalizing browser quirks. Subclasses do not necessarily have to implement a
-   * DOM interface; custom application-specific events can also subclass this.
-   */
-  // $FlowFixMe[missing-this-annot]
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-
-    for (var propName in Interface) {
-      if (!Interface.hasOwnProperty(propName)) {
-        continue;
+function warnUnhydratedInstance(returnFiber, instance) {
+  {
+    switch (returnFiber.tag) {
+      case HostRoot: {
+        didNotHydrateInstanceWithinContainer(
+          returnFiber.stateNode.containerInfo,
+          instance
+        );
+        break;
       }
 
-      var normalize = Interface[propName];
+      case HostSingleton:
+      case HostComponent: {
+        var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+        didNotHydrateInstance(
+          returnFiber.type,
+          returnFiber.memoizedProps,
+          returnFiber.stateNode,
+          instance, // TODO: Delete this argument when we remove the legacy root API.
+          isConcurrentMode
+        );
+        break;
+      }
 
-      if (normalize) {
-        this[propName] = normalize(nativeEvent);
-      } else {
-        this[propName] = nativeEvent[propName];
+      case SuspenseComponent: {
+        var suspenseState = returnFiber.memoizedState;
+        if (suspenseState.dehydrated !== null)
+          didNotHydrateInstanceWithinSuspenseInstance(
+            suspenseState.dehydrated,
+            instance
+          );
+        break;
       }
     }
+  }
+}
 
-    var defaultPrevented =
-      nativeEvent.defaultPrevented != null
-        ? nativeEvent.defaultPrevented
-        : nativeEvent.returnValue === false;
+function deleteHydratableInstance(returnFiber, instance) {
+  warnUnhydratedInstance(returnFiber, instance);
+  var childToDelete = createFiberFromHostInstanceForDeletion();
+  childToDelete.stateNode = instance;
+  childToDelete.return = returnFiber;
+  var deletions = returnFiber.deletions;
 
-    if (defaultPrevented) {
-      this.isDefaultPrevented = functionThatReturnsTrue;
-    } else {
-      this.isDefaultPrevented = functionThatReturnsFalse;
-    }
-
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  } // $FlowFixMe[prop-missing] found when upgrading Flow
+  if (deletions === null) {
+    returnFiber.deletions = [childToDelete];
+    returnFiber.flags |= ChildDeletion;
+  } else {
+    deletions.push(childToDelete);
+  }
+}
 
-  assign(SyntheticBaseEvent.prototype, {
-    // $FlowFixMe[missing-this-annot]
-    preventDefault: function () {
-      this.defaultPrevented = true;
-      var event = this.nativeEvent;
+function warnNonhydratedInstance(returnFiber, fiber) {
+  {
+    if (didSuspendOrErrorDEV) {
+      // Inside a boundary that already suspended. We're currently rendering the
+      // siblings of a suspended node. The mismatch may be due to the missing
+      // data, so it's probably a false positive.
+      return;
+    }
 
-      if (!event) {
-        return;
-      }
+    switch (returnFiber.tag) {
+      case HostRoot: {
+        var parentContainer = returnFiber.stateNode.containerInfo;
 
-      if (event.preventDefault) {
-        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.returnValue !== "unknown") {
-        event.returnValue = false;
-      }
+        switch (fiber.tag) {
+          case HostSingleton:
+          case HostComponent:
+            var type = fiber.type;
+            didNotFindHydratableInstanceWithinContainer(parentContainer, type);
+            break;
 
-      this.isDefaultPrevented = functionThatReturnsTrue;
-    },
-    // $FlowFixMe[missing-this-annot]
-    stopPropagation: function () {
-      var event = this.nativeEvent;
+          case HostText:
+            var text = fiber.pendingProps;
+            didNotFindHydratableTextInstanceWithinContainer(
+              parentContainer,
+              text
+            );
+            break;
+        }
 
-      if (!event) {
-        return;
+        break;
       }
 
-      if (event.stopPropagation) {
-        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.cancelBubble !== "unknown") {
-        // The ChangeEventPlugin registers a "propertychange" event for
-        // IE. This event does not support bubbling or cancelling, and
-        // any references to cancelBubble throw "Member not found".  A
-        // typeof check of "unknown" circumvents this issue (and is also
-        // IE specific).
-        event.cancelBubble = true;
-      }
+      case HostSingleton:
+      case HostComponent: {
+        var parentType = returnFiber.type;
+        var parentProps = returnFiber.memoizedProps;
+        var parentInstance = returnFiber.stateNode;
 
-      this.isPropagationStopped = functionThatReturnsTrue;
-    },
+        switch (fiber.tag) {
+          case HostSingleton:
+          case HostComponent: {
+            var _type = fiber.type;
+            var _props = fiber.pendingProps;
+            var isConcurrentMode =
+              (returnFiber.mode & ConcurrentMode) !== NoMode;
+            didNotFindHydratableInstance(
+              parentType,
+              parentProps,
+              parentInstance,
+              _type,
+              _props, // TODO: Delete this argument when we remove the legacy root API.
+              isConcurrentMode
+            );
+            break;
+          }
 
-    /**
-     * We release all dispatched `SyntheticEvent`s after each event loop, adding
-     * them back into the pool. This allows a way to hold onto a reference that
-     * won't be added back into the pool.
-     */
-    persist: function () {
-      // Modern event system doesn't use pooling.
-    },
+          case HostText: {
+            var _text = fiber.pendingProps;
 
-    /**
-     * Checks if this event should be released back into the pool.
-     *
-     * @return {boolean} True if this should not be released, false otherwise.
-     */
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
-}
-/**
- * @interface Event
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+            var _isConcurrentMode =
+              (returnFiber.mode & ConcurrentMode) !== NoMode;
 
-var EventInterface = {
-  eventPhase: 0,
-  bubbles: 0,
-  cancelable: 0,
-  timeStamp: function (event) {
-    return event.timeStamp || Date.now();
-  },
-  defaultPrevented: 0,
-  isTrusted: 0
-};
-var SyntheticEvent = createSyntheticEvent(EventInterface);
+            didNotFindHydratableTextInstance(
+              parentType,
+              parentProps,
+              parentInstance,
+              _text, // TODO: Delete this argument when we remove the legacy root API.
+              _isConcurrentMode
+            );
+            break;
+          }
+        }
 
-var UIEventInterface = assign({}, EventInterface, {
-  view: 0,
-  detail: 0
-});
+        break;
+      }
 
-var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
-var lastMovementX;
-var lastMovementY;
-var lastMouseEvent;
+      case SuspenseComponent: {
+        var suspenseState = returnFiber.memoizedState;
+        var _parentInstance = suspenseState.dehydrated;
+        if (_parentInstance !== null)
+          switch (fiber.tag) {
+            case HostSingleton:
+            case HostComponent:
+              var _type2 = fiber.type;
+              didNotFindHydratableInstanceWithinSuspenseInstance(
+                _parentInstance,
+                _type2
+              );
+              break;
 
-function updateMouseMovementPolyfillState(event) {
-  if (event !== lastMouseEvent) {
-    if (lastMouseEvent && event.type === "mousemove") {
-      // $FlowFixMe assuming this is a number
-      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe assuming this is a number
+            case HostText:
+              var _text2 = fiber.pendingProps;
+              didNotFindHydratableTextInstanceWithinSuspenseInstance(
+                _parentInstance,
+                _text2
+              );
+              break;
+          }
+        break;
+      }
 
-      lastMovementY = event.screenY - lastMouseEvent.screenY;
-    } else {
-      lastMovementX = 0;
-      lastMovementY = 0;
+      default:
+        return;
     }
-
-    lastMouseEvent = event;
   }
 }
-/**
- * @interface MouseEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
 
-var MouseEventInterface = assign({}, UIEventInterface, {
-  screenX: 0,
-  screenY: 0,
-  clientX: 0,
-  clientY: 0,
-  pageX: 0,
-  pageY: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  altKey: 0,
-  metaKey: 0,
-  getModifierState: getEventModifierState,
-  button: 0,
-  buttons: 0,
-  relatedTarget: function (event) {
-    if (event.relatedTarget === undefined)
-      return event.fromElement === event.srcElement
-        ? event.toElement
-        : event.fromElement;
-    return event.relatedTarget;
-  },
-  movementX: function (event) {
-    if ("movementX" in event) {
-      return event.movementX;
-    }
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & ~Hydrating) | Placement;
+  warnNonhydratedInstance(returnFiber, fiber);
+}
 
-    updateMouseMovementPolyfillState(event);
-    return lastMovementX;
-  },
-  movementY: function (event) {
-    if ("movementY" in event) {
-      return event.movementY;
-    } // Don't need to call updateMouseMovementPolyfillState() here
-    // because it's guaranteed to have already run when movementX
-    // was copied.
+function tryHydrateInstance(fiber, nextInstance) {
+  // fiber is a HostComponent Fiber
+  var instance = canHydrateInstance(nextInstance, fiber.type);
 
-    return lastMovementY;
+  if (instance !== null) {
+    fiber.stateNode = instance;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = getFirstHydratableChild(instance);
+    rootOrSingletonContext = false;
+    return true;
   }
-});
-
-var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
-/**
- * @interface DragEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
-
-var DragEventInterface = assign({}, MouseEventInterface, {
-  dataTransfer: 0
-});
-
-var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
-/**
- * @interface FocusEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
 
-var FocusEventInterface = assign({}, UIEventInterface, {
-  relatedTarget: 0
-});
-
-var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
- * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
- */
+  return false;
+}
 
-var AnimationEventInterface = assign({}, EventInterface, {
-  animationName: 0,
-  elapsedTime: 0,
-  pseudoElement: 0
-});
+function tryHydrateText(fiber, nextInstance) {
+  // fiber is a HostText Fiber
+  var text = fiber.pendingProps;
+  var textInstance = canHydrateTextInstance(nextInstance, text);
 
-var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/clipboard-apis/
- */
+  if (textInstance !== null) {
+    fiber.stateNode = textInstance;
+    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
 
-var ClipboardEventInterface = assign({}, EventInterface, {
-  clipboardData: function (event) {
-    return "clipboardData" in event
-      ? event.clipboardData
-      : window.clipboardData;
+    nextHydratableInstance = null;
+    return true;
   }
-});
 
-var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
- */
+  return false;
+}
 
-var CompositionEventInterface = assign({}, EventInterface, {
-  data: 0
-});
+function tryHydrateSuspense(fiber, nextInstance) {
+  // fiber is a SuspenseComponent Fiber
+  var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
 
-var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
- *      /#events-inputevents
- */
-// Happens to share the same list for now.
+  if (suspenseInstance !== null) {
+    var suspenseState = {
+      dehydrated: suspenseInstance,
+      treeContext: getSuspendedTreeContext(),
+      retryLane: OffscreenLane
+    };
+    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
+    // This simplifies the code for getHostSibling and deleting nodes,
+    // since it doesn't have to consider all Suspense boundaries and
+    // check if they're dehydrated ones or not.
 
-var SyntheticInputEvent = SyntheticCompositionEvent;
-/**
- * Normalization of deprecated HTML5 `key` values
- * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
- */
+    var dehydratedFragment =
+      createFiberFromDehydratedFragment(suspenseInstance);
+    dehydratedFragment.return = fiber;
+    fiber.child = dehydratedFragment;
+    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
+    // it during the first pass. Instead, we'll reenter it later.
 
-var normalizeKey = {
-  Esc: "Escape",
-  Spacebar: " ",
-  Left: "ArrowLeft",
-  Up: "ArrowUp",
-  Right: "ArrowRight",
-  Down: "ArrowDown",
-  Del: "Delete",
-  Win: "OS",
-  Menu: "ContextMenu",
-  Apps: "ContextMenu",
-  Scroll: "ScrollLock",
-  MozPrintableKey: "Unidentified"
-};
-/**
- * Translation from legacy `keyCode` to HTML5 `key`
- * Only special keys supported, all others depend on keyboard layout or browser
- * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
- */
+    nextHydratableInstance = null;
+    return true;
+  }
 
-var translateToKey = {
-  "8": "Backspace",
-  "9": "Tab",
-  "12": "Clear",
-  "13": "Enter",
-  "16": "Shift",
-  "17": "Control",
-  "18": "Alt",
-  "19": "Pause",
-  "20": "CapsLock",
-  "27": "Escape",
-  "32": " ",
-  "33": "PageUp",
-  "34": "PageDown",
-  "35": "End",
-  "36": "Home",
-  "37": "ArrowLeft",
-  "38": "ArrowUp",
-  "39": "ArrowRight",
-  "40": "ArrowDown",
-  "45": "Insert",
-  "46": "Delete",
-  "112": "F1",
-  "113": "F2",
-  "114": "F3",
-  "115": "F4",
-  "116": "F5",
-  "117": "F6",
-  "118": "F7",
-  "119": "F8",
-  "120": "F9",
-  "121": "F10",
-  "122": "F11",
-  "123": "F12",
-  "144": "NumLock",
-  "145": "ScrollLock",
-  "224": "Meta"
-};
-/**
- * @param {object} nativeEvent Native browser event.
- * @return {string} Normalized `key` property.
- */
+  return false;
+}
 
-function getEventKey(nativeEvent) {
-  if (nativeEvent.key) {
-    // Normalize inconsistent values reported by browsers due to
-    // implementations of a working draft specification.
-    // FireFox implements `key` but returns `MozPrintableKey` for all
-    // printable characters (normalized to `Unidentified`), ignore it.
-    var key = normalizeKey[nativeEvent.key] || nativeEvent.key; // $FlowFixMe unable to index with a `mixed` value
+function shouldClientRenderOnMismatch(fiber) {
+  return (
+    (fiber.mode & ConcurrentMode) !== NoMode &&
+    (fiber.flags & DidCapture) === NoFlags$1
+  );
+}
 
-    if (key !== "Unidentified") {
-      return key;
-    }
-  } // Browser does not implement `key`, polyfill as much of it as we can.
+function throwOnHydrationMismatch(fiber) {
+  throw new Error(
+    "Hydration failed because the initial UI does not match what was " +
+      "rendered on the server."
+  );
+}
 
-  if (nativeEvent.type === "keypress") {
-    var charCode = getEventCharCode(
-      // $FlowFixMe unable to narrow to `KeyboardEvent`
-      nativeEvent
-    ); // The enter-key is technically both printable and non-printable and can
-    // thus be captured by `keypress`, no other non-printable key should.
+function claimHydratableSingleton(fiber) {
+  {
+    if (!isHydrating) {
+      return;
+    }
 
-    return charCode === 13 ? "Enter" : String.fromCharCode(charCode);
+    var currentRootContainer = getRootHostContainer();
+    var currentHostContext = getHostContext();
+    var instance = (fiber.stateNode = resolveSingletonInstance(
+      fiber.type,
+      fiber.pendingProps,
+      currentRootContainer,
+      currentHostContext,
+      false
+    ));
+    hydrationParentFiber = fiber;
+    rootOrSingletonContext = true;
+    nextHydratableInstance = getFirstHydratableChild(instance);
   }
+}
 
-  if (nativeEvent.type === "keydown" || nativeEvent.type === "keyup") {
-    // While user keyboard layout determines the actual meaning of each
-    // `keyCode` value, almost all function keys have a universal value.
-    // $FlowFixMe unable to index with a `mixed` value
-    return translateToKey[nativeEvent.keyCode] || "Unidentified";
+function advanceToFirstAttemptableInstance(fiber) {
+  // fiber is HostComponent Fiber
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    )
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
   }
-
-  return "";
 }
-/**
- * Translation from modifier key to the associated property in the event.
- * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
- */
-
-var modifierKeyToProp = {
-  Alt: "altKey",
-  Control: "ctrlKey",
-  Meta: "metaKey",
-  Shift: "shiftKey"
-}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
-// getModifierState. If getModifierState is not supported, we map it to a set of
-// modifier keys exposed by the event. In this case, Lock-keys are not supported.
-// $FlowFixMe[missing-local-annot]
-// $FlowFixMe[missing-this-annot]
-
-function modifierStateGetter(keyArg) {
-  var syntheticEvent = this;
-  var nativeEvent = syntheticEvent.nativeEvent;
 
-  if (nativeEvent.getModifierState) {
-    return nativeEvent.getModifierState(keyArg);
+function advanceToFirstAttemptableTextInstance() {
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForTextInstance(nextHydratableInstance)
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
   }
-
-  var keyProp = modifierKeyToProp[keyArg];
-  return keyProp ? !!nativeEvent[keyProp] : false;
 }
 
-function getEventModifierState(nativeEvent) {
-  return modifierStateGetter;
+function advanceToFirstAttemptableSuspenseInstance() {
+  while (
+    nextHydratableInstance &&
+    shouldSkipHydratableForSuspenseInstance(nextHydratableInstance)
+  ) {
+    // Flow doesn't understand that inside this block nextHydratableInstance is not null
+    var instance = nextHydratableInstance;
+    nextHydratableInstance = getNextHydratableSibling(instance);
+  }
 }
-/**
- * @interface KeyboardEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
-
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-  key: getEventKey,
-  code: 0,
-  location: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  altKey: 0,
-  metaKey: 0,
-  repeat: 0,
-  locale: 0,
-  getModifierState: getEventModifierState,
-  // Legacy Interface
-  charCode: function (event) {
-    // `charCode` is the result of a KeyPress event and represents the value of
-    // the actual printable character.
-    // KeyPress is deprecated, but its replacement is not yet final and not
-    // implemented in any major browser. Only KeyPress has charCode.
-    if (event.type === "keypress") {
-      return getEventCharCode(
-        // $FlowFixMe unable to narrow to `KeyboardEvent`
-        event
-      );
-    }
 
-    return 0;
-  },
-  keyCode: function (event) {
-    // `keyCode` is the result of a KeyDown/Up event and represents the value of
-    // physical keyboard key.
-    // The actual meaning of the value depends on the users' keyboard layout
-    // which cannot be detected. Assuming that it is a US keyboard layout
-    // provides a surprisingly accurate mapping for US and European users.
-    // Due to this, it is left to the user to implement at this time.
-    if (event.type === "keydown" || event.type === "keyup") {
-      return event.keyCode;
-    }
+function tryToClaimNextHydratableInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-    return 0;
-  },
-  which: function (event) {
-    // `which` is an alias for either `keyCode` or `charCode` depending on the
-    // type of the event.
-    if (event.type === "keypress") {
-      return getEventCharCode(
-        // $FlowFixMe unable to narrow to `KeyboardEvent`
-        event
-      );
+  {
+    if (!isHydratableType(fiber.type, fiber.pendingProps)) {
+      // This fiber never hydrates from the DOM and always does an insert
+      fiber.flags = (fiber.flags & ~Hydrating) | Placement;
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      return;
     }
+  }
 
-    if (event.type === "keydown" || event.type === "keyup") {
-      return event.keyCode;
-    }
+  var initialInstance = nextHydratableInstance;
 
-    return 0;
+  if (rootOrSingletonContext) {
+    // We may need to skip past certain nodes in these contexts
+    advanceToFirstAttemptableInstance(fiber);
   }
-});
 
-var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
-/**
- * @interface PointerEvent
- * @see http://www.w3.org/TR/pointerevents/
- */
+  var nextInstance = nextHydratableInstance;
 
-var PointerEventInterface = assign({}, MouseEventInterface, {
-  pointerId: 0,
-  width: 0,
-  height: 0,
-  pressure: 0,
-  tangentialPressure: 0,
-  tiltX: 0,
-  tiltY: 0,
-  twist: 0,
-  pointerType: 0,
-  isPrimary: 0
-});
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
 
-var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
-/**
- * @interface TouchEvent
- * @see http://www.w3.org/TR/touch-events/
- */
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
 
-var TouchEventInterface = assign({}, UIEventInterface, {
-  touches: 0,
-  targetTouches: 0,
-  changedTouches: 0,
-  altKey: 0,
-  metaKey: 0,
-  ctrlKey: 0,
-  shiftKey: 0,
-  getModifierState: getEventModifierState
-});
+  var firstAttemptedInstance = nextInstance;
 
-var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
-/**
- * @interface Event
- * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
- * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
- */
+  if (!tryHydrateInstance(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-var TransitionEventInterface = assign({}, EventInterface, {
-  propertyName: 0,
-  elapsedTime: 0,
-  pseudoElement: 0
-});
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
 
-var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
-/**
- * @interface WheelEvent
- * @see http://www.w3.org/TR/DOM-Level-3-Events/
- */
+    if (rootOrSingletonContext) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableInstance(fiber);
+    }
 
-var WheelEventInterface = assign({}, MouseEventInterface, {
-  deltaX: function (event) {
-    return "deltaX" in event
-      ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
-      : "wheelDeltaX" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDeltaX
-      : 0;
-  },
-  deltaY: function (event) {
-    return "deltaY" in event
-      ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
-      : "wheelDeltaY" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
-      : "wheelDelta" in event // $FlowFixMe assuming this is a number
-      ? -event.wheelDelta
-      : 0;
-  },
-  deltaZ: 0,
-  // Browsers without "deltaMode" is reporting in raw wheel delta where one
-  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
-  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
-  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
-  deltaMode: 0
-});
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateInstance(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
+}
 
-var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+function tryToClaimNextHydratableTextInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-var START_KEYCODE = 229;
-var canUseCompositionEvent = canUseDOM && "CompositionEvent" in window;
-var documentMode = null;
+  var text = fiber.pendingProps;
+  var isHydratable = isHydratableText(text);
+  var initialInstance = nextHydratableInstance;
 
-if (canUseDOM && "documentMode" in document) {
-  documentMode = document.documentMode;
-} // Webkit offers a very useful `textInput` event that can be used to
-// directly represent `beforeInput`. The IE `textinput` event is not as
-// useful, so we don't use it.
+  if (rootOrSingletonContext && isHydratable) {
+    // We may need to skip past certain nodes in these contexts.
+    // We don't skip if the text is not hydratable because we know no hydratables
+    // exist which could match this Fiber
+    advanceToFirstAttemptableTextInstance();
+  }
 
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
-// by the native compositionend event may be incorrect. Japanese ideographic
-// spaces, for instance (\u3000) are not recorded correctly.
+  var nextInstance = nextHydratableInstance;
 
-var useFallbackCompositionData =
-  canUseDOM &&
-  (!canUseCompositionEvent ||
-    (documentMode && documentMode > 8 && documentMode <= 11));
-var SPACEBAR_CODE = 32;
-var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+  if (!nextInstance || !isHydratable) {
+    // We exclude non hydrabable text because we know there are no matching hydratables.
+    // We either throw or insert depending on the render mode.
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
 
-function registerEvents$3() {
-  registerTwoPhaseEvent("onBeforeInput", [
-    "compositionend",
-    "keypress",
-    "textInput",
-    "paste"
-  ]);
-  registerTwoPhaseEvent("onCompositionEnd", [
-    "compositionend",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-  registerTwoPhaseEvent("onCompositionStart", [
-    "compositionstart",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-  registerTwoPhaseEvent("onCompositionUpdate", [
-    "compositionupdate",
-    "focusout",
-    "keydown",
-    "keypress",
-    "keyup",
-    "mousedown"
-  ]);
-} // Track whether we've ever handled a keypress on the space key.
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
 
-var hasSpaceKeypress = false;
-/**
- * Return whether a native keypress event is assumed to be a command.
- * This is required because Firefox fires `keypress` events for key commands
- * (cut, copy, select-all, etc.) even though no character is inserted.
- */
+  var firstAttemptedInstance = nextInstance;
 
-function isKeypressCommand(nativeEvent) {
-  return (
-    (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
-    !(nativeEvent.ctrlKey && nativeEvent.altKey)
-  );
-}
-/**
- * Translate native top level events into event types.
- */
+  if (!tryHydrateText(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-function getCompositionEventType(domEventName) {
-  switch (domEventName) {
-    case "compositionstart":
-      return "onCompositionStart";
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
 
-    case "compositionend":
-      return "onCompositionEnd";
+    if (rootOrSingletonContext && isHydratable) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableTextInstance();
+    }
 
-    case "compositionupdate":
-      return "onCompositionUpdate";
-  }
-}
-/**
- * Does our fallback best-guess model think this event signifies that
- * composition has begun?
- */
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateText(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-function isFallbackCompositionStart(domEventName, nativeEvent) {
-  return domEventName === "keydown" && nativeEvent.keyCode === START_KEYCODE;
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+  }
 }
-/**
- * Does our fallback mode think that this event is the end of composition?
- */
-
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      // Command keys insert or clear IME input.
-      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
 
-    case "keydown":
-      // Expect IME keyCode on each keydown. If we get any other
-      // code we must have exited earlier.
-      return nativeEvent.keyCode !== START_KEYCODE;
+function tryToClaimNextHydratableSuspenseInstance(fiber) {
+  if (!isHydrating) {
+    return;
+  }
 
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      // Events are not possible without cancelling IME.
-      return true;
+  var initialInstance = nextHydratableInstance;
 
-    default:
-      return false;
+  if (rootOrSingletonContext) {
+    // We may need to skip past certain nodes in these contexts
+    advanceToFirstAttemptableSuspenseInstance();
   }
-}
-/**
- * Google Input Tools provides composition data via a CustomEvent,
- * with the `data` property populated in the `detail` object. If this
- * is available on the event object, use it. If not, this is a plain
- * composition event and we have nothing special to extract.
- *
- * @param {object} nativeEvent
- * @return {?string}
- */
 
-function getDataFromCustomEvent(nativeEvent) {
-  var detail = nativeEvent.detail;
+  var nextInstance = nextHydratableInstance;
 
-  if (typeof detail === "object" && "data" in detail) {
-    return detail.data;
-  }
+  if (!nextInstance) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // Nothing to hydrate. Make it an insertion.
 
-  return null;
-}
-/**
- * Check if a composition event was triggered by Korean IME.
- * Our fallback mode does not work well with IE's Korean IME,
- * so just use native composition events when Korean IME is used.
- * Although CompositionEvent.locale property is deprecated,
- * it is available in IE, where our fallback mode is enabled.
- *
- * @param {object} nativeEvent
- * @return {boolean}
- */
+    insertNonHydratedInstance(hydrationParentFiber, fiber);
+    isHydrating = false;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = initialInstance;
+    return;
+  }
 
-function isUsingKoreanIME(nativeEvent) {
-  return nativeEvent.locale === "ko";
-} // Track the current IME composition status, if any.
+  var firstAttemptedInstance = nextInstance;
 
-var isComposing = false;
-/**
- * @return {?object} A SyntheticCompositionEvent.
- */
+  if (!tryHydrateSuspense(fiber, nextInstance)) {
+    if (shouldClientRenderOnMismatch(fiber)) {
+      warnNonhydratedInstance(hydrationParentFiber, fiber);
+      throwOnHydrationMismatch();
+    } // If we can't hydrate this instance let's try the next one.
+    // We use this as a heuristic. It's based on intuition and not data so it
+    // might be flawed or unnecessary.
 
-function extractCompositionEvent(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget
-) {
-  var eventType;
-  var fallbackData;
+    nextHydratableInstance = getNextHydratableSibling(nextInstance);
+    var prevHydrationParentFiber = hydrationParentFiber;
 
-  if (canUseCompositionEvent) {
-    eventType = getCompositionEventType(domEventName);
-  } else if (!isComposing) {
-    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
-      eventType = "onCompositionStart";
+    if (rootOrSingletonContext) {
+      // We may need to skip past certain nodes in these contexts
+      advanceToFirstAttemptableSuspenseInstance();
     }
-  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
-    eventType = "onCompositionEnd";
-  }
 
-  if (!eventType) {
-    return null;
-  }
+    if (
+      !nextHydratableInstance ||
+      !tryHydrateSuspense(fiber, nextHydratableInstance)
+    ) {
+      // Nothing to hydrate. Make it an insertion.
+      insertNonHydratedInstance(hydrationParentFiber, fiber);
+      isHydrating = false;
+      hydrationParentFiber = fiber;
+      nextHydratableInstance = initialInstance;
+      return;
+    } // We matched the next one, we'll now assume that the first one was
+    // superfluous and we'll delete it. Since we can't eagerly delete it
+    // we'll have to schedule a deletion. To do that, this node needs a dummy
+    // fiber associated with it.
 
-  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
-    // The current composition is stored statically and must not be
-    // overwritten while composition continues.
-    if (!isComposing && eventType === "onCompositionStart") {
-      isComposing = initialize(nativeEventTarget);
-    } else if (eventType === "onCompositionEnd") {
-      if (isComposing) {
-        fallbackData = getData();
-      }
-    }
+    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
   }
+}
 
-  var listeners = accumulateTwoPhaseListeners(targetInst, eventType);
-
-  if (listeners.length > 0) {
-    var event = new SyntheticCompositionEvent(
-      eventType,
-      domEventName,
-      null,
-      nativeEvent,
-      nativeEventTarget
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
+function prepareToHydrateHostInstance(fiber, hostContext) {
+  var instance = fiber.stateNode;
+  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
+  var updatePayload = hydrateInstance(
+    instance,
+    fiber.type,
+    fiber.memoizedProps,
+    hostContext,
+    fiber,
+    shouldWarnIfMismatchDev
+  ); // TODO: Type this specific to this type of component.
 
-    if (fallbackData) {
-      // Inject data generated from fallback path into the synthetic event.
-      // This matches the property of native CompositionEventInterface.
-      // $FlowFixMe[incompatible-use]
-      event.data = fallbackData;
-    } else {
-      var customData = getDataFromCustomEvent(nativeEvent);
+  fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
+  // is a new ref we mark this as an update.
 
-      if (customData !== null) {
-        // $FlowFixMe[incompatible-use]
-        event.data = customData;
-      }
-    }
+  if (updatePayload !== null) {
+    return true;
   }
+
+  return false;
 }
 
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
+function prepareToHydrateHostTextInstance(fiber) {
+  var textInstance = fiber.stateNode;
+  var textContent = fiber.memoizedProps;
+  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
+  var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
 
-    case "keypress":
-      /**
-       * If native `textInput` events are available, our goal is to make
-       * use of them. However, there is a special case: the spacebar key.
-       * In Webkit, preventing default on a spacebar `textInput` event
-       * cancels character insertion, but it *also* causes the browser
-       * to fall back to its default spacebar behavior of scrolling the
-       * page.
-       *
-       * Tracking at:
-       * https://code.google.com/p/chromium/issues/detail?id=355103
-       *
-       * To avoid this issue, use the keypress event as if no `textInput`
-       * event is available.
-       */
-      var which = nativeEvent.which;
+  if (shouldUpdate) {
+    // We assume that prepareToHydrateHostTextInstance is called in a context where the
+    // hydration parent is the parent host component of this host text.
+    var returnFiber = hydrationParentFiber;
 
-      if (which !== SPACEBAR_CODE) {
-        return null;
-      }
+    if (returnFiber !== null) {
+      switch (returnFiber.tag) {
+        case HostRoot: {
+          var parentContainer = returnFiber.stateNode.containerInfo;
+          var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
+          didNotMatchHydratedContainerTextInstance(
+            parentContainer,
+            textInstance,
+            textContent, // TODO: Delete this argument when we remove the legacy root API.
+            isConcurrentMode,
+            shouldWarnIfMismatchDev
+          );
+          break;
+        }
 
-      hasSpaceKeypress = true;
-      return SPACEBAR_CHAR;
+        case HostSingleton:
+        case HostComponent: {
+          var parentType = returnFiber.type;
+          var parentProps = returnFiber.memoizedProps;
+          var parentInstance = returnFiber.stateNode;
 
-    case "textInput":
-      // Record the characters to be added to the DOM.
-      var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
-      // it at the keypress level and bail immediately. Android Chrome
-      // doesn't give us keycodes, so we need to ignore it.
+          var _isConcurrentMode2 =
+            (returnFiber.mode & ConcurrentMode) !== NoMode;
 
-      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
-        return null;
+          didNotMatchHydratedTextInstance(
+            parentType,
+            parentProps,
+            parentInstance,
+            textInstance,
+            textContent, // TODO: Delete this argument when we remove the legacy root API.
+            _isConcurrentMode2,
+            shouldWarnIfMismatchDev
+          );
+          break;
+        }
       }
+    }
+  }
 
-      return chars;
+  return shouldUpdate;
+}
 
-    default:
-      // For other native event types, do nothing.
-      return null;
+function prepareToHydrateHostSuspenseInstance(fiber) {
+  var suspenseState = fiber.memoizedState;
+  var suspenseInstance =
+    suspenseState !== null ? suspenseState.dehydrated : null;
+
+  if (!suspenseInstance) {
+    throw new Error(
+      "Expected to have a hydrated suspense instance. " +
+        "This error is likely caused by a bug in React. Please file an issue."
+    );
   }
+
+  hydrateSuspenseInstance(suspenseInstance, fiber);
 }
-/**
- * For browsers that do not provide the `textInput` event, extract the
- * appropriate string to use for SyntheticInputEvent.
- */
 
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  // If we are currently composing (IME) and using a fallback to do so,
-  // try to extract the composed characters from the fallback object.
-  // If composition event is available, we extract a string only at
-  // compositionevent, otherwise extract it at fallback events.
-  if (isComposing) {
-    if (
-      domEventName === "compositionend" ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-    ) {
-      var chars = getData();
-      reset();
-      isComposing = false;
-      return chars;
-    }
+function skipPastDehydratedSuspenseInstance(fiber) {
+  var suspenseState = fiber.memoizedState;
+  var suspenseInstance =
+    suspenseState !== null ? suspenseState.dehydrated : null;
 
-    return null;
+  if (!suspenseInstance) {
+    throw new Error(
+      "Expected to have a hydrated suspense instance. " +
+        "This error is likely caused by a bug in React. Please file an issue."
+    );
   }
 
-  switch (domEventName) {
-    case "paste":
-      // If a paste event occurs after a keypress, throw out the input
-      // chars. Paste events should not lead to BeforeInput events.
-      return null;
+  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+}
 
-    case "keypress":
-      /**
-       * As of v27, Firefox may fire keypress events even when no character
-       * will be inserted. A few possibilities:
-       *
-       * - `which` is `0`. Arrow keys, Esc key, etc.
-       *
-       * - `which` is the pressed key code, but no char is available.
-       *   Ex: 'AltGr + d` in Polish. There is no modified character for
-       *   this key combination and no character is inserted into the
-       *   document, but FF fires the keypress for char code `100` anyway.
-       *   No `input` event will occur.
-       *
-       * - `which` is the pressed key code, but a command combination is
-       *   being used. Ex: `Cmd+C`. No character is inserted, and no
-       *   `input` event will occur.
-       */
-      if (!isKeypressCommand(nativeEvent)) {
-        // IE fires the `keypress` event when a user types an emoji via
-        // Touch keyboard of Windows.  In such a case, the `char` property
-        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
-        // is 2, the property `which` does not represent an emoji correctly.
-        // In such a case, we directly return the `char` property instead of
-        // using `which`.
-        if (nativeEvent.char && nativeEvent.char.length > 1) {
-          return nativeEvent.char;
-        } else if (nativeEvent.which) {
-          return String.fromCharCode(nativeEvent.which);
-        }
-      }
+function popToNextHostParent(fiber) {
+  hydrationParentFiber = fiber.return;
 
-      return null;
+  while (hydrationParentFiber) {
+    switch (hydrationParentFiber.tag) {
+      case HostRoot:
+      case HostSingleton:
+        rootOrSingletonContext = true;
+        return;
 
-    case "compositionend":
-      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)
-        ? null
-        : nativeEvent.data;
+      case HostComponent:
+      case SuspenseComponent:
+        rootOrSingletonContext = false;
+        return;
 
-    default:
-      return null;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
   }
 }
-/**
- * Extract a SyntheticInputEvent for `beforeInput`, based on either native
- * `textInput` or fallback behavior.
- *
- * @return {?object} A SyntheticInputEvent.
- */
-
-function extractBeforeInputEvent(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget
-) {
-  var chars;
-
-  if (canUseTextInputEvent) {
-    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
-  } else {
-    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
-  } // If no characters are being inserted, no BeforeInput event should
-  // be fired.
 
-  if (!chars) {
-    return null;
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) {
+    // We're deeper than the current hydration context, inside an inserted
+    // tree.
+    return false;
   }
 
-  var listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
+  if (!isHydrating) {
+    // If we're not currently hydrating but we're in a hydration context, then
+    // we were an insertion and now need to pop up reenter hydration of our
+    // siblings.
+    popToNextHostParent(fiber);
+    isHydrating = true;
+    return false;
+  }
 
-  if (listeners.length > 0) {
-    var event = new SyntheticInputEvent(
-      "onBeforeInput",
-      "beforeinput",
-      null,
-      nativeEvent,
-      nativeEventTarget
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    }); // $FlowFixMe[incompatible-use]
+  var shouldClear = false;
 
-    event.data = chars;
+  {
+    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
+    // that have singleton text content
+    if (
+      fiber.tag !== HostRoot &&
+      fiber.tag !== HostSingleton &&
+      !(
+        fiber.tag === HostComponent &&
+        shouldSetTextContent(fiber.type, fiber.memoizedProps)
+      )
+    ) {
+      shouldClear = true;
+    }
   }
-}
-/**
- * Create an `onBeforeInput` event to match
- * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
- *
- * This event plugin is based on the native `textInput` event
- * available in Chrome, Safari, Opera, and IE. This event fires after
- * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
- *
- * `beforeInput` is spec'd but not implemented in any browsers, and
- * the `input` event does not provide any useful information about what has
- * actually been added, contrary to the spec. Thus, `textInput` is the best
- * available event to identify the characters that have actually been inserted
- * into the target node.
- *
- * This plugin is also responsible for emitting `composition` events, thus
- * allowing us to share composition fallback code for both `beforeInput` and
- * `composition` event types.
- */
 
-function extractEvents$5(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  extractCompositionEvent(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  );
-  extractBeforeInputEvent(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  );
-}
+  if (shouldClear) {
+    var nextInstance = nextHydratableInstance;
 
-/**
- * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
- */
-var supportedInputTypes = {
-  color: true,
-  date: true,
-  datetime: true,
-  "datetime-local": true,
-  email: true,
-  month: true,
-  number: true,
-  password: true,
-  range: true,
-  search: true,
-  tel: true,
-  text: true,
-  time: true,
-  url: true,
-  week: true
-};
+    if (nextInstance) {
+      if (shouldClientRenderOnMismatch(fiber)) {
+        warnIfUnhydratedTailNodes(fiber);
+        throwOnHydrationMismatch();
+      } else {
+        while (nextInstance) {
+          deleteHydratableInstance(fiber, nextInstance);
+          nextInstance = getNextHydratableSibling(nextInstance);
+        }
+      }
+    }
+  }
 
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  popToNextHostParent(fiber);
 
-  if (nodeName === "input") {
-    return !!supportedInputTypes[elem.type];
+  if (fiber.tag === SuspenseComponent) {
+    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
+  } else {
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratableSibling(fiber.stateNode)
+      : null;
   }
 
-  if (nodeName === "textarea") {
-    return true;
-  }
+  return true;
+}
 
-  return false;
+function hasUnhydratedTailNodes() {
+  return isHydrating && nextHydratableInstance !== null;
 }
 
-/**
- * Checks if an event is supported in the current execution environment.
- *
- * NOTE: This will not work correctly for non-generic events such as `change`,
- * `reset`, `load`, `error`, and `select`.
- *
- * Borrows from Modernizr.
- *
- * @param {string} eventNameSuffix Event name, e.g. "click".
- * @return {boolean} True if the event is supported.
- * @internal
- * @license Modernizr 3.0.0pre (Custom Build) | MIT
- */
+function warnIfUnhydratedTailNodes(fiber) {
+  var nextInstance = nextHydratableInstance;
 
-function isEventSupported(eventNameSuffix) {
-  if (!canUseDOM) {
-    return false;
+  while (nextInstance) {
+    warnUnhydratedInstance(fiber, nextInstance);
+    nextInstance = getNextHydratableSibling(nextInstance);
   }
+}
 
-  var eventName = "on" + eventNameSuffix;
-  var isSupported = eventName in document;
+function resetHydrationState() {
+  hydrationParentFiber = null;
+  nextHydratableInstance = null;
+  isHydrating = false;
+  didSuspendOrErrorDEV = false;
+}
 
-  if (!isSupported) {
-    var element = document.createElement("div");
-    element.setAttribute(eventName, "return;");
-    isSupported = typeof element[eventName] === "function";
+function upgradeHydrationErrorsToRecoverable() {
+  if (hydrationErrors !== null) {
+    // Successfully completed a forced client render. The errors that occurred
+    // during the hydration attempt are now recovered. We will log them in
+    // commit phase, once the entire tree has finished.
+    queueRecoverableErrors(hydrationErrors);
+    hydrationErrors = null;
   }
-
-  return isSupported;
 }
 
-function registerEvents$2() {
-  registerTwoPhaseEvent("onChange", [
-    "change",
-    "click",
-    "focusin",
-    "focusout",
-    "input",
-    "keydown",
-    "keyup",
-    "selectionchange"
-  ]);
+function getIsHydrating() {
+  return isHydrating;
 }
 
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
-) {
-  // Flag this event loop as needing state restore.
-  enqueueStateRestore(target);
-  var listeners = accumulateTwoPhaseListeners(inst, "onChange");
-
-  if (listeners.length > 0) {
-    var event = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    );
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
+function queueHydrationError(error) {
+  if (hydrationErrors === null) {
+    hydrationErrors = [error];
+  } else {
+    hydrationErrors.push(error);
   }
 }
-/**
- * For IE shims
- */
 
-var activeElement$1 = null;
-var activeElementInst$1 = null;
-/**
- * SECTION: handle `change` event
- */
+// we wait until the current render is over (either finished or interrupted)
+// before adding it to the fiber/hook queue. Push to this array so we can
+// access the queue, fiber, update, et al later.
 
-function shouldUseChangeEvent(elem) {
-  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName === "select" || (nodeName === "input" && elem.type === "file")
-  );
-}
+var concurrentQueues = [];
+var concurrentQueuesIndex = 0;
+var concurrentlyUpdatedLanes = NoLanes;
+function finishQueueingConcurrentUpdates() {
+  var endIndex = concurrentQueuesIndex;
+  concurrentQueuesIndex = 0;
+  concurrentlyUpdatedLanes = NoLanes;
+  var i = 0;
 
-function manualDispatchChangeEvent(nativeEvent) {
-  var dispatchQueue = [];
-  createAndAccumulateChangeEvent(
-    dispatchQueue,
-    activeElementInst$1,
-    nativeEvent,
-    getEventTarget(nativeEvent)
-  ); // If change and propertychange bubbled, we'd just bind to it like all the
-  // other events and have it go through ReactBrowserEventEmitter. Since it
-  // doesn't, we manually listen for the events and so we have to enqueue and
-  // process the abstract event manually.
-  //
-  // Batching is necessary here in order to ensure that all event handlers run
-  // before the next rerender (including event handlers attached to ancestor
-  // elements instead of directly on the input). Without this, controlled
-  // components don't work properly in conjunction with event bubbling because
-  // the component is rerendered and the value reverted before all the event
-  // handlers can run. See https://github.com/facebook/react/issues/708.
+  while (i < endIndex) {
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
 
-  batchedUpdates$1(runEventInBatch, dispatchQueue);
-}
+    if (queue !== null && update !== null) {
+      var pending = queue.pending;
 
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
-}
+      if (pending === null) {
+        // This is the first update. Create a circular list.
+        update.next = update;
+      } else {
+        update.next = pending.next;
+        pending.next = update;
+      }
 
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
+      queue.pending = update;
+    }
 
-  if (updateValueIfChanged(targetNode)) {
-    return targetInst;
+    if (lane !== NoLane) {
+      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
   }
 }
-
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if (domEventName === "change") {
-    return targetInst;
-  }
+function getConcurrentlyUpdatedLanes() {
+  return concurrentlyUpdatedLanes;
 }
-/**
- * SECTION: handle `input` event
- */
 
-var isInputEventSupported = false;
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  // Don't update the `childLanes` on the return path yet. If we already in
+  // the middle of rendering, wait until after it has completed.
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
+  // scheduled, to perform an eager bailout, so we need to update it immediately.
+  // TODO: We should probably move this to the "shared" queue instead.
 
-if (canUseDOM) {
-  // IE9 claims to support the input event but fails to trigger it when
-  // deleting text, so we ignore its input events.
-  isInputEventSupported =
-    isEventSupported("input") &&
-    (!document.documentMode || document.documentMode > 9);
+  fiber.lanes = mergeLanes(fiber.lanes, lane);
+  var alternate = fiber.alternate;
+
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  }
 }
-/**
- * (For IE <=9) Starts tracking propertychange events on the passed-in element
- * and override the value property so that we can distinguish user events from
- * value changes in JS.
- */
 
-function startWatchingForValueChange(target, targetInst) {
-  activeElement$1 = target;
-  activeElementInst$1 = targetInst;
-  activeElement$1.attachEvent("onpropertychange", handlePropertyChange);
+function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
 }
-/**
- * (For IE <=9) Removes the event listeners from the currently-tracked element,
- * if any exists.
- */
+function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
+  // This function is used to queue an update that doesn't need a rerender. The
+  // only reason we queue it is in case there's a subsequent higher priority
+  // update that causes it to be rebased.
+  var lane = NoLane;
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
+  // queue. However, since this is a bail out, we're not scheduling any work
+  // here. So the update we just queued will leak until something else happens
+  // to schedule work (if ever).
+  //
+  // Check if we're currently in the middle of rendering a tree, and if not,
+  // process the queue immediately to prevent a leak.
 
-function stopWatchingForValueChange() {
-  if (!activeElement$1) {
-    return;
+  var isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+
+  if (!isConcurrentlyRendering) {
+    finishQueueingConcurrentUpdates();
   }
+}
+function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
+  var concurrentQueue = queue;
+  var concurrentUpdate = update;
+  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
+  return getRootForUpdatedFiber(fiber);
+}
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
+} // Calling this function outside this module should only be done for backwards
+// compatibility and should always be accompanied by a warning.
 
-  activeElement$1.detachEvent("onpropertychange", handlePropertyChange);
-  activeElement$1 = null;
-  activeElementInst$1 = null;
+function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
+  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
+  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
+  // undefined behavior and we can change it if we need to; it just so happens
+  // that, at the time of this writing, there's an internal product test that
+  // happens to rely on this.
+  var root = getRootForUpdatedFiber(sourceFiber);
+  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
+  return root;
 }
-/**
- * (For IE <=9) Handles a propertychange event, sending a `change` event if
- * the value of the active element has changed.
- */
-// $FlowFixMe[missing-local-annot]
 
-function handlePropertyChange(nativeEvent) {
-  if (nativeEvent.propertyName !== "value") {
-    return;
-  }
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  // Update the source fiber's lanes
+  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
+  var alternate = sourceFiber.alternate;
 
-  if (getInstIfValueChanged(activeElementInst$1)) {
-    manualDispatchChangeEvent(nativeEvent);
-  }
-}
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, lane);
+  } // Walk the parent path to the root and update the child lanes.
 
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  if (domEventName === "focusin") {
-    // In IE9, propertychange fires for most input events but is buggy and
-    // doesn't fire when text is deleted, but conveniently, selectionchange
-    // appears to fire in all of the remaining cases so we catch those and
-    // forward the event if the value has changed
-    // In either case, we don't want to call the event handler if the value
-    // is changed from JS so we redefine a setter for `.value` that updates
-    // our activeElementValue variable, allowing us to ignore those changes
-    //
-    // stopWatching() should be a noop here but we call it just in case we
-    // missed a blur event somehow.
-    stopWatchingForValueChange();
-    startWatchingForValueChange(target, targetInst);
-  } else if (domEventName === "focusout") {
-    stopWatchingForValueChange();
-  }
-} // For IE8 and IE9.
+  var isHidden = false;
+  var parent = sourceFiber.return;
+  var node = sourceFiber;
 
-function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
-  if (
-    domEventName === "selectionchange" ||
-    domEventName === "keyup" ||
-    domEventName === "keydown"
-  ) {
-    // On the selectionchange event, the target is just document which isn't
-    // helpful for us so just check activeElement instead.
-    //
-    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
-    // propertychange on the first input event after setting `value` from a
-    // script and fires only keydown, keypress, keyup. Catching keyup usually
-    // gets it and catching keydown lets us fire an event for the first
-    // keystroke if user does a key repeat (it'll be a little delayed: right
-    // before the second keystroke). Other input methods (e.g., paste) seem to
-    // fire selectionchange normally.
-    return getInstIfValueChanged(activeElementInst$1);
-  }
-}
-/**
- * SECTION: handle `click` event
- */
+  while (parent !== null) {
+    parent.childLanes = mergeLanes(parent.childLanes, lane);
+    alternate = parent.alternate;
 
-function shouldUseClickEvent(elem) {
-  // Use the `click` event to detect changes to checkbox and radio inputs.
-  // This approach works across all browsers, whereas `change` does not fire
-  // until `blur` in IE8.
-  var nodeName = elem.nodeName;
-  return (
-    nodeName &&
-    nodeName.toLowerCase() === "input" &&
-    (elem.type === "checkbox" || elem.type === "radio")
-  );
-}
+    if (alternate !== null) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
+    }
 
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if (domEventName === "click") {
-    return getInstIfValueChanged(targetInst);
+    if (parent.tag === OffscreenComponent) {
+      // Check if this offscreen boundary is currently hidden.
+      //
+      // The instance may be null if the Offscreen parent was unmounted. Usually
+      // the parent wouldn't be reachable in that case because we disconnect
+      // fibers from the tree when they are deleted. However, there's a weird
+      // edge case where setState is called on a fiber that was interrupted
+      // before it ever mounted. Because it never mounts, it also never gets
+      // deleted. Because it never gets deleted, its return pointer never gets
+      // disconnected. Which means it may be attached to a deleted Offscreen
+      // parent node. (This discovery suggests it may be better for memory usage
+      // if we don't attach the `return` pointer until the commit phase, though
+      // in order to do that we'd need some other way to track the return
+      // pointer during the initial render, like on the stack.)
+      //
+      // This case is always accompanied by a warning, but we still need to
+      // account for it. (There may be other cases that we haven't discovered,
+      // too.)
+      var offscreenInstance = parent.stateNode;
+
+      if (
+        offscreenInstance !== null &&
+        !(offscreenInstance._visibility & OffscreenVisible)
+      ) {
+        isHidden = true;
+      }
+    }
+
+    node = parent;
+    parent = parent.return;
   }
-}
 
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if (domEventName === "input" || domEventName === "change") {
-    return getInstIfValueChanged(targetInst);
+  if (isHidden && update !== null && node.tag === HostRoot) {
+    var root = node.stateNode;
+    markHiddenUpdate(root, update, lane);
   }
 }
 
-function handleControlledInputBlur(node) {
-  var state = node._wrapperState;
+function getRootForUpdatedFiber(sourceFiber) {
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
+  // update queues do not have a backpointer to the root, the only way to do
+  // this currently is to walk up the return path. This used to not be a big
+  // deal because we would have to walk up the return path to set
+  // the `childLanes`, anyway, but now those two traversals happen at
+  // different times.
+  // TODO: Consider adding a `root` backpointer on the update queue.
 
-  if (!state || !state.controlled || node.type !== "number") {
-    return;
-  }
+  detectUpdateOnUnmountedFiber(sourceFiber, sourceFiber);
+  var node = sourceFiber;
+  var parent = node.return;
 
-  if (!disableInputAttributeSyncing) {
-    // If controlled, assign the value attribute to the current value on blur
-    setDefaultValue(node, "number", node.value);
+  while (parent !== null) {
+    detectUpdateOnUnmountedFiber(sourceFiber, node);
+    node = parent;
+    parent = node.return;
   }
+
+  return node.tag === HostRoot ? node.stateNode : null;
 }
-/**
- * This plugin creates an `onChange` event that normalizes change events
- * across form elements. This event fires at a time when it's possible to
- * change the element's value without seeing a flicker.
- *
- * Supported elements are:
- * - input (see `isTextInputElement`)
- * - textarea
- * - select
- */
 
-function extractEvents$4(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
-  var getTargetInstFunc, handleEventFunc;
+function detectUpdateOnUnmountedFiber(sourceFiber, parent) {
+  {
+    var alternate = parent.alternate;
 
-  if (shouldUseChangeEvent(targetNode)) {
-    getTargetInstFunc = getTargetInstForChangeEvent;
-  } else if (isTextInputElement(targetNode)) {
-    if (isInputEventSupported) {
-      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-    } else {
-      getTargetInstFunc = getTargetInstForInputEventPolyfill;
-      handleEventFunc = handleEventsForInputEventPolyfill;
+    if (
+      alternate === null &&
+      (parent.flags & (Placement | Hydrating)) !== NoFlags$1
+    ) {
+      warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
     }
-  } else if (shouldUseClickEvent(targetNode)) {
-    getTargetInstFunc = getTargetInstForClickEvent;
-  } else if (
-    enableCustomElementPropertySupport &&
-    targetInst &&
-    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
-  ) {
-    getTargetInstFunc = getTargetInstForChangeEvent;
   }
+}
 
-  if (getTargetInstFunc) {
-    var inst = getTargetInstFunc(domEventName, targetInst);
-
-    if (inst) {
-      createAndAccumulateChangeEvent(
-        dispatchQueue,
-        inst,
-        nativeEvent,
-        nativeEventTarget
-      );
-      return;
-    }
-  }
+var UpdateState = 0;
+var ReplaceState = 1;
+var ForceUpdate = 2;
+var CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
+// It should only be read right after calling `processUpdateQueue`, via
+// `checkHasForceUpdateAfterProcessing`.
 
-  if (handleEventFunc) {
-    handleEventFunc(domEventName, targetNode, targetInst);
-  } // When blurring, set the value attribute for number inputs
+var hasForceUpdate = false;
+var didWarnUpdateInsideUpdate;
+var currentlyProcessingQueue;
 
-  if (domEventName === "focusout") {
-    handleControlledInputBlur(targetNode);
-  }
+{
+  didWarnUpdateInsideUpdate = false;
+  currentlyProcessingQueue = null;
 }
 
-function registerEvents$1() {
-  registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-  registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-  registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-  registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+function initializeUpdateQueue(fiber) {
+  var queue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: {
+      pending: null,
+      lanes: NoLanes,
+      hiddenCallbacks: null
+    },
+    callbacks: null
+  };
+  fiber.updateQueue = queue;
 }
-/**
- * For almost every interaction we care about, there will be both a top-level
- * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
- * we do not extract duplicate events. However, moving the mouse into the
- * browser from outside will not fire a `mouseout` event. In this case, we use
- * the `mouseover` top-level event.
- */
-
-function extractEvents$3(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var isOverEvent =
-    domEventName === "mouseover" || domEventName === "pointerover";
-  var isOutEvent = domEventName === "mouseout" || domEventName === "pointerout";
-
-  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
-    // If this is an over event with a target, we might have already dispatched
-    // the event in the out event of the other target. If this is replayed,
-    // then it's because we couldn't dispatch against this target previously
-    // so we have to do it now instead.
-    var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
+function cloneUpdateQueue(current, workInProgress) {
+  // Clone the update queue from current. Unless it's already a clone.
+  var queue = workInProgress.updateQueue;
+  var currentQueue = current.updateQueue;
 
-    if (related) {
-      // If the related node is managed by React, we can assume that we have
-      // already dispatched the corresponding events during its mouseout.
-      if (
-        getClosestInstanceFromNode(related) ||
-        isContainerMarkedAsRoot(related)
-      ) {
-        return;
-      }
-    }
+  if (queue === currentQueue) {
+    var clone = {
+      baseState: currentQueue.baseState,
+      firstBaseUpdate: currentQueue.firstBaseUpdate,
+      lastBaseUpdate: currentQueue.lastBaseUpdate,
+      shared: currentQueue.shared,
+      callbacks: null
+    };
+    workInProgress.updateQueue = clone;
   }
+}
+function createUpdate(lane) {
+  var update = {
+    lane: lane,
+    tag: UpdateState,
+    payload: null,
+    callback: null,
+    next: null
+  };
+  return update;
+}
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
 
-  if (!isOutEvent && !isOverEvent) {
-    // Must not be a mouse or pointer in or out - ignoring.
-    return;
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
+    return null;
   }
 
-  var win; // TODO: why is this nullable in the types but we read from it?
+  var sharedQueue = updateQueue.shared;
 
-  if (nativeEventTarget.window === nativeEventTarget) {
-    // `nativeEventTarget` is probably a window object.
-    win = nativeEventTarget;
-  } else {
-    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
-    var doc = nativeEventTarget.ownerDocument;
+  {
+    if (
+      currentlyProcessingQueue === sharedQueue &&
+      !didWarnUpdateInsideUpdate
+    ) {
+      var componentName = getComponentNameFromFiber(fiber);
 
-    if (doc) {
-      win = doc.defaultView || doc.parentWindow;
-    } else {
-      win = window;
+      error(
+        "An update (setState, replaceState, or forceUpdate) was scheduled " +
+          "from inside an update function. Update functions should be pure, " +
+          "with zero side-effects. Consider using componentDidUpdate or a " +
+          "callback.\n\nPlease update the following component: %s",
+        componentName
+      );
+
+      didWarnUpdateInsideUpdate = true;
     }
   }
 
-  var from;
-  var to;
-
-  if (isOutEvent) {
-    var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
+  if (isUnsafeClassRenderPhaseUpdate(fiber)) {
+    // This is an unsafe render phase update. Add directly to the update
+    // queue so we can process it immediately during the current render.
+    var pending = sharedQueue.pending;
 
-    from = targetInst;
-    to = _related ? getClosestInstanceFromNode(_related) : null;
+    if (pending === null) {
+      // This is the first update. Create a circular list.
+      update.next = update;
+    } else {
+      update.next = pending.next;
+      pending.next = update;
+    }
 
-    if (to !== null) {
-      var nearestMounted = getNearestMountedFiber(to);
-      var tag = to.tag;
+    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
+    // this fiber. This is for backwards compatibility in the case where you
+    // update a different component during render phase than the one that is
+    // currently renderings (a pattern that is accompanied by a warning).
 
-      if (
-        to !== nearestMounted ||
-        (tag !== HostComponent && tag !== HostSingleton && tag !== HostText)
-      ) {
-        to = null;
-      }
-    }
+    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
   } else {
-    // Moving to a node from outside the window.
-    from = null;
-    to = targetInst;
+    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
   }
+}
+function entangleTransitions(root, fiber, lane) {
+  var updateQueue = fiber.updateQueue;
 
-  if (from === to) {
-    // Nothing pertains to our managed components.
+  if (updateQueue === null) {
+    // Only occurs if the fiber has been unmounted.
     return;
   }
 
-  var SyntheticEventCtor = SyntheticMouseEvent;
-  var leaveEventType = "onMouseLeave";
-  var enterEventType = "onMouseEnter";
-  var eventTypePrefix = "mouse";
+  var sharedQueue = updateQueue.shared;
 
-  if (domEventName === "pointerout" || domEventName === "pointerover") {
-    SyntheticEventCtor = SyntheticPointerEvent;
-    leaveEventType = "onPointerLeave";
-    enterEventType = "onPointerEnter";
-    eventTypePrefix = "pointer";
-  }
+  if (isTransitionLane(lane)) {
+    var queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
+    // have finished. We can remove them from the shared queue, which represents
+    // a superset of the actually pending lanes. In some cases we may entangle
+    // more than we need to, but that's OK. In fact it's worse if we *don't*
+    // entangle when we should.
 
-  var fromNode = from == null ? win : getNodeFromInstance(from);
-  var toNode = to == null ? win : getNodeFromInstance(to);
-  var leave = new SyntheticEventCtor(
-    leaveEventType,
-    eventTypePrefix + "leave",
-    from,
-    nativeEvent,
-    nativeEventTarget
-  );
-  leave.target = fromNode;
-  leave.relatedTarget = toNode;
-  var enter = null; // We should only process this nativeEvent if we are processing
-  // the first ancestor. Next time, we will ignore the event.
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
 
-  var nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
+    var newQueueLanes = mergeLanes(queueLanes, lane);
+    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
 
-  if (nativeTargetInst === targetInst) {
-    var enterEvent = new SyntheticEventCtor(
-      enterEventType,
-      eventTypePrefix + "enter",
-      to,
-      nativeEvent,
-      nativeEventTarget
-    );
-    enterEvent.target = toNode;
-    enterEvent.relatedTarget = fromNode;
-    enter = enterEvent;
+    markRootEntangled(root, newQueueLanes);
   }
-
-  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
 }
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  // Captured updates are updates that are thrown by a child during the render
+  // phase. They should be discarded if the render is aborted. Therefore,
+  // we should only put them on the work-in-progress queue, not the current one.
+  var queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
 
-/**
- * inlined Object.is polyfill to avoid requiring consumers ship their own
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
- */
-function is(x, y) {
-  return (
-    (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
-  );
-}
+  var current = workInProgress.alternate;
 
-var objectIs = typeof Object.is === "function" ? Object.is : is; // $FlowFixMe[method-unbinding]
+  if (current !== null) {
+    var currentQueue = current.updateQueue;
 
-/**
- * Performs equality by iterating through keys on an object and returning false
- * when any key has values which are not strictly equal between the arguments.
- * Returns true when the values of all keys are strictly equal.
- */
+    if (queue === currentQueue) {
+      // The work-in-progress queue is the same as current. This happens when
+      // we bail out on a parent fiber that then captures an error thrown by
+      // a child. Since we want to append the update only to the work-in
+      // -progress queue, we need to clone the updates. We usually clone during
+      // processUpdateQueue, but that didn't happen in this case because we
+      // skipped over the parent when we bailed out.
+      var newFirst = null;
+      var newLast = null;
+      var firstBaseUpdate = queue.firstBaseUpdate;
 
-function shallowEqual(objA, objB) {
-  if (objectIs(objA, objB)) {
-    return true;
-  }
+      if (firstBaseUpdate !== null) {
+        // Loop through the updates and clone them.
+        var update = firstBaseUpdate;
 
-  if (
-    typeof objA !== "object" ||
-    objA === null ||
-    typeof objB !== "object" ||
-    objB === null
-  ) {
-    return false;
-  }
+        do {
+          var clone = {
+            lane: update.lane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
 
-  var keysA = Object.keys(objA);
-  var keysB = Object.keys(objB);
+          if (newLast === null) {
+            newFirst = newLast = clone;
+          } else {
+            newLast.next = clone;
+            newLast = clone;
+          } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-  if (keysA.length !== keysB.length) {
-    return false;
-  } // Test for A's keys different from B.
+          update = update.next;
+        } while (update !== null); // Append the captured update the end of the cloned list.
 
-  for (var i = 0; i < keysA.length; i++) {
-    var currentKey = keysA[i];
+        if (newLast === null) {
+          newFirst = newLast = capturedUpdate;
+        } else {
+          newLast.next = capturedUpdate;
+          newLast = capturedUpdate;
+        }
+      } else {
+        // There are no base updates.
+        newFirst = newLast = capturedUpdate;
+      }
 
-    if (
-      !hasOwnProperty.call(objB, currentKey) ||
-      !objectIs(objA[currentKey], objB[currentKey])
-    ) {
-      return false;
+      queue = {
+        baseState: currentQueue.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: currentQueue.shared,
+        callbacks: currentQueue.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
     }
-  }
-
-  return true;
-}
+  } // Append the update to the end of the list.
 
-/**
- * Given any node return the first leaf node without children.
- *
- * @param {DOMElement|DOMTextNode} node
- * @return {DOMElement|DOMTextNode}
- */
+  var lastBaseUpdate = queue.lastBaseUpdate;
 
-function getLeafNode(node) {
-  while (node && node.firstChild) {
-    node = node.firstChild;
+  if (lastBaseUpdate === null) {
+    queue.firstBaseUpdate = capturedUpdate;
+  } else {
+    lastBaseUpdate.next = capturedUpdate;
   }
 
-  return node;
-}
-/**
- * Get the next sibling within a container. This will walk up the
- * DOM if a node's siblings have been exhausted.
- *
- * @param {DOMElement|DOMTextNode} node
- * @return {?DOMElement|DOMTextNode}
- */
-
-function getSiblingNode(node) {
-  while (node) {
-    if (node.nextSibling) {
-      return node.nextSibling;
-    }
-
-    node = node.parentNode;
-  }
+  queue.lastBaseUpdate = capturedUpdate;
 }
-/**
- * Get object describing the nodes which contain characters at offset.
- *
- * @param {DOMElement|DOMTextNode} root
- * @param {number} offset
- * @return {?object}
- */
-
-function getNodeForCharacterOffset(root, offset) {
-  var node = getLeafNode(root);
-  var nodeStart = 0;
-  var nodeEnd = 0;
 
-  while (node) {
-    if (node.nodeType === TEXT_NODE) {
-      nodeEnd = nodeStart + node.textContent.length;
+function getStateFromUpdate(
+  workInProgress,
+  queue,
+  update,
+  prevState,
+  nextProps,
+  instance
+) {
+  switch (update.tag) {
+    case ReplaceState: {
+      var payload = update.payload;
 
-      if (nodeStart <= offset && nodeEnd >= offset) {
-        return {
-          node: node,
-          offset: offset - nodeStart
-        };
-      }
+      if (typeof payload === "function") {
+        // Updater function
+        {
+          enterDisallowedContextReadInDEV();
+        }
 
-      nodeStart = nodeEnd;
-    }
+        var nextState = payload.call(instance, prevState, nextProps);
 
-    node = getLeafNode(getSiblingNode(node));
-  }
-}
+        {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
 
-/**
- * @param {DOMElement} outerNode
- * @return {?object}
- */
+            try {
+              payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
 
-function getOffsets(outerNode) {
-  var ownerDocument = outerNode.ownerDocument;
-  var win = (ownerDocument && ownerDocument.defaultView) || window;
-  var selection = win.getSelection && win.getSelection();
+          exitDisallowedContextReadInDEV();
+        }
 
-  if (!selection || selection.rangeCount === 0) {
-    return null;
-  }
+        return nextState;
+      } // State object
 
-  var anchorNode = selection.anchorNode,
-    anchorOffset = selection.anchorOffset,
-    focusNode = selection.focusNode,
-    focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
-  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
-  // expose properties, triggering a "Permission denied error" if any of its
-  // properties are accessed. The only seemingly possible way to avoid erroring
-  // is to access a property that typically works for non-anonymous divs and
-  // catch any error that may otherwise arise. See
-  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+      return payload;
+    }
 
-  try {
-    /* eslint-disable ft-flow/no-unused-expressions */
-    anchorNode.nodeType;
-    focusNode.nodeType;
-    /* eslint-enable ft-flow/no-unused-expressions */
-  } catch (e) {
-    return null;
-  }
+    case CaptureUpdate: {
+      workInProgress.flags =
+        (workInProgress.flags & ~ShouldCapture) | DidCapture;
+    }
+    // Intentional fallthrough
 
-  return getModernOffsetsFromPoints(
-    outerNode,
-    anchorNode,
-    anchorOffset,
-    focusNode,
-    focusOffset
-  );
-}
-/**
- * Returns {start, end} where `start` is the character/codepoint index of
- * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
- * `end` is the index of (focusNode, focusOffset).
- *
- * Returns null if you pass in garbage input but we should probably just crash.
- *
- * Exported only for testing.
- */
+    case UpdateState: {
+      var _payload = update.payload;
+      var partialState;
 
-function getModernOffsetsFromPoints(
-  outerNode,
-  anchorNode,
-  anchorOffset,
-  focusNode,
-  focusOffset
-) {
-  var length = 0;
-  var start = -1;
-  var end = -1;
-  var indexWithinAnchor = 0;
-  var indexWithinFocus = 0;
-  var node = outerNode;
-  var parentNode = null;
+      if (typeof _payload === "function") {
+        // Updater function
+        {
+          enterDisallowedContextReadInDEV();
+        }
 
-  outer: while (true) {
-    var next = null;
+        partialState = _payload.call(instance, prevState, nextProps);
 
-    while (true) {
-      if (
-        node === anchorNode &&
-        (anchorOffset === 0 || node.nodeType === TEXT_NODE)
-      ) {
-        start = length + anchorOffset;
-      }
+        {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
 
-      if (
-        node === focusNode &&
-        (focusOffset === 0 || node.nodeType === TEXT_NODE)
-      ) {
-        end = length + focusOffset;
-      }
+            try {
+              _payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
 
-      if (node.nodeType === TEXT_NODE) {
-        length += node.nodeValue.length;
+          exitDisallowedContextReadInDEV();
+        }
+      } else {
+        // Partial state object
+        partialState = _payload;
       }
 
-      if ((next = node.firstChild) === null) {
-        break;
-      } // Moving from `node` to its first child `next`.
+      if (partialState === null || partialState === undefined) {
+        // Null and undefined are treated as no-ops.
+        return prevState;
+      } // Merge the partial state and the previous state.
 
-      parentNode = node;
-      node = next;
+      return assign({}, prevState, partialState);
     }
 
-    while (true) {
-      if (node === outerNode) {
-        // If `outerNode` has children, this is always the second time visiting
-        // it. If it has no children, this is still the first loop, and the only
-        // valid selection is anchorNode and focusNode both equal to this node
-        // and both offsets 0, in which case we will have handled above.
-        break outer;
-      }
-
-      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
-        start = length;
-      }
-
-      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
-        end = length;
-      }
-
-      if ((next = node.nextSibling) !== null) {
-        break;
-      }
-
-      node = parentNode;
-      parentNode = node.parentNode;
-    } // Moving from `node` to its next sibling `next`.
-
-    node = next;
-  }
-
-  if (start === -1 || end === -1) {
-    // This should never happen. (Would happen if the anchor/focus nodes aren't
-    // actually inside the passed-in node.)
-    return null;
+    case ForceUpdate: {
+      hasForceUpdate = true;
+      return prevState;
+    }
   }
 
-  return {
-    start: start,
-    end: end
-  };
+  return prevState;
 }
-/**
- * In modern non-IE browsers, we can support both forward and backward
- * selections.
- *
- * Note: IE10+ supports the Selection object, but it does not support
- * the `extend` method, which means that even in modern IE, it's not possible
- * to programmatically create a backward selection. Thus, for all IE
- * versions, we use the old IE API to create our selections.
- *
- * @param {DOMElement|DOMTextNode} node
- * @param {object} offsets
- */
 
-function setOffsets(node, offsets) {
-  var doc = node.ownerDocument || document;
-  var win = (doc && doc.defaultView) || window; // Edge fails with "Object expected" in some scenarios.
-  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
-  // fails when pasting 100+ items)
+function processUpdateQueue(workInProgress, props, instance, renderLanes) {
+  // This is always non-null on a ClassComponent or HostRoot
+  var queue = workInProgress.updateQueue;
+  hasForceUpdate = false;
 
-  if (!win.getSelection) {
-    return;
+  {
+    currentlyProcessingQueue = queue.shared;
   }
 
-  var selection = win.getSelection();
-  var length = node.textContent.length;
-  var start = Math.min(offsets.start, length);
-  var end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
-  // Flip backward selections, so we can set with a single range.
-
-  if (!selection.extend && start > end) {
-    var temp = end;
-    end = start;
-    start = temp;
-  }
+  var firstBaseUpdate = queue.firstBaseUpdate;
+  var lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
 
-  var startMarker = getNodeForCharacterOffset(node, start);
-  var endMarker = getNodeForCharacterOffset(node, end);
+  var pendingQueue = queue.shared.pending;
 
-  if (startMarker && endMarker) {
-    if (
-      selection.rangeCount === 1 &&
-      selection.anchorNode === startMarker.node &&
-      selection.anchorOffset === startMarker.offset &&
-      selection.focusNode === endMarker.node &&
-      selection.focusOffset === endMarker.offset
-    ) {
-      return;
-    }
+  if (pendingQueue !== null) {
+    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
+    // and last so that it's non-circular.
 
-    var range = doc.createRange();
-    range.setStart(startMarker.node, startMarker.offset);
-    selection.removeAllRanges();
+    var lastPendingUpdate = pendingQueue;
+    var firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null; // Append pending updates to base queue
 
-    if (start > end) {
-      selection.addRange(range);
-      selection.extend(endMarker.node, endMarker.offset);
+    if (lastBaseUpdate === null) {
+      firstBaseUpdate = firstPendingUpdate;
     } else {
-      range.setEnd(endMarker.node, endMarker.offset);
-      selection.addRange(range);
+      lastBaseUpdate.next = firstPendingUpdate;
     }
-  }
-}
-
-function isTextNode(node) {
-  return node && node.nodeType === TEXT_NODE;
-}
 
-function containsNode$1(outerNode, innerNode) {
-  if (!outerNode || !innerNode) {
-    return false;
-  } else if (outerNode === innerNode) {
-    return true;
-  } else if (isTextNode(outerNode)) {
-    return false;
-  } else if (isTextNode(innerNode)) {
-    return containsNode$1(outerNode, innerNode.parentNode);
-  } else if ("contains" in outerNode) {
-    return outerNode.contains(innerNode);
-  } else if (outerNode.compareDocumentPosition) {
-    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
-  } else {
-    return false;
-  }
-}
+    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
+    // we need to transfer the updates to that queue, too. Because the base
+    // queue is a singly-linked list with no cycles, we can append to both
+    // lists and take advantage of structural sharing.
+    // TODO: Pass `current` as argument
 
-function isInDocument(node) {
-  return (
-    node &&
-    node.ownerDocument &&
-    containsNode$1(node.ownerDocument.documentElement, node)
-  );
-}
+    var current = workInProgress.alternate;
 
-function isSameOriginFrame(iframe) {
-  try {
-    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
-    // to throw, e.g. if it has a cross-origin src attribute.
-    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
-    // iframe.contentDocument.defaultView;
-    // A safety way is to access one of the cross origin properties: Window or Location
-    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
-    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
-    return typeof iframe.contentWindow.location.href === "string";
-  } catch (err) {
-    return false;
-  }
-}
+    if (current !== null) {
+      // This is always non-null on a ClassComponent or HostRoot
+      var currentQueue = current.updateQueue;
+      var currentLastBaseUpdate = currentQueue.lastBaseUpdate;
 
-function getActiveElementDeep() {
-  var win = window;
-  var element = getActiveElement();
+      if (currentLastBaseUpdate !== lastBaseUpdate) {
+        if (currentLastBaseUpdate === null) {
+          currentQueue.firstBaseUpdate = firstPendingUpdate;
+        } else {
+          currentLastBaseUpdate.next = firstPendingUpdate;
+        }
 
-  while (element instanceof win.HTMLIFrameElement) {
-    if (isSameOriginFrame(element)) {
-      win = element.contentWindow;
-    } else {
-      return element;
+        currentQueue.lastBaseUpdate = lastPendingUpdate;
+      }
     }
+  } // These values may change as we process the queue.
 
-    element = getActiveElement(win.document);
-  }
+  if (firstBaseUpdate !== null) {
+    // Iterate through the list of updates to compute the result.
+    var newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
+    // from the original lanes.
 
-  return element;
-}
-/**
- * @ReactInputSelection: React input selection module. Based on Selection.js,
- * but modified to be suitable for react and has a couple of bug fixes (doesn't
- * assume buttons have range selections allowed).
- * Input selection module for React.
- */
+    var newLanes = NoLanes;
+    var newBaseState = null;
+    var newFirstBaseUpdate = null;
+    var newLastBaseUpdate = null;
+    var update = firstBaseUpdate;
 
-/**
- * @hasSelectionCapabilities: we get the element types that support selection
- * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
- * and `selectionEnd` rows.
- */
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      var updateLane = removeLanes(update.lane, OffscreenLane);
+      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
 
-function hasSelectionCapabilities(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName &&
-    ((nodeName === "input" &&
-      (elem.type === "text" ||
-        elem.type === "search" ||
-        elem.type === "tel" ||
-        elem.type === "url" ||
-        elem.type === "password")) ||
-      nodeName === "textarea" ||
-      elem.contentEditable === "true")
-  );
-}
-function getSelectionInformation() {
-  var focusedElem = getActiveElementDeep();
-  return {
-    focusedElem: focusedElem,
-    selectionRange: hasSelectionCapabilities(focusedElem)
-      ? getSelection$1(focusedElem)
-      : null
-  };
-}
-/**
- * @restoreSelection: If any selection information was potentially lost,
- * restore it. This is useful when performing operations that could remove dom
- * nodes and place them back in, resulting in focus being lost.
- */
+      var shouldSkipUpdate = isHiddenUpdate
+        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
+        : !isSubsetOfLanes(renderLanes, updateLane);
 
-function restoreSelection(priorSelectionInformation) {
-  var curFocusedElem = getActiveElementDeep();
-  var priorFocusedElem = priorSelectionInformation.focusedElem;
-  var priorSelectionRange = priorSelectionInformation.selectionRange;
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        var clone = {
+          lane: updateLane,
+          tag: update.tag,
+          payload: update.payload,
+          callback: update.callback,
+          next: null
+        };
 
-  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
-    if (
-      priorSelectionRange !== null &&
-      hasSelectionCapabilities(priorFocusedElem)
-    ) {
-      setSelection(priorFocusedElem, priorSelectionRange);
-    } // Focusing a node can change the scroll position, which is undesirable
+        if (newLastBaseUpdate === null) {
+          newFirstBaseUpdate = newLastBaseUpdate = clone;
+          newBaseState = newState;
+        } else {
+          newLastBaseUpdate = newLastBaseUpdate.next = clone;
+        } // Update the remaining priority in the queue.
 
-    var ancestors = [];
-    var ancestor = priorFocusedElem;
+        newLanes = mergeLanes(newLanes, updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newLastBaseUpdate !== null) {
+          var _clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            tag: update.tag,
+            payload: update.payload,
+            // When this update is rebased, we should not fire its
+            // callback again.
+            callback: null,
+            next: null
+          };
+          newLastBaseUpdate = newLastBaseUpdate.next = _clone;
+        } // Process this update.
 
-    while ((ancestor = ancestor.parentNode)) {
-      if (ancestor.nodeType === ELEMENT_NODE) {
-        ancestors.push({
-          element: ancestor,
-          left: ancestor.scrollLeft,
-          top: ancestor.scrollTop
-        });
+        newState = getStateFromUpdate(
+          workInProgress,
+          queue,
+          update,
+          newState,
+          props,
+          instance
+        );
+        var callback = update.callback;
+
+        if (callback !== null) {
+          workInProgress.flags |= Callback;
+
+          if (isHiddenUpdate) {
+            workInProgress.flags |= Visibility;
+          }
+
+          var callbacks = queue.callbacks;
+
+          if (callbacks === null) {
+            queue.callbacks = [callback];
+          } else {
+            callbacks.push(callback);
+          }
+        }
+      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+
+      update = update.next;
+
+      if (update === null) {
+        pendingQueue = queue.shared.pending;
+
+        if (pendingQueue === null) {
+          break;
+        } else {
+          // An update was scheduled from inside a reducer. Add the new
+          // pending updates to the end of the list and keep processing.
+          var _lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
+          // unravel them when transferring them to the base queue.
+
+          var _firstPendingUpdate = _lastPendingUpdate.next;
+          _lastPendingUpdate.next = null;
+          update = _firstPendingUpdate;
+          queue.lastBaseUpdate = _lastPendingUpdate;
+          queue.shared.pending = null;
+        }
       }
-    }
+    } while (true);
 
-    if (typeof priorFocusedElem.focus === "function") {
-      priorFocusedElem.focus();
+    if (newLastBaseUpdate === null) {
+      newBaseState = newState;
     }
 
-    for (var i = 0; i < ancestors.length; i++) {
-      var info = ancestors[i];
-      info.element.scrollLeft = info.left;
-      info.element.scrollTop = info.top;
-    }
+    queue.baseState = newBaseState;
+    queue.firstBaseUpdate = newFirstBaseUpdate;
+    queue.lastBaseUpdate = newLastBaseUpdate;
+
+    if (firstBaseUpdate === null) {
+      // `queue.lanes` is used for entangling transitions. We can set it back to
+      // zero once the queue is empty.
+      queue.shared.lanes = NoLanes;
+    } // 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.
+
+    markSkippedUpdateLanes(newLanes);
+    workInProgress.lanes = newLanes;
+    workInProgress.memoizedState = newState;
   }
-}
-/**
- * @getSelection: Gets the selection bounds of a focused textarea, input or
- * contentEditable node.
- * -@input: Look up selection bounds of this input
- * -@return {start: selectionStart, end: selectionEnd}
- */
 
-function getSelection$1(input) {
-  var selection;
+  {
+    currentlyProcessingQueue = null;
+  }
+}
 
-  if ("selectionStart" in input) {
-    // Modern browser with input or textarea.
-    selection = {
-      start: input.selectionStart,
-      end: input.selectionEnd
-    };
-  } else {
-    // Content editable or old IE textarea.
-    selection = getOffsets(input);
+function callCallback(callback, context) {
+  if (typeof callback !== "function") {
+    throw new Error(
+      "Invalid argument passed as callback. Expected a function. Instead " +
+        ("received: " + callback)
+    );
   }
 
-  return (
-    selection || {
-      start: 0,
-      end: 0
-    }
-  );
+  callback.call(context);
 }
-/**
- * @setSelection: Sets the selection bounds of a textarea or input and focuses
- * the input.
- * -@input     Set selection bounds of this input or textarea
- * -@offsets   Object of same form that is returned from get*
- */
 
-function setSelection(input, offsets) {
-  var start = offsets.start;
-  var end = offsets.end;
+function resetHasForceUpdateBeforeProcessing() {
+  hasForceUpdate = false;
+}
+function checkHasForceUpdateAfterProcessing() {
+  return hasForceUpdate;
+}
+function deferHiddenCallbacks(updateQueue) {
+  // When an update finishes on a hidden component, its callback should not
+  // be fired until/unless the component is made visible again. Stash the
+  // callback on the shared queue object so it can be fired later.
+  var newHiddenCallbacks = updateQueue.callbacks;
 
-  if (end === undefined) {
-    end = start;
-  }
+  if (newHiddenCallbacks !== null) {
+    var existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
 
-  if ("selectionStart" in input) {
-    input.selectionStart = start;
-    input.selectionEnd = Math.min(end, input.value.length);
-  } else {
-    setOffsets(input, offsets);
+    if (existingHiddenCallbacks === null) {
+      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+    } else {
+      updateQueue.shared.hiddenCallbacks =
+        existingHiddenCallbacks.concat(newHiddenCallbacks);
+    }
   }
 }
+function commitHiddenCallbacks(updateQueue, context) {
+  // This component is switching from hidden -> visible. Commit any callbacks
+  // that were previously deferred.
+  var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
 
-var skipSelectionChangeEvent =
-  canUseDOM && "documentMode" in document && document.documentMode <= 11;
+  if (hiddenCallbacks !== null) {
+    updateQueue.shared.hiddenCallbacks = null;
 
-function registerEvents() {
-  registerTwoPhaseEvent("onSelect", [
-    "focusout",
-    "contextmenu",
-    "dragend",
-    "focusin",
-    "keydown",
-    "keyup",
-    "mousedown",
-    "mouseup",
-    "selectionchange"
-  ]);
+    for (var i = 0; i < hiddenCallbacks.length; i++) {
+      var callback = hiddenCallbacks[i];
+      callCallback(callback, context);
+    }
+  }
 }
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
 
-var activeElement = null;
-var activeElementInst = null;
-var lastSelection = null;
-var mouseDown = false;
-/**
- * Get an object which is a unique representation of the current selection.
- *
- * The return value will not be consistent across nodes or browsers, but
- * two identical selections on the same node will return identical objects.
- */
+  if (callbacks !== null) {
+    updateQueue.callbacks = null;
 
-function getSelection(node) {
-  if ("selectionStart" in node && hasSelectionCapabilities(node)) {
-    return {
-      start: node.selectionStart,
-      end: node.selectionEnd
-    };
-  } else {
-    var win = (node.ownerDocument && node.ownerDocument.defaultView) || window;
-    var selection = win.getSelection();
-    return {
-      anchorNode: selection.anchorNode,
-      anchorOffset: selection.anchorOffset,
-      focusNode: selection.focusNode,
-      focusOffset: selection.focusOffset
-    };
+    for (var i = 0; i < callbacks.length; i++) {
+      var callback = callbacks[i];
+      callCallback(callback, context);
+    }
   }
 }
-/**
- * Get document associated with the event target.
- */
 
-function getEventTargetDocument(eventTarget) {
-  return eventTarget.window === eventTarget
-    ? eventTarget.document
-    : eventTarget.nodeType === DOCUMENT_NODE
-    ? eventTarget
-    : eventTarget.ownerDocument;
-}
 /**
- * Poll selection to see whether it's changed.
- *
- * @param {object} nativeEvent
- * @param {object} nativeEventTarget
- * @return {?SyntheticEvent}
+ * Performs equality by iterating through keys on an object and returning false
+ * when any key has values which are not strictly equal between the arguments.
+ * Returns true when the values of all keys are strictly equal.
  */
 
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  // Ensure we have the right element, and that the user is not dragging a
-  // selection (this matches native `select` event behavior). In HTML5, select
-  // fires only on input and textarea thus if there's no focused element we
-  // won't dispatch.
-  var doc = getEventTargetDocument(nativeEventTarget);
+function shallowEqual(objA, objB) {
+  if (objectIs(objA, objB)) {
+    return true;
+  }
 
   if (
-    mouseDown ||
-    activeElement == null ||
-    activeElement !== getActiveElement(doc)
+    typeof objA !== "object" ||
+    objA === null ||
+    typeof objB !== "object" ||
+    objB === null
   ) {
-    return;
-  } // Only fire when selection has actually changed.
+    return false;
+  }
 
-  var currentSelection = getSelection(activeElement);
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
 
-  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
-    lastSelection = currentSelection;
-    var listeners = accumulateTwoPhaseListeners(activeElementInst, "onSelect");
+  if (keysA.length !== keysB.length) {
+    return false;
+  } // Test for A's keys different from B.
 
-    if (listeners.length > 0) {
-      var event = new SyntheticEvent(
-        "onSelect",
-        "select",
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
-      dispatchQueue.push({
-        event: event,
-        listeners: listeners
-      });
-      event.target = activeElement;
+  for (var i = 0; i < keysA.length; i++) {
+    var currentKey = keysA[i];
+
+    if (
+      !hasOwnProperty.call(objB, currentKey) ||
+      !objectIs(objA[currentKey], objB[currentKey])
+    ) {
+      return false;
     }
   }
+
+  return true;
 }
-/**
- * This plugin creates an `onSelect` event that normalizes select events
- * across form elements.
- *
- * Supported elements are:
- * - input (see `isTextInputElement`)
- * - textarea
- * - contentEditable
- *
- * This differs from native browser implementations in the following ways:
- * - Fires on contentEditable fields as well as inputs.
- * - Fires for collapsed selection.
- * - Fires after user input.
- */
 
-function extractEvents$2(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+var ReactStrictModeWarnings = {
+  recordUnsafeLifecycleWarnings: function (fiber, instance) {},
+  flushPendingUnsafeLifecycleWarnings: function () {},
+  recordLegacyContextWarning: function (fiber, instance) {},
+  flushLegacyContextWarning: function () {},
+  discardPendingWarnings: function () {}
+};
 
-  switch (domEventName) {
-    // Track the input node that has focus.
-    case "focusin":
-      if (
-        isTextInputElement(targetNode) ||
-        targetNode.contentEditable === "true"
-      ) {
-        activeElement = targetNode;
-        activeElementInst = targetInst;
-        lastSelection = null;
+{
+  var findStrictRoot = function (fiber) {
+    var maybeStrictRoot = null;
+    var node = fiber;
+
+    while (node !== null) {
+      if (node.mode & StrictLegacyMode) {
+        maybeStrictRoot = node;
       }
 
-      break;
+      node = node.return;
+    }
 
-    case "focusout":
-      activeElement = null;
-      activeElementInst = null;
-      lastSelection = null;
-      break;
-    // Don't fire the event while the user is dragging. This matches the
-    // semantics of the native select event.
+    return maybeStrictRoot;
+  };
 
-    case "mousedown":
-      mouseDown = true;
-      break;
+  var setToSortedString = function (set) {
+    var array = [];
+    set.forEach(function (value) {
+      array.push(value);
+    });
+    return array.sort().join(", ");
+  };
 
-    case "contextmenu":
-    case "mouseup":
-    case "dragend":
-      mouseDown = false;
-      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-      break;
-    // Chrome and IE fire non-standard event when selection is changed (and
-    // sometimes when it hasn't). IE's event fires out of order with respect
-    // to key and input events on deletion, so we discard it.
-    //
-    // Firefox doesn't support selectionchange, so check selection status
-    // after each key entry. The selection changes after keydown and before
-    // keyup, but we check on keydown as well in the case of holding down a
-    // key, when multiple keydown events are fired but only one keyup is.
-    // This is also our approach for IE handling, for the reason above.
+  var pendingComponentWillMountWarnings = [];
+  var pendingUNSAFE_ComponentWillMountWarnings = [];
+  var pendingComponentWillReceivePropsWarnings = [];
+  var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+  var pendingComponentWillUpdateWarnings = [];
+  var pendingUNSAFE_ComponentWillUpdateWarnings = []; // Tracks components we have already warned about.
 
-    case "selectionchange":
-      if (skipSelectionChangeEvent) {
-        break;
-      }
+  var didWarnAboutUnsafeLifecycles = new Set();
 
-    // falls through
+  ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (
+    fiber,
+    instance
+  ) {
+    // Dedupe strategy: Warn once per component.
+    if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
+      return;
+    }
 
-    case "keydown":
-    case "keyup":
-      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-  }
-}
+    if (
+      typeof instance.componentWillMount === "function" && // Don't warn about react-lifecycles-compat polyfilled components.
+      instance.componentWillMount.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillMountWarnings.push(fiber);
+    }
 
-/**
- * Generate a mapping of standard vendor prefixes using the defined style property and event name.
- *
- * @param {string} styleProp
- * @param {string} eventName
- * @returns {object}
- */
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillMount === "function"
+    ) {
+      pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
+    }
 
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
-}
-/**
- * A list of event names to a configurable list of vendor prefixes.
- */
+    if (
+      typeof instance.componentWillReceiveProps === "function" &&
+      instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillReceivePropsWarnings.push(fiber);
+    }
 
-var vendorPrefixes = {
-  animationend: makePrefixMap("Animation", "AnimationEnd"),
-  animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-  animationstart: makePrefixMap("Animation", "AnimationStart"),
-  transitionend: makePrefixMap("Transition", "TransitionEnd")
-};
-/**
- * Event names that have already been detected and prefixed (if applicable).
- */
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillReceiveProps === "function"
+    ) {
+      pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
+    }
 
-var prefixedEventNames = {};
-/**
- * Element to check for prefixes on.
- */
+    if (
+      typeof instance.componentWillUpdate === "function" &&
+      instance.componentWillUpdate.__suppressDeprecationWarning !== true
+    ) {
+      pendingComponentWillUpdateWarnings.push(fiber);
+    }
 
-var style = {};
-/**
- * Bootstrap if a DOM exists.
- */
+    if (
+      fiber.mode & StrictLegacyMode &&
+      typeof instance.UNSAFE_componentWillUpdate === "function"
+    ) {
+      pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
+    }
+  };
 
-if (canUseDOM) {
-  style = document.createElement("div").style; // On some platforms, in particular some releases of Android 4.x,
-  // the un-prefixed "animation" and "transition" properties are defined on the
-  // style object but the events that fire will still be prefixed, so we need
-  // to check if the un-prefixed events are usable, and if not remove them from the map.
+  ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
+    // We do an initial pass to gather component names
+    var componentWillMountUniqueNames = new Set();
 
-  if (!("AnimationEvent" in window)) {
-    delete vendorPrefixes.animationend.animation;
-    delete vendorPrefixes.animationiteration.animation;
-    delete vendorPrefixes.animationstart.animation;
-  } // Same as above
+    if (pendingComponentWillMountWarnings.length > 0) {
+      pendingComponentWillMountWarnings.forEach(function (fiber) {
+        componentWillMountUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillMountWarnings = [];
+    }
 
-  if (!("TransitionEvent" in window)) {
-    delete vendorPrefixes.transitionend.transition;
-  }
-}
-/**
- * Attempts to determine the correct vendor prefixed event name.
- *
- * @param {string} eventName
- * @returns {string}
- */
+    var UNSAFE_componentWillMountUniqueNames = new Set();
 
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) {
-    return prefixedEventNames[eventName];
-  } else if (!vendorPrefixes[eventName]) {
-    return eventName;
-  }
+    if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillMountUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillMountWarnings = [];
+    }
 
-  var prefixMap = vendorPrefixes[eventName];
+    var componentWillReceivePropsUniqueNames = new Set();
 
-  for (var styleProp in prefixMap) {
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
+    if (pendingComponentWillReceivePropsWarnings.length > 0) {
+      pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        componentWillReceivePropsUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillReceivePropsWarnings = [];
     }
-  }
 
-  return eventName;
-}
+    var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
 
-var ANIMATION_END = getVendorPrefixedEventName("animationend");
-var ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration");
-var ANIMATION_START = getVendorPrefixedEventName("animationstart");
-var TRANSITION_END = getVendorPrefixedEventName("transitionend");
+    if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillReceivePropsUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+    }
 
-var topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
-//
-// E.g. it needs "pointerDown", not "pointerdown".
-// This is because we derive both React name ("onPointerDown")
-// and DOM name ("pointerdown") from the same list.
-//
-// Exceptions that don't match this convention are listed separately.
-//
-// prettier-ignore
+    var componentWillUpdateUniqueNames = new Set();
 
-var simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'toggle', 'touchMove', 'waiting', 'wheel'];
+    if (pendingComponentWillUpdateWarnings.length > 0) {
+      pendingComponentWillUpdateWarnings.forEach(function (fiber) {
+        componentWillUpdateUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingComponentWillUpdateWarnings = [];
+    }
 
-{
-  // Special case: these two events don't have on* React handler
-  // and are only accessible via the createEventHandle API.
-  topLevelEventsToReactNames.set("beforeblur", null);
-  topLevelEventsToReactNames.set("afterblur", null);
-}
+    var UNSAFE_componentWillUpdateUniqueNames = new Set();
 
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
-}
+    if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
+      pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillUpdateUniqueNames.add(
+          getComponentNameFromFiber(fiber) || "Component"
+        );
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      });
+      pendingUNSAFE_ComponentWillUpdateWarnings = [];
+    } // Finally, we flush all the warnings
+    // UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
 
-function registerSimpleEvents() {
-  for (var i = 0; i < simpleEventPluginEvents.length; i++) {
-    var eventName = simpleEventPluginEvents[i];
-    var domEventName = eventName.toLowerCase();
-    var capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
-    registerSimpleEvent(domEventName, "on" + capitalizedEvent);
-  } // Special cases where event names don't match.
+    if (UNSAFE_componentWillMountUniqueNames.size > 0) {
+      var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
 
-  registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-  registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-  registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-  registerSimpleEvent("dblclick", "onDoubleClick");
-  registerSimpleEvent("focusin", "onFocus");
-  registerSimpleEvent("focusout", "onBlur");
-  registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
-}
+      error(
+        "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
+          "\nPlease update the following components: %s",
+        sortedNames
+      );
+    }
 
-function extractEvents$1(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  var reactName = topLevelEventsToReactNames.get(domEventName);
+    if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
+      var _sortedNames = setToSortedString(
+        UNSAFE_componentWillReceivePropsUniqueNames
+      );
 
-  if (reactName === undefined) {
-    return;
-  }
+      error(
+        "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " +
+          "and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* If you're updating state whenever props change, " +
+          "refactor your code to use memoization techniques or move it to " +
+          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames
+      );
+    }
 
-  var SyntheticEventCtor = SyntheticEvent;
-  var reactEventType = domEventName;
+    if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
+      var _sortedNames2 = setToSortedString(
+        UNSAFE_componentWillUpdateUniqueNames
+      );
 
-  switch (domEventName) {
-    case "keypress":
-      // Firefox creates a keypress event for function keys too. This removes
-      // the unwanted keypress events. Enter is however both printable and
-      // non-printable. One would expect Tab to be as well (but it isn't).
-      if (getEventCharCode(nativeEvent) === 0) {
-        return;
-      }
+      error(
+        "Using UNSAFE_componentWillUpdate in strict mode is not recommended " +
+          "and may indicate bugs in your code. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames2
+      );
+    }
 
-    /* falls through */
+    if (componentWillMountUniqueNames.size > 0) {
+      var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);
 
-    case "keydown":
-    case "keyup":
-      SyntheticEventCtor = SyntheticKeyboardEvent;
-      break;
+      warn(
+        "componentWillMount has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
+          "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames3
+      );
+    }
 
-    case "focusin":
-      reactEventType = "focus";
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+    if (componentWillReceivePropsUniqueNames.size > 0) {
+      var _sortedNames4 = setToSortedString(
+        componentWillReceivePropsUniqueNames
+      );
 
-    case "focusout":
-      reactEventType = "blur";
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+      warn(
+        "componentWillReceiveProps has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* If you're updating state whenever props change, refactor your " +
+          "code to use memoization techniques or move it to " +
+          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
+          "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames4
+      );
+    }
 
-    case "beforeblur":
-    case "afterblur":
-      SyntheticEventCtor = SyntheticFocusEvent;
-      break;
+    if (componentWillUpdateUniqueNames.size > 0) {
+      var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);
 
-    case "click":
-      // Firefox creates a click event on right mouse clicks. This removes the
-      // unwanted click events.
-      if (nativeEvent.button === 2) {
-        return;
-      }
+      warn(
+        "componentWillUpdate has been renamed, and is not recommended for use. " +
+          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
+          "* Move data fetching code or side effects to componentDidUpdate.\n" +
+          "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " +
+          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
+          "To rename all deprecated lifecycles to their new names, you can run " +
+          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
+          "\nPlease update the following components: %s",
+        _sortedNames5
+      );
+    }
+  };
 
-    /* falls through */
+  var pendingLegacyContextWarning = new Map(); // Tracks components we have already warned about.
 
-    case "auxclick":
-    case "dblclick":
-    case "mousedown":
-    case "mousemove":
-    case "mouseup": // TODO: Disabled elements should not respond to mouse events
+  var didWarnAboutLegacyContext = new Set();
 
-    /* falls through */
+  ReactStrictModeWarnings.recordLegacyContextWarning = function (
+    fiber,
+    instance
+  ) {
+    var strictRoot = findStrictRoot(fiber);
 
-    case "mouseout":
-    case "mouseover":
-    case "contextmenu":
-      SyntheticEventCtor = SyntheticMouseEvent;
-      break;
+    if (strictRoot === null) {
+      error(
+        "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."
+      );
 
-    case "drag":
-    case "dragend":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "dragstart":
-    case "drop":
-      SyntheticEventCtor = SyntheticDragEvent;
-      break;
+      return;
+    } // Dedup strategy: Warn once per component.
 
-    case "touchcancel":
-    case "touchend":
-    case "touchmove":
-    case "touchstart":
-      SyntheticEventCtor = SyntheticTouchEvent;
-      break;
+    if (didWarnAboutLegacyContext.has(fiber.type)) {
+      return;
+    }
 
-    case ANIMATION_END:
-    case ANIMATION_ITERATION:
-    case ANIMATION_START:
-      SyntheticEventCtor = SyntheticAnimationEvent;
-      break;
+    var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
 
-    case TRANSITION_END:
-      SyntheticEventCtor = SyntheticTransitionEvent;
-      break;
+    if (
+      fiber.type.contextTypes != null ||
+      fiber.type.childContextTypes != null ||
+      (instance !== null && typeof instance.getChildContext === "function")
+    ) {
+      if (warningsForRoot === undefined) {
+        warningsForRoot = [];
+        pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
+      }
 
-    case "scroll":
-      SyntheticEventCtor = SyntheticUIEvent;
-      break;
+      warningsForRoot.push(fiber);
+    }
+  };
 
-    case "wheel":
-      SyntheticEventCtor = SyntheticWheelEvent;
-      break;
+  ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+    pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
+      if (fiberArray.length === 0) {
+        return;
+      }
 
-    case "copy":
-    case "cut":
-    case "paste":
-      SyntheticEventCtor = SyntheticClipboardEvent;
-      break;
+      var firstFiber = fiberArray[0];
+      var uniqueNames = new Set();
+      fiberArray.forEach(function (fiber) {
+        uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutLegacyContext.add(fiber.type);
+      });
+      var sortedNames = setToSortedString(uniqueNames);
 
-    case "gotpointercapture":
-    case "lostpointercapture":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "pointerup":
-      SyntheticEventCtor = SyntheticPointerEvent;
-      break;
-  }
+      try {
+        setCurrentFiber(firstFiber);
 
-  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
+        error(
+          "Legacy context API has been detected within a strict-mode tree." +
+            "\n\nThe old API will be supported in all 16.x releases, but applications " +
+            "using it should migrate to the new version." +
+            "\n\nPlease update the following components: %s" +
+            "\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context",
+          sortedNames
+        );
+      } finally {
+        resetCurrentFiber();
+      }
+    });
+  };
 
-  if (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) {
-    var listeners = accumulateEventHandleNonManagedNodeListeners(
-      // TODO: this cast may not make sense for events like
-      // "focus" where React listens to e.g. "focusin".
-      reactEventType,
-      targetContainer,
-      inCapturePhase
-    );
+  ReactStrictModeWarnings.discardPendingWarnings = function () {
+    pendingComponentWillMountWarnings = [];
+    pendingUNSAFE_ComponentWillMountWarnings = [];
+    pendingComponentWillReceivePropsWarnings = [];
+    pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+    pendingComponentWillUpdateWarnings = [];
+    pendingUNSAFE_ComponentWillUpdateWarnings = [];
+    pendingLegacyContextWarning = new Map();
+  };
+}
 
-    if (listeners.length > 0) {
-      // Intentionally create event lazily.
-      var event = new SyntheticEventCtor(
-        reactName,
-        reactEventType,
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
-      dispatchQueue.push({
-        event: event,
-        listeners: listeners
-      });
-    }
-  } else {
-    // Some events don't bubble in the browser.
-    // In the past, React has always bubbled them, but this can be surprising.
-    // We're going to try aligning closer to the browser behavior by not bubbling
-    // them in React either. We'll start by not bubbling onScroll, and then expand.
-    var accumulateTargetOnly =
-      !inCapturePhase && // TODO: ideally, we'd eventually add all events from
-      // nonDelegatedEvents list in DOMPluginEventSystem.
-      // Then we can remove this special list.
-      // This is a breaking change that can wait until React 18.
-      domEventName === "scroll";
+var ReactCurrentActQueue$2 = ReactSharedInternals.ReactCurrentActQueue; // An error that is thrown (e.g. by `use`) to trigger Suspense. If we
+// detect this is caught by userspace, we'll log a warning in development.
 
-    var _listeners = accumulateSinglePhaseListeners(
-      targetInst,
-      reactName,
-      nativeEvent.type,
-      inCapturePhase,
-      accumulateTargetOnly,
-      nativeEvent
-    );
+var SuspenseException = new Error(
+  "Suspense Exception: This is not a real error! It's an implementation " +
+    "detail of `use` to interrupt the current render. You must either " +
+    "rethrow it immediately, or move the `use` call outside of the " +
+    "`try/catch` block. Capturing without rethrowing will lead to " +
+    "unexpected behavior.\n\n" +
+    "To handle async errors, wrap your component in an error boundary, or " +
+    "call the promise's `.catch` method and pass the result to `use`"
+);
+function createThenableState() {
+  // The ThenableState is created the first time a component suspends. If it
+  // suspends again, we'll reuse the same state.
+  return [];
+}
+function isThenableResolved(thenable) {
+  var status = thenable.status;
+  return status === "fulfilled" || status === "rejected";
+}
 
-    if (_listeners.length > 0) {
-      // Intentionally create event lazily.
-      var _event = new SyntheticEventCtor(
-        reactName,
-        reactEventType,
-        null,
-        nativeEvent,
-        nativeEventTarget
-      );
+function noop$1() {}
 
-      dispatchQueue.push({
-        event: _event,
-        listeners: _listeners
-      });
-    }
+function trackUsedThenable(thenableState, thenable, index) {
+  if (ReactCurrentActQueue$2.current !== null) {
+    ReactCurrentActQueue$2.didUsePromise = true;
   }
-}
 
-registerSimpleEvents();
-registerEvents$1();
-registerEvents$2();
-registerEvents();
-registerEvents$3();
+  var previous = thenableState[index];
 
-function extractEvents(
-  dispatchQueue,
-  domEventName,
-  targetInst,
-  nativeEvent,
-  nativeEventTarget,
-  eventSystemFlags,
-  targetContainer
-) {
-  // TODO: we should remove the concept of a "SimpleEventPlugin".
-  // This is the basic functionality of the event system. All
-  // the other plugins are essentially polyfills. So the plugin
-  // should probably be inlined somewhere and have its logic
-  // be core the to event system. This would potentially allow
-  // us to ship builds of React without the polyfilled plugins below.
-  extractEvents$1(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget,
-    eventSystemFlags,
-    targetContainer
-  );
-  var shouldProcessPolyfillPlugins =
-    (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
-  // event's native "bubble" phase, which means that we're
-  // not in the capture phase. That's because we emulate
-  // the capture phase here still. This is a trade-off,
-  // because in an ideal world we would not emulate and use
-  // the phases properly, like we do with the SimpleEvent
-  // plugin. However, the plugins below either expect
-  // emulation (EnterLeave) or use state localized to that
-  // plugin (BeforeInput, Change, Select). The state in
-  // these modules complicates things, as you'll essentially
-  // get the case where the capture phase event might change
-  // state, only for the following bubble event to come in
-  // later and not trigger anything as the state now
-  // invalidates the heuristics of the event plugin. We
-  // could alter all these plugins to work in such ways, but
-  // that might cause other unknown side-effects that we
-  // can't foresee right now.
-
-  if (shouldProcessPolyfillPlugins) {
-    extractEvents$3(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$4(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$2(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-    extractEvents$5(
-      dispatchQueue,
-      domEventName,
-      targetInst,
-      nativeEvent,
-      nativeEventTarget
-    );
-  }
-} // List of events that need to be individually attached to media elements.
-
-var mediaEventTypes = [
-  "abort",
-  "canplay",
-  "canplaythrough",
-  "durationchange",
-  "emptied",
-  "encrypted",
-  "ended",
-  "error",
-  "loadeddata",
-  "loadedmetadata",
-  "loadstart",
-  "pause",
-  "play",
-  "playing",
-  "progress",
-  "ratechange",
-  "resize",
-  "seeked",
-  "seeking",
-  "stalled",
-  "suspend",
-  "timeupdate",
-  "volumechange",
-  "waiting"
-]; // We should not delegate these events to the container, but rather
-// set them on the actual target element itself. This is primarily
-// because these events do not consistently bubble in the DOM.
+  if (previous === undefined) {
+    thenableState.push(thenable);
+  } else {
+    if (previous !== thenable) {
+      // Reuse the previous thenable, and drop the new one. We can assume
+      // they represent the same value, because components are idempotent.
+      // Avoid an unhandled rejection errors for the Promises that we'll
+      // intentionally ignore.
+      thenable.then(noop$1, noop$1);
+      thenable = previous;
+    }
+  } // We use an expando to track the status and result of a thenable so that we
+  // can synchronously unwrap the value. Think of this as an extension of the
+  // Promise API, or a custom interface that is a superset of Thenable.
+  //
+  // If the thenable doesn't have a status, set it to "pending" and attach
+  // a listener that will update its status and result when it resolves.
 
-var nonDelegatedEvents = new Set(
-  ["cancel", "close", "invalid", "load", "scroll", "toggle"].concat(
-    mediaEventTypes
-  )
-);
+  switch (thenable.status) {
+    case "fulfilled": {
+      var fulfilledValue = thenable.value;
+      return fulfilledValue;
+    }
 
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
-  event.currentTarget = null;
-}
+    case "rejected": {
+      var rejectedError = thenable.reason;
+      throw rejectedError;
+    }
 
-function processDispatchQueueItemsInOrder(
-  event,
-  dispatchListeners,
-  inCapturePhase
-) {
-  var previousInstance;
+    default: {
+      if (typeof thenable.status === "string") {
+        // Only instrument the thenable if the status if not defined. If
+        // it's defined, but an unknown value, assume it's been instrumented by
+        // some custom userspace implementation. We treat it as "pending".
+        // Attach a dummy listener, to ensure that any lazy initialization can
+        // happen. Flight lazily parses JSON when the value is actually awaited.
+        thenable.then(noop$1, noop$1);
+      } else {
+        var pendingThenable = thenable;
+        pendingThenable.status = "pending";
+        pendingThenable.then(
+          function (fulfilledValue) {
+            if (thenable.status === "pending") {
+              var fulfilledThenable = thenable;
+              fulfilledThenable.status = "fulfilled";
+              fulfilledThenable.value = fulfilledValue;
+            }
+          },
+          function (error) {
+            if (thenable.status === "pending") {
+              var rejectedThenable = thenable;
+              rejectedThenable.status = "rejected";
+              rejectedThenable.reason = error;
+            }
+          }
+        );
+      } // Check one more time in case the thenable resolved synchronously.
 
-  if (inCapturePhase) {
-    for (var i = dispatchListeners.length - 1; i >= 0; i--) {
-      var _dispatchListeners$i = dispatchListeners[i],
-        instance = _dispatchListeners$i.instance,
-        currentTarget = _dispatchListeners$i.currentTarget,
-        listener = _dispatchListeners$i.listener;
+      switch (thenable.status) {
+        case "fulfilled": {
+          var fulfilledThenable = thenable;
+          return fulfilledThenable.value;
+        }
 
-      if (instance !== previousInstance && event.isPropagationStopped()) {
-        return;
-      }
+        case "rejected": {
+          var rejectedThenable = thenable;
+          throw rejectedThenable.reason;
+        }
+      } // Suspend.
+      //
+      // Throwing here is an implementation detail that allows us to unwind the
+      // call stack. But we shouldn't allow it to leak into userspace. Throw an
+      // opaque placeholder value instead of the actual thenable. If it doesn't
+      // get captured by the work loop, log a warning, because that means
+      // something in userspace must have caught it.
 
-      executeDispatch(event, listener, currentTarget);
-      previousInstance = instance;
-    }
-  } else {
-    for (var _i = 0; _i < dispatchListeners.length; _i++) {
-      var _dispatchListeners$_i = dispatchListeners[_i],
-        _instance = _dispatchListeners$_i.instance,
-        _currentTarget = _dispatchListeners$_i.currentTarget,
-        _listener = _dispatchListeners$_i.listener;
+      suspendedThenable = thenable;
 
-      if (_instance !== previousInstance && event.isPropagationStopped()) {
-        return;
+      {
+        needsToResetSuspendedThenableDEV = true;
       }
 
-      executeDispatch(event, _listener, _currentTarget);
-      previousInstance = _instance;
+      throw SuspenseException;
     }
   }
-}
-
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
-
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event,
-      listeners = _dispatchQueue$i.listeners;
-    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
-  } // This would be a good time to rethrow if any of the event handlers threw.
+} // This is used to track the actual thenable that suspended so it can be
+// passed to the rest of the Suspense implementation — which, for historical
+// reasons, expects to receive a thenable.
 
-  rethrowCaughtError();
-}
+var suspendedThenable = null;
+var needsToResetSuspendedThenableDEV = false;
+function getSuspendedThenable() {
+  // This is called right after `use` suspends by throwing an exception. `use`
+  // throws an opaque value instead of the thenable itself so that it can't be
+  // caught in userspace. Then the work loop accesses the actual thenable using
+  // this function.
+  if (suspendedThenable === null) {
+    throw new Error(
+      "Expected a suspended thenable. This is a bug in React. Please file " +
+        "an issue."
+    );
+  }
 
-function dispatchEventsForPlugins(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst,
-  targetContainer
-) {
-  var nativeEventTarget = getEventTarget(nativeEvent);
-  var dispatchQueue = [];
-  extractEvents(
-    dispatchQueue,
-    domEventName,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget,
-    eventSystemFlags,
-    targetContainer
-  );
-  processDispatchQueue(dispatchQueue, eventSystemFlags);
-}
+  var thenable = suspendedThenable;
+  suspendedThenable = null;
 
-function listenToNonDelegatedEvent(domEventName, targetElement) {
   {
-    if (!nonDelegatedEvents.has(domEventName)) {
-      error(
-        'Did not expect a listenToNonDelegatedEvent() call for "%s". ' +
-          "This is a bug in React. Please file an issue.",
-        domEventName
-      );
-    }
+    needsToResetSuspendedThenableDEV = false;
   }
 
-  var isCapturePhaseListener = false;
-  var listenerSet = getEventListenerSet(targetElement);
-  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
-
-  if (!listenerSet.has(listenerSetKey)) {
-    addTrappedEventListener(
-      targetElement,
-      domEventName,
-      IS_NON_DELEGATED,
-      isCapturePhaseListener
-    );
-    listenerSet.add(listenerSetKey);
-  }
+  return thenable;
 }
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+function checkIfUseWrappedInTryCatch() {
   {
-    if (nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener) {
-      error(
-        'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. ' +
-          "This is a bug in React. Please file an issue.",
-        domEventName
-      );
+    // This was set right before SuspenseException was thrown, and it should
+    // have been cleared when the exception was handled. If it wasn't,
+    // it must have been caught by userspace.
+    if (needsToResetSuspendedThenableDEV) {
+      needsToResetSuspendedThenableDEV = false;
+      return true;
     }
   }
 
-  var eventSystemFlags = 0;
+  return false;
+}
 
-  if (isCapturePhaseListener) {
-    eventSystemFlags |= IS_CAPTURE_PHASE;
-  }
+var thenableState$1 = null;
+var thenableIndexCounter$1 = 0;
+var didWarnAboutMaps;
+var didWarnAboutGenerators;
+var didWarnAboutStringRefs;
+var ownerHasKeyUseWarning;
+var ownerHasFunctionTypeWarning;
 
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
-} // This is only used by createEventHandle when the
-// target is not a DOM element. E.g. window.
+var warnForMissingKey = function (child, returnFiber) {};
 
-function listenToNativeEventForNonManagedEventTarget(
-  domEventName,
-  isCapturePhaseListener,
-  target
-) {
-  var eventSystemFlags = IS_EVENT_HANDLE_NON_MANAGED_NODE;
-  var listenerSet = getEventListenerSet(target);
-  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+{
+  didWarnAboutMaps = false;
+  didWarnAboutGenerators = false;
+  didWarnAboutStringRefs = {};
+  /**
+   * Warn if there's no key explicitly set on dynamic arrays of children or
+   * object keys are not valid. This allows us to keep track of children between
+   * updates.
+   */
 
-  if (!listenerSet.has(listenerSetKey)) {
-    if (isCapturePhaseListener) {
-      eventSystemFlags |= IS_CAPTURE_PHASE;
+  ownerHasKeyUseWarning = {};
+  ownerHasFunctionTypeWarning = {};
+
+  warnForMissingKey = function (child, returnFiber) {
+    if (child === null || typeof child !== "object") {
+      return;
     }
 
-    addTrappedEventListener(
-      target,
-      domEventName,
-      eventSystemFlags,
-      isCapturePhaseListener
-    );
-    listenerSet.add(listenerSetKey);
-  }
-}
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = true;
-    allNativeEvents.forEach(function (domEventName) {
-      // We handle selectionchange separately because it
-      // doesn't bubble and needs to be on the document.
-      if (domEventName !== "selectionchange") {
-        if (!nonDelegatedEvents.has(domEventName)) {
-          listenToNativeEvent(domEventName, false, rootContainerElement);
-        }
+    if (!child._store || child._store.validated || child.key != null) {
+      return;
+    }
 
-        listenToNativeEvent(domEventName, true, rootContainerElement);
-      }
-    });
-    var ownerDocument =
-      rootContainerElement.nodeType === DOCUMENT_NODE
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
+    if (typeof child._store !== "object") {
+      throw new Error(
+        "React Component in warnForMissingKey should have a _store. " +
+          "This error is likely caused by a bug in React. Please file an issue."
+      );
+    } // $FlowFixMe unable to narrow type from mixed to writable object
 
-    if (ownerDocument !== null) {
-      // The selectionchange event also needs deduplication
-      // but it is attached to the document.
-      if (!ownerDocument[listeningMarker]) {
-        ownerDocument[listeningMarker] = true;
-        listenToNativeEvent("selectionchange", false, ownerDocument);
-      }
+    child._store.validated = true;
+    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
+
+    if (ownerHasKeyUseWarning[componentName]) {
+      return;
     }
-  }
+
+    ownerHasKeyUseWarning[componentName] = true;
+
+    error(
+      "Each child in a list should have a unique " +
+        '"key" prop. See https://reactjs.org/link/warning-keys for ' +
+        "more information."
+    );
+  };
 }
 
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  var listener = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  ); // If passive option is not supported, then the event will be
-  // active and not passive.
+function isReactClass(type) {
+  return type.prototype && type.prototype.isReactComponent;
+}
 
-  var isPassiveListener = undefined;
+function unwrapThenable(thenable) {
+  var index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
 
-  if (passiveBrowserEventsSupported) {
-    // Browsers introduced an intervention, making these events
-    // passive by default on document. React doesn't bind them
-    // to document anymore, but changing this now would undo
-    // the performance wins from the change. So we emulate
-    // the existing behavior manually on the roots now.
-    // https://github.com/facebook/react/issues/19651
-    if (
-      domEventName === "touchstart" ||
-      domEventName === "touchmove" ||
-      domEventName === "wheel"
-    ) {
-      isPassiveListener = true;
-    }
+  if (thenableState$1 === null) {
+    thenableState$1 = createThenableState();
   }
 
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  var unsubscribeListener; // When legacyFBSupport is enabled, it's for when we
-  // want to add a one time event listener to a container.
-  // This should only be used with enableLegacyFBSupport
-  // due to requirement to provide compatibility with
-  // internal FB www event tooling. This works by removing
-  // the event listener as soon as it is invoked. We could
-  // also attempt to use the {once: true} param on
-  // addEventListener, but that requires support and some
-  // browsers do not support this today, and given this is
-  // to support legacy code patterns, it's likely they'll
-  // need support for such browsers.
-
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = listener; // $FlowFixMe[missing-this-annot]
-    // $FlowFixMe[definition-cycle]
+  return trackUsedThenable(thenableState$1, thenable, index);
+}
 
-    listener = function () {
-      removeEventListener(
-        targetContainer,
-        domEventName,
-        unsubscribeListener,
-        isCapturePhaseListener
-      );
+function coerceRef(returnFiber, current, element) {
+  var mixedRef = element.ref;
 
-      for (
-        var _len = arguments.length, p = new Array(_len), _key = 0;
-        _key < _len;
-        _key++
+  if (
+    mixedRef !== null &&
+    typeof mixedRef !== "function" &&
+    typeof mixedRef !== "object"
+  ) {
+    {
+      if (
+        // We warn in ReactElement.js if owner and self are equal for string refs
+        // because these cannot be automatically converted to an arrow function
+        // using a codemod. Therefore, we don't have to warn about string refs again.
+        !(
+          element._owner &&
+          element._self &&
+          element._owner.stateNode !== element._self
+        ) && // Will already throw with "Function components cannot have string refs"
+        !(element._owner && element._owner.tag !== ClassComponent) && // Will already warn with "Function components cannot be given refs"
+        !(typeof element.type === "function" && !isReactClass(element.type)) && // Will already throw with "Element ref was specified as a string (someStringRef) but no owner was set"
+        element._owner
       ) {
-        p[_key] = arguments[_key];
-      }
+        var componentName =
+          getComponentNameFromFiber(returnFiber) || "Component";
 
-      return originalListener.apply(this, p);
-    };
-  } // TODO: There are too many combinations here. Consolidate them.
+        if (!didWarnAboutStringRefs[componentName]) {
+          error(
+            'Component "%s" contains the string ref "%s". Support for string refs ' +
+              "will be removed in a future major release. We recommend using " +
+              "useRef() or createRef() instead. " +
+              "Learn more about using refs safely here: " +
+              "https://reactjs.org/link/strict-mode-string-ref",
+            componentName,
+            mixedRef
+          );
 
-  if (isCapturePhaseListener) {
-    if (isPassiveListener !== undefined) {
-      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        listener,
-        isPassiveListener
-      );
-    } else {
-      unsubscribeListener = addEventCaptureListener(
-        targetContainer,
-        domEventName,
-        listener
-      );
-    }
-  } else {
-    if (isPassiveListener !== undefined) {
-      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        listener,
-        isPassiveListener
-      );
-    } else {
-      unsubscribeListener = addEventBubbleListener(
-        targetContainer,
-        domEventName,
-        listener
-      );
+          didWarnAboutStringRefs[componentName] = true;
+        }
+      }
     }
-  }
-}
-
-function deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer) {
-  // We defer all click events with legacy FB support mode on.
-  // This means we add a one time event listener to trigger
-  // after the FB delegated listeners fire.
-  var isDeferredListenerForLegacyFBSupport = true;
-  addTrappedEventListener(
-    targetContainer,
-    domEventName,
-    IS_LEGACY_FB_SUPPORT_MODE,
-    false,
-    isDeferredListenerForLegacyFBSupport
-  );
-}
-
-function isMatchingRootContainer(grandContainer, targetContainer) {
-  return (
-    grandContainer === targetContainer ||
-    (grandContainer.nodeType === COMMENT_NODE &&
-      grandContainer.parentNode === targetContainer)
-  );
-}
-
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst,
-  targetContainer
-) {
-  var ancestorInst = targetInst;
-
-  if (
-    (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 &&
-    (eventSystemFlags & IS_NON_DELEGATED) === 0
-  ) {
-    var targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
-    // defer the event to the null with a one
-    // time event listener so we can defer the event.
 
-    if (
-      enableLegacyFBSupport && // If our event flags match the required flags for entering
-      // FB legacy mode and we are processing the "click" event,
-      // then we can defer the event to the "document", to allow
-      // for legacy FB support, where the expected behavior was to
-      // match React < 16 behavior of delegated clicks to the doc.
-      domEventName === "click" &&
-      (eventSystemFlags & SHOULD_NOT_DEFER_CLICK_FOR_FB_SUPPORT_MODE) === 0 &&
-      !isReplayingEvent(nativeEvent)
-    ) {
-      deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer);
-      return;
-    }
+    if (element._owner) {
+      var owner = element._owner;
+      var inst;
 
-    if (targetInst !== null) {
-      // The below logic attempts to work out if we need to change
-      // the target fiber to a different ancestor. We had similar logic
-      // in the legacy event system, except the big difference between
-      // systems is that the modern event system now has an event listener
-      // attached to each React Root and React Portal Root. Together,
-      // the DOM nodes representing these roots are the "rootContainer".
-      // To figure out which ancestor instance we should use, we traverse
-      // up the fiber tree from the target instance and attempt to find
-      // root boundaries that match that of our current "rootContainer".
-      // If we find that "rootContainer", we find the parent fiber
-      // sub-tree for that root and make that our ancestor instance.
-      var node = targetInst;
+      if (owner) {
+        var ownerFiber = owner;
 
-      mainLoop: while (true) {
-        if (node === null) {
-          return;
+        if (ownerFiber.tag !== ClassComponent) {
+          throw new Error(
+            "Function components cannot have string refs. " +
+              "We recommend using useRef() instead. " +
+              "Learn more about using refs safely here: " +
+              "https://reactjs.org/link/strict-mode-string-ref"
+          );
         }
 
-        var nodeTag = node.tag;
-
-        if (nodeTag === HostRoot || nodeTag === HostPortal) {
-          var container = node.stateNode.containerInfo;
-
-          if (isMatchingRootContainer(container, targetContainerNode)) {
-            break;
-          }
-
-          if (nodeTag === HostPortal) {
-            // The target is a portal, but it's not the rootContainer we're looking for.
-            // Normally portals handle their own events all the way down to the root.
-            // So we should be able to stop now. However, we don't know if this portal
-            // was part of *our* root.
-            var grandNode = node.return;
-
-            while (grandNode !== null) {
-              var grandTag = grandNode.tag;
-
-              if (grandTag === HostRoot || grandTag === HostPortal) {
-                var grandContainer = grandNode.stateNode.containerInfo;
+        inst = ownerFiber.stateNode;
+      }
 
-                if (
-                  isMatchingRootContainer(grandContainer, targetContainerNode)
-                ) {
-                  // This is the rootContainer we're looking for and we found it as
-                  // a parent of the Portal. That means we can ignore it because the
-                  // Portal will bubble through to us.
-                  return;
-                }
-              }
+      if (!inst) {
+        throw new Error(
+          "Missing owner for string ref " +
+            mixedRef +
+            ". This error is likely caused by a " +
+            "bug in React. Please file an issue."
+        );
+      } // Assigning this to a const so Flow knows it won't change in the closure
 
-              grandNode = grandNode.return;
-            }
-          } // Now we need to find it's corresponding host fiber in the other
-          // tree. To do this we can use getClosestInstanceFromNode, but we
-          // need to validate that the fiber is a host instance, otherwise
-          // we need to traverse up through the DOM till we find the correct
-          // node that is from the other tree.
+      var resolvedInst = inst;
 
-          while (container !== null) {
-            var parentNode = getClosestInstanceFromNode(container);
+      {
+        checkPropStringCoercion(mixedRef, "ref");
+      }
 
-            if (parentNode === null) {
-              return;
-            }
+      var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
 
-            var parentTag = parentNode.tag;
+      if (
+        current !== null &&
+        current.ref !== null &&
+        typeof current.ref === "function" &&
+        current.ref._stringRef === stringRef
+      ) {
+        return current.ref;
+      }
 
-            if (
-              parentTag === HostComponent ||
-              parentTag === HostText ||
-              parentTag === HostHoistable ||
-              parentTag === HostSingleton
-            ) {
-              node = ancestorInst = parentNode;
-              continue mainLoop;
-            }
+      var ref = function (value) {
+        var refs = resolvedInst.refs;
 
-            container = container.parentNode;
-          }
+        if (value === null) {
+          delete refs[stringRef];
+        } else {
+          refs[stringRef] = value;
         }
+      };
 
-        node = node.return;
+      ref._stringRef = stringRef;
+      return ref;
+    } else {
+      if (typeof mixedRef !== "string") {
+        throw new Error(
+          "Expected ref to be a function, a string, an object returned by React.createRef(), or null."
+        );
+      }
+
+      if (!element._owner) {
+        throw new Error(
+          "Element ref was specified as a string (" +
+            mixedRef +
+            ") but no owner was set. This could happen for one of" +
+            " the following reasons:\n" +
+            "1. You may be adding a ref to a function component\n" +
+            "2. You may be adding a ref to a component that was not created inside a component's render method\n" +
+            "3. You have multiple copies of React loaded\n" +
+            "See https://reactjs.org/link/refs-must-have-owner for more information."
+        );
       }
     }
   }
 
-  batchedUpdates$1(function () {
-    return dispatchEventsForPlugins(
-      domEventName,
-      eventSystemFlags,
-      nativeEvent,
-      ancestorInst,
-      targetContainer
-    );
-  });
+  return mixedRef;
 }
 
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  // $FlowFixMe[method-unbinding]
+  var childString = Object.prototype.toString.call(newChild);
+  throw new Error(
+    "Objects are not valid as a React child (found: " +
+      (childString === "[object Object]"
+        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
+        : childString) +
+      "). " +
+      "If you meant to render a collection of children, use an array " +
+      "instead."
+  );
 }
 
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  var captureName = reactName !== null ? reactName + "Capture" : null;
-  var reactEventName = inCapturePhase ? captureName : reactName;
-  var listeners = [];
-  var instance = targetFiber;
-  var lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
-
-  while (instance !== null) {
-    var _instance2 = instance,
-      stateNode = _instance2.stateNode,
-      tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+function warnOnFunctionType(returnFiber) {
+  {
+    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
 
-    if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
-    ) {
-      lastHostComponent = stateNode; // createEventHandle listeners
+    if (ownerHasFunctionTypeWarning[componentName]) {
+      return;
+    }
 
-      {
-        var eventHandlerListeners = getEventHandlerListeners(lastHostComponent);
+    ownerHasFunctionTypeWarning[componentName] = true;
 
-        if (eventHandlerListeners !== null) {
-          eventHandlerListeners.forEach(function (entry) {
-            if (
-              entry.type === nativeEventType &&
-              entry.capture === inCapturePhase
-            ) {
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-            }
-          });
-        }
-      } // Standard React on* listeners, i.e. onClick or onClickCapture
+    error(
+      "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."
+    );
+  }
+}
 
-      if (reactEventName !== null) {
-        var listener = getListener(instance, reactEventName);
+function resolveLazy(lazyType) {
+  var payload = lazyType._payload;
+  var init = lazyType._init;
+  return init(payload);
+} // This wrapper function exists because I expect to clone the code in each path
+// to be able to optimize each path individually by branching early. This needs
+// a compiler or we can do it manually. Helpers that don't need this branching
+// live outside of this function.
 
-        if (listener != null) {
-          listeners.push(
-            createDispatchListener(instance, listener, lastHostComponent)
-          );
-        }
-      }
-    } else if (
-      tag === ScopeComponent &&
-      lastHostComponent !== null &&
-      stateNode !== null
-    ) {
-      // Scopes
-      var reactScopeInstance = stateNode;
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return;
+    }
 
-      var _eventHandlerListeners = getEventHandlerListeners(reactScopeInstance);
+    var deletions = returnFiber.deletions;
 
-      if (_eventHandlerListeners !== null) {
-        _eventHandlerListeners.forEach(function (entry) {
-          if (
-            entry.type === nativeEventType &&
-            entry.capture === inCapturePhase
-          ) {
-            listeners.push(
-              createDispatchListener(
-                instance,
-                entry.callback,
-                lastHostComponent
-              )
-            );
-          }
-        });
-      }
-    } // If we are only accumulating events for the target, then we don't
-    // continue to propagate through the React fiber tree to find other
-    // listeners.
+    if (deletions === null) {
+      returnFiber.deletions = [childToDelete];
+      returnFiber.flags |= ChildDeletion;
+    } else {
+      deletions.push(childToDelete);
+    }
+  }
 
-    if (accumulateTargetOnly) {
-      break;
-    } // If we are processing the onBeforeBlur event, then we need to take
-    // into consideration that part of the React tree might have been hidden
-    // or deleted (as we're invoking this event during commit). We can find
-    // this out by checking if intercept fiber set on the event matches the
-    // current instance fiber. In which case, we should clear all existing
-    // listeners.
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) {
+      // Noop.
+      return null;
+    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
+    // assuming that after the first child we've already added everything.
 
-    if (nativeEvent.type === "beforeblur") {
-      // $FlowFixMe[prop-missing] internal field
-      var detachedInterceptFiber = nativeEvent._detachedInterceptFiber;
+    var childToDelete = currentFirstChild;
 
-      if (
-        detachedInterceptFiber !== null &&
-        (detachedInterceptFiber === instance ||
-          detachedInterceptFiber === instance.alternate)
-      ) {
-        listeners = [];
-      }
+    while (childToDelete !== null) {
+      deleteChild(returnFiber, childToDelete);
+      childToDelete = childToDelete.sibling;
     }
 
-    instance = instance.return;
+    return null;
   }
 
-  return listeners;
-} // We should only use this function for:
-// - BeforeInputEventPlugin
-// - ChangeEventPlugin
-// - SelectEventPlugin
-// This is because we only process these plugins
-// in the bubble phase, so we need to accumulate two
-// phase event listeners (via emulation).
-
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  var captureName = reactName + "Capture";
-  var listeners = [];
-  var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
-
-  while (instance !== null) {
-    var _instance3 = instance,
-      stateNode = _instance3.stateNode,
-      tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e. <div>)
-
-    if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
-    ) {
-      var currentTarget = stateNode;
-      var captureListener = getListener(instance, captureName);
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    // Add the remaining children to a temporary map so that we can find them by
+    // keys quickly. Implicit (null) keys get added to this set with their index
+    // instead.
+    var existingChildren = new Map();
+    var existingChild = currentFirstChild;
 
-      if (captureListener != null) {
-        listeners.unshift(
-          createDispatchListener(instance, captureListener, currentTarget)
-        );
+    while (existingChild !== null) {
+      if (existingChild.key !== null) {
+        existingChildren.set(existingChild.key, existingChild);
+      } else {
+        existingChildren.set(existingChild.index, existingChild);
       }
 
-      var bubbleListener = getListener(instance, reactName);
-
-      if (bubbleListener != null) {
-        listeners.push(
-          createDispatchListener(instance, bubbleListener, currentTarget)
-        );
-      }
+      existingChild = existingChild.sibling;
     }
 
-    instance = instance.return;
+    return existingChildren;
   }
 
-  return listeners;
-}
-
-function getParent(inst) {
-  if (inst === null) {
-    return null;
+  function useFiber(fiber, pendingProps) {
+    // We currently set sibling to null and index to 0 here because it is easy
+    // to forget to do before returning it. E.g. for the single child case.
+    var clone = createWorkInProgress(fiber, pendingProps);
+    clone.index = 0;
+    clone.sibling = null;
+    return clone;
   }
 
-  do {
-    // $FlowFixMe[incompatible-use] found when upgrading Flow
-    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
-    // That is depending on if we want nested subtrees (layers) to bubble
-    // events to their parent. We could also go through parentNode on the
-    // host node but that wouldn't work for React Native and doesn't let us
-    // do the portal feature.
-  } while (inst && inst.tag !== HostComponent && inst.tag !== HostSingleton);
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
 
-  if (inst) {
-    return inst;
-  }
+    if (!shouldTrackSideEffects) {
+      // During hydration, the useId algorithm needs to know which fibers are
+      // part of a list of children (arrays, iterators).
+      newFiber.flags |= Forked;
+      return lastPlacedIndex;
+    }
 
-  return null;
-}
-/**
- * Return the lowest common ancestor of A and B, or null if they are in
- * different trees.
- */
+    var current = newFiber.alternate;
 
-function getLowestCommonAncestor(instA, instB) {
-  var nodeA = instA;
-  var nodeB = instB;
-  var depthA = 0;
+    if (current !== null) {
+      var oldIndex = current.index;
 
-  for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
-    depthA++;
+      if (oldIndex < lastPlacedIndex) {
+        // This is a move.
+        newFiber.flags |= Placement | PlacementDEV;
+        return lastPlacedIndex;
+      } else {
+        // This item can stay in place.
+        return oldIndex;
+      }
+    } else {
+      // This is an insertion.
+      newFiber.flags |= Placement | PlacementDEV;
+      return lastPlacedIndex;
+    }
   }
 
-  var depthB = 0;
+  function placeSingleChild(newFiber) {
+    // This is simpler for the single child case. We only need to do a
+    // placement for inserting new children.
+    if (shouldTrackSideEffects && newFiber.alternate === null) {
+      newFiber.flags |= Placement | PlacementDEV;
+    }
 
-  for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
-    depthB++;
-  } // If A is deeper, crawl up.
-
-  while (depthA - depthB > 0) {
-    nodeA = getParent(nodeA);
-    depthA--;
-  } // If B is deeper, crawl up.
+    return newFiber;
+  }
 
-  while (depthB - depthA > 0) {
-    nodeB = getParent(nodeB);
-    depthB--;
-  } // Walk in lockstep until we find a match.
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (current === null || current.tag !== HostText) {
+      // Insert
+      var created = createFiberFromText(textContent, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, textContent);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
 
-  var depth = depthA;
+  function updateElement(returnFiber, current, element, lanes) {
+    var elementType = element.type;
 
-  while (depth--) {
-    if (nodeA === nodeB || (nodeB !== null && nodeA === nodeB.alternate)) {
-      return nodeA;
+    if (elementType === REACT_FRAGMENT_TYPE) {
+      return updateFragment(
+        returnFiber,
+        current,
+        element.props.children,
+        lanes,
+        element.key
+      );
     }
 
-    nodeA = getParent(nodeA);
-    nodeB = getParent(nodeB);
-  }
+    if (current !== null) {
+      if (
+        current.elementType === elementType || // Keep this check inline so it only runs on the false path:
+        isCompatibleFamilyForHotReloading(current, element) || // Lazy types should reconcile their resolved type.
+        // We need to do this after the Hot Reloading check above,
+        // because hot reloading has different semantics than prod because
+        // it doesn't resuspend. So we can't let the call below suspend.
+        (typeof elementType === "object" &&
+          elementType !== null &&
+          elementType.$$typeof === REACT_LAZY_TYPE &&
+          resolveLazy(elementType) === current.type)
+      ) {
+        // Move based on index
+        var existing = useFiber(current, element.props);
+        existing.ref = coerceRef(returnFiber, current, element);
+        existing.return = returnFiber;
 
-  return null;
-}
+        {
+          existing._debugSource = element._source;
+          existing._debugOwner = element._owner;
+        }
 
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  var registrationName = event._reactName;
-  var listeners = [];
-  var instance = target;
+        return existing;
+      }
+    } // Insert
 
-  while (instance !== null) {
-    if (instance === common) {
-      break;
-    }
+    var created = createFiberFromElement(element, returnFiber.mode, lanes);
+    created.ref = coerceRef(returnFiber, current, element);
+    created.return = returnFiber;
+    return created;
+  }
 
-    var _instance4 = instance,
-      alternate = _instance4.alternate,
-      stateNode = _instance4.stateNode,
-      tag = _instance4.tag;
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (
+      current === null ||
+      current.tag !== HostPortal ||
+      current.stateNode.containerInfo !== portal.containerInfo ||
+      current.stateNode.implementation !== portal.implementation
+    ) {
+      // Insert
+      var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, portal.children || []);
+      existing.return = returnFiber;
+      return existing;
+    }
+  }
 
-    if (alternate !== null && alternate === common) {
-      break;
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (current === null || current.tag !== Fragment) {
+      // Insert
+      var created = createFiberFromFragment(
+        fragment,
+        returnFiber.mode,
+        lanes,
+        key
+      );
+      created.return = returnFiber;
+      return created;
+    } else {
+      // Update
+      var existing = useFiber(current, fragment);
+      existing.return = returnFiber;
+      return existing;
     }
+  }
 
+  function createChild(returnFiber, newChild, lanes) {
     if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      stateNode !== null
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
     ) {
-      var currentTarget = stateNode;
-
-      if (inCapturePhase) {
-        var captureListener = getListener(instance, registrationName);
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      var created = createFiberFromText("" + newChild, returnFiber.mode, lanes);
+      created.return = returnFiber;
+      return created;
+    }
 
-        if (captureListener != null) {
-          listeners.unshift(
-            createDispatchListener(instance, captureListener, currentTarget)
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          var _created = createFiberFromElement(
+            newChild,
+            returnFiber.mode,
+            lanes
           );
+
+          _created.ref = coerceRef(returnFiber, null, newChild);
+          _created.return = returnFiber;
+          return _created;
         }
-      } else if (!inCapturePhase) {
-        var bubbleListener = getListener(instance, registrationName);
 
-        if (bubbleListener != null) {
-          listeners.push(
-            createDispatchListener(instance, bubbleListener, currentTarget)
+        case REACT_PORTAL_TYPE: {
+          var _created2 = createFiberFromPortal(
+            newChild,
+            returnFiber.mode,
+            lanes
           );
-        }
-      }
-    }
 
-    instance = instance.return;
-  }
+          _created2.return = returnFiber;
+          return _created2;
+        }
 
-  if (listeners.length !== 0) {
-    dispatchQueue.push({
-      event: event,
-      listeners: listeners
-    });
-  }
-} // We should only use this function for:
-// - EnterLeaveEventPlugin
-// This is because we only process this plugin
-// in the bubble phase, so we need to accumulate two
-// phase event listeners.
+        case REACT_LAZY_TYPE: {
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return createChild(returnFiber, init(payload), lanes);
+        }
+      }
 
-function accumulateEnterLeaveTwoPhaseListeners(
-  dispatchQueue,
-  leaveEvent,
-  enterEvent,
-  from,
-  to
-) {
-  var common = from && to ? getLowestCommonAncestor(from, to) : null;
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        var _created3 = createFiberFromFragment(
+          newChild,
+          returnFiber.mode,
+          lanes,
+          null
+        );
 
-  if (from !== null) {
-    accumulateEnterLeaveListenersForEvent(
-      dispatchQueue,
-      leaveEvent,
-      from,
-      common,
-      false
-    );
-  }
+        _created3.return = returnFiber;
+        return _created3;
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-  if (to !== null && enterEvent !== null) {
-    accumulateEnterLeaveListenersForEvent(
-      dispatchQueue,
-      enterEvent,
-      to,
-      common,
-      true
-    );
-  }
-}
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [];
-  var eventListeners = getEventHandlerListeners(currentTarget);
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return createChild(returnFiber, unwrapThenable(thenable), lanes);
+      }
 
-  if (eventListeners !== null) {
-    eventListeners.forEach(function (entry) {
-      if (entry.type === reactEventType && entry.capture === inCapturePhase) {
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return createChild(
+          returnFiber,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
         );
       }
-    });
-  }
 
-  return listeners;
-}
-function getListenerSetKey(domEventName, capture) {
-  return domEventName + "__" + (capture ? "capture" : "bubble");
-}
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
 
-var didWarnInvalidHydration = false;
-var didWarnScriptTags = false;
-var DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML";
-var SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning";
-var SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
-var AUTOFOCUS = "autoFocus";
-var CHILDREN = "children";
-var STYLE$1 = "style";
-var HTML = "__html";
-var warnedUnknownTags;
-var canDiffStyleForHydrationWarning;
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    }
 
-{
-  warnedUnknownTags = {
-    // There are working polyfills for <dialog>. Let people use it.
-    dialog: true,
-    // Electron ships a custom <webview> tag to display external web content in
-    // an isolated frame and process.
-    // This tag is not present in non Electron environments such as JSDom which
-    // is often used for testing purposes.
-    // @see https://electronjs.org/docs/api/webview-tag
-    webview: true
-  }; // IE 11 parses & normalizes the style attribute as opposed to other
-  // browsers. It adds spaces and sorts the properties in some
-  // non-alphabetical order. Handling that would require sorting CSS
-  // properties in the client & server versions or applying
-  // `expectedStyle` to a temporary DOM node to read its `style` attribute
-  // normalized. Since it only affects IE, we're skipping style warnings
-  // in that browser completely in favor of doing all that work.
-  // See https://github.com/facebook/react/issues/11807
+    return null;
+  }
 
-  canDiffStyleForHydrationWarning = canUseDOM && !document.documentMode;
-}
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    // Update the fiber if the keys match, otherwise return null.
+    var key = oldFiber !== null ? oldFiber.key : null;
 
-function validatePropertiesInDevelopment(type, props) {
-  {
-    validateProperties$2(type, props);
-    validateProperties$1(type, props);
-    validateProperties(type, props, {
-      registrationNameDependencies: registrationNameDependencies,
-      possibleRegistrationNames: possibleRegistrationNames
-    });
-  }
-}
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
+    ) {
+      // Text nodes don't have keys. If the previous node is implicitly keyed
+      // we can continue to replace it without aborting even if it is not a text
+      // node.
+      if (key !== null) {
+        return null;
+      }
 
-function warnForPropDifference(propName, serverValue, clientValue) {
-  {
-    if (didWarnInvalidHydration) {
-      return;
+      return updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
     }
 
-    var normalizedClientValue = normalizeMarkupForTextOrAttribute(clientValue);
-    var normalizedServerValue = normalizeMarkupForTextOrAttribute(serverValue);
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          if (newChild.key === key) {
+            return updateElement(returnFiber, oldFiber, newChild, lanes);
+          } else {
+            return null;
+          }
+        }
 
-    if (normalizedServerValue === normalizedClientValue) {
-      return;
-    }
+        case REACT_PORTAL_TYPE: {
+          if (newChild.key === key) {
+            return updatePortal(returnFiber, oldFiber, newChild, lanes);
+          } else {
+            return null;
+          }
+        }
 
-    didWarnInvalidHydration = true;
+        case REACT_LAZY_TYPE: {
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return updateSlot(returnFiber, oldFiber, init(payload), lanes);
+        }
+      }
 
-    error(
-      "Prop `%s` did not match. Server: %s Client: %s",
-      propName,
-      JSON.stringify(normalizedServerValue),
-      JSON.stringify(normalizedClientValue)
-    );
-  }
-}
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        if (key !== null) {
+          return null;
+        }
 
-function warnForExtraAttributes(attributeNames) {
-  {
-    if (didWarnInvalidHydration) {
-      return;
-    }
+        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-    didWarnInvalidHydration = true;
-    var names = [];
-    attributeNames.forEach(function (name) {
-      names.push(name);
-    });
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          unwrapThenable(thenable),
+          lanes
+        );
+      }
 
-    error("Extra attributes from the server: %s", names);
-  }
-}
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-function warnForInvalidEventListener(registrationName, listener) {
-  {
-    if (listener === false) {
-      error(
-        "Expected `%s` listener to be a function, instead got `false`.\n\n" +
-          "If you used to conditionally omit it with %s={condition && value}, " +
-          "pass %s={condition ? value : undefined} instead.",
-        registrationName,
-        registrationName,
-        registrationName
-      );
-    } else {
-      error(
-        "Expected `%s` listener to be a function, instead got a value of `%s` type.",
-        registrationName,
-        typeof listener
-      );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-  }
-} // Parse the HTML and read it back to normalize the HTML string so that it
-// can be used for comparison.
 
-function normalizeHTML(parent, html) {
-  {
-    // We could have created a separate document here to avoid
-    // re-initializing custom elements if they exist. But this breaks
-    // how <noscript> is being handled. So we use the same document.
-    // See the discussion in https://github.com/facebook/react/pull/11157.
-    var testElement =
-      parent.namespaceURI === HTML_NAMESPACE
-        ? parent.ownerDocument.createElement(parent.tagName)
-        : parent.ownerDocument.createElementNS(
-            parent.namespaceURI,
-            parent.tagName
-          );
-    testElement.innerHTML = html;
-    return testElement.innerHTML;
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    }
+
+    return null;
   }
-} // HTML parsing normalizes CR and CRLF to LF.
-// It also can turn \u0000 into \uFFFD inside attributes.
-// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
-// If we have a mismatch, it might be caused by that.
-// We will still patch up in this case but not fire the warning.
 
-var NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
-var NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+  function updateFromMap(
+    existingChildren,
+    returnFiber,
+    newIdx,
+    newChild,
+    lanes
+  ) {
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
+    ) {
+      // Text nodes don't have keys, so we neither have to check the old nor
+      // new node for the key. If both are text nodes, they match.
+      var matchedFiber = existingChildren.get(newIdx) || null;
+      return updateTextNode(returnFiber, matchedFiber, "" + newChild, lanes);
+    }
 
-function normalizeMarkupForTextOrAttribute(markup) {
-  {
-    checkHtmlStringCoercion(markup);
-  }
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE: {
+          var _matchedFiber =
+            existingChildren.get(
+              newChild.key === null ? newIdx : newChild.key
+            ) || null;
 
-  var markupString = typeof markup === "string" ? markup : "" + markup;
-  return markupString
-    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
-    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
-}
+          return updateElement(returnFiber, _matchedFiber, newChild, lanes);
+        }
 
-function checkForUnmatchedText(
-  serverText,
-  clientText,
-  isConcurrentMode,
-  shouldWarnDev
-) {
-  var normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
-  var normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
+        case REACT_PORTAL_TYPE: {
+          var _matchedFiber2 =
+            existingChildren.get(
+              newChild.key === null ? newIdx : newChild.key
+            ) || null;
 
-  if (normalizedServerText === normalizedClientText) {
-    return;
-  }
+          return updatePortal(returnFiber, _matchedFiber2, newChild, lanes);
+        }
 
-  if (shouldWarnDev) {
-    {
-      if (!didWarnInvalidHydration) {
-        didWarnInvalidHydration = true;
-
-        error(
-          'Text content did not match. Server: "%s" Client: "%s"',
-          normalizedServerText,
-          normalizedClientText
-        );
+        case REACT_LAZY_TYPE:
+          var payload = newChild._payload;
+          var init = newChild._init;
+          return updateFromMap(
+            existingChildren,
+            returnFiber,
+            newIdx,
+            init(payload),
+            lanes
+          );
       }
-    }
-  }
-
-  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
-    // In concurrent roots, we throw when there's a text mismatch and revert to
-    // client rendering, up to the nearest Suspense boundary.
-    throw new Error("Text content does not match server-rendered HTML.");
-  }
-}
-function getOwnerDocumentFromRootContainer(rootContainerElement) {
-  return rootContainerElement.nodeType === DOCUMENT_NODE
-    ? rootContainerElement
-    : rootContainerElement.ownerDocument;
-}
-
-function noop$1() {}
 
-function trapClickOnNonInteractiveElement(node) {
-  // Mobile Safari does not fire properly bubble click events on
-  // non-interactive elements, which means delegated click listeners do not
-  // fire. The workaround for this bug involves attaching an empty click
-  // listener on the target node.
-  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
-  // Just set it using the onclick property so that we don't have to manage any
-  // bookkeeping for it. Not sure if we need to clear it when the listener is
-  // removed.
-  // TODO: Only do this for the relevant Safaris maybe?
-  node.onclick = noop$1;
-}
+      if (isArray(newChild) || getIteratorFn(newChild)) {
+        var _matchedFiber3 = existingChildren.get(newIdx) || null;
 
-function setInitialDOMProperties(
-  tag,
-  domElement,
-  nextProps,
-  isCustomComponentTag
-) {
-  for (var propKey in nextProps) {
-    if (!nextProps.hasOwnProperty(propKey)) {
-      continue;
-    }
+        return updateFragment(
+          returnFiber,
+          _matchedFiber3,
+          newChild,
+          lanes,
+          null
+        );
+      } // Usable node types
+      //
+      // Unwrap the inner value and recursively call this function again.
 
-    var nextProp = nextProps[propKey];
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          unwrapThenable(thenable),
+          lanes
+        );
+      }
 
-    if (propKey === STYLE$1) {
-      {
-        if (nextProp) {
-          // Freeze the next style object so that we can assume it won't be
-          // mutated. We have already warned for this in the past.
-          Object.freeze(nextProp);
-        }
-      } // Relies on `updateStylesByID` not mutating `styleUpdates`.
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-      setValueForStyles(domElement, nextProp);
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      var nextHtml = nextProp ? nextProp[HTML] : undefined;
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
 
-      if (nextHtml != null) {
-        setInnerHTML$1(domElement, nextHtml);
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
       }
-    } else if (propKey === CHILDREN) {
-      if (typeof nextProp === "string") {
-        // Avoid setting initial textContent when the text is empty. In IE11 setting
-        // textContent on a <textarea> will cause the placeholder to not
-        // show within the <textarea> until it has been focused and blurred again.
-        // https://github.com/facebook/react/issues/6731#issuecomment-254874553
-        var canSetTextContent =
-          tag !== "body" && (tag !== "textarea" || nextProp !== "");
+    }
 
-        if (canSetTextContent) {
-          setTextContent(domElement, nextProp);
-        }
-      } else if (typeof nextProp === "number") {
-        var _canSetTextContent = tag !== "body";
+    return null;
+  }
+  /**
+   * Warns if there is a duplicate or missing key
+   */
 
-        if (_canSetTextContent) {
-          setTextContent(domElement, "" + nextProp);
-        }
+  function warnOnInvalidKey(child, knownKeys, returnFiber) {
+    {
+      if (typeof child !== "object" || child === null) {
+        return knownKeys;
       }
-    } else if (
-      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-      propKey === SUPPRESS_HYDRATION_WARNING$1
-    );
-    else if (propKey === AUTOFOCUS);
-    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      if (nextProp != null) {
-        if (typeof nextProp !== "function") {
-          warnForInvalidEventListener(propKey, nextProp);
-        }
 
-        if (propKey === "onScroll") {
-          listenToNonDelegatedEvent("scroll", domElement);
-        }
-      }
-    } else if (nextProp != null) {
-      setValueForProperty(domElement, propKey, nextProp, isCustomComponentTag);
-    }
-  }
-}
+      switch (child.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+        case REACT_PORTAL_TYPE:
+          warnForMissingKey(child, returnFiber);
+          var key = child.key;
 
-function updateDOMProperties(
-  domElement,
-  updatePayload,
-  wasCustomComponentTag,
-  isCustomComponentTag
-) {
-  // TODO: Handle wasCustomComponentTag
-  for (var i = 0; i < updatePayload.length; i += 2) {
-    var propKey = updatePayload[i];
-    var propValue = updatePayload[i + 1];
+          if (typeof key !== "string") {
+            break;
+          }
 
-    if (propKey === STYLE$1) {
-      setValueForStyles(domElement, propValue);
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      setInnerHTML$1(domElement, propValue);
-    } else if (propKey === CHILDREN) {
-      setTextContent(domElement, propValue);
-    } else {
-      setValueForProperty(domElement, propKey, propValue, isCustomComponentTag);
-    }
-  }
-} // creates a script element that won't execute
+          if (knownKeys === null) {
+            knownKeys = new Set();
+            knownKeys.add(key);
+            break;
+          }
 
-function createPotentiallyInlineScriptElement(ownerDocument) {
-  // Create the script via .innerHTML so its "parser-inserted" flag is
-  // set to true and it does not execute
-  var div = ownerDocument.createElement("div");
+          if (!knownKeys.has(key)) {
+            knownKeys.add(key);
+            break;
+          }
 
-  {
-    if (enableTrustedTypesIntegration && !didWarnScriptTags) {
-      error(
-        "Encountered a script tag while rendering React component. " +
-          "Scripts inside React components are never executed when rendering " +
-          "on the client. Consider using template tag instead " +
-          "(https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)."
-      );
+          error(
+            "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.",
+            key
+          );
 
-      didWarnScriptTags = true;
+          break;
+
+        case REACT_LAZY_TYPE:
+          var payload = child._payload;
+          var init = child._init;
+          warnOnInvalidKey(init(payload), knownKeys, returnFiber);
+          break;
+      }
     }
+
+    return knownKeys;
   }
 
-  div.innerHTML = "<script><" + "/script>"; // eslint-disable-line
-  // This is guaranteed to yield a script element.
+  function reconcileChildrenArray(
+    returnFiber,
+    currentFirstChild,
+    newChildren,
+    lanes
+  ) {
+    // This algorithm can't optimize by searching from both ends since we
+    // don't have backpointers on fibers. I'm trying to see how far we can get
+    // with that model. If it ends up not being worth the tradeoffs, we can
+    // add it later.
+    // Even with a two ended optimization, we'd want to optimize for the case
+    // where there are few changes and brute force the comparison instead of
+    // going for the Map. It'd like to explore hitting that path first in
+    // forward-only mode and only go for the Map once we notice that we need
+    // lots of look ahead. This doesn't handle reversal as well as two ended
+    // search but that's unusual. Besides, for the two ended optimization to
+    // work on Iterables, we'd need to copy the whole set.
+    // In this first iteration, we'll just live with hitting the bad case
+    // (adding everything to a Map) in for every insert/move.
+    // If you change this code, also update reconcileChildrenIterator() which
+    // uses the same algorithm.
+    {
+      // First, validate keys.
+      var knownKeys = null;
 
-  var firstChild = div.firstChild;
-  var element = div.removeChild(firstChild);
-  return element;
-}
-function createSelectElement(props, ownerDocument) {
-  var element;
+      for (var i = 0; i < newChildren.length; i++) {
+        var child = newChildren[i];
+        knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+      }
+    }
 
-  if (typeof props.is === "string") {
-    element = ownerDocument.createElement("select", {
-      is: props.is
-    });
-  } else {
-    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
-    // See discussion in https://github.com/facebook/react/pull/6896
-    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
-    element = ownerDocument.createElement("select");
-  }
+    var resultingFirstChild = null;
+    var previousNewFiber = null;
+    var oldFiber = currentFirstChild;
+    var lastPlacedIndex = 0;
+    var newIdx = 0;
+    var nextOldFiber = null;
 
-  if (props.multiple) {
-    element.multiple = true;
-  } else if (props.size) {
-    // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
-    // it is possible that no option is selected.
-    //
-    // This is only necessary when a select in "single selection mode".
-    element.size = props.size;
-  }
+    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
 
-  return element;
-} // Creates elements in the HTML namesapce
+      var newFiber = updateSlot(
+        returnFiber,
+        oldFiber,
+        newChildren[newIdx],
+        lanes
+      );
 
-function createHTMLElement(type, props, ownerDocument) {
-  {
-    switch (type) {
-      case "script":
-      case "select":
-        error(
-          'createHTMLElement was called with a "%s" type. This type has special creation logic in React and should use the create function implemented specifically for it. This is a bug in React.',
-          type
-        );
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
 
         break;
+      }
 
-      case "svg":
-      case "math":
-        error(
-          'createHTMLElement was called with a "%s" type. This type must be created with Document.createElementNS which this method does not implement. This is a bug in React.',
-          type
-        );
-    }
-  }
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
+      }
 
-  var isCustomComponentTag;
-  var element;
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
 
-  {
-    isCustomComponentTag = isCustomComponent(type, props); // Should this check be gated by parent namespace? Not sure we want to
-    // allow <SVG> or <mATH>.
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
 
-    if (!isCustomComponentTag && type !== type.toLowerCase()) {
-      error(
-        "<%s /> is using incorrect casing. " +
-          "Use PascalCase for React components, " +
-          "or lowercase for HTML elements.",
-        type
-      );
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
     }
-  }
 
-  if (typeof props.is === "string") {
-    element = ownerDocument.createElement(type, {
-      is: props.is
-    });
-  } else {
-    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
-    // See discussion in https://github.com/facebook/react/pull/6896
-    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
-    element = ownerDocument.createElement(type);
-  }
+    if (newIdx === newChildren.length) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
 
-  {
-    if (
-      !isCustomComponentTag && // $FlowFixMe[method-unbinding]
-      Object.prototype.toString.call(element) ===
-        "[object HTMLUnknownElement]" &&
-      !hasOwnProperty.call(warnedUnknownTags, type)
-    ) {
-      warnedUnknownTags[type] = true;
+      if (getIsHydrating()) {
+        var numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
+      }
 
-      error(
-        "The tag <%s> is unrecognized in this browser. " +
-          "If you meant to render a React component, start its name with " +
-          "an uppercase letter.",
-        type
-      );
+      return resultingFirstChild;
     }
-  }
 
-  return element;
-}
-function createTextNode(text, rootContainerElement) {
-  return getOwnerDocumentFromRootContainer(rootContainerElement).createTextNode(
-    text
-  );
-}
-function setInitialProperties(domElement, tag, rawProps) {
-  var isCustomComponentTag = isCustomComponent(tag, rawProps);
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; newIdx < newChildren.length; newIdx++) {
+        var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
 
-  {
-    validatePropertiesInDevelopment(tag, rawProps);
-  } // TODO: Make sure that we check isMounted before firing any of these events.
+        if (_newFiber === null) {
+          continue;
+        }
 
-  var props;
+        lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);
 
-  switch (tag) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", domElement);
-      listenToNonDelegatedEvent("close", domElement);
-      props = rawProps;
-      break;
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = _newFiber;
+        } else {
+          previousNewFiber.sibling = _newFiber;
+        }
 
-    case "iframe":
-    case "object":
-    case "embed":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the load event.
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
+        previousNewFiber = _newFiber;
+      }
 
-    case "video":
-    case "audio":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for all the media events.
-      for (var i = 0; i < mediaEventTypes.length; i++) {
-        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+      if (getIsHydrating()) {
+        var _numberOfForks = newIdx;
+        pushTreeFork(returnFiber, _numberOfForks);
       }
 
-      props = rawProps;
-      break;
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
 
-    case "source":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the error event.
-      listenToNonDelegatedEvent("error", domElement);
-      props = rawProps;
-      break;
+    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
 
-    case "img":
-    case "image":
-    case "link":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for error and load events.
-      listenToNonDelegatedEvent("error", domElement);
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
+    for (; newIdx < newChildren.length; newIdx++) {
+      var _newFiber2 = updateFromMap(
+        existingChildren,
+        returnFiber,
+        newIdx,
+        newChildren[newIdx],
+        lanes
+      );
 
-    case "details":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the toggle event.
-      listenToNonDelegatedEvent("toggle", domElement);
-      props = rawProps;
-      break;
+      if (_newFiber2 !== null) {
+        if (shouldTrackSideEffects) {
+          if (_newFiber2.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(
+              _newFiber2.key === null ? newIdx : _newFiber2.key
+            );
+          }
+        }
 
-    case "input":
-      initWrapperState$2(domElement, rawProps);
-      props = getHostProps$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+        lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+        if (previousNewFiber === null) {
+          resultingFirstChild = _newFiber2;
+        } else {
+          previousNewFiber.sibling = _newFiber2;
+        }
 
-    case "option":
-      validateProps(domElement, rawProps);
-      props = rawProps;
-      break;
+        previousNewFiber = _newFiber2;
+      }
+    }
 
-    case "select":
-      initWrapperState$1(domElement, rawProps);
-      props = getHostProps$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+    if (getIsHydrating()) {
+      var _numberOfForks2 = newIdx;
+      pushTreeFork(returnFiber, _numberOfForks2);
+    }
 
-    case "textarea":
-      initWrapperState(domElement, rawProps);
-      props = getHostProps(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+    return resultingFirstChild;
+  }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+  function reconcileChildrenIterator(
+    returnFiber,
+    currentFirstChild,
+    newChildrenIterable,
+    lanes
+  ) {
+    // This is the same implementation as reconcileChildrenArray(),
+    // but using the iterator instead.
+    var iteratorFn = getIteratorFn(newChildrenIterable);
 
-    default:
-      props = rawProps;
-  }
+    if (typeof iteratorFn !== "function") {
+      throw new Error(
+        "An object is not an iterable. This error is likely caused by a bug in " +
+          "React. Please file an issue."
+      );
+    }
 
-  assertValidProps(tag, props);
-  setInitialDOMProperties(tag, domElement, props, isCustomComponentTag);
+    {
+      // We don't support rendering Generators because it's a mutation.
+      // See https://github.com/facebook/react/issues/12995
+      if (
+        typeof Symbol === "function" && // $FlowFixMe Flow doesn't know about toStringTag
+        newChildrenIterable[Symbol.toStringTag] === "Generator"
+      ) {
+        if (!didWarnAboutGenerators) {
+          error(
+            "Using Generators as children is unsupported and will likely yield " +
+              "unexpected results because enumerating a generator mutates it. " +
+              "You may convert it to an array with `Array.from()` or the " +
+              "`[...spread]` operator before rendering. Keep in mind " +
+              "you might need to polyfill these features for older browsers."
+          );
+        }
 
-  switch (tag) {
-    case "input":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper$3(domElement, rawProps, false);
-      break;
+        didWarnAboutGenerators = true;
+      } // Warn about using Maps as children
 
-    case "textarea":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper(domElement);
-      break;
+      if (newChildrenIterable.entries === iteratorFn) {
+        if (!didWarnAboutMaps) {
+          error(
+            "Using Maps as children is not supported. " +
+              "Use an array of keyed ReactElements instead."
+          );
+        }
 
-    case "option":
-      postMountWrapper$2(domElement, rawProps);
-      break;
+        didWarnAboutMaps = true;
+      } // First, validate keys.
+      // We'll get a different iterator later for the main pass.
 
-    case "select":
-      postMountWrapper$1(domElement, rawProps);
-      break;
+      var _newChildren = iteratorFn.call(newChildrenIterable);
 
-    default:
-      if (typeof props.onClick === "function") {
-        // TODO: This cast may not be sound for SVG, MathML or custom elements.
-        trapClickOnNonInteractiveElement(domElement);
+      if (_newChildren) {
+        var knownKeys = null;
+
+        var _step = _newChildren.next();
+
+        for (; !_step.done; _step = _newChildren.next()) {
+          var child = _step.value;
+          knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
+        }
       }
+    }
 
-      break;
-  }
-} // Calculate the diff between the two objects.
+    var newChildren = iteratorFn.call(newChildrenIterable);
 
-function diffProperties(domElement, tag, lastRawProps, nextRawProps) {
-  {
-    validatePropertiesInDevelopment(tag, nextRawProps);
-  }
+    if (newChildren == null) {
+      throw new Error("An iterable object provided no iterator.");
+    }
 
-  var updatePayload = null;
-  var lastProps;
-  var nextProps;
+    var resultingFirstChild = null;
+    var previousNewFiber = null;
+    var oldFiber = currentFirstChild;
+    var lastPlacedIndex = 0;
+    var newIdx = 0;
+    var nextOldFiber = null;
+    var step = newChildren.next();
 
-  switch (tag) {
-    case "input":
-      lastProps = getHostProps$2(domElement, lastRawProps);
-      nextProps = getHostProps$2(domElement, nextRawProps);
-      updatePayload = [];
-      break;
+    for (
+      ;
+      oldFiber !== null && !step.done;
+      newIdx++, step = newChildren.next()
+    ) {
+      if (oldFiber.index > newIdx) {
+        nextOldFiber = oldFiber;
+        oldFiber = null;
+      } else {
+        nextOldFiber = oldFiber.sibling;
+      }
 
-    case "select":
-      lastProps = getHostProps$1(domElement, lastRawProps);
-      nextProps = getHostProps$1(domElement, nextRawProps);
-      updatePayload = [];
-      break;
+      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
 
-    case "textarea":
-      lastProps = getHostProps(domElement, lastRawProps);
-      nextProps = getHostProps(domElement, nextRawProps);
-      updatePayload = [];
-      break;
+      if (newFiber === null) {
+        // TODO: This breaks on empty slots like null children. That's
+        // unfortunate because it triggers the slow path all the time. We need
+        // a better way to communicate whether this was a miss or null,
+        // boolean, undefined, etc.
+        if (oldFiber === null) {
+          oldFiber = nextOldFiber;
+        }
 
-    default:
-      lastProps = lastRawProps;
-      nextProps = nextRawProps;
+        break;
+      }
 
-      if (
-        typeof lastProps.onClick !== "function" &&
-        typeof nextProps.onClick === "function"
-      ) {
-        // TODO: This cast may not be sound for SVG, MathML or custom elements.
-        trapClickOnNonInteractiveElement(domElement);
+      if (shouldTrackSideEffects) {
+        if (oldFiber && newFiber.alternate === null) {
+          // We matched the slot, but we didn't reuse the existing fiber, so we
+          // need to delete the existing child.
+          deleteChild(returnFiber, oldFiber);
+        }
       }
 
-      break;
-  }
+      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
 
-  assertValidProps(tag, nextProps);
-  var propKey;
-  var styleName;
-  var styleUpdates = null;
+      if (previousNewFiber === null) {
+        // TODO: Move out of the loop. This only happens for the first run.
+        resultingFirstChild = newFiber;
+      } else {
+        // TODO: Defer siblings if we're not at the right index for this slot.
+        // I.e. if we had null values before, then we want to defer this
+        // for each null value. However, we also don't want to call updateSlot
+        // with the previous one.
+        previousNewFiber.sibling = newFiber;
+      }
 
-  for (propKey in lastProps) {
-    if (
-      nextProps.hasOwnProperty(propKey) ||
-      !lastProps.hasOwnProperty(propKey) ||
-      lastProps[propKey] == null
-    ) {
-      continue;
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
     }
 
-    if (propKey === STYLE$1) {
-      var lastStyle = lastProps[propKey];
-
-      for (styleName in lastStyle) {
-        if (lastStyle.hasOwnProperty(styleName)) {
-          if (!styleUpdates) {
-            styleUpdates = {};
-          }
+    if (step.done) {
+      // We've reached the end of the new children. We can delete the rest.
+      deleteRemainingChildren(returnFiber, oldFiber);
 
-          styleUpdates[styleName] = "";
-        }
-      }
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML || propKey === CHILDREN);
-    else if (
-      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-      propKey === SUPPRESS_HYDRATION_WARNING$1
-    );
-    else if (propKey === AUTOFOCUS);
-    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      // This is a special case. If any listener updates we need to ensure
-      // that the "current" fiber pointer gets updated so we need a commit
-      // to update this element.
-      if (!updatePayload) {
-        updatePayload = [];
+      if (getIsHydrating()) {
+        var numberOfForks = newIdx;
+        pushTreeFork(returnFiber, numberOfForks);
       }
-    } else {
-      // For all other deleted properties we add it to the queue. We use
-      // the allowed property list in the commit phase instead.
-      (updatePayload = updatePayload || []).push(propKey, null);
+
+      return resultingFirstChild;
     }
-  }
 
-  for (propKey in nextProps) {
-    var nextProp = nextProps[propKey];
-    var lastProp = lastProps != null ? lastProps[propKey] : undefined;
+    if (oldFiber === null) {
+      // If we don't have any more existing children we can choose a fast path
+      // since the rest will all be insertions.
+      for (; !step.done; newIdx++, step = newChildren.next()) {
+        var _newFiber3 = createChild(returnFiber, step.value, lanes);
 
-    if (
-      !nextProps.hasOwnProperty(propKey) ||
-      nextProp === lastProp ||
-      (nextProp == null && lastProp == null)
-    ) {
-      continue;
-    }
+        if (_newFiber3 === null) {
+          continue;
+        }
 
-    if (propKey === STYLE$1) {
-      {
-        if (nextProp) {
-          // Freeze the next style object so that we can assume it won't be
-          // mutated. We have already warned for this in the past.
-          Object.freeze(nextProp);
+        lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);
+
+        if (previousNewFiber === null) {
+          // TODO: Move out of the loop. This only happens for the first run.
+          resultingFirstChild = _newFiber3;
+        } else {
+          previousNewFiber.sibling = _newFiber3;
         }
+
+        previousNewFiber = _newFiber3;
       }
 
-      if (lastProp) {
-        // Unset styles on `lastProp` but not on `nextProp`.
-        for (styleName in lastProp) {
-          if (
-            lastProp.hasOwnProperty(styleName) &&
-            (!nextProp || !nextProp.hasOwnProperty(styleName))
-          ) {
-            if (!styleUpdates) {
-              styleUpdates = {};
-            }
+      if (getIsHydrating()) {
+        var _numberOfForks3 = newIdx;
+        pushTreeFork(returnFiber, _numberOfForks3);
+      }
 
-            styleUpdates[styleName] = "";
-          }
-        } // Update styles that changed since `lastProp`.
+      return resultingFirstChild;
+    } // Add all children to a key map for quick lookups.
 
-        for (styleName in nextProp) {
-          if (
-            nextProp.hasOwnProperty(styleName) &&
-            lastProp[styleName] !== nextProp[styleName]
-          ) {
-            if (!styleUpdates) {
-              styleUpdates = {};
-            }
+    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
 
-            styleUpdates[styleName] = nextProp[styleName];
-          }
-        }
-      } else {
-        // Relies on `updateStylesByID` not mutating `styleUpdates`.
-        if (!styleUpdates) {
-          if (!updatePayload) {
-            updatePayload = [];
-          }
+    for (; !step.done; newIdx++, step = newChildren.next()) {
+      var _newFiber4 = updateFromMap(
+        existingChildren,
+        returnFiber,
+        newIdx,
+        step.value,
+        lanes
+      );
 
-          updatePayload.push(propKey, styleUpdates);
+      if (_newFiber4 !== null) {
+        if (shouldTrackSideEffects) {
+          if (_newFiber4.alternate !== null) {
+            // The new fiber is a work in progress, but if there exists a
+            // current, that means that we reused the fiber. We need to delete
+            // it from the child list so that we don't add it to the deletion
+            // list.
+            existingChildren.delete(
+              _newFiber4.key === null ? newIdx : _newFiber4.key
+            );
+          }
         }
 
-        styleUpdates = nextProp;
-      }
-    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-      var nextHtml = nextProp ? nextProp[HTML] : undefined;
-      var lastHtml = lastProp ? lastProp[HTML] : undefined;
+        lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);
 
-      if (nextHtml != null) {
-        if (lastHtml !== nextHtml) {
-          (updatePayload = updatePayload || []).push(propKey, nextHtml);
-        }
-      }
-    } else if (propKey === CHILDREN) {
-      if (typeof nextProp === "string" || typeof nextProp === "number") {
-        (updatePayload = updatePayload || []).push(propKey, "" + nextProp);
-      }
-    } else if (
-      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-      propKey === SUPPRESS_HYDRATION_WARNING$1
-    );
-    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      if (nextProp != null) {
-        // We eagerly listen to this even though we haven't committed yet.
-        if (typeof nextProp !== "function") {
-          warnForInvalidEventListener(propKey, nextProp);
+        if (previousNewFiber === null) {
+          resultingFirstChild = _newFiber4;
+        } else {
+          previousNewFiber.sibling = _newFiber4;
         }
 
-        if (propKey === "onScroll") {
-          listenToNonDelegatedEvent("scroll", domElement);
-        }
+        previousNewFiber = _newFiber4;
       }
+    }
 
-      if (!updatePayload && lastProp !== nextProp) {
-        // This is a special case. If any listener updates we need to ensure
-        // that the "current" props pointer gets updated so we need a commit
-        // to update this element.
-        updatePayload = [];
-      }
-    } else {
-      // For any other property we always add it to the queue and then we
-      // filter it out using the allowed property list during the commit.
-      (updatePayload = updatePayload || []).push(propKey, nextProp);
+    if (shouldTrackSideEffects) {
+      // Any existing children that weren't consumed above were deleted. We need
+      // to add them to the deletion list.
+      existingChildren.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
     }
-  }
 
-  if (styleUpdates) {
-    {
-      validateShorthandPropertyCollisionInDev(styleUpdates, nextProps[STYLE$1]);
+    if (getIsHydrating()) {
+      var _numberOfForks4 = newIdx;
+      pushTreeFork(returnFiber, _numberOfForks4);
     }
 
-    (updatePayload = updatePayload || []).push(STYLE$1, styleUpdates);
+    return resultingFirstChild;
   }
 
-  return updatePayload;
-} // Apply the diff.
-
-function updateProperties(
-  domElement,
-  updatePayload,
-  tag,
-  lastRawProps,
-  nextRawProps
-) {
-  // Update checked *before* name.
-  // In the middle of an update, it is possible to have multiple checked.
-  // When a checked radio tries to change name, browser makes another radio's checked false.
-  if (
-    tag === "input" &&
-    nextRawProps.type === "radio" &&
-    nextRawProps.name != null
+  function reconcileSingleTextNode(
+    returnFiber,
+    currentFirstChild,
+    textContent,
+    lanes
   ) {
-    updateChecked(domElement, nextRawProps);
+    // There's no need to check for keys on text nodes since we don't have a
+    // way to define them.
+    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
+      // We already have an existing node so let's just update it and delete
+      // the rest.
+      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+      var existing = useFiber(currentFirstChild, textContent);
+      existing.return = returnFiber;
+      return existing;
+    } // The existing first child is not a text node so we need to create one
+    // and delete the existing ones.
+
+    deleteRemainingChildren(returnFiber, currentFirstChild);
+    var created = createFiberFromText(textContent, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
   }
 
-  var wasCustomComponentTag = isCustomComponent(tag, lastRawProps);
-  var isCustomComponentTag = isCustomComponent(tag, nextRawProps); // Apply the diff.
+  function reconcileSingleElement(
+    returnFiber,
+    currentFirstChild,
+    element,
+    lanes
+  ) {
+    var key = element.key;
+    var child = currentFirstChild;
 
-  updateDOMProperties(
-    domElement,
-    updatePayload,
-    wasCustomComponentTag,
-    isCustomComponentTag
-  ); // TODO: Ensure that an update gets scheduled if any of the special props
-  // changed.
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        var elementType = element.type;
 
-  switch (tag) {
-    case "input":
-      // Update the wrapper around inputs *after* updating props. This has to
-      // happen after `updateDOMProperties`. Otherwise HTML5 input validations
-      // raise warnings and prevent the new value from being assigned.
-      updateWrapper$1(domElement, nextRawProps);
-      break;
+        if (elementType === REACT_FRAGMENT_TYPE) {
+          if (child.tag === Fragment) {
+            deleteRemainingChildren(returnFiber, child.sibling);
+            var existing = useFiber(child, element.props.children);
+            existing.return = returnFiber;
 
-    case "textarea":
-      updateWrapper(domElement, nextRawProps);
-      break;
+            {
+              existing._debugSource = element._source;
+              existing._debugOwner = element._owner;
+            }
 
-    case "select":
-      // <select> value update needs to occur after <option> children
-      // reconciliation
-      postUpdateWrapper(domElement, nextRawProps);
-      break;
-  }
-}
+            return existing;
+          }
+        } else {
+          if (
+            child.elementType === elementType || // Keep this check inline so it only runs on the false path:
+            isCompatibleFamilyForHotReloading(child, element) || // Lazy types should reconcile their resolved type.
+            // We need to do this after the Hot Reloading check above,
+            // because hot reloading has different semantics than prod because
+            // it doesn't resuspend. So we can't let the call below suspend.
+            (typeof elementType === "object" &&
+              elementType !== null &&
+              elementType.$$typeof === REACT_LAZY_TYPE &&
+              resolveLazy(elementType) === child.type)
+          ) {
+            deleteRemainingChildren(returnFiber, child.sibling);
 
-function getPossibleStandardName(propName) {
-  {
-    var lowerCasedName = propName.toLowerCase();
+            var _existing = useFiber(child, element.props);
 
-    if (!possibleStandardNames.hasOwnProperty(lowerCasedName)) {
-      return null;
-    }
+            _existing.ref = coerceRef(returnFiber, child, element);
+            _existing.return = returnFiber;
 
-    return possibleStandardNames[lowerCasedName] || null;
-  }
-}
+            {
+              _existing._debugSource = element._source;
+              _existing._debugOwner = element._owner;
+            }
 
-function diffHydratedProperties(
-  domElement,
-  tag,
-  rawProps,
-  isConcurrentMode,
-  shouldWarnDev,
-  parentNamespaceDev
-) {
-  var isCustomComponentTag;
-  var extraAttributeNames;
-
-  {
-    isCustomComponentTag = isCustomComponent(tag, rawProps);
-    validatePropertiesInDevelopment(tag, rawProps);
-  } // TODO: Make sure that we check isMounted before firing any of these events.
-
-  switch (tag) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", domElement);
-      listenToNonDelegatedEvent("close", domElement);
-      break;
-
-    case "iframe":
-    case "object":
-    case "embed":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the load event.
-      listenToNonDelegatedEvent("load", domElement);
-      break;
+            return _existing;
+          }
+        } // Didn't match.
 
-    case "video":
-    case "audio":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for all the media events.
-      for (var i = 0; i < mediaEventTypes.length; i++) {
-        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
+        deleteRemainingChildren(returnFiber, child);
+        break;
+      } else {
+        deleteChild(returnFiber, child);
       }
 
-      break;
-
-    case "source":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the error event.
-      listenToNonDelegatedEvent("error", domElement);
-      break;
-
-    case "img":
-    case "image":
-    case "link":
-      // We listen to these events in case to ensure emulated bubble
-      // listeners still fire for error and load events.
-      listenToNonDelegatedEvent("error", domElement);
-      listenToNonDelegatedEvent("load", domElement);
-      break;
+      child = child.sibling;
+    }
 
-    case "details":
-      // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the toggle event.
-      listenToNonDelegatedEvent("toggle", domElement);
-      break;
+    if (element.type === REACT_FRAGMENT_TYPE) {
+      var created = createFiberFromFragment(
+        element.props.children,
+        returnFiber.mode,
+        lanes,
+        element.key
+      );
+      created.return = returnFiber;
+      return created;
+    } else {
+      var _created4 = createFiberFromElement(element, returnFiber.mode, lanes);
 
-    case "input":
-      initWrapperState$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+      _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
+      _created4.return = returnFiber;
+      return _created4;
+    }
+  }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+  function reconcileSinglePortal(
+    returnFiber,
+    currentFirstChild,
+    portal,
+    lanes
+  ) {
+    var key = portal.key;
+    var child = currentFirstChild;
 
-    case "option":
-      validateProps(domElement, rawProps);
-      break;
+    while (child !== null) {
+      // TODO: If key === null and child.key === null, then this only applies to
+      // the first item in the list.
+      if (child.key === key) {
+        if (
+          child.tag === HostPortal &&
+          child.stateNode.containerInfo === portal.containerInfo &&
+          child.stateNode.implementation === portal.implementation
+        ) {
+          deleteRemainingChildren(returnFiber, child.sibling);
+          var existing = useFiber(child, portal.children || []);
+          existing.return = returnFiber;
+          return existing;
+        } else {
+          deleteRemainingChildren(returnFiber, child);
+          break;
+        }
+      } else {
+        deleteChild(returnFiber, child);
+      }
 
-    case "select":
-      initWrapperState$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+      child = child.sibling;
+    }
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
+    var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
+    created.return = returnFiber;
+    return created;
+  } // This API will tag the children with the side-effect of the reconciliation
+  // itself. They will be added to the side-effect list as we pass through the
+  // children and the parent.
 
-    case "textarea":
-      initWrapperState(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
-      // listeners still fire for the invalid event.
+  function reconcileChildFibersImpl(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    // This function is not recursive.
+    // If the top level item is an array, we treat it as a set of children,
+    // not as a fragment. Nested arrays on the other hand will be treated as
+    // fragment nodes. Recursion happens at the normal flow.
+    // Handle top level unkeyed fragments as if they were arrays.
+    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
+    // We treat the ambiguous cases above the same.
+    // TODO: Let's use recursion like we do for Usable nodes?
+    var isUnkeyedTopLevelFragment =
+      typeof newChild === "object" &&
+      newChild !== null &&
+      newChild.type === REACT_FRAGMENT_TYPE &&
+      newChild.key === null;
 
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-  }
+    if (isUnkeyedTopLevelFragment) {
+      newChild = newChild.props.children;
+    } // Handle object types
 
-  assertValidProps(tag, rawProps);
+    if (typeof newChild === "object" && newChild !== null) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return placeSingleChild(
+            reconcileSingleElement(
+              returnFiber,
+              currentFirstChild,
+              newChild,
+              lanes
+            )
+          );
 
-  {
-    extraAttributeNames = new Set();
-    var attributes = domElement.attributes;
+        case REACT_PORTAL_TYPE:
+          return placeSingleChild(
+            reconcileSinglePortal(
+              returnFiber,
+              currentFirstChild,
+              newChild,
+              lanes
+            )
+          );
 
-    for (var _i = 0; _i < attributes.length; _i++) {
-      var name = attributes[_i].name.toLowerCase();
+        case REACT_LAZY_TYPE:
+          var payload = newChild._payload;
+          var init = newChild._init; // TODO: This function is supposed to be non-recursive.
 
-      switch (name) {
-        // Controlled attributes are not validated
-        // TODO: Only ignore them on controlled tags.
-        case "value":
-          break;
+          return reconcileChildFibers(
+            returnFiber,
+            currentFirstChild,
+            init(payload),
+            lanes
+          );
+      }
 
-        case "checked":
-          break;
+      if (isArray(newChild)) {
+        return reconcileChildrenArray(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      }
 
-        case "selected":
-          break;
+      if (getIteratorFn(newChild)) {
+        return reconcileChildrenIterator(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      } // Usables are a valid React node type. When React encounters a Usable in
+      // a child position, it unwraps it using the same algorithm as `use`. For
+      // example, for promises, React will throw an exception to unwind the
+      // stack, then replay the component once the promise resolves.
+      //
+      // A difference from `use` is that React will keep unwrapping the value
+      // until it reaches a non-Usable type.
+      //
+      // e.g. Usable<Usable<Usable<T>>> should resolve to T
+      //
+      // The structure is a bit unfortunate. Ideally, we shouldn't need to
+      // replay the entire begin phase of the parent fiber in order to reconcile
+      // the children again. This would require a somewhat significant refactor,
+      // because reconcilation happens deep within the begin phase, and
+      // depending on the type of work, not always at the end. We should
+      // consider as an future improvement.
 
-        default:
-          // Intentionally use the original name.
-          // See discussion in https://github.com/facebook/react/pull/10676.
-          extraAttributeNames.add(attributes[_i].name);
+      if (typeof newChild.then === "function") {
+        var thenable = newChild;
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          unwrapThenable(thenable),
+          lanes
+        );
       }
-    }
-  }
 
-  var updatePayload = null;
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      ) {
+        var context = newChild;
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          readContextDuringReconcilation(returnFiber, context, lanes),
+          lanes
+        );
+      }
 
-  for (var propKey in rawProps) {
-    if (!rawProps.hasOwnProperty(propKey)) {
-      continue;
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
 
-    var nextProp = rawProps[propKey];
-
-    if (propKey === CHILDREN) {
-      // For text content children we compare against textContent. This
-      // might match additional HTML that is hidden when we read it using
-      // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
-      // satisfies our requirement. Our requirement is not to produce perfect
-      // HTML and attributes. Ideally we should preserve structure but it's
-      // ok not to if the visible content is still enough to indicate what
-      // even listeners these nodes might be wired up to.
-      // TODO: Warn if there is more than a single textNode as a child.
-      // TODO: Should we use domElement.firstChild.nodeValue to compare?
-      if (typeof nextProp === "string") {
-        if (domElement.textContent !== nextProp) {
-          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
-            checkForUnmatchedText(
-              domElement.textContent,
-              nextProp,
-              isConcurrentMode,
-              shouldWarnDev
-            );
-          }
-
-          updatePayload = [CHILDREN, nextProp];
-        }
-      } else if (typeof nextProp === "number") {
-        if (domElement.textContent !== "" + nextProp) {
-          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
-            checkForUnmatchedText(
-              domElement.textContent,
-              nextProp,
-              isConcurrentMode,
-              shouldWarnDev
-            );
-          }
-
-          updatePayload = [CHILDREN, "" + nextProp];
-        }
-      }
-    } else if (registrationNameDependencies.hasOwnProperty(propKey)) {
-      if (nextProp != null) {
-        if (typeof nextProp !== "function") {
-          warnForInvalidEventListener(propKey, nextProp);
-        }
-
-        if (propKey === "onScroll") {
-          listenToNonDelegatedEvent("scroll", domElement);
-        }
-      }
-    } else if (
-      shouldWarnDev &&
-      true && // Convince Flow we've calculated it (it's DEV-only in this method.)
-      typeof isCustomComponentTag === "boolean"
+    if (
+      (typeof newChild === "string" && newChild !== "") ||
+      typeof newChild === "number"
     ) {
-      // Validate that the properties correspond to their expected values.
-      var serverValue = void 0;
-      var propertyInfo =
-        isCustomComponentTag && enableCustomElementPropertySupport
-          ? null
-          : getPropertyInfo(propKey);
-
-      if (rawProps[SUPPRESS_HYDRATION_WARNING$1] === true);
-      else if (
-        propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
-        propKey === SUPPRESS_HYDRATION_WARNING$1 || // Controlled attributes are not validated
-        // TODO: Only ignore them on controlled tags.
-        propKey === "value" ||
-        propKey === "checked" ||
-        propKey === "selected"
+      return placeSingleChild(
+        reconcileSingleTextNode(
+          returnFiber,
+          currentFirstChild,
+          "" + newChild,
+          lanes
+        )
       );
-      else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
-        var serverHTML = domElement.innerHTML;
-        var nextHtml = nextProp ? nextProp[HTML] : undefined;
-
-        if (nextHtml != null) {
-          var expectedHTML = normalizeHTML(domElement, nextHtml);
+    }
 
-          if (expectedHTML !== serverHTML) {
-            warnForPropDifference(propKey, serverHTML, expectedHTML);
-          }
-        }
-      } else if (propKey === STYLE$1) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.delete(propKey);
+    {
+      if (typeof newChild === "function") {
+        warnOnFunctionType(returnFiber);
+      }
+    } // Remaining cases are all treated as empty.
 
-        if (canDiffStyleForHydrationWarning) {
-          var expectedStyle = createDangerousStringForStyles(nextProp);
-          serverValue = domElement.getAttribute("style");
+    return deleteRemainingChildren(returnFiber, currentFirstChild);
+  }
 
-          if (expectedStyle !== serverValue) {
-            warnForPropDifference(propKey, serverValue, expectedStyle);
-          }
-        }
-      } else if (
-        enableCustomElementPropertySupport &&
-        isCustomComponentTag &&
-        (propKey === "offsetParent" ||
-          propKey === "offsetTop" ||
-          propKey === "offsetLeft" ||
-          propKey === "offsetWidth" ||
-          propKey === "offsetHeight" ||
-          propKey === "isContentEditable" ||
-          propKey === "outerText" ||
-          propKey === "outerHTML")
-      ) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.delete(propKey.toLowerCase());
+  function reconcileChildFibers(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    // This indirection only exists so we can reset `thenableState` at the end.
+    // It should get inlined by Closure.
+    thenableIndexCounter$1 = 0;
+    var firstChildFiber = reconcileChildFibersImpl(
+      returnFiber,
+      currentFirstChild,
+      newChild,
+      lanes
+    );
+    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
+    // set at the beginning.
 
-        {
-          error(
-            "Assignment to read-only property will result in a no-op: `%s`",
-            propKey
-          );
-        }
-      } else if (isCustomComponentTag && !enableCustomElementPropertySupport) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.delete(propKey.toLowerCase());
-        serverValue = getValueForAttribute(
-          domElement,
-          propKey,
-          nextProp,
-          isCustomComponentTag
-        );
+    return firstChildFiber;
+  }
 
-        if (nextProp !== serverValue) {
-          warnForPropDifference(propKey, serverValue, nextProp);
-        }
-      } else if (
-        !shouldIgnoreAttribute(propKey, propertyInfo, isCustomComponentTag) &&
-        !shouldRemoveAttribute(
-          propKey,
-          nextProp,
-          propertyInfo,
-          isCustomComponentTag
-        )
-      ) {
-        var isMismatchDueToBadCasing = false;
+  return reconcileChildFibers;
+}
 
-        if (propertyInfo !== null) {
-          // $FlowFixMe - Should be inferred as not undefined.
-          extraAttributeNames.delete(propertyInfo.attributeName);
-          serverValue = getValueForProperty(
-            domElement,
-            propKey,
-            nextProp,
-            propertyInfo
-          );
-        } else {
-          var ownNamespaceDev = parentNamespaceDev;
+var reconcileChildFibers = createChildReconciler(true);
+var mountChildFibers = createChildReconciler(false);
+function resetChildReconcilerOnUnwind() {
+  // On unwind, clear any pending thenables that were used.
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+}
+function cloneChildFibers(current, workInProgress) {
+  if (current !== null && workInProgress.child !== current.child) {
+    throw new Error("Resuming work not yet implemented.");
+  }
 
-          if (ownNamespaceDev === HTML_NAMESPACE) {
-            ownNamespaceDev = getIntrinsicNamespace(tag);
-          }
+  if (workInProgress.child === null) {
+    return;
+  }
 
-          if (ownNamespaceDev === HTML_NAMESPACE) {
-            // $FlowFixMe - Should be inferred as not undefined.
-            extraAttributeNames.delete(propKey.toLowerCase());
-          } else {
-            var standardName = getPossibleStandardName(propKey);
+  var currentChild = workInProgress.child;
+  var newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
+  workInProgress.child = newChild;
+  newChild.return = workInProgress;
 
-            if (standardName !== null && standardName !== propKey) {
-              // If an SVG prop is supplied with bad casing, it will
-              // be successfully parsed from HTML, but will produce a mismatch
-              // (and would be incorrectly rendered on the client).
-              // However, we already warn about bad casing elsewhere.
-              // So we'll skip the misleading extra mismatch warning in this case.
-              isMismatchDueToBadCasing = true; // $FlowFixMe - Should be inferred as not undefined.
+  while (currentChild.sibling !== null) {
+    currentChild = currentChild.sibling;
+    newChild = newChild.sibling = createWorkInProgress(
+      currentChild,
+      currentChild.pendingProps
+    );
+    newChild.return = workInProgress;
+  }
 
-              extraAttributeNames.delete(standardName);
-            } // $FlowFixMe - Should be inferred as not undefined.
+  newChild.sibling = null;
+} // Reset a workInProgress child set to prepare it for a second pass.
 
-            extraAttributeNames.delete(propKey);
-          }
+function resetChildFibers(workInProgress, lanes) {
+  var child = workInProgress.child;
 
-          serverValue = getValueForAttribute(
-            domElement,
-            propKey,
-            nextProp,
-            isCustomComponentTag
-          );
-        }
+  while (child !== null) {
+    resetWorkInProgress(child, lanes);
+    child = child.sibling;
+  }
+}
 
-        var dontWarnCustomElement =
-          enableCustomElementPropertySupport &&
-          isCustomComponentTag &&
-          (typeof nextProp === "function" || typeof nextProp === "object");
+// TODO: This isn't being used yet, but it's intended to replace the
+// InvisibleParentContext that is currently managed by SuspenseContext.
 
-        if (
-          !dontWarnCustomElement &&
-          nextProp !== serverValue &&
-          !isMismatchDueToBadCasing
-        ) {
-          warnForPropDifference(propKey, serverValue, nextProp);
-        }
+var currentTreeHiddenStackCursor = createCursor(null);
+var prevRenderLanesStackCursor = createCursor(NoLanes);
+function pushHiddenContext(fiber, context) {
+  var prevRenderLanes = getRenderLanes();
+  push(prevRenderLanesStackCursor, prevRenderLanes, fiber);
+  push(currentTreeHiddenStackCursor, context, fiber); // When rendering a subtree that's currently hidden, we must include all
+  // lanes that would have rendered if the hidden subtree hadn't been deferred.
+  // That is, in order to reveal content from hidden -> visible, we must commit
+  // all the updates that we skipped when we originally hid the tree.
+
+  setRenderLanes(mergeLanes(prevRenderLanes, context.baseLanes));
+}
+function reuseHiddenContextOnStack(fiber) {
+  // This subtree is not currently hidden, so we don't need to add any lanes
+  // to the render lanes. But we still need to push something to avoid a
+  // context mismatch. Reuse the existing context on the stack.
+  push(prevRenderLanesStackCursor, getRenderLanes(), fiber);
+  push(
+    currentTreeHiddenStackCursor,
+    currentTreeHiddenStackCursor.current,
+    fiber
+  );
+}
+function popHiddenContext(fiber) {
+  // Restore the previous render lanes from the stack
+  setRenderLanes(prevRenderLanesStackCursor.current);
+  pop(currentTreeHiddenStackCursor, fiber);
+  pop(prevRenderLanesStackCursor, fiber);
+}
+function isCurrentTreeHidden() {
+  return currentTreeHiddenStackCursor.current !== null;
+}
+
+// suspends, i.e. it's the nearest `catch` block on the stack.
+
+var suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
+// Everything above this is the "shell". When this is null, it means we're
+// rendering in the shell of the app. If it's non-null, it means we're rendering
+// deeper than the shell, inside a new tree that wasn't already visible.
+//
+// The main way we use this concept is to determine whether showing a fallback
+// would result in a desirable or undesirable loading state. Activing a fallback
+// in the shell is considered an undersirable loading state, because it would
+// mean hiding visible (albeit stale) content in the current tree — we prefer to
+// show the stale content, rather than switch to a fallback. But showing a
+// fallback in a new tree is fine, because there's no stale content to
+// prefer instead.
+
+var shellBoundary = null;
+function getShellBoundary() {
+  return shellBoundary;
+}
+function pushPrimaryTreeSuspenseHandler(handler) {
+  // TODO: Pass as argument
+  var current = handler.alternate;
+  var props = handler.pendingProps; // Experimental feature: Some Suspense boundaries are marked as having an
+  // undesirable fallback state. These have special behavior where we only
+  // activate the fallback if there's no other boundary on the stack that we can
+  // use instead.
+
+  if (
+    props.unstable_avoidThisFallback === true && // If an avoided boundary is already visible, it behaves identically to
+    // a regular Suspense boundary.
+    (current === null || isCurrentTreeHidden())
+  ) {
+    if (shellBoundary === null) {
+      // We're rendering in the shell. There's no parent Suspense boundary that
+      // can provide a desirable fallback state. We'll use this boundary.
+      push(suspenseHandlerStackCursor, handler, handler); // However, because this is not a desirable fallback, the children are
+      // still considered part of the shell. So we intentionally don't assign
+      // to `shellBoundary`.
+    } else {
+      // There's already a parent Suspense boundary that can provide a desirable
+      // fallback state. Prefer that one.
+      var handlerOnStack = suspenseHandlerStackCursor.current;
+      push(suspenseHandlerStackCursor, handlerOnStack, handler);
+    }
+
+    return;
+  } // TODO: If the parent Suspense handler already suspended, there's no reason
+  // to push a nested Suspense handler, because it will get replaced by the
+  // outer fallback, anyway. Consider this as a future optimization.
+
+  push(suspenseHandlerStackCursor, handler, handler);
+
+  if (shellBoundary === null) {
+    if (current === null || isCurrentTreeHidden()) {
+      // This boundary is not visible in the current UI.
+      shellBoundary = handler;
+    } else {
+      var prevState = current.memoizedState;
+
+      if (prevState !== null) {
+        // This boundary is showing a fallback in the current UI.
+        shellBoundary = handler;
       }
     }
   }
+}
+function pushFallbackTreeSuspenseHandler(fiber) {
+  // We're about to render the fallback. If something in the fallback suspends,
+  // it's akin to throwing inside of a `catch` block. This boundary should not
+  // capture. Reuse the existing handler on the stack.
+  reuseSuspenseHandlerOnStack(fiber);
+}
+function pushOffscreenSuspenseHandler(fiber) {
+  if (fiber.tag === OffscreenComponent) {
+    push(suspenseHandlerStackCursor, fiber, fiber);
 
-  {
-    if (shouldWarnDev) {
-      if (
-        // $FlowFixMe - Should be inferred as not undefined.
-        extraAttributeNames.size > 0 &&
-        rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true
-      ) {
-        // $FlowFixMe - Should be inferred as not undefined.
-        warnForExtraAttributes(extraAttributeNames);
+    if (shellBoundary !== null);
+    else {
+      var current = fiber.alternate;
+
+      if (current !== null) {
+        var prevState = current.memoizedState;
+
+        if (prevState !== null) {
+          // This is the first boundary in the stack that's already showing
+          // a fallback. So everything outside is considered the shell.
+          shellBoundary = fiber;
+        }
       }
     }
+  } else {
+    // This is a LegacyHidden component.
+    reuseSuspenseHandlerOnStack(fiber);
   }
+}
+function reuseSuspenseHandlerOnStack(fiber) {
+  push(suspenseHandlerStackCursor, getSuspenseHandler(), fiber);
+}
+function getSuspenseHandler() {
+  return suspenseHandlerStackCursor.current;
+}
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor, fiber);
 
-  switch (tag) {
-    case "input":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper$3(domElement, rawProps, true);
-      break;
+  if (shellBoundary === fiber) {
+    // Popping back into the shell.
+    shellBoundary = null;
+  }
+} // SuspenseList context
+// TODO: Move to a separate module? We may change the SuspenseList
+// implementation to hide/show in the commit phase, anyway.
 
-    case "textarea":
-      // TODO: Make sure we check if this is still unmounted or do any clean
-      // up necessary since we never stop tracking anymore.
-      track(domElement);
-      postMountWrapper(domElement);
-      break;
+var DefaultSuspenseContext = 0;
+var SubtreeSuspenseContextMask = 1; // ForceSuspenseFallback can be used by SuspenseList to force newly added
+// items into their fallback state during one of the render passes.
 
-    case "select":
-    case "option":
-      // For input and textarea we current always set the value property at
-      // post mount to force it to diverge from attributes. However, for
-      // option and select we don't quite do the same thing and select
-      // is not resilient to the DOM state changing so we don't do that here.
-      // TODO: Consider not doing this for input and textarea.
-      break;
+var ForceSuspenseFallback = 2;
+var suspenseStackCursor = createCursor(DefaultSuspenseContext);
+function hasSuspenseListContext(parentContext, flag) {
+  return (parentContext & flag) !== 0;
+}
+function setDefaultShallowSuspenseListContext(parentContext) {
+  return parentContext & SubtreeSuspenseContextMask;
+}
+function setShallowSuspenseListContext(parentContext, shallowContext) {
+  return (parentContext & SubtreeSuspenseContextMask) | shallowContext;
+}
+function pushSuspenseListContext(fiber, newContext) {
+  push(suspenseStackCursor, newContext, fiber);
+}
+function popSuspenseListContext(fiber) {
+  pop(suspenseStackCursor, fiber);
+}
 
-    default:
-      if (typeof rawProps.onClick === "function") {
-        // TODO: This cast may not be sound for SVG, MathML or custom elements.
-        trapClickOnNonInteractiveElement(domElement);
+// A non-null SuspenseState means that it is blocked for one reason or another.
+// - A non-null dehydrated field means it's blocked pending hydration.
+//   - A non-null dehydrated field can use isSuspenseInstancePending or
+//     isSuspenseInstanceFallback to query the reason for being dehydrated.
+// - A null dehydrated field means it's blocked by something suspending and
+//   we're currently showing a fallback instead.
+
+function findFirstSuspended(row) {
+  var node = row;
+
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      var state = node.memoizedState;
+
+      if (state !== null) {
+        var dehydrated = state.dehydrated;
+
+        if (
+          dehydrated === null ||
+          isSuspenseInstancePending(dehydrated) ||
+          isSuspenseInstanceFallback(dehydrated)
+        ) {
+          return node;
+        }
       }
+    } else if (
+      node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
+      // keep track of whether it suspended or not.
+      node.memoizedProps.revealOrder !== undefined
+    ) {
+      var didSuspend = (node.flags & DidCapture) !== NoFlags$1;
 
-      break;
+      if (didSuspend) {
+        return node;
+      }
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+
+    if (node === row) {
+      return null;
+    }
+
+    while (node.sibling === null) {
+      if (node.return === null || node.return === row) {
+        return null;
+      }
+
+      node = node.return;
+    }
+
+    node.sibling.return = node.return;
+    node = node.sibling;
   }
 
-  return updatePayload;
+  return null;
 }
-function diffHydratedText(textNode, text, isConcurrentMode) {
-  var isDifferent = textNode.nodeValue !== text;
-  return isDifferent;
+
+var NoFlags =
+  /*   */
+  0; // Represents whether effect should fire.
+
+var HasEffect =
+  /* */
+  1; // Represents the phase in which the effect (not the clean-up) fires.
+
+var Insertion =
+  /* */
+  2;
+var Layout =
+  /*    */
+  4;
+var Passive =
+  /*   */
+  8;
+
+// and should be reset before starting a new render.
+// This tracks which mutable sources need to be reset after a render.
+
+var workInProgressSources = [];
+var rendererSigil$1;
+
+{
+  // Used to detect multiple renderers using the same mutable source.
+  rendererSigil$1 = {};
 }
-function warnForDeletedHydratableElement(parentNode, child) {
-  {
-    if (didWarnInvalidHydration) {
-      return;
-    }
 
-    didWarnInvalidHydration = true;
+function markSourceAsDirty(mutableSource) {
+  workInProgressSources.push(mutableSource);
+}
+function resetWorkInProgressVersions() {
+  for (var i = 0; i < workInProgressSources.length; i++) {
+    var mutableSource = workInProgressSources[i];
 
-    error(
-      "Did not expect server HTML to contain a <%s> in <%s>.",
-      child.nodeName.toLowerCase(),
-      parentNode.nodeName.toLowerCase()
-    );
+    {
+      mutableSource._workInProgressVersionPrimary = null;
+    }
   }
+
+  workInProgressSources.length = 0;
 }
-function warnForDeletedHydratableText(parentNode, child) {
+function getWorkInProgressVersion(mutableSource) {
   {
-    if (didWarnInvalidHydration) {
-      return;
+    return mutableSource._workInProgressVersionPrimary;
+  }
+}
+function setWorkInProgressVersion(mutableSource, version) {
+  {
+    mutableSource._workInProgressVersionPrimary = version;
+  }
+
+  workInProgressSources.push(mutableSource);
+}
+function warnAboutMultipleRenderersDEV(mutableSource) {
+  {
+    {
+      if (mutableSource._currentPrimaryRenderer == null) {
+        mutableSource._currentPrimaryRenderer = rendererSigil$1;
+      } else if (mutableSource._currentPrimaryRenderer !== rendererSigil$1) {
+        error(
+          "Detected multiple renderers concurrently rendering the " +
+            "same mutable source. This is currently unsupported."
+        );
+      }
     }
+  }
+} // Eager reads the version of a mutable source and stores it on the root.
+// This ensures that the version used for server rendering matches the one
+// that is eventually read during hydration.
+// If they don't match there's a potential tear and a full deopt render is required.
 
-    didWarnInvalidHydration = true;
+function registerMutableSourceForHydration(root, mutableSource) {
+  var getVersion = mutableSource._getVersion;
+  var version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
+  // Retaining it forever may interfere with GC.
 
-    error(
-      'Did not expect server HTML to contain the text node "%s" in <%s>.',
-      child.nodeValue,
-      parentNode.nodeName.toLowerCase()
-    );
+  if (root.mutableSourceEagerHydrationData == null) {
+    root.mutableSourceEagerHydrationData = [mutableSource, version];
+  } else {
+    root.mutableSourceEagerHydrationData.push(mutableSource, version);
   }
 }
-function warnForInsertedHydratedElement(parentNode, tag, props) {
+
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig;
+var didWarnAboutMismatchedHooksForComponent;
+var didWarnUncachedGetSnapshot;
+var didWarnAboutUseWrappedInTryCatch;
+
+{
+  didWarnAboutMismatchedHooksForComponent = new Set();
+  didWarnAboutUseWrappedInTryCatch = new Set();
+} // These are set right before calling the component.
+
+var renderLanes$1 = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
+// the work-in-progress hook.
+
+var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
+// current hook list is the list that belongs to the current fiber. The
+// work-in-progress hook list is a new list that will be added to the
+// work-in-progress fiber.
+
+var currentHook = null;
+var workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
+// does not get reset if we do another render pass; only when we're completely
+// finished evaluating this component. This is an optimization so we know
+// whether we need to clear render phase updates after a throw.
+
+var didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
+// gets reset after each attempt.
+// TODO: Maybe there's some way to consolidate this with
+// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+
+var didScheduleRenderPhaseUpdateDuringThisPass = false;
+var shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+
+var localIdCounter = 0; // Counts number of `use`-d thenables
+
+var thenableIndexCounter = 0;
+var thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
+// hydration). This counter is global, so client ids are not stable across
+// render attempts.
+
+var globalClientIdCounter = 0;
+var RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+
+var currentHookNameInDev = null; // In DEV, this list ensures that hooks are called in the same order between renders.
+// The list stores the order of hooks used during the initial render (mount).
+// Subsequent renders (updates) reference this list.
+
+var hookTypesDev = null;
+var hookTypesUpdateIndexDev = -1; // In DEV, this tracks whether currently rendering component needs to ignore
+// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
+// When true, such Hooks will always be "remounted". Only used during hot reload.
+
+var ignorePreviousDependencies = false;
+
+function mountHookTypesDev() {
   {
-    if (didWarnInvalidHydration) {
-      return;
+    var hookName = currentHookNameInDev;
+
+    if (hookTypesDev === null) {
+      hookTypesDev = [hookName];
+    } else {
+      hookTypesDev.push(hookName);
     }
+  }
+}
 
-    didWarnInvalidHydration = true;
+function updateHookTypesDev() {
+  {
+    var hookName = currentHookNameInDev;
 
-    error(
-      "Expected server HTML to contain a matching <%s> in <%s>.",
-      tag,
-      parentNode.nodeName.toLowerCase()
-    );
+    if (hookTypesDev !== null) {
+      hookTypesUpdateIndexDev++;
+
+      if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
+        warnOnHookMismatchInDev(hookName);
+      }
+    }
   }
 }
-function warnForInsertedHydratedText(parentNode, text) {
+
+function checkDepsAreArrayDev(deps) {
   {
-    if (text === "") {
-      // We expect to insert empty text nodes since they're not represented in
-      // the HTML.
-      // TODO: Remove this special case if we can just avoid inserting empty
-      // text nodes.
-      return;
+    if (deps !== undefined && deps !== null && !isArray(deps)) {
+      // Verify deps, but only on mount to avoid extra checks.
+      // It's unlikely their type would change as usually you define them inline.
+      error(
+        "%s received a final argument that is not an array (instead, received `%s`). When " +
+          "specified, the final argument must be an array.",
+        currentHookNameInDev,
+        typeof deps
+      );
     }
+  }
+}
 
-    if (didWarnInvalidHydration) {
-      return;
-    }
+function warnOnHookMismatchInDev(currentHookName) {
+  {
+    var componentName = getComponentNameFromFiber(currentlyRenderingFiber$1);
 
-    didWarnInvalidHydration = true;
+    if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
+      didWarnAboutMismatchedHooksForComponent.add(componentName);
 
-    error(
-      'Expected server HTML to contain a matching text node for "%s" in <%s>.',
-      text,
-      parentNode.nodeName.toLowerCase()
-    );
-  }
-}
-function restoreControlledState(domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      restoreControlledState$3(domElement, props);
-      return;
+      if (hookTypesDev !== null) {
+        var table = "";
+        var secondColumnStart = 30;
 
-    case "textarea":
-      restoreControlledState$1(domElement, props);
-      return;
+        for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
+          var oldHookName = hookTypesDev[i];
+          var newHookName =
+            i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
+          var row = i + 1 + ". " + oldHookName; // Extra space so second column lines up
+          // lol @ IE not supporting String#repeat
 
-    case "select":
-      restoreControlledState$2(domElement, props);
-      return;
+          while (row.length < secondColumnStart) {
+            row += " ";
+          }
+
+          row += newHookName + "\n";
+          table += row;
+        }
+
+        error(
+          "React has detected a change in the order of Hooks called by %s. " +
+            "This will lead to bugs and errors if not fixed. " +
+            "For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n" +
+            "   Previous render            Next render\n" +
+            "   ------------------------------------------------------\n" +
+            "%s" +
+            "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+          componentName,
+          table
+        );
+      }
+    }
   }
 }
 
-// This validation code was written based on the HTML5 parsing spec:
-// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
-//
-// Note: this does not catch all invalid nesting, nor does it try to (as it's
-// not clear what practical benefit doing so provides); instead, we warn only
-// for cases where the parser will give a parse tree differing from what React
-// intended. For example, <b><div></div></b> is invalid but we don't warn
-// because it still parses correctly; we do warn for other cases like nested
-// <p> tags where the beginning of the second element implicitly closes the
-// first, causing a confusing mess.
-// https://html.spec.whatwg.org/multipage/syntax.html#special
-var specialTags = [
-  "address",
-  "applet",
-  "area",
-  "article",
-  "aside",
-  "base",
-  "basefont",
-  "bgsound",
-  "blockquote",
-  "body",
-  "br",
-  "button",
-  "caption",
-  "center",
-  "col",
-  "colgroup",
-  "dd",
-  "details",
-  "dir",
-  "div",
-  "dl",
-  "dt",
-  "embed",
-  "fieldset",
-  "figcaption",
-  "figure",
-  "footer",
-  "form",
-  "frame",
-  "frameset",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "head",
-  "header",
-  "hgroup",
-  "hr",
-  "html",
-  "iframe",
-  "img",
-  "input",
-  "isindex",
-  "li",
-  "link",
-  "listing",
-  "main",
-  "marquee",
-  "menu",
-  "menuitem",
-  "meta",
-  "nav",
-  "noembed",
-  "noframes",
-  "noscript",
-  "object",
-  "ol",
-  "p",
-  "param",
-  "plaintext",
-  "pre",
-  "script",
-  "section",
-  "select",
-  "source",
-  "style",
-  "summary",
-  "table",
-  "tbody",
-  "td",
-  "template",
-  "textarea",
-  "tfoot",
-  "th",
-  "thead",
-  "title",
-  "tr",
-  "track",
-  "ul",
-  "wbr",
-  "xmp"
-]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
+function throwInvalidHookError() {
+  throw new Error(
+    "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for" +
+      " one of the following reasons:\n" +
+      "1. You might have mismatching versions of React and the renderer (such as React DOM)\n" +
+      "2. You might be breaking the Rules of Hooks\n" +
+      "3. You might have more than one copy of React in the same app\n" +
+      "See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."
+  );
+}
 
-var inScopeTags = [
-  "applet",
-  "caption",
-  "html",
-  "table",
-  "td",
-  "th",
-  "marquee",
-  "object",
-  "template", // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
-  // TODO: Distinguish by namespace here -- for <title>, including it here
-  // errs on the side of fewer warnings
-  "foreignObject",
-  "desc",
-  "title"
-]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
+function areHookInputsEqual(nextDeps, prevDeps) {
+  {
+    if (ignorePreviousDependencies) {
+      // Only true when this component is being hot reloaded.
+      return false;
+    }
+  }
 
-var buttonScopeTags = inScopeTags.concat(["button"]); // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
+  if (prevDeps === null) {
+    {
+      error(
+        "%s received a final argument during this render, but not during " +
+          "the previous render. Even though the final argument is optional, " +
+          "its type cannot change between renders.",
+        currentHookNameInDev
+      );
+    }
 
-var impliedEndTags = ["dd", "dt", "li", "option", "optgroup", "p", "rp", "rt"];
-var emptyAncestorInfoDev = {
-  current: null,
-  formTag: null,
-  aTagInScope: null,
-  buttonTagInScope: null,
-  nobrTagInScope: null,
-  pTagInButtonScope: null,
-  listItemTagAutoclosing: null,
-  dlItemTagAutoclosing: null,
-  containerTagInScope: null
-};
+    return false;
+  }
 
-function updatedAncestorInfoDev(oldInfo, tag) {
   {
-    var ancestorInfo = assign({}, oldInfo || emptyAncestorInfoDev);
-
-    var info = {
-      tag: tag
-    };
+    // Don't bother comparing lengths in prod because these arrays should be
+    // passed inline.
+    if (nextDeps.length !== prevDeps.length) {
+      error(
+        "The final argument passed to %s changed size between renders. The " +
+          "order and size of this array must remain constant.\n\n" +
+          "Previous: %s\n" +
+          "Incoming: %s",
+        currentHookNameInDev,
+        "[" + prevDeps.join(", ") + "]",
+        "[" + nextDeps.join(", ") + "]"
+      );
+    }
+  } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-    if (inScopeTags.indexOf(tag) !== -1) {
-      ancestorInfo.aTagInScope = null;
-      ancestorInfo.buttonTagInScope = null;
-      ancestorInfo.nobrTagInScope = null;
+  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    if (objectIs(nextDeps[i], prevDeps[i])) {
+      continue;
     }
 
-    if (buttonScopeTags.indexOf(tag) !== -1) {
-      ancestorInfo.pTagInButtonScope = null;
-    } // See rules for 'li', 'dd', 'dt' start tags in
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
+    return false;
+  }
 
-    if (
-      specialTags.indexOf(tag) !== -1 &&
-      tag !== "address" &&
-      tag !== "div" &&
-      tag !== "p"
-    ) {
-      ancestorInfo.listItemTagAutoclosing = null;
-      ancestorInfo.dlItemTagAutoclosing = null;
-    }
+  return true;
+}
 
-    ancestorInfo.current = info;
+function renderWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg,
+  nextRenderLanes
+) {
+  renderLanes$1 = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
 
-    if (tag === "form") {
-      ancestorInfo.formTag = info;
-    }
+  {
+    hookTypesDev = current !== null ? current._debugHookTypes : null;
+    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
 
-    if (tag === "a") {
-      ancestorInfo.aTagInScope = info;
-    }
+    ignorePreviousDependencies =
+      current !== null && current.type !== workInProgress.type;
+  }
 
-    if (tag === "button") {
-      ancestorInfo.buttonTagInScope = info;
-    }
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = NoLanes; // The following should have already been reset
+  // currentHook = null;
+  // workInProgressHook = null;
+  // didScheduleRenderPhaseUpdate = false;
+  // localIdCounter = 0;
+  // thenableIndexCounter = 0;
+  // thenableState = null;
+  // TODO Warn if no hooks are used at all during mount, then some are used during update.
+  // Currently we will identify the update render as a mount because memoizedState === null.
+  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
+  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
+  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
+  // so memoizedState would be null during updates and mounts.
 
-    if (tag === "nobr") {
-      ancestorInfo.nobrTagInScope = info;
+  {
+    if (current !== null && current.memoizedState !== null) {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
+    } else if (hookTypesDev !== null) {
+      // This dispatcher handles an edge case where a component is updating,
+      // but no stateful hooks have been used.
+      // We want to match the production code behavior (which will use HooksDispatcherOnMount),
+      // but with the extra DEV validation to ensure hooks ordering hasn't changed.
+      // This dispatcher does that.
+      ReactCurrentDispatcher$1.current =
+        HooksDispatcherOnMountWithHookTypesInDEV;
+    } else {
+      ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
     }
+  } // In Strict Mode, during development, user functions are double invoked to
+  // help detect side effects. The logic for how this is implemented for in
+  // hook components is a bit complex so let's break it down.
+  //
+  // We will invoke the entire component function twice. However, during the
+  // second invocation of the component, the hook state from the first
+  // invocation will be reused. That means things like `useMemo` functions won't
+  // run again, because the deps will match and the memoized result will
+  // be reused.
+  //
+  // We want memoized functions to run twice, too, so account for this, user
+  // functions are double invoked during the *first* invocation of the component
+  // function, and are *not* double invoked during the second incovation:
+  //
+  // - First execution of component function: user functions are double invoked
+  // - Second execution of component function (in Strict Mode, during
+  //   development): user functions are not double invoked.
+  //
+  // This is intentional for a few reasons; most importantly, it's because of
+  // how `use` works when something suspends: it reuses the promise that was
+  // passed during the first attempt. This is itself a form of memoization.
+  // We need to be able to memoize the reactive inputs to the `use` call using
+  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
+  // come from the same component invocation as the output.
+  //
+  // There are plenty of tests to ensure this behavior is correct.
 
-    if (tag === "p") {
-      ancestorInfo.pTagInButtonScope = info;
-    }
+  var shouldDoubleRenderDEV =
+    (workInProgress.mode & StrictLegacyMode) !== NoMode;
+  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
+  var children = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
 
-    if (tag === "li") {
-      ancestorInfo.listItemTagAutoclosing = info;
-    }
+  if (didScheduleRenderPhaseUpdateDuringThisPass) {
+    // Keep rendering until the component stabilizes (there are no more render
+    // phase updates).
+    children = renderWithHooksAgain(
+      workInProgress,
+      Component,
+      props,
+      secondArg
+    );
+  }
 
-    if (tag === "dd" || tag === "dt") {
-      ancestorInfo.dlItemTagAutoclosing = info;
-    }
+  if (shouldDoubleRenderDEV) {
+    // In development, components are invoked twice to help detect side effects.
+    setIsStrictModeForDevtools(true);
 
-    if (tag === "#document" || tag === "html") {
-      ancestorInfo.containerTagInScope = null;
-    } else if (!ancestorInfo.containerTagInScope) {
-      ancestorInfo.containerTagInScope = info;
+    try {
+      children = renderWithHooksAgain(
+        workInProgress,
+        Component,
+        props,
+        secondArg
+      );
+    } finally {
+      setIsStrictModeForDevtools(false);
     }
-
-    return ancestorInfo;
   }
+
+  finishRenderingHooks(current, workInProgress);
+  return children;
 }
-/**
- * Returns whether
- */
 
-function isTagValidWithParent(tag, parentTag) {
-  // First, let's check if we're in an unusual parsing mode...
-  switch (parentTag) {
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
-    case "select":
-      return tag === "option" || tag === "optgroup" || tag === "#text";
+function finishRenderingHooks(current, workInProgress) {
+  // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
 
-    case "optgroup":
-      return tag === "option" || tag === "#text";
-    // Strictly speaking, seeing an <option> doesn't mean we're in a <select>
-    // but
+  {
+    workInProgress._debugHookTypes = hookTypesDev;
+  } // This check uses currentHook so that it works the same in DEV and prod bundles.
+  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
 
-    case "option":
-      return tag === "#text";
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
-    // No special behavior since these rules fall back to "in body" mode for
-    // all except special table nodes which cause bad parsing behavior anyway.
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
+  var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+  renderLanes$1 = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
 
-    case "tr":
-      return (
-        tag === "th" ||
-        tag === "td" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
-      );
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
+  {
+    currentHookNameInDev = null;
+    hookTypesDev = null;
+    hookTypesUpdateIndexDev = -1; // Confirm that a static flag was not added or removed since the last
+    // render. If this fires, it suggests that we incorrectly reset the static
+    // flags in some other part of the codebase. This has happened before, for
+    // example, in the SuspenseList implementation.
 
-    case "tbody":
-    case "thead":
-    case "tfoot":
-      return (
-        tag === "tr" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
+    if (
+      current !== null &&
+      (current.flags & StaticMask) !== (workInProgress.flags & StaticMask) && // Disable this warning in legacy mode, because legacy Suspense is weird
+      // and creates false positives. To make this work in legacy mode, we'd
+      // need to mark fibers that commit in an incomplete state, somehow. For
+      // now I'll disable the warning that most of the bugs that would trigger
+      // it are either exclusive to concurrent mode or exist in both.
+      (current.mode & ConcurrentMode) !== NoMode
+    ) {
+      error(
+        "Internal React error: Expected static flag was missing. Please " +
+          "notify the React team."
       );
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
-
-    case "colgroup":
-      return tag === "col" || tag === "template";
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
+    }
+  }
 
-    case "table":
-      return (
-        tag === "caption" ||
-        tag === "colgroup" ||
-        tag === "tbody" ||
-        tag === "tfoot" ||
-        tag === "thead" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
-      );
-    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
+  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
+  // localIdCounter = 0;
 
-    case "head":
-      return (
-        tag === "base" ||
-        tag === "basefont" ||
-        tag === "bgsound" ||
-        tag === "link" ||
-        tag === "meta" ||
-        tag === "title" ||
-        tag === "noscript" ||
-        tag === "noframes" ||
-        tag === "style" ||
-        tag === "script" ||
-        tag === "template"
-      );
-    // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
+  thenableIndexCounter = 0;
+  thenableState = null;
 
-    case "html":
-      return tag === "head" || tag === "body" || tag === "frameset";
+  if (didRenderTooFewHooks) {
+    throw new Error(
+      "Rendered fewer hooks than expected. This may be caused by an accidental " +
+        "early return statement."
+    );
+  }
 
-    case "frameset":
-      return tag === "frame";
+  if (enableLazyContextPropagation) {
+    if (current !== null) {
+      if (!checkIfWorkInProgressReceivedUpdate()) {
+        // If there were no changes to props or state, we need to check if there
+        // was a context change. We didn't already do this because there's no
+        // 1:1 correspondence between dependencies and hooks. Although, because
+        // there almost always is in the common case (`readContext` is an
+        // internal API), we could compare in there. OTOH, we only hit this case
+        // if everything else bails out, so on the whole it might be better to
+        // keep the comparison out of the common path.
+        var currentDependencies = current.dependencies;
 
-    case "#document":
-      return tag === "html";
-  } // Probably in the "in body" parsing mode, so we outlaw only tag combos
-  // where the parsing rules cause implicit opens or closes to be added.
-  // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
+        if (
+          currentDependencies !== null &&
+          checkIfContextChanged(currentDependencies)
+        ) {
+          markWorkInProgressReceivedUpdate();
+        }
+      }
+    }
+  }
 
-  switch (tag) {
-    case "h1":
-    case "h2":
-    case "h3":
-    case "h4":
-    case "h5":
-    case "h6":
-      return (
-        parentTag !== "h1" &&
-        parentTag !== "h2" &&
-        parentTag !== "h3" &&
-        parentTag !== "h4" &&
-        parentTag !== "h5" &&
-        parentTag !== "h6"
-      );
+  {
+    if (checkIfUseWrappedInTryCatch()) {
+      var componentName =
+        getComponentNameFromFiber(workInProgress) || "Unknown";
 
-    case "rp":
-    case "rt":
-      return impliedEndTags.indexOf(parentTag) === -1;
+      if (!didWarnAboutUseWrappedInTryCatch.has(componentName)) {
+        didWarnAboutUseWrappedInTryCatch.add(componentName);
 
-    case "body":
-    case "caption":
-    case "col":
-    case "colgroup":
-    case "frameset":
-    case "frame":
-    case "head":
-    case "html":
-    case "tbody":
-    case "td":
-    case "tfoot":
-    case "th":
-    case "thead":
-    case "tr":
-      // These tags are only valid with a few parents that have special child
-      // parsing rules -- if we're down here, then none of those matched and
-      // so we allow it only if we don't know what the parent is, as all other
-      // cases are invalid.
-      return parentTag == null;
+        error(
+          "`use` was called from inside a try/catch block. This is not allowed " +
+            "and can lead to unexpected behavior. To handle errors triggered " +
+            "by `use`, wrap your component in a error boundary."
+        );
+      }
+    }
   }
-
-  return true;
 }
-/**
- * Returns whether
- */
-
-function findInvalidAncestorForTag(tag, ancestorInfo) {
-  switch (tag) {
-    case "address":
-    case "article":
-    case "aside":
-    case "blockquote":
-    case "center":
-    case "details":
-    case "dialog":
-    case "dir":
-    case "div":
-    case "dl":
-    case "fieldset":
-    case "figcaption":
-    case "figure":
-    case "footer":
-    case "header":
-    case "hgroup":
-    case "main":
-    case "menu":
-    case "nav":
-    case "ol":
-    case "p":
-    case "section":
-    case "summary":
-    case "ul":
-    case "pre":
-    case "listing":
-    case "table":
-    case "hr":
-    case "xmp":
-    case "h1":
-    case "h2":
-    case "h3":
-    case "h4":
-    case "h5":
-    case "h6":
-      return ancestorInfo.pTagInButtonScope;
-
-    case "form":
-      return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
-
-    case "li":
-      return ancestorInfo.listItemTagAutoclosing;
-
-    case "dd":
-    case "dt":
-      return ancestorInfo.dlItemTagAutoclosing;
-
-    case "button":
-      return ancestorInfo.buttonTagInScope;
 
-    case "a":
-      // Spec says something about storing a list of markers, but it sounds
-      // equivalent to this check.
-      return ancestorInfo.aTagInScope;
+function replaySuspendedComponentWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg
+) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves.
+  //
+  // It's a simplified version of renderWithHooks, but it doesn't need to do
+  // most of the set up work because they weren't reset when we suspended; they
+  // only get reset when the component either completes (finishRenderingHooks)
+  // or unwinds (resetHooksOnUnwind).
+  {
+    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
 
-    case "nobr":
-      return ancestorInfo.nobrTagInScope;
+    ignorePreviousDependencies =
+      current !== null && current.type !== workInProgress.type;
   }
 
-  return null;
+  var children = renderWithHooksAgain(
+    workInProgress,
+    Component,
+    props,
+    secondArg
+  );
+  finishRenderingHooks(current, workInProgress);
+  return children;
 }
 
-var didWarn = {};
-
-function validateDOMNesting(childTag, childText, ancestorInfo) {
-  {
-    ancestorInfo = ancestorInfo || emptyAncestorInfoDev;
-    var parentInfo = ancestorInfo.current;
-    var parentTag = parentInfo && parentInfo.tag;
-
-    if (childText != null) {
-      if (childTag != null) {
-        error(
-          "validateDOMNesting: when childText is passed, childTag should be null"
-        );
-      }
-
-      childTag = "#text";
-    } else if (childTag == null) {
-      error("validateDOMNesting: when childText or childTag must be provided");
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  // This is used to perform another render pass. It's used when setState is
+  // called during render, and for double invoking components in Strict Mode
+  // during development.
+  //
+  // The state from the previous pass is reused whenever possible. So, state
+  // updates that were already processed are not processed again, and memoized
+  // functions (`useMemo`) are not invoked again.
+  //
+  // Keep rendering in a loop for as long as render phase updates continue to
+  // be scheduled. Use a counter to prevent infinite loops.
+  var numberOfReRenders = 0;
+  var children;
 
-      return;
+  do {
+    if (didScheduleRenderPhaseUpdateDuringThisPass) {
+      // It's possible that a use() value depended on a state that was updated in
+      // this rerender, so we need to watch for different thenables this time.
+      thenableState = null;
     }
 
-    var invalidParent = isTagValidWithParent(childTag, parentTag)
-      ? null
-      : parentInfo;
-    var invalidAncestor = invalidParent
-      ? null
-      : findInvalidAncestorForTag(childTag, ancestorInfo);
-    var invalidParentOrAncestor = invalidParent || invalidAncestor;
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = false;
 
-    if (!invalidParentOrAncestor) {
-      return;
+    if (numberOfReRenders >= RE_RENDER_LIMIT) {
+      throw new Error(
+        "Too many re-renders. React limits the number of renders to prevent " +
+          "an infinite loop."
+      );
     }
 
-    var ancestorTag = invalidParentOrAncestor.tag;
-    var warnKey = String(!!invalidParent) + "|" + childTag + "|" + ancestorTag; // eslint-disable-next-line react-internal/safe-string-coercion
+    numberOfReRenders += 1;
 
-    if (didWarn[warnKey]) {
-      return;
-    }
+    {
+      // Even when hot reloading, allow dependencies to stabilize
+      // after first render to prevent infinite render phase updates.
+      ignorePreviousDependencies = false;
+    } // Start over from the beginning of the list
 
-    didWarn[warnKey] = true;
-    var tagDisplayName = childTag;
-    var whitespaceInfo = "";
+    currentHook = null;
+    workInProgressHook = null;
+    workInProgress.updateQueue = null;
 
-    if (childTag === "#text") {
-      if (childText != null && /\S/.test(childText)) {
-        tagDisplayName = "Text nodes";
-      } else {
-        tagDisplayName = "Whitespace text nodes";
-        whitespaceInfo =
-          " Make sure you don't have any extra whitespace between tags on " +
-          "each line of your source code.";
-      }
-    } else {
-      tagDisplayName = "<" + childTag + ">";
+    {
+      // Also validate hook order for cascading updates.
+      hookTypesUpdateIndexDev = -1;
     }
 
-    if (invalidParent) {
-      var info = "";
-
-      if (ancestorTag === "table" && childTag === "tr") {
-        info +=
-          " Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by " +
-          "the browser.";
-      }
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV;
+    children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
 
-      error(
-        "validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s",
-        tagDisplayName,
-        ancestorTag,
-        whitespaceInfo,
-        info
-      );
-    } else {
-      error(
-        "validateDOMNesting(...): %s cannot appear as a descendant of " +
-          "<%s>.",
-        tagDisplayName,
-        ancestorTag
-      );
-    }
-  }
+  return children;
 }
 
-var valueStack = [];
-var fiberStack;
-
-{
-  fiberStack = [];
+function checkDidRenderIdHook() {
+  // This should be called immediately after every renderWithHooks call.
+  // Conceptually, it's part of the return value of renderWithHooks; it's only a
+  // separate function to avoid using an array tuple.
+  var didRenderIdHook = localIdCounter !== 0;
+  localIdCounter = 0;
+  return didRenderIdHook;
 }
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
+  // complete phase (bubbleProperties).
 
-var index = -1;
+  if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+    workInProgress.flags &= ~(
+      MountPassiveDev |
+      MountLayoutDev |
+      Passive$1 |
+      Update
+    );
+  } else {
+    workInProgress.flags &= ~(Passive$1 | Update);
+  }
 
-function createCursor(defaultValue) {
-  return {
-    current: defaultValue
-  };
+  current.lanes = removeLanes(current.lanes, lanes);
+}
+function resetHooksAfterThrow() {
+  // This is called immediaetly after a throw. It shouldn't reset the entire
+  // module state, because the work loop might decide to replay the component
+  // again without rewinding.
+  //
+  // It should only reset things like the current dispatcher, to prevent hooks
+  // from being called outside of a component.
+  // We can assume the previous dispatcher is always this one, since we set it
+  // at the beginning of the render phase and there's no re-entrance.
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
 }
+function resetHooksOnUnwind() {
+  if (didScheduleRenderPhaseUpdate) {
+    // There were render phase updates. These are only valid for this render
+    // phase, which we are now aborting. Remove the updates from the queues so
+    // they do not persist to the next render. Do not remove updates from hooks
+    // that weren't processed.
+    //
+    // Only reset the updates from the queue if it has a clone. If it does
+    // not have a clone, that means it wasn't processed, and the updates were
+    // scheduled before we entered the render phase.
+    var hook = currentlyRenderingFiber$1.memoizedState;
 
-function pop(cursor, fiber) {
-  if (index < 0) {
-    {
-      error("Unexpected pop.");
-    }
+    while (hook !== null) {
+      var queue = hook.queue;
 
-    return;
-  }
+      if (queue !== null) {
+        queue.pending = null;
+      }
 
-  {
-    if (fiber !== fiberStack[index]) {
-      error("Unexpected Fiber popped.");
+      hook = hook.next;
     }
+
+    didScheduleRenderPhaseUpdate = false;
   }
 
-  cursor.current = valueStack[index];
-  valueStack[index] = null;
+  renderLanes$1 = NoLanes;
+  currentlyRenderingFiber$1 = null;
+  currentHook = null;
+  workInProgressHook = null;
 
   {
-    fiberStack[index] = null;
+    hookTypesDev = null;
+    hookTypesUpdateIndexDev = -1;
+    currentHookNameInDev = null;
   }
 
-  index--;
+  didScheduleRenderPhaseUpdateDuringThisPass = false;
+  localIdCounter = 0;
+  thenableIndexCounter = 0;
+  thenableState = null;
 }
 
-function push(cursor, value, fiber) {
-  index++;
-  valueStack[index] = cursor.current;
+function mountWorkInProgressHook() {
+  var hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
 
-  {
-    fiberStack[index] = fiber;
+  if (workInProgressHook === null) {
+    // This is the first hook in the list
+    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
+  } else {
+    // Append to the end of the list
+    workInProgressHook = workInProgressHook.next = hook;
   }
 
-  cursor.current = value;
+  return workInProgressHook;
 }
 
-var contextStackCursor = createCursor(null);
-var contextFiberStackCursor = createCursor(null);
-var rootInstanceStackCursor = createCursor(null);
+function updateWorkInProgressHook() {
+  // This function is used both for updates and for re-renders triggered by a
+  // render phase update. It assumes there is either a current hook we can
+  // clone, or a work-in-progress hook from a previous render pass that we can
+  // use as a base.
+  var nextCurrentHook;
 
-function requiredContext(c) {
-  {
-    if (c === null) {
-      error(
-        "Expected host context to exist. This error is likely caused by a bug " +
-          "in React. Please file an issue."
-      );
+  if (currentHook === null) {
+    var current = currentlyRenderingFiber$1.alternate;
+
+    if (current !== null) {
+      nextCurrentHook = current.memoizedState;
+    } else {
+      nextCurrentHook = null;
     }
+  } else {
+    nextCurrentHook = currentHook.next;
   }
 
-  return c;
-}
-
-function getCurrentRootHostContainer() {
-  return rootInstanceStackCursor.current;
-}
-
-function getRootHostContainer() {
-  var rootInstance = requiredContext(rootInstanceStackCursor.current);
-  return rootInstance;
-}
-
-function pushHostContainer(fiber, nextRootInstance) {
-  // Push current root instance onto the stack;
-  // This allows us to reset root when portals are popped.
-  push(rootInstanceStackCursor, nextRootInstance, fiber); // Track the context and the Fiber that provided it.
-  // This enables us to pop only Fibers that provide unique contexts.
+  var nextWorkInProgressHook;
 
-  push(contextFiberStackCursor, fiber, fiber); // Finally, we need to push the host context to the stack.
-  // However, we can't just call getRootHostContext() and push it because
-  // we'd have a different number of entries on the stack depending on
-  // whether getRootHostContext() throws somewhere in renderer code or not.
-  // So we push an empty value first. This lets us safely unwind on errors.
+  if (workInProgressHook === null) {
+    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
+  } else {
+    nextWorkInProgressHook = workInProgressHook.next;
+  }
 
-  push(contextStackCursor, null, fiber);
-  var nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.
+  if (nextWorkInProgressHook !== null) {
+    // There's already a work-in-progress. Reuse it.
+    workInProgressHook = nextWorkInProgressHook;
+    nextWorkInProgressHook = workInProgressHook.next;
+    currentHook = nextCurrentHook;
+  } else {
+    // Clone from the current hook.
+    if (nextCurrentHook === null) {
+      var currentFiber = currentlyRenderingFiber$1.alternate;
 
-  pop(contextStackCursor, fiber);
-  push(contextStackCursor, nextRootContext, fiber);
-}
+      if (currentFiber === null) {
+        // This is the initial render. This branch is reached when the component
+        // suspends, resumes, then renders an additional hook.
+        // Should never be reached because we should switch to the mount dispatcher first.
+        throw new Error(
+          "Update hook called on initial render. This is likely a bug in React. Please file an issue."
+        );
+      } else {
+        // This is an update. We should always have a current hook.
+        throw new Error("Rendered more hooks than during the previous render.");
+      }
+    }
 
-function popHostContainer(fiber) {
-  pop(contextStackCursor, fiber);
-  pop(contextFiberStackCursor, fiber);
-  pop(rootInstanceStackCursor, fiber);
-}
+    currentHook = nextCurrentHook;
+    var newHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
 
-function getHostContext() {
-  var context = requiredContext(contextStackCursor.current);
-  return context;
-}
+    if (workInProgressHook === null) {
+      // This is the first hook in the list.
+      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
+    } else {
+      // Append to the end of the list.
+      workInProgressHook = workInProgressHook.next = newHook;
+    }
+  }
 
-function pushHostContext(fiber) {
-  var context = requiredContext(contextStackCursor.current);
-  var nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.
+  return workInProgressHook;
+} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
+// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
 
-  if (context === nextContext) {
-    return;
-  } // Track the context and the Fiber that provided it.
-  // This enables us to pop only Fibers that provide unique contexts.
+var createFunctionComponentUpdateQueue;
 
-  push(contextFiberStackCursor, fiber, fiber);
-  push(contextStackCursor, nextContext, fiber);
+{
+  createFunctionComponentUpdateQueue = function () {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  };
 }
 
-function popHostContext(fiber) {
-  // Do not pop unless this Fiber provided the current context.
-  // pushHostContext() only pushes Fibers that provide unique contexts.
-  if (contextFiberStackCursor.current !== fiber) {
-    return;
-  }
+function use(usable) {
+  if (usable !== null && typeof usable === "object") {
+    // $FlowFixMe[method-unbinding]
+    if (typeof usable.then === "function") {
+      // This is a thenable.
+      var thenable = usable; // Track the position of the thenable within this fiber.
 
-  pop(contextStackCursor, fiber);
-  pop(contextFiberStackCursor, fiber);
-}
+      var index = thenableIndexCounter;
+      thenableIndexCounter += 1;
 
-var ReactDOMSharedInternals = Internals;
+      if (thenableState === null) {
+        thenableState = createThenableState();
+      }
 
-function validateLinkPropsForStyleResource(props) {
-  {
-    // This should only be called when we know we are opting into Resource semantics (i.e. precedence is not null)
-    var href = props.href,
-      onLoad = props.onLoad,
-      onError = props.onError,
-      disabled = props.disabled;
-    var includedProps = [];
-    if (onLoad) includedProps.push("`onLoad`");
-    if (onError) includedProps.push("`onError`");
-    if (disabled != null) includedProps.push("`disabled`");
-    var includedPropsPhrase = propNamesListJoin(includedProps, "and");
-    includedPropsPhrase += includedProps.length === 1 ? " prop" : " props";
-    var withArticlePhrase =
-      includedProps.length === 1
-        ? "an " + includedPropsPhrase
-        : "the " + includedPropsPhrase;
+      var result = trackUsedThenable(thenableState, thenable, index);
 
-    if (includedProps.length) {
-      error(
-        'React encountered a <link rel="stylesheet" href="%s" ... /> with a `precedence` prop that' +
-          " also included %s. The presence of loading and error handlers indicates an intent to manage" +
-          " the stylesheet loading state from your from your Component code and React will not hoist or" +
-          " deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet" +
-          " using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.",
-        href,
-        withArticlePhrase,
-        includedPropsPhrase
-      );
+      if (
+        currentlyRenderingFiber$1.alternate === null &&
+        (workInProgressHook === null
+          ? currentlyRenderingFiber$1.memoizedState === null
+          : workInProgressHook.next === null)
+      ) {
+        // Initial render, and either this is the first time the component is
+        // called, or there were no Hooks called after this use() the previous
+        // time (perhaps because it threw). Subsequent Hook calls should use the
+        // mount dispatcher.
+        {
+          ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
+        }
+      }
 
-      return true;
+      return result;
+    } else if (
+      usable.$$typeof === REACT_CONTEXT_TYPE ||
+      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    ) {
+      var context = usable;
+      return readContext(context);
     }
-  }
+  } // eslint-disable-next-line react-internal/safe-string-coercion
 
-  return false;
+  throw new Error("An unsupported type was passed to use(): " + String(usable));
 }
 
-function propNamesListJoin(list, combinator) {
-  switch (list.length) {
-    case 0:
-      return "";
-
-    case 1:
-      return list[0];
-
-    case 2:
-      return list[0] + " " + combinator + " " + list[1];
-
-    default:
-      return (
-        list.slice(0, -1).join(", ") +
-        ", " +
-        combinator +
-        " " +
-        list[list.length - 1]
-      );
-  }
-}
-
-function validatePreloadArguments(href, options) {
-  {
-    if (!href || typeof href !== "string") {
-      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
-
-      error(
-        "ReactDOM.preload() expected the first argument to be a string representing an href but found %s instead.",
-        typeOfArg
-      );
-    } else if (typeof options !== "object" || options === null) {
-      var _typeOfArg = getValueDescriptorExpectingObjectForWarning(options);
+function useMemoCache(size) {
+  var memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
 
-      error(
-        'ReactDOM.preload() expected the second argument to be an options argument containing at least an "as" property' +
-          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
-        _typeOfArg,
-        href
-      );
-    } else {
-      var as = options.as;
+  var updateQueue = currentlyRenderingFiber$1.updateQueue;
 
-      switch (as) {
-        // Font specific validation of options
-        case "font": {
-          if (options.crossOrigin === "use-credentials") {
-            error(
-              'ReactDOM.preload() was called with an "as" type of "font" and with a "crossOrigin" option of "use-credentials".' +
-                ' Fonts preloading must use crossOrigin "anonymous" to be functional. Please update your font preload to omit' +
-                ' the crossOrigin option or change it to any other value than "use-credentials" (Browsers default all other values' +
-                ' to anonymous mode). The href for the preload call where this warning originated is "%s"',
-              href
-            );
-          }
+  if (updateQueue !== null) {
+    memoCache = updateQueue.memoCache;
+  } // Otherwise clone from the current fiber
 
-          break;
-        }
+  if (memoCache == null) {
+    var current = currentlyRenderingFiber$1.alternate;
 
-        case "script":
-        case "style": {
-          break;
-        }
-        // We have an invalid as type and need to warn
+    if (current !== null) {
+      var currentUpdateQueue = current.updateQueue;
 
-        default: {
-          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
+      if (currentUpdateQueue !== null) {
+        var currentMemoCache = currentUpdateQueue.memoCache;
 
-          error(
-            'ReactDOM.preload() expected a valid "as" type in the options (second) argument but found %s instead.' +
-              " Please use one of the following valid values instead: %s. The href for the preload call where this" +
-              ' warning originated is "%s".',
-            typeOfAs,
-            '"style", "font", or "script"',
-            href
-          );
+        if (currentMemoCache != null) {
+          memoCache = {
+            data: currentMemoCache.data.map(function (array) {
+              return array.slice();
+            }),
+            index: 0
+          };
         }
       }
     }
-  }
-}
-function validatePreinitArguments(href, options) {
-  {
-    if (!href || typeof href !== "string") {
-      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
+  } // Finally fall back to allocating a fresh instance of the cache
 
-      error(
-        "ReactDOM.preinit() expected the first argument to be a string representing an href but found %s instead.",
-        typeOfArg
-      );
-    } else if (typeof options !== "object" || options === null) {
-      var _typeOfArg2 = getValueDescriptorExpectingObjectForWarning(options);
+  if (memoCache == null) {
+    memoCache = {
+      data: [],
+      index: 0
+    };
+  }
 
-      error(
-        'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
-          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
-        _typeOfArg2,
-        href
-      );
-    } else {
-      var as = options.as;
+  if (updateQueue === null) {
+    updateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = updateQueue;
+  }
 
-      switch (as) {
-        case "style":
-        case "script": {
-          break;
-        }
-        // We have an invalid as type and need to warn
+  updateQueue.memoCache = memoCache;
+  var data = memoCache.data[memoCache.index];
 
-        default: {
-          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
+  if (data === undefined) {
+    data = memoCache.data[memoCache.index] = new Array(size);
 
-          error(
-            'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
-              ' specifying the Resource type. It found %s instead. Currently, valid resource types for for preinit are "style"' +
-              ' and "script". The href for the preinit call where this warning originated is "%s".',
-            typeOfAs,
-            href
-          );
-        }
-      }
+    for (var i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL;
+    }
+  } else if (data.length !== size) {
+    // TODO: consider warning or throwing here
+    {
+      error(
+        "Expected a constant size argument for each invocation of useMemoCache. " +
+          "The previous cache was allocated with size %s but size %s was requested.",
+        data.length,
+        size
+      );
     }
   }
-}
-function getValueDescriptorExpectingObjectForWarning(thing) {
-  return thing === null
-    ? "`null`"
-    : thing === undefined
-    ? "`undefined`"
-    : thing === ""
-    ? "an empty string"
-    : 'something with type "' + typeof thing + '"';
-}
-function getValueDescriptorExpectingEnumForWarning(thing) {
-  return thing === null
-    ? "`null`"
-    : thing === undefined
-    ? "`undefined`"
-    : thing === ""
-    ? "an empty string"
-    : typeof thing === "string"
-    ? JSON.stringify(thing)
-    : 'something with type "' + typeof thing + '"';
-}
-
-var Dispatcher$1 = ReactDOMSharedInternals.Dispatcher;
-// In the future this may need to change, especially when modules / scripts are supported
-// It is valid to preload even when we aren't actively rendering. For cases where Float functions are
-// called when there is no rendering we track the last used document. It is not safe to insert
-// arbitrary resources into the lastCurrentDocument b/c it may not actually be the document
-// that the resource is meant to apply too (for example stylesheets or scripts). This is only
-// appropriate for resources that don't really have a strict tie to the document itself for example
-// preloads
 
-var lastCurrentDocument = null;
-var previousDispatcher = null;
-function prepareToRenderResources(rootContainer) {
-  var rootNode = getHoistableRoot(rootContainer);
-  lastCurrentDocument = getDocumentFromRoot(rootNode);
-  previousDispatcher = Dispatcher$1.current;
-  Dispatcher$1.current = ReactDOMClientDispatcher;
-}
-function cleanupAfterRenderResources() {
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
+  memoCache.index++;
+  return data;
 }
-function prepareToCommitHoistables() {
-  tagCaches = null;
-} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
-// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
-// from Internals -> ReactDOM -> FloatClient -> Internals so this doesn't introduce a new one.
-
-var ReactDOMClientDispatcher = {
-  prefetchDNS: prefetchDNS$1,
-  preconnect: preconnect$1,
-  preload: preload$1,
-  preinit: preinit$1
-}; // global collections of Resources
 
-var preloadPropsMap = new Map();
-var preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
-
-function getHoistableRoot(container) {
-  // $FlowFixMe[method-unbinding]
-  return typeof container.getRootNode === "function"
-    ? /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
-       * but it's either a `Document` or `ShadowRoot`. */
-      container.getRootNode()
-    : container.ownerDocument;
+function basicStateReducer(state, action) {
+  // $FlowFixMe: Flow doesn't like mixed types
+  return typeof action === "function" ? action(state) : action;
 }
 
-function getCurrentResourceRoot() {
-  var currentContainer = getCurrentRootHostContainer();
-  return currentContainer ? getHoistableRoot(currentContainer) : null;
-} // Preloads are somewhat special. Even if we don't have the Document
-// used by the root that is rendering a component trying to insert a preload
-// we can still seed the file cache by doing the preload on any document we have
-// access to. We prefer the currentDocument if it exists, we also prefer the
-// lastCurrentDocument if that exists. As a fallback we will use the window.document
-// if available.
-
-function getDocumentForPreloads() {
-  var root = getCurrentResourceRoot();
+function mountReducer(reducer, initialArg, init) {
+  var hook = mountWorkInProgressHook();
+  var initialState;
 
-  if (root) {
-    return root.ownerDocument || root;
+  if (init !== undefined) {
+    initialState = init(initialArg);
   } else {
-    try {
-      return lastCurrentDocument || window.document;
-    } catch (error) {
-      return null;
-    }
+    initialState = initialArg;
   }
-}
 
-function getDocumentFromRoot(root) {
-  return root.ownerDocument || root;
+  hook.memoizedState = hook.baseState = initialState;
+  var queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: reducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  var dispatch = (queue.dispatch = dispatchReducerAction.bind(
+    null,
+    currentlyRenderingFiber$1,
+    queue
+  ));
+  return [hook.memoizedState, dispatch];
 }
 
-function preconnectAs(rel, crossOrigin, href) {
-  var ownerDocument = getDocumentForPreloads();
+function updateReducer(reducer, initialArg, init) {
+  var hook = updateWorkInProgressHook();
+  var queue = hook.queue;
 
-  if (typeof href === "string" && href && ownerDocument) {
-    var limitedEscapedHref =
-      escapeSelectorAttributeValueInsideDoubleQuotes(href);
-    var key = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
+  if (queue === null) {
+    throw new Error(
+      "Should have a queue. This is likely a bug in React. Please file an issue."
+    );
+  }
 
-    if (typeof crossOrigin === "string") {
-      key += '[crossorigin="' + crossOrigin + '"]';
-    }
+  queue.lastRenderedReducer = reducer;
+  var current = currentHook; // The last rebase update that is NOT part of the base state.
 
-    if (!preconnectsSet.has(key)) {
-      preconnectsSet.add(key);
-      var preconnectProps = {
-        rel: rel,
-        crossOrigin: crossOrigin,
-        href: href
-      };
+  var baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.
 
-      if (null === ownerDocument.querySelector(key)) {
-        var preloadInstance = ownerDocument.createElement("link");
-        setInitialProperties(preloadInstance, "link", preconnectProps);
-        markNodeAsHoistable(preloadInstance);
-        ownerDocument.head.appendChild(preloadInstance);
-      }
+  var pendingQueue = queue.pending;
+
+  if (pendingQueue !== null) {
+    // We have new updates that haven't been processed yet.
+    // We'll add them to the base queue.
+    if (baseQueue !== null) {
+      // Merge the pending queue and the base queue.
+      var baseFirst = baseQueue.next;
+      var pendingFirst = pendingQueue.next;
+      baseQueue.next = pendingFirst;
+      pendingQueue.next = baseFirst;
     }
-  }
-} // --------------------------------------
-//      ReactDOM.prefetchDNS
-// --------------------------------------
 
-function prefetchDNS$1(href, options) {
-  {
-    if (typeof href !== "string" || !href) {
-      error(
-        "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
-        getValueDescriptorExpectingObjectForWarning(href)
-      );
-    } else if (options != null) {
-      if (
-        typeof options === "object" &&
-        hasOwnProperty.call(options, "crossOrigin")
-      ) {
-        error(
-          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
-          getValueDescriptorExpectingEnumForWarning(options)
-        );
-      } else {
+    {
+      if (current.baseQueue !== baseQueue) {
+        // Internal invariant that should never happen, but feasibly could in
+        // the future if we implement resuming, or some form of that.
         error(
-          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
-          getValueDescriptorExpectingEnumForWarning(options)
+          "Internal error: Expected work-in-progress queue to be a clone. " +
+            "This is a bug in React."
         );
       }
     }
-  }
-
-  preconnectAs("dns-prefetch", null, href);
-} // --------------------------------------
-//      ReactDOM.preconnect
-// --------------------------------------
 
-function preconnect$1(href, options) {
-  {
-    if (typeof href !== "string" || !href) {
-      error(
-        "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
-        getValueDescriptorExpectingObjectForWarning(href)
-      );
-    } else if (options != null && typeof options !== "object") {
-      error(
-        "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
-        getValueDescriptorExpectingEnumForWarning(options)
-      );
-    } else if (options != null && typeof options.crossOrigin !== "string") {
-      error(
-        "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
-        getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
-      );
-    }
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
   }
 
-  var crossOrigin =
-    options == null || typeof options.crossOrigin !== "string"
-      ? null
-      : options.crossOrigin === "use-credentials"
-      ? "use-credentials"
-      : "";
-  preconnectAs("preconnect", crossOrigin, href);
-} // --------------------------------------
-//      ReactDOM.preload
-// --------------------------------------
+  if (baseQueue !== null) {
+    // We have a queue to process.
+    var first = baseQueue.next;
+    var newState = current.baseState;
+    var newBaseState = null;
+    var newBaseQueueFirst = null;
+    var newBaseQueueLast = null;
+    var update = first;
 
-function preload$1(href, options) {
-  {
-    validatePreloadArguments(href, options);
-  }
+    do {
+      // An extra OffscreenLane bit is added to updates that were made to
+      // a hidden tree, so that we can distinguish them from updates that were
+      // already there when the tree was hidden.
+      var updateLane = removeLanes(update.lane, OffscreenLane);
+      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
+      // it's not a "base" update and we should disregard the extra base lanes
+      // that were added to renderLanes when we entered the Offscreen tree.
 
-  var ownerDocument = getDocumentForPreloads();
+      var shouldSkipUpdate = isHiddenUpdate
+        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
+        : !isSubsetOfLanes(renderLanes$1, updateLane);
 
-  if (
-    typeof href === "string" &&
-    href &&
-    typeof options === "object" &&
-    options !== null &&
-    ownerDocument
-  ) {
-    var as = options.as;
-    var limitedEscapedHref =
-      escapeSelectorAttributeValueInsideDoubleQuotes(href);
-    var preloadKey =
-      'link[rel="preload"][as="' + as + '"][href="' + limitedEscapedHref + '"]';
-    var key = preloadKey;
+      if (shouldSkipUpdate) {
+        // Priority is insufficient. Skip this update. If this is the first
+        // skipped update, the previous update/state is the new base
+        // update/state.
+        var clone = {
+          lane: updateLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
 
-    switch (as) {
-      case "style":
-        key = getStyleKey(href);
-        break;
+        if (newBaseQueueLast === null) {
+          newBaseQueueFirst = newBaseQueueLast = clone;
+          newBaseState = newState;
+        } else {
+          newBaseQueueLast = newBaseQueueLast.next = clone;
+        } // Update the remaining priority in the queue.
+        // TODO: Don't need to accumulate this. Instead, we can remove
+        // renderLanes from the original lanes.
 
-      case "script":
-        key = getScriptKey(href);
-        break;
-    }
+        currentlyRenderingFiber$1.lanes = mergeLanes(
+          currentlyRenderingFiber$1.lanes,
+          updateLane
+        );
+        markSkippedUpdateLanes(updateLane);
+      } else {
+        // This update does have sufficient priority.
+        if (newBaseQueueLast !== null) {
+          var _clone = {
+            // This update is going to be committed so we never want uncommit
+            // it. Using NoLane works because 0 is a subset of all bitmasks, so
+            // this will never be skipped by the check above.
+            lane: NoLane,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          };
+          newBaseQueueLast = newBaseQueueLast.next = _clone;
+        } // Process this update.
 
-    if (!preloadPropsMap.has(key)) {
-      var preloadProps = preloadPropsFromPreloadOptions(href, as, options);
-      preloadPropsMap.set(key, preloadProps);
+        var action = update.action;
 
-      if (null === ownerDocument.querySelector(preloadKey)) {
-        var preloadInstance = ownerDocument.createElement("link");
-        setInitialProperties(preloadInstance, "link", preloadProps);
-        markNodeAsHoistable(preloadInstance);
-        ownerDocument.head.appendChild(preloadInstance);
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          reducer(newState, action);
+        }
+
+        if (update.hasEagerState) {
+          // If this update is a state update (not a reducer) and was processed eagerly,
+          // we can use the eagerly computed state
+          newState = update.eagerState;
+        } else {
+          newState = reducer(newState, action);
+        }
       }
+
+      update = update.next;
+    } while (update !== null && update !== first);
+
+    if (newBaseQueueLast === null) {
+      newBaseState = newState;
+    } else {
+      newBaseQueueLast.next = newBaseQueueFirst;
+    } // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
+
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
     }
-  }
-}
 
-function preloadPropsFromPreloadOptions(href, as, options) {
-  return {
-    href: href,
-    rel: "preload",
-    as: as,
-    crossOrigin: as === "font" ? "" : options.crossOrigin,
-    integrity: options.integrity,
-    type: options.type
-  };
-} // --------------------------------------
-//      ReactDOM.preinit
-// --------------------------------------
+    hook.memoizedState = newState;
+    hook.baseState = newBaseState;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = newState;
+  }
 
-function preinit$1(href, options) {
-  {
-    validatePreinitArguments(href, options);
+  if (baseQueue === null) {
+    // `queue.lanes` is used for entangling transitions. We can set it back to
+    // zero once the queue is empty.
+    queue.lanes = NoLanes;
   }
 
-  if (
-    typeof href === "string" &&
-    href &&
-    typeof options === "object" &&
-    options !== null
-  ) {
-    var resourceRoot = getCurrentResourceRoot();
-    var as = options.as;
+  var dispatch = queue.dispatch;
+  return [hook.memoizedState, dispatch];
+}
 
-    if (!resourceRoot) {
-      if (as === "style" || as === "script") {
-        // We are going to emit a preload as a best effort fallback since this preinit
-        // was called outside of a render. Given the passive nature of this fallback
-        // we do not warn in dev when props disagree if there happens to already be a
-        // matching preload with this href
-        var preloadDocument = getDocumentForPreloads();
+function rerenderReducer(reducer, initialArg, init) {
+  var hook = updateWorkInProgressHook();
+  var queue = hook.queue;
 
-        if (preloadDocument) {
-          var limitedEscapedHref =
-            escapeSelectorAttributeValueInsideDoubleQuotes(href);
-          var preloadKey =
-            'link[rel="preload"][as="' +
-            as +
-            '"][href="' +
-            limitedEscapedHref +
-            '"]';
-          var key = preloadKey;
+  if (queue === null) {
+    throw new Error(
+      "Should have a queue. This is likely a bug in React. Please file an issue."
+    );
+  }
 
-          switch (as) {
-            case "style":
-              key = getStyleKey(href);
-              break;
+  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
+  // work-in-progress hook.
 
-            case "script":
-              key = getScriptKey(href);
-              break;
-          }
+  var dispatch = queue.dispatch;
+  var lastRenderPhaseUpdate = queue.pending;
+  var newState = hook.memoizedState;
 
-          if (!preloadPropsMap.has(key)) {
-            var preloadProps = preloadPropsFromPreinitOptions(
-              href,
-              as,
-              options
-            );
-            preloadPropsMap.set(key, preloadProps);
+  if (lastRenderPhaseUpdate !== null) {
+    // The queue doesn't persist past this render pass.
+    queue.pending = null;
+    var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+    var update = firstRenderPhaseUpdate;
 
-            if (null === preloadDocument.querySelector(preloadKey)) {
-              var preloadInstance = preloadDocument.createElement("link");
-              setInitialProperties(preloadInstance, "link", preloadProps);
-              markNodeAsHoistable(preloadInstance);
-              preloadDocument.head.appendChild(preloadInstance);
-            }
-          }
-        }
-      }
+    do {
+      // Process this render phase update. We don't have to check the
+      // priority because it will always be the same as the current
+      // render's.
+      var action = update.action;
+      newState = reducer(newState, action);
+      update = update.next;
+    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
+    // different from the current state.
 
-      return;
+    if (!objectIs(newState, hook.memoizedState)) {
+      markWorkInProgressReceivedUpdate();
     }
 
-    switch (as) {
-      case "style": {
-        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
-
-        var _key = getStyleKey(href);
-
-        var precedence = options.precedence || "default"; // Check if this resource already exists
-
-        var resource = styles.get(_key);
-
-        if (resource) {
-          // We can early return. The resource exists and there is nothing
-          // more to do
-          return;
-        } // Attempt to hydrate instance from DOM
+    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
+    // the base state unless the queue is empty.
+    // TODO: Not sure if this is the desired semantics, but it's what we
+    // do for gDSFP. I can't remember why.
 
-        var instance = resourceRoot.querySelector(
-          getStylesheetSelectorFromKey(_key)
-        );
+    if (hook.baseQueue === null) {
+      hook.baseState = newState;
+    }
 
-        if (!instance) {
-          // Construct a new instance and insert it
-          var stylesheetProps = stylesheetPropsFromPreinitOptions(
-            href,
-            precedence,
-            options
-          );
+    queue.lastRenderedState = newState;
+  }
 
-          var _preloadProps = preloadPropsMap.get(_key);
+  return [newState, dispatch];
+}
 
-          if (_preloadProps) {
-            adoptPreloadPropsForStylesheet(stylesheetProps, _preloadProps);
-          }
+function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+  {
+    warnAboutMultipleRenderersDEV(source);
+  }
 
-          var ownerDocument = getDocumentFromRoot(resourceRoot);
-          instance = ownerDocument.createElement("link");
-          markNodeAsHoistable(instance);
-          setInitialProperties(instance, "link", stylesheetProps);
-          insertStylesheet(instance, precedence, resourceRoot);
-        } // Construct a Resource and cache it
+  var getVersion = source._getVersion;
+  var version = getVersion(source._source); // Is it safe for this component to read from this source during the current render?
 
-        resource = {
-          type: "stylesheet",
-          instance: instance,
-          count: 1
-        };
-        styles.set(_key, resource);
-        return;
-      }
+  var isSafeToReadFromSource = false; // Check the version first.
+  // If this render has already been started with a specific version,
+  // we can use it alone to determine if we can safely read from the source.
 
-      case "script": {
-        var src = href;
-        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+  var currentRenderVersion = getWorkInProgressVersion(source);
 
-        var _key2 = getScriptKey(src); // Check if this resource already exists
+  if (currentRenderVersion !== null) {
+    // It's safe to read if the store hasn't been mutated since the last time
+    // we read something.
+    isSafeToReadFromSource = currentRenderVersion === version;
+  } else {
+    // If there's no version, then this is the first time we've read from the
+    // source during the current render pass, so we need to do a bit more work.
+    // What we need to determine is if there are any hooks that already
+    // subscribed to the source, and if so, whether there are any pending
+    // mutations that haven't been synchronized yet.
+    //
+    // If there are no pending mutations, then `root.mutableReadLanes` will be
+    // empty, and we know we can safely read.
+    //
+    // If there *are* pending mutations, we may still be able to safely read
+    // if the currently rendering lanes are inclusive of the pending mutation
+    // lanes, since that guarantees that the value we're about to read from
+    // the source is consistent with the values that we read during the most
+    // recent mutation.
+    isSafeToReadFromSource = isSubsetOfLanes(
+      renderLanes$1,
+      root.mutableReadLanes
+    );
 
-        var _resource = scripts.get(_key2);
+    if (isSafeToReadFromSource) {
+      // If it's safe to read from this source during the current render,
+      // store the version in case other components read from it.
+      // A changed version number will let those components know to throw and restart the render.
+      setWorkInProgressVersion(source, version);
+    }
+  }
 
-        if (_resource) {
-          // We can early return. The resource exists and there is nothing
-          // more to do
-          return;
-        } // Attempt to hydrate instance from DOM
+  if (isSafeToReadFromSource) {
+    var snapshot = getSnapshot(source._source);
 
-        var _instance = resourceRoot.querySelector(
-          getScriptSelectorFromKey(_key2)
+    {
+      if (typeof snapshot === "function") {
+        error(
+          "Mutable source should not return a function as the snapshot value. " +
+            "Functions may close over mutable values and cause tearing."
         );
-
-        if (!_instance) {
-          // Construct a new instance and insert it
-          var scriptProps = scriptPropsFromPreinitOptions(src, options); // Adopt certain preload props
-
-          var _preloadProps2 = preloadPropsMap.get(_key2);
-
-          if (_preloadProps2) {
-            adoptPreloadPropsForScript(scriptProps, _preloadProps2);
-          }
-
-          var _ownerDocument = getDocumentFromRoot(resourceRoot);
-
-          _instance = _ownerDocument.createElement("script");
-          markNodeAsHoistable(_instance);
-          setInitialProperties(_instance, "link", scriptProps);
-
-          _ownerDocument.head.appendChild(_instance);
-        } // Construct a Resource and cache it
-
-        _resource = {
-          type: "script",
-          instance: _instance,
-          count: 1
-        };
-        scripts.set(_key2, _resource);
-        return;
       }
     }
-  }
-}
 
-function preloadPropsFromPreinitOptions(href, as, options) {
-  return {
-    href: href,
-    rel: "preload",
-    as: as,
-    crossOrigin: as === "font" ? "" : options.crossOrigin,
-    integrity: options.integrity
-  };
-}
+    return snapshot;
+  } else {
+    // This handles the special case of a mutable source being shared between renderers.
+    // In that case, if the source is mutated between the first and second renderer,
+    // The second renderer don't know that it needs to reset the WIP version during unwind,
+    // (because the hook only marks sources as dirty if it's written to their WIP version).
+    // That would cause this tear check to throw again and eventually be visible to the user.
+    // We can avoid this infinite loop by explicitly marking the source as dirty.
+    //
+    // This can lead to tearing in the first renderer when it resumes,
+    // but there's nothing we can do about that (short of throwing here and refusing to continue the render).
+    markSourceAsDirty(source); // Intentioally throw an error to force React to retry synchronously. During
+    // the synchronous retry, it will block interleaved mutations, so we should
+    // get a consistent read. Therefore, the following error should never be
+    // visible to the user.
+    // We expect this error not to be thrown during the synchronous retry,
+    // because we blocked interleaved mutations.
 
-function stylesheetPropsFromPreinitOptions(href, precedence, options) {
-  return {
-    rel: "stylesheet",
-    href: href,
-    "data-precedence": precedence,
-    crossOrigin: options.crossOrigin
-  };
+    throw new Error(
+      "Cannot read from mutable source during the current render without tearing. This may be a bug in React. Please file an issue."
+    );
+  }
 }
 
-function scriptPropsFromPreinitOptions(src, options) {
-  return {
-    src: src,
-    async: true,
-    crossOrigin: options.crossOrigin,
-    integrity: options.integrity
-  };
-} // --------------------------------------
-//      Resources from render
-// --------------------------------------
-// This function is called in begin work and we should always have a currentDocument set
-
-function getResource(type, currentProps, pendingProps) {
-  var resourceRoot = getCurrentResourceRoot();
+function useMutableSource(hook, source, getSnapshot, subscribe) {
+  var root = getWorkInProgressRoot();
 
-  if (!resourceRoot) {
+  if (root === null) {
     throw new Error(
-      '"resourceRoot" was expected to exist. This is a bug in React.'
+      "Expected a work-in-progress root. This is a bug in React. Please file an issue."
     );
   }
 
-  switch (type) {
-    case "meta":
-    case "title": {
-      return null;
-    }
-
-    case "style": {
-      if (
-        typeof pendingProps.precedence === "string" &&
-        typeof pendingProps.href === "string"
-      ) {
-        var key = getStyleKey(pendingProps.href);
-        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
-        var resource = styles.get(key);
-
-        if (!resource) {
-          resource = {
-            type: "style",
-            instance: null,
-            count: 0
-          };
-          styles.set(key, resource);
-        }
-
-        return resource;
-      }
+  var getVersion = source._getVersion;
+  var version = getVersion(source._source);
+  var dispatcher = ReactCurrentDispatcher$1.current; // eslint-disable-next-line prefer-const
 
-      return {
-        type: "void",
-        instance: null,
-        count: 0
-      };
-    }
+  var _dispatcher$useState = dispatcher.useState(function () {
+      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    }),
+    currentSnapshot = _dispatcher$useState[0],
+    setSnapshot = _dispatcher$useState[1];
 
-    case "link": {
-      if (
-        pendingProps.rel === "stylesheet" &&
-        typeof pendingProps.href === "string" &&
-        typeof pendingProps.precedence === "string"
-      ) {
-        var qualifiedProps = pendingProps;
+  var snapshot = currentSnapshot; // Grab a handle to the state hook as well.
+  // We use it to clear the pending update queue if we have a new source.
 
-        var _key3 = getStyleKey(qualifiedProps.href);
+  var stateHook = workInProgressHook;
+  var memoizedState = hook.memoizedState;
+  var refs = memoizedState.refs;
+  var prevGetSnapshot = refs.getSnapshot;
+  var prevSource = memoizedState.source;
+  var prevSubscribe = memoizedState.subscribe;
+  var fiber = currentlyRenderingFiber$1;
+  hook.memoizedState = {
+    refs: refs,
+    source: source,
+    subscribe: subscribe
+  }; // Sync the values needed by our subscription handler after each commit.
 
-        var _styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+  dispatcher.useEffect(
+    function () {
+      refs.getSnapshot = getSnapshot; // Normally the dispatch function for a state hook never changes,
+      // but this hook recreates the queue in certain cases  to avoid updates from stale sources.
+      // handleChange() below needs to reference the dispatch function without re-subscribing,
+      // so we use a ref to ensure that it always has the latest version.
 
-        var _resource2 = _styles.get(_key3);
+      refs.setSnapshot = setSnapshot; // Check for a possible change between when we last rendered now.
 
-        if (!_resource2) {
-          // We asserted this above but Flow can't figure out that the type satisfies
-          var ownerDocument = getDocumentFromRoot(resourceRoot);
-          _resource2 = {
-            type: "stylesheet",
-            instance: null,
-            count: 0
-          };
+      var maybeNewVersion = getVersion(source._source);
 
-          _styles.set(_key3, _resource2);
+      if (!objectIs(version, maybeNewVersion)) {
+        var maybeNewSnapshot = getSnapshot(source._source);
 
-          if (!preloadPropsMap.has(_key3)) {
-            preloadStylesheet(
-              ownerDocument,
-              _key3,
-              preloadPropsFromStylesheet(qualifiedProps)
+        {
+          if (typeof maybeNewSnapshot === "function") {
+            error(
+              "Mutable source should not return a function as the snapshot value. " +
+                "Functions may close over mutable values and cause tearing."
             );
           }
         }
 
-        return _resource2;
-      }
+        if (!objectIs(snapshot, maybeNewSnapshot)) {
+          setSnapshot(maybeNewSnapshot);
+          var lane = requestUpdateLane(fiber);
+          markRootMutableRead(root, lane);
+        } // If the source mutated between render and now,
+        // there may be state updates already scheduled from the old source.
+        // Entangle the updates so that they render in the same batch.
 
-      return null;
-    }
+        markRootEntangled(root, root.mutableReadLanes);
+      }
+    },
+    [getSnapshot, source, subscribe]
+  ); // If we got a new source or subscribe function, re-subscribe in a passive effect.
 
-    case "script": {
-      if (typeof pendingProps.src === "string" && pendingProps.async === true) {
-        var scriptProps = pendingProps;
+  dispatcher.useEffect(
+    function () {
+      var handleChange = function () {
+        var latestGetSnapshot = refs.getSnapshot;
+        var latestSetSnapshot = refs.setSnapshot;
 
-        var _key4 = getScriptKey(scriptProps.src);
+        try {
+          latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
 
-        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+          var lane = requestUpdateLane(fiber);
+          markRootMutableRead(root, lane);
+        } catch (error) {
+          // A selector might throw after a source mutation.
+          // e.g. it might try to read from a part of the store that no longer exists.
+          // In this case we should still schedule an update with React.
+          // Worst case the selector will throw again and then an error boundary will handle it.
+          latestSetSnapshot(function () {
+            throw error;
+          });
+        }
+      };
 
-        var _resource3 = scripts.get(_key4);
+      var unsubscribe = subscribe(source._source, handleChange);
 
-        if (!_resource3) {
-          _resource3 = {
-            type: "script",
-            instance: null,
-            count: 0
-          };
-          scripts.set(_key4, _resource3);
+      {
+        if (typeof unsubscribe !== "function") {
+          error(
+            "Mutable source subscribe function must return an unsubscribe function."
+          );
         }
-
-        return _resource3;
       }
 
-      return {
-        type: "void",
-        instance: null,
-        count: 0
-      };
-    }
+      return unsubscribe;
+    },
+    [source, subscribe]
+  ); // If any of the inputs to useMutableSource change, reading is potentially unsafe.
+  //
+  // If either the source or the subscription have changed we can't can't trust the update queue.
+  // Maybe the source changed in a way that the old subscription ignored but the new one depends on.
+  //
+  // If the getSnapshot function changed, we also shouldn't rely on the update queue.
+  // It's possible that the underlying source was mutated between the when the last "change" event fired,
+  // and when the current render (with the new getSnapshot function) is processed.
+  //
+  // In both cases, we need to throw away pending updates (since they are no longer relevant)
+  // and treat reading from the source as we do in the mount case.
 
-    default: {
-      throw new Error(
-        'getResource encountered a type it did not expect: "' +
-          type +
-          '". this is a bug in React.'
-      );
-    }
+  if (
+    !objectIs(prevGetSnapshot, getSnapshot) ||
+    !objectIs(prevSource, source) ||
+    !objectIs(prevSubscribe, subscribe)
+  ) {
+    // Create a new queue and setState method,
+    // So if there are interleaved updates, they get pushed to the older queue.
+    // When this becomes current, the previous queue and dispatch method will be discarded,
+    // including any interleaving updates that occur.
+    var newQueue = {
+      pending: null,
+      lanes: NoLanes,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: snapshot
+    };
+    newQueue.dispatch = setSnapshot = dispatchSetState.bind(
+      null,
+      currentlyRenderingFiber$1,
+      newQueue
+    );
+    stateHook.queue = newQueue;
+    stateHook.baseQueue = null;
+    snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    stateHook.memoizedState = stateHook.baseState = snapshot;
   }
-}
 
-function styleTagPropsFromRawProps(rawProps) {
-  return assign({}, rawProps, {
-    "data-href": rawProps.href,
-    "data-precedence": rawProps.precedence,
-    href: null,
-    precedence: null
-  });
+  return snapshot;
 }
 
-function getStyleKey(href) {
-  var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
-  return 'href~="' + limitedEscapedHref + '"';
+function mountMutableSource(source, getSnapshot, subscribe) {
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = {
+    refs: {
+      getSnapshot: getSnapshot,
+      setSnapshot: null
+    },
+    source: source,
+    subscribe: subscribe
+  };
+  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
 
-function getStyleTagSelectorFromKey(key) {
-  return "style[data-" + key + "]";
+function updateMutableSource(source, getSnapshot, subscribe) {
+  var hook = updateWorkInProgressHook();
+  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
 
-function getStylesheetSelectorFromKey(key) {
-  return 'link[rel="stylesheet"][' + key + "]";
-}
-
-function getPreloadStylesheetSelectorFromKey(key) {
-  return 'link[rel="preload"][as="style"][' + key + "]";
-}
-
-function stylesheetPropsFromRawProps(rawProps) {
-  return assign({}, rawProps, {
-    "data-precedence": rawProps.precedence,
-    precedence: null
-  });
-}
-
-function preloadStylesheet(ownerDocument, key, preloadProps) {
-  preloadPropsMap.set(key, preloadProps);
+function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  var fiber = currentlyRenderingFiber$1;
+  var hook = mountWorkInProgressHook();
+  var nextSnapshot;
+  var isHydrating = getIsHydrating();
 
-  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
-    // There is no matching stylesheet instance in the Document.
-    // We will insert a preload now to kick off loading because
-    // we expect this stylesheet to commit
-    if (
-      null ===
-      ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key))
-    ) {
-      var preloadInstance = ownerDocument.createElement("link");
-      setInitialProperties(preloadInstance, "link", preloadProps);
-      markNodeAsHoistable(preloadInstance);
-      ownerDocument.head.appendChild(preloadInstance);
+  if (isHydrating) {
+    if (getServerSnapshot === undefined) {
+      throw new Error(
+        "Missing getServerSnapshot, which is required for " +
+          "server-rendered content. Will revert to client rendering."
+      );
     }
-  }
-}
-
-function preloadPropsFromStylesheet(props) {
-  return {
-    rel: "preload",
-    as: "style",
-    href: props.href,
-    crossOrigin: props.crossOrigin,
-    integrity: props.integrity,
-    media: props.media,
-    hrefLang: props.hrefLang,
-    referrerPolicy: props.referrerPolicy
-  };
-}
 
-function getScriptKey(src) {
-  var limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
-  return '[src="' + limitedEscapedSrc + '"]';
-}
+    nextSnapshot = getServerSnapshot();
 
-function getScriptSelectorFromKey(key) {
-  return "script[async]" + key;
-} // --------------------------------------
-//      Hoistable Resource Reconciliation
-// --------------------------------------
+    {
+      if (!didWarnUncachedGetSnapshot) {
+        if (nextSnapshot !== getServerSnapshot()) {
+          error(
+            "The result of getServerSnapshot should be cached to avoid an infinite loop"
+          );
 
-function acquireResource(hoistableRoot, resource, props) {
-  resource.count++;
+          didWarnUncachedGetSnapshot = true;
+        }
+      }
+    }
+  } else {
+    nextSnapshot = getSnapshot();
 
-  if (resource.instance === null) {
-    switch (resource.type) {
-      case "style": {
-        var qualifiedProps = props;
-        var key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
+    {
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedSnapshot = getSnapshot();
 
-        var instance = hoistableRoot.querySelector(
-          getStyleTagSelectorFromKey(key)
-        );
+        if (!objectIs(nextSnapshot, cachedSnapshot)) {
+          error(
+            "The result of getSnapshot should be cached to avoid an infinite loop"
+          );
 
-        if (instance) {
-          resource.instance = instance;
-          markNodeAsHoistable(instance);
-          return instance;
+          didWarnUncachedGetSnapshot = true;
         }
-
-        var styleProps = styleTagPropsFromRawProps(props);
-        var ownerDocument = getDocumentFromRoot(hoistableRoot);
-        instance = ownerDocument.createElement("style");
-        markNodeAsHoistable(instance);
-        setInitialProperties(instance, "style", styleProps);
-        insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
-        resource.instance = instance;
-        return instance;
       }
+    } // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
+    //
+    // We won't do this if we're hydrating server-rendered content, because if
+    // the content is stale, it's already visible anyway. Instead we'll patch
+    // it up in a passive effect.
 
-      case "stylesheet": {
-        // This typing is enforce by `getResource`. If we change the logic
-        // there for what qualifies as a stylesheet resource we need to ensure
-        // this cast still makes sense;
-        var _qualifiedProps = props;
-
-        var _key5 = getStyleKey(_qualifiedProps.href); // Attempt to hydrate instance from DOM
+    var root = getWorkInProgressRoot();
 
-        var _instance2 = hoistableRoot.querySelector(
-          getStylesheetSelectorFromKey(_key5)
-        );
+    if (root === null) {
+      throw new Error(
+        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+      );
+    }
 
-        if (_instance2) {
-          resource.instance = _instance2;
-          markNodeAsHoistable(_instance2);
-          return _instance2;
-        }
+    if (!includesBlockingLane(root, renderLanes$1)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+  } // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
 
-        var stylesheetProps = stylesheetPropsFromRawProps(props);
-        var preloadProps = preloadPropsMap.get(_key5);
+  hook.memoizedState = nextSnapshot;
+  var inst = {
+    value: nextSnapshot,
+    getSnapshot: getSnapshot
+  };
+  hook.queue = inst; // Schedule an effect to subscribe to the store.
 
-        if (preloadProps) {
-          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
-        } // Construct and insert a new instance
+  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
+  // this whenever subscribe, getSnapshot, or value changes. Because there's no
+  // clean-up function, and we track the deps correctly, we can call pushEffect
+  // directly, without storing any additional state. For the same reason, we
+  // don't need to set a static flag, either.
+  // TODO: We can move this to the passive phase once we add a pre-commit
+  // consistency check. See the next comment.
 
-        var _ownerDocument2 = getDocumentFromRoot(hoistableRoot);
+  fiber.flags |= Passive$1;
+  pushEffect(
+    HasEffect | Passive,
+    updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
+    undefined,
+    null
+  );
+  return nextSnapshot;
+}
 
-        _instance2 = _ownerDocument2.createElement("link");
-        markNodeAsHoistable(_instance2);
-        var linkInstance = _instance2;
-        linkInstance._p = new Promise(function (resolve, reject) {
-          linkInstance.onload = resolve;
-          linkInstance.onerror = reject;
-        }).then(
-          function () {
-            return (linkInstance._p.s = "l");
-          },
-          function () {
-            return (linkInstance._p.s = "e");
-          }
-        );
-        setInitialProperties(_instance2, "link", stylesheetProps);
-        insertStylesheet(_instance2, _qualifiedProps.precedence, hoistableRoot);
-        resource.instance = _instance2;
-        return _instance2;
-      }
+function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+  var fiber = currentlyRenderingFiber$1;
+  var hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
+  // normal rules of React, and only works because store updates are
+  // always synchronous.
 
-      case "script": {
-        // This typing is enforce by `getResource`. If we change the logic
-        // there for what qualifies as a stylesheet resource we need to ensure
-        // this cast still makes sense;
-        var borrowedScriptProps = props;
+  var nextSnapshot = getSnapshot();
 
-        var _key6 = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
+  {
+    if (!didWarnUncachedGetSnapshot) {
+      var cachedSnapshot = getSnapshot();
 
-        var _instance3 = hoistableRoot.querySelector(
-          getScriptSelectorFromKey(_key6)
+      if (!objectIs(nextSnapshot, cachedSnapshot)) {
+        error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
         );
 
-        if (_instance3) {
-          resource.instance = _instance3;
-          markNodeAsHoistable(_instance3);
-          return _instance3;
-        }
-
-        var scriptProps = borrowedScriptProps;
-
-        var _preloadProps3 = preloadPropsMap.get(_key6);
+        didWarnUncachedGetSnapshot = true;
+      }
+    }
+  }
 
-        if (_preloadProps3) {
-          scriptProps = assign({}, borrowedScriptProps);
-          adoptPreloadPropsForScript(scriptProps, _preloadProps3);
-        } // Construct and insert a new instance
+  var prevSnapshot = (currentHook || hook).memoizedState;
+  var snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
 
-        var _ownerDocument3 = getDocumentFromRoot(hoistableRoot);
+  if (snapshotChanged) {
+    hook.memoizedState = nextSnapshot;
+    markWorkInProgressReceivedUpdate();
+  }
 
-        _instance3 = _ownerDocument3.createElement("script");
-        markNodeAsHoistable(_instance3);
-        setInitialProperties(_instance3, "link", scriptProps);
+  var inst = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [
+    subscribe
+  ]); // Whenever getSnapshot or subscribe changes, we need to check in the
+  // commit phase if there was an interleaved mutation. In concurrent mode
+  // this can happen all the time, but even in synchronous mode, an earlier
+  // effect may have mutated the store.
 
-        _ownerDocument3.head.appendChild(_instance3);
+  if (
+    inst.getSnapshot !== getSnapshot ||
+    snapshotChanged || // Check if the susbcribe function changed. We can save some memory by
+    // checking whether we scheduled a subscription effect above.
+    (workInProgressHook !== null &&
+      workInProgressHook.memoizedState.tag & HasEffect)
+  ) {
+    fiber.flags |= Passive$1;
+    pushEffect(
+      HasEffect | Passive,
+      updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
+      undefined,
+      null
+    ); // Unless we're rendering a blocking lane, schedule a consistency check.
+    // Right before committing, we will walk the tree and check if any of the
+    // stores were mutated.
 
-        resource.instance = _instance3;
-        return _instance3;
-      }
+    var root = getWorkInProgressRoot();
 
-      case "void": {
-        return null;
-      }
+    if (root === null) {
+      throw new Error(
+        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+      );
+    }
 
-      default: {
-        throw new Error(
-          'acquireResource encountered a resource type it did not expect: "' +
-            resource.type +
-            '". this is a bug in React.'
-        );
-      }
+    if (!includesBlockingLane(root, renderLanes$1)) {
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
     }
   }
 
-  return resource.instance;
-}
-function releaseResource(resource) {
-  resource.count--;
+  return nextSnapshot;
 }
 
-function insertStylesheet(instance, precedence, root) {
-  var nodes = root.querySelectorAll(
-    'link[rel="stylesheet"][data-precedence],style[data-precedence]'
-  );
-  var last = nodes.length ? nodes[nodes.length - 1] : null;
-  var prior = last;
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= StoreConsistency;
+  var check = {
+    getSnapshot: getSnapshot,
+    value: renderedSnapshot
+  };
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
-    var nodePrecedence = node.dataset.precedence;
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.stores = [check];
+  } else {
+    var stores = componentUpdateQueue.stores;
 
-    if (nodePrecedence === precedence) {
-      prior = node;
-    } else if (prior !== last) {
-      break;
+    if (stores === null) {
+      componentUpdateQueue.stores = [check];
+    } else {
+      stores.push(check);
     }
   }
+}
 
-  if (prior) {
-    // We get the prior from the document so we know it is in the tree.
-    // We also know that links can't be the topmost Node so the parentNode
-    // must exist.
-    prior.parentNode.insertBefore(instance, prior.nextSibling);
-  } else {
-    var parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
-    parent.insertBefore(instance, parent.firstChild);
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  // These are updated in the passive phase
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
+  // have been in an event that fired before the passive effects, or it could
+  // have been in a layout effect. In that case, we would have used the old
+  // snapsho and getSnapshot values to bail out. We need to check one more time.
+
+  if (checkIfSnapshotChanged(inst)) {
+    // Force a re-render.
+    forceStoreRerender(fiber);
   }
 }
 
-function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
-  if (stylesheetProps.crossOrigin == null)
-    stylesheetProps.crossOrigin = preloadProps.crossOrigin;
-  if (stylesheetProps.referrerPolicy == null)
-    stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
-  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+function subscribeToStore(fiber, inst, subscribe) {
+  var handleStoreChange = function () {
+    // The store changed. Check if the snapshot changed since the last time we
+    // read from the store.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceStoreRerender(fiber);
+    }
+  }; // Subscribe to the store and return a clean-up function.
+
+  return subscribe(handleStoreChange);
 }
 
-function adoptPreloadPropsForScript(scriptProps, preloadProps) {
-  if (scriptProps.crossOrigin == null)
-    scriptProps.crossOrigin = preloadProps.crossOrigin;
-  if (scriptProps.referrerPolicy == null)
-    scriptProps.referrerPolicy = preloadProps.referrerPolicy;
-  if (scriptProps.integrity == null)
-    scriptProps.referrerPolicy = preloadProps.integrity;
-} // --------------------------------------
-//      Hoistable Element Reconciliation
-// --------------------------------------
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  var prevValue = inst.value;
 
-var tagCaches = null;
-function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
-  var ownerDocument = getDocumentFromRoot(hoistableRoot);
-  var instance = null;
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
 
-  getInstance: switch (type) {
-    case "title": {
-      instance = ownerDocument.getElementsByTagName("title")[0];
+function forceStoreRerender(fiber) {
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-      if (
-        !instance ||
-        isOwnedInstance(instance) ||
-        instance.namespaceURI === SVG_NAMESPACE ||
-        instance.hasAttribute("itemprop")
-      ) {
-        instance = ownerDocument.createElement(type);
-        ownerDocument.head.insertBefore(
-          instance,
-          ownerDocument.querySelector("head > title")
-        );
-      }
+  if (root !== null) {
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
+}
 
-      setInitialProperties(instance, type, props);
-      precacheFiberNode(internalInstanceHandle, instance);
-      markNodeAsHoistable(instance);
-      return instance;
-    }
+function mountState(initialState) {
+  var hook = mountWorkInProgressHook();
 
-    case "link": {
-      var cache = getHydratableHoistableCache("link", "href", ownerDocument);
-      var key = type + (props.href || "");
-      var maybeNodes = cache.get(key);
+  if (typeof initialState === "function") {
+    // $FlowFixMe: Flow doesn't like mixed types
+    initialState = initialState();
+  }
 
-      if (maybeNodes) {
-        var nodes = maybeNodes;
+  hook.memoizedState = hook.baseState = initialState;
+  var queue = {
+    pending: null,
+    lanes: NoLanes,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
+  };
+  hook.queue = queue;
+  var dispatch = (queue.dispatch = dispatchSetState.bind(
+    null,
+    currentlyRenderingFiber$1,
+    queue
+  ));
+  return [hook.memoizedState, dispatch];
+}
 
-        for (var i = 0; i < nodes.length; i++) {
-          var node = nodes[i];
+function updateState(initialState) {
+  return updateReducer(basicStateReducer);
+}
 
-          if (
-            node.getAttribute("href") !==
-              (props.href == null ? null : props.href) ||
-            node.getAttribute("rel") !==
-              (props.rel == null ? null : props.rel) ||
-            node.getAttribute("title") !==
-              (props.title == null ? null : props.title) ||
-            node.getAttribute("crossorigin") !==
-              (props.crossOrigin == null ? null : props.crossOrigin)
-          ) {
-            // mismatch, try the next node;
-            continue;
-          }
+function rerenderState(initialState) {
+  return rerenderReducer(basicStateReducer);
+}
 
-          instance = node;
-          nodes.splice(i, 1);
-          break getInstance;
-        }
-      }
+function pushEffect(tag, create, destroy, deps) {
+  var effect = {
+    tag: tag,
+    create: create,
+    destroy: destroy,
+    deps: deps,
+    // Circular
+    next: null
+  };
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-      instance = ownerDocument.createElement(type);
-      setInitialProperties(instance, type, props);
-      ownerDocument.head.appendChild(instance);
-      break;
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.lastEffect = effect.next = effect;
+  } else {
+    var lastEffect = componentUpdateQueue.lastEffect;
+
+    if (lastEffect === null) {
+      componentUpdateQueue.lastEffect = effect.next = effect;
+    } else {
+      var firstEffect = lastEffect.next;
+      lastEffect.next = effect;
+      effect.next = firstEffect;
+      componentUpdateQueue.lastEffect = effect;
     }
+  }
 
-    case "meta": {
-      var _cache = getHydratableHoistableCache(
-        "meta",
-        "content",
-        ownerDocument
-      );
+  return effect;
+}
 
-      var _key7 = type + (props.content || "");
+var stackContainsErrorMessage = null;
 
-      var _maybeNodes = _cache.get(_key7);
+function getCallerStackFrame() {
+  // eslint-disable-next-line react-internal/prod-error-codes
+  var stackFrames = new Error("Error message").stack.split("\n"); // Some browsers (e.g. Chrome) include the error message in the stack
+  // but others (e.g. Firefox) do not.
 
-      if (_maybeNodes) {
-        var _nodes = _maybeNodes;
+  if (stackContainsErrorMessage === null) {
+    stackContainsErrorMessage = stackFrames[0].includes("Error message");
+  }
 
-        for (var _i = 0; _i < _nodes.length; _i++) {
-          var _node = _nodes[_i]; // We coerce content to string because it is the most likely one to
-          // use a `toString` capable value. For the rest we just do identity match
-          // passing non-strings here is not really valid anyway.
+  return stackContainsErrorMessage
+    ? stackFrames.slice(3, 4).join("\n")
+    : stackFrames.slice(2, 3).join("\n");
+}
 
-          {
-            checkAttributeStringCoercion(props.content, "content");
-          }
-
-          if (
-            _node.getAttribute("content") !==
-              (props.content == null ? null : "" + props.content) ||
-            _node.getAttribute("name") !==
-              (props.name == null ? null : props.name) ||
-            _node.getAttribute("property") !==
-              (props.property == null ? null : props.property) ||
-            _node.getAttribute("http-equiv") !==
-              (props.httpEquiv == null ? null : props.httpEquiv) ||
-            _node.getAttribute("charset") !==
-              (props.charSet == null ? null : props.charSet)
-          ) {
-            // mismatch, try the next node;
-            continue;
-          }
-
-          instance = _node;
-
-          _nodes.splice(_i, 1);
-
-          break getInstance;
-        }
-      }
-
-      instance = ownerDocument.createElement(type);
-      setInitialProperties(instance, type, props);
-      ownerDocument.head.appendChild(instance);
-      break;
-    }
-
-    default:
-      throw new Error(
-        'getNodesForType encountered a type it did not expect: "' +
-          type +
-          '". This is a bug in React.'
-      );
-  } // This node is a match
-
-  precacheFiberNode(internalInstanceHandle, instance);
-  markNodeAsHoistable(instance);
-  return instance;
-}
-
-function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
-  var cache;
-  var caches;
+function mountRef(initialValue) {
+  var hook = mountWorkInProgressHook();
 
-  if (tagCaches === null) {
-    cache = new Map();
-    caches = tagCaches = new Map();
-    caches.set(ownerDocument, cache);
-  } else {
-    caches = tagCaches;
-    var maybeCache = caches.get(ownerDocument);
+  if (enableUseRefAccessWarning) {
+    {
+      // Support lazy initialization pattern shown in docs.
+      // We need to store the caller stack frame so that we don't warn on subsequent renders.
+      var hasBeenInitialized = initialValue != null;
+      var lazyInitGetterStack = null;
+      var didCheckForLazyInit = false; // Only warn once per component+hook.
 
-    if (!maybeCache) {
-      cache = new Map();
-      caches.set(ownerDocument, cache);
-    } else {
-      cache = maybeCache;
-    }
-  }
+      var didWarnAboutRead = false;
+      var didWarnAboutWrite = false;
+      var current = initialValue;
+      var ref = {
+        get current() {
+          if (!hasBeenInitialized) {
+            didCheckForLazyInit = true;
+            lazyInitGetterStack = getCallerStackFrame();
+          } else if (currentlyRenderingFiber$1 !== null && !didWarnAboutRead) {
+            if (
+              lazyInitGetterStack === null ||
+              lazyInitGetterStack !== getCallerStackFrame()
+            ) {
+              didWarnAboutRead = true;
 
-  if (cache.has(type)) {
-    // We use type as a special key that signals that this cache has been seeded for this type
-    return cache;
-  } // Mark this cache as seeded for this type
+              warn(
+                "%s: Unsafe read of a mutable value during render.\n\n" +
+                  "Reading from a ref during render is only safe if:\n" +
+                  "1. The ref value has not been updated, or\n" +
+                  "2. The ref holds a lazily-initialized value that is only set once.\n",
+                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
+                  "Unknown"
+              );
+            }
+          }
 
-  cache.set(type, null);
-  var nodes = ownerDocument.getElementsByTagName(type);
+          return current;
+        },
 
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
+        set current(value) {
+          if (currentlyRenderingFiber$1 !== null && !didWarnAboutWrite) {
+            if (hasBeenInitialized || !didCheckForLazyInit) {
+              didWarnAboutWrite = true;
 
-    if (
-      !isOwnedInstance(node) &&
-      (type !== "link" || node.getAttribute("rel") !== "stylesheet") &&
-      node.namespaceURI !== SVG_NAMESPACE
-    ) {
-      var nodeKey = node.getAttribute(keyAttribute) || "";
-      var key = type + nodeKey;
-      var existing = cache.get(key);
+              warn(
+                "%s: Unsafe write of a mutable value during render.\n\n" +
+                  "Writing to a ref during render is only safe if the ref holds " +
+                  "a lazily-initialized value that is only set once.\n",
+                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
+                  "Unknown"
+              );
+            }
+          }
 
-      if (existing) {
-        existing.push(node);
-      } else {
-        cache.set(key, [node]);
-      }
+          hasBeenInitialized = true;
+          current = value;
+        }
+      };
+      Object.seal(ref);
+      hook.memoizedState = ref;
+      return ref;
     }
+  } else {
+    var _ref2 = {
+      current: initialValue
+    };
+    hook.memoizedState = _ref2;
+    return _ref2;
   }
-
-  return cache;
 }
 
-function mountHoistable(hoistableRoot, type, instance) {
-  var ownerDocument = getDocumentFromRoot(hoistableRoot);
-  ownerDocument.head.insertBefore(
-    instance,
-    type === "title" ? ownerDocument.querySelector("head > title") : null
-  );
+function updateRef(initialValue) {
+  var hook = updateWorkInProgressHook();
+  return hook.memoizedState;
 }
-function unmountHoistable(instance) {
-  instance.parentNode.removeChild(instance);
-} // When passing user input into querySelector(All) the embedded string must not alter
-// the semantics of the query. This escape function is safe to use when we know the
-// provided value is going to be wrapped in double quotes as part of an attribute selector
-// Do not use it anywhere else
-// we escape double quotes and backslashes
 
-var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
-
-function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
-  return value.replace(
-    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
-    function (ch) {
-      return "\\" + ch.charCodeAt(0).toString(16);
-    }
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    HasEffect | hookFlags,
+    create,
+    undefined,
+    nextDeps
   );
 }
 
-var SUPPRESS_HYDRATION_WARNING = "suppressHydrationWarning";
-var SUSPENSE_START_DATA = "$";
-var SUSPENSE_END_DATA = "/$";
-var SUSPENSE_PENDING_START_DATA = "$?";
-var SUSPENSE_FALLBACK_START_DATA = "$!";
-var STYLE = "style";
-var eventsEnabled = null;
-var selectionInformation = null;
-function getRootHostContext(rootContainerInstance) {
-  var type;
-  var namespace;
-  var nodeType = rootContainerInstance.nodeType;
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var destroy = undefined; // currentHook is null when rerendering after a render phase state update.
 
-  switch (nodeType) {
-    case DOCUMENT_NODE:
-    case DOCUMENT_FRAGMENT_NODE: {
-      type = nodeType === DOCUMENT_NODE ? "#document" : "#fragment";
-      var root = rootContainerInstance.documentElement;
-      namespace = root ? root.namespaceURI : getChildNamespace(null, "");
-      break;
-    }
+  if (currentHook !== null) {
+    var prevEffect = currentHook.memoizedState;
+    destroy = prevEffect.destroy;
 
-    default: {
-      var container =
-        nodeType === COMMENT_NODE
-          ? rootContainerInstance.parentNode
-          : rootContainerInstance;
-      var ownNamespace = container.namespaceURI || null;
-      type = container.tagName;
-      namespace = getChildNamespace(ownNamespace, type);
-      break;
+    if (nextDeps !== null) {
+      var prevDeps = prevEffect.deps;
+
+      if (areHookInputsEqual(nextDeps, prevDeps)) {
+        hook.memoizedState = pushEffect(hookFlags, create, destroy, nextDeps);
+        return;
+      }
     }
   }
 
-  {
-    var validatedTag = type.toLowerCase();
-    var ancestorInfo = updatedAncestorInfoDev(null, validatedTag);
-    return {
-      namespace: namespace,
-      ancestorInfo: ancestorInfo
-    };
-  }
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    HasEffect | hookFlags,
+    create,
+    destroy,
+    nextDeps
+  );
 }
-function getChildHostContext(parentHostContext, type) {
-  {
-    var parentHostContextDev = parentHostContext;
-    var namespace = getChildNamespace(parentHostContextDev.namespace, type);
-    var ancestorInfo = updatedAncestorInfoDev(
-      parentHostContextDev.ancestorInfo,
-      type
+
+function mountEffect(create, deps) {
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    mountEffectImpl(
+      MountPassiveDev | Passive$1 | PassiveStatic,
+      Passive,
+      create,
+      deps
     );
-    return {
-      namespace: namespace,
-      ancestorInfo: ancestorInfo
-    };
+  } else {
+    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
   }
 }
-function getPublicInstance(instance) {
-  return instance;
+
+function updateEffect(create, deps) {
+  updateEffectImpl(Passive$1, Passive, create, deps);
 }
-function prepareForCommit(containerInfo) {
-  eventsEnabled = isEnabled();
-  selectionInformation = getSelectionInformation();
-  var activeInstance = null;
 
-  {
-    var focusedElem = selectionInformation.focusedElem;
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
 
-    if (focusedElem !== null) {
-      activeInstance = getClosestInstanceFromNode(focusedElem);
-    }
-  }
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    var events = componentUpdateQueue.events;
 
-  setEnabled(false);
-  return activeInstance;
-}
-function beforeActiveInstanceBlur(internalInstanceHandle) {
-  {
-    setEnabled(true);
-    dispatchBeforeDetachedBlur(
-      selectionInformation.focusedElem,
-      internalInstanceHandle
-    );
-    setEnabled(false);
-  }
-}
-function afterActiveInstanceBlur() {
-  {
-    setEnabled(true);
-    dispatchAfterDetachedBlur(selectionInformation.focusedElem);
-    setEnabled(false);
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
+    } else {
+      events.push(payload);
+    }
   }
 }
-function resetAfterCommit(containerInfo) {
-  restoreSelection(selectionInformation);
-  setEnabled(eventsEnabled);
-  eventsEnabled = null;
-  selectionInformation = null;
-}
-function createHoistableInstance(
-  type,
-  props,
-  rootContainerInstance,
-  internalInstanceHandle
-) {
-  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
-  var domElement = createHTMLElement(type, props, ownerDocument);
-  precacheFiberNode(internalInstanceHandle, domElement);
-  updateFiberProps(domElement, props);
-  setInitialProperties(domElement, type, props);
-  markNodeAsHoistable(domElement);
-  return domElement;
-}
-function createInstance(
-  type,
-  props,
-  rootContainerInstance,
-  hostContext,
-  internalInstanceHandle
-) {
-  var namespace;
 
-  {
-    // TODO: take namespace into account when validating.
-    var hostContextDev = hostContext;
-    validateDOMNesting(type, null, hostContextDev.ancestorInfo);
+function mountEvent(callback) {
+  var hook = mountWorkInProgressHook();
+  var ref = {
+    impl: callback
+  };
+  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
 
-    if (
-      typeof props.children === "string" ||
-      typeof props.children === "number"
-    ) {
-      var string = "" + props.children;
-      var ownAncestorInfo = updatedAncestorInfoDev(
-        hostContextDev.ancestorInfo,
-        type
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw new Error(
+        "A function wrapped in useEffectEvent can't be called during rendering."
       );
-      validateDOMNesting(null, string, ownAncestorInfo);
     }
 
-    namespace = hostContextDev.namespace;
-  }
+    return ref.impl.apply(undefined, arguments);
+  };
+}
 
-  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
-  var domElement;
+function updateEvent(callback) {
+  var hook = updateWorkInProgressHook();
+  var ref = hook.memoizedState;
+  useEffectEventImpl({
+    ref: ref,
+    nextImpl: callback
+  }); // $FlowIgnore[incompatible-return]
 
-  switch (namespace) {
-    case SVG_NAMESPACE:
-    case MATH_NAMESPACE:
-      domElement = ownerDocument.createElementNS(namespace, type);
-      break;
+  return function eventFn() {
+    if (isInvalidExecutionContextForEventFunction()) {
+      throw new Error(
+        "A function wrapped in useEffectEvent can't be called during rendering."
+      );
+    }
 
-    default:
-      switch (type) {
-        case "svg":
-          domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
-          break;
+    return ref.impl.apply(undefined, arguments);
+  };
+}
 
-        case "math":
-          domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
-          break;
+function mountInsertionEffect(create, deps) {
+  mountEffectImpl(Update, Insertion, create, deps);
+}
 
-        case "script":
-          domElement = createPotentiallyInlineScriptElement(ownerDocument);
-          break;
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(Update, Insertion, create, deps);
+}
 
-        case "select":
-          domElement = createSelectElement(props, ownerDocument);
-          break;
+function mountLayoutEffect(create, deps) {
+  var fiberFlags = Update | LayoutStatic;
 
-        default:
-          domElement = createHTMLElement(type, props, ownerDocument);
-      }
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    fiberFlags |= MountLayoutDev;
   }
 
-  precacheFiberNode(internalInstanceHandle, domElement);
-  updateFiberProps(domElement, props);
-  return domElement;
+  return mountEffectImpl(fiberFlags, Layout, create, deps);
 }
-function appendInitialChild(parentInstance, child) {
-  parentInstance.appendChild(child);
+
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(Update, Layout, create, deps);
 }
-function finalizeInitialChildren(domElement, type, props, hostContext) {
-  setInitialProperties(domElement, type, props);
 
-  switch (type) {
-    case "button":
-    case "input":
-    case "select":
-    case "textarea":
-      return !!props.autoFocus;
+function imperativeHandleEffect(create, ref) {
+  if (typeof ref === "function") {
+    var refCallback = ref;
+    var inst = create();
+    refCallback(inst);
+    return function () {
+      refCallback(null);
+    };
+  } else if (ref !== null && ref !== undefined) {
+    var refObject = ref;
 
-    case "img":
-      return true;
+    {
+      if (!refObject.hasOwnProperty("current")) {
+        error(
+          "Expected useImperativeHandle() first argument to either be a " +
+            "ref callback or React.createRef() object. Instead received: %s.",
+          "an object with keys {" + Object.keys(refObject).join(", ") + "}"
+        );
+      }
+    }
 
-    default:
-      return false;
+    var _inst = create();
+
+    refObject.current = _inst;
+    return function () {
+      refObject.current = null;
+    };
   }
 }
-function prepareUpdate(domElement, type, oldProps, newProps, hostContext) {
-  {
-    var hostContextDev = hostContext;
 
-    if (
-      typeof newProps.children !== typeof oldProps.children &&
-      (typeof newProps.children === "string" ||
-        typeof newProps.children === "number")
-    ) {
-      var string = "" + newProps.children;
-      var ownAncestorInfo = updatedAncestorInfoDev(
-        hostContextDev.ancestorInfo,
-        type
+function mountImperativeHandle(ref, create, deps) {
+  {
+    if (typeof create !== "function") {
+      error(
+        "Expected useImperativeHandle() second argument to be a function " +
+          "that creates a handle. Instead received: %s.",
+        create !== null ? typeof create : "null"
       );
-      validateDOMNesting(null, string, ownAncestorInfo);
     }
+  } // TODO: If deps are provided, should we skip comparing the ref itself?
+
+  var effectDeps =
+    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  var fiberFlags = Update | LayoutStatic;
+
+  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
+    fiberFlags |= MountLayoutDev;
   }
 
-  return diffProperties(domElement, type, oldProps, newProps);
-}
-function shouldSetTextContent(type, props) {
-  return (
-    type === "textarea" ||
-    type === "noscript" ||
-    typeof props.children === "string" ||
-    typeof props.children === "number" ||
-    (typeof props.dangerouslySetInnerHTML === "object" &&
-      props.dangerouslySetInnerHTML !== null &&
-      props.dangerouslySetInnerHTML.__html != null)
+  mountEffectImpl(
+    fiberFlags,
+    Layout,
+    imperativeHandleEffect.bind(null, create, ref),
+    effectDeps
   );
 }
-function createTextInstance(
-  text,
-  rootContainerInstance,
-  hostContext,
-  internalInstanceHandle
-) {
+
+function updateImperativeHandle(ref, create, deps) {
   {
-    var hostContextDev = hostContext;
-    validateDOMNesting(null, text, hostContextDev.ancestorInfo);
-  }
+    if (typeof create !== "function") {
+      error(
+        "Expected useImperativeHandle() second argument to be a function " +
+          "that creates a handle. Instead received: %s.",
+        create !== null ? typeof create : "null"
+      );
+    }
+  } // TODO: If deps are provided, should we skip comparing the ref itself?
 
-  var textNode = createTextNode(text, rootContainerInstance);
-  precacheFiberNode(internalInstanceHandle, textNode);
-  return textNode;
+  var effectDeps =
+    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+  updateEffectImpl(
+    Update,
+    Layout,
+    imperativeHandleEffect.bind(null, create, ref),
+    effectDeps
+  );
 }
-function getCurrentEventPriority() {
-  var currentEvent = window.event;
-
-  if (currentEvent === undefined) {
-    return DefaultEventPriority;
-  }
 
-  return getEventPriority(currentEvent.type);
+function mountDebugValue(value, formatterFn) {
+  // This hook is normally a no-op.
+  // The react-debug-hooks package injects its own implementation
+  // so that e.g. DevTools can display custom hook values.
 }
-// if a component just imports ReactDOM (e.g. for findDOMNode).
-// Some environments might not have setTimeout or clearTimeout.
 
-var scheduleTimeout = typeof setTimeout === "function" ? setTimeout : undefined;
-var cancelTimeout =
-  typeof clearTimeout === "function" ? clearTimeout : undefined;
-var noTimeout = -1;
-var localPromise = typeof Promise === "function" ? Promise : undefined;
-var localRequestAnimationFrame =
-  typeof requestAnimationFrame === "function"
-    ? requestAnimationFrame
-    : scheduleTimeout;
-function getInstanceFromNode(node) {
-  return getClosestInstanceFromNode(node) || null;
-}
-function preparePortalMount(portalInstance) {
-  listenToAllSupportedEvents(portalInstance);
-}
-function prepareScopeUpdate(scopeInstance, internalInstanceHandle) {
-  {
-    precacheFiberNode(internalInstanceHandle, scopeInstance);
-  }
-}
-function getInstanceFromScope(scopeInstance) {
-  {
-    return getFiberFromScopeInstance(scopeInstance);
-  }
-} // -------------------
-var scheduleMicrotask =
-  typeof queueMicrotask === "function"
-    ? queueMicrotask
-    : typeof localPromise !== "undefined"
-    ? function (callback) {
-        return localPromise
-          .resolve(null)
-          .then(callback)
-          .catch(handleErrorInNextTick);
-      }
-    : scheduleTimeout; // TODO: Determine the best fallback here.
+var updateDebugValue = mountDebugValue;
 
-function handleErrorInNextTick(error) {
-  setTimeout(function () {
-    throw error;
-  });
-} // -------------------
-function commitMount(domElement, type, newProps, internalInstanceHandle) {
-  // Despite the naming that might imply otherwise, this method only
-  // fires if there is an `Update` effect scheduled during mounting.
-  // This happens if `finalizeInitialChildren` returns `true` (which it
-  // does to implement the `autoFocus` attribute on the client). But
-  // there are also other cases when this might happen (such as patching
-  // up text content during hydration mismatch). So we'll check this again.
-  switch (type) {
-    case "button":
-    case "input":
-    case "select":
-    case "textarea":
-      if (newProps.autoFocus) {
-        domElement.focus();
-      }
+function mountCallback(callback, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
+}
 
-      return;
+function updateCallback(callback, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var prevState = hook.memoizedState;
 
-    case "img": {
-      if (newProps.src) {
-        domElement.src = newProps.src;
-      }
+  if (nextDeps !== null) {
+    var prevDeps = prevState[1];
 
-      return;
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
     }
   }
-}
-function commitUpdate(
-  domElement,
-  updatePayload,
-  type,
-  oldProps,
-  newProps,
-  internalInstanceHandle
-) {
-  // Apply the diff to the DOM node.
-  updateProperties(domElement, updatePayload, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
-  // with current event handlers.
 
-  updateFiberProps(domElement, newProps);
-}
-function resetTextContent(domElement) {
-  setTextContent(domElement, "");
-}
-function commitTextUpdate(textInstance, oldText, newText) {
-  textInstance.nodeValue = newText;
-}
-function appendChild(parentInstance, child) {
-  parentInstance.appendChild(child);
+  hook.memoizedState = [callback, nextDeps];
+  return callback;
 }
-function appendChildToContainer(container, child) {
-  var parentNode;
-
-  if (container.nodeType === COMMENT_NODE) {
-    parentNode = container.parentNode;
-    parentNode.insertBefore(child, container);
-  } else {
-    parentNode = container;
-    parentNode.appendChild(child);
-  } // This container might be used for a portal.
-  // If something inside a portal is clicked, that click should bubble
-  // through the React tree. However, on Mobile Safari the click would
-  // never bubble through the *DOM* tree unless an ancestor with onclick
-  // event exists. So we wouldn't see it and dispatch it.
-  // This is why we ensure that non React root containers have inline onclick
-  // defined.
-  // https://github.com/facebook/react/issues/11918
 
-  var reactRootContainer = container._reactRootContainer;
+function mountMemo(nextCreate, deps) {
+  var hook = mountWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
 
-  if (
-    (reactRootContainer === null || reactRootContainer === undefined) &&
-    parentNode.onclick === null
-  ) {
-    // TODO: This cast may not be sound for SVG, MathML or custom elements.
-    trapClickOnNonInteractiveElement(parentNode);
-  }
-}
-function insertBefore(parentInstance, child, beforeChild) {
-  parentInstance.insertBefore(child, beforeChild);
-}
-function insertInContainerBefore(container, child, beforeChild) {
-  if (container.nodeType === COMMENT_NODE) {
-    container.parentNode.insertBefore(child, beforeChild);
-  } else {
-    container.insertBefore(child, beforeChild);
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
   }
-}
 
-function createEvent(type, bubbles) {
-  var event = document.createEvent("Event");
-  event.initEvent(type, bubbles, false);
-  return event;
+  var nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
 }
 
-function dispatchBeforeDetachedBlur(target, internalInstanceHandle) {
-  {
-    var event = createEvent("beforeblur", true); // Dispatch "beforeblur" directly on the target,
-    // so it gets picked up by the event system and
-    // can propagate through the React internal tree.
-    // $FlowFixMe: internal field
+function updateMemo(nextCreate, deps) {
+  var hook = updateWorkInProgressHook();
+  var nextDeps = deps === undefined ? null : deps;
+  var prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
 
-    event._detachedInterceptFiber = internalInstanceHandle;
-    target.dispatchEvent(event);
+  if (nextDeps !== null) {
+    var prevDeps = prevState[1];
+
+    if (areHookInputsEqual(nextDeps, prevDeps)) {
+      return prevState[0];
+    }
   }
-}
 
-function dispatchAfterDetachedBlur(target) {
-  {
-    var event = createEvent("afterblur", false); // So we know what was detached, make the relatedTarget the
-    // detached target on the "afterblur" event.
+  if (shouldDoubleInvokeUserFnsInHooksDEV) {
+    nextCreate();
+  }
 
-    event.relatedTarget = target; // Dispatch the event on the document.
+  var nextValue = nextCreate();
+  hook.memoizedState = [nextValue, nextDeps];
+  return nextValue;
+}
 
-    document.dispatchEvent(event);
-  }
+function mountDeferredValue(value) {
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = value;
+  return value;
 }
 
-function removeChild(parentInstance, child) {
-  parentInstance.removeChild(child);
+function updateDeferredValue(value) {
+  var hook = updateWorkInProgressHook();
+  var resolvedCurrentHook = currentHook;
+  var prevValue = resolvedCurrentHook.memoizedState;
+  return updateDeferredValueImpl(hook, prevValue, value);
 }
-function removeChildFromContainer(container, child) {
-  if (container.nodeType === COMMENT_NODE) {
-    container.parentNode.removeChild(child);
+
+function rerenderDeferredValue(value) {
+  var hook = updateWorkInProgressHook();
+
+  if (currentHook === null) {
+    // This is a rerender during a mount.
+    hook.memoizedState = value;
+    return value;
   } else {
-    container.removeChild(child);
+    // This is a rerender during an update.
+    var prevValue = currentHook.memoizedState;
+    return updateDeferredValueImpl(hook, prevValue, value);
   }
 }
-function clearSuspenseBoundary(parentInstance, suspenseInstance) {
-  var node = suspenseInstance; // Delete all nodes within this suspense boundary.
-  // There might be nested nodes so we need to keep track of how
-  // deep we are and only break out when we're back on top.
-
-  var depth = 0;
-
-  do {
-    var nextNode = node.nextSibling;
-    parentInstance.removeChild(node);
 
-    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
-      var data = nextNode.data;
+function updateDeferredValueImpl(hook, prevValue, value) {
+  var shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes$1);
 
-      if (data === SUSPENSE_END_DATA) {
-        if (depth === 0) {
-          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
+  if (shouldDeferValue) {
+    // This is an urgent update. If the value has changed, keep using the
+    // previous value and spawn a deferred render to update it later.
+    if (!objectIs(value, prevValue)) {
+      // Schedule a deferred render
+      var deferredLane = claimNextTransitionLane();
+      currentlyRenderingFiber$1.lanes = mergeLanes(
+        currentlyRenderingFiber$1.lanes,
+        deferredLane
+      );
+      markSkippedUpdateLanes(deferredLane); // Set this to true to indicate that the rendered value is inconsistent
+      // from the latest value. The name "baseState" doesn't really match how we
+      // use it because we're reusing a state hook field instead of creating a
+      // new one.
 
-          retryIfBlockedOn(suspenseInstance);
-          return;
-        } else {
-          depth--;
-        }
-      } else if (
-        data === SUSPENSE_START_DATA ||
-        data === SUSPENSE_PENDING_START_DATA ||
-        data === SUSPENSE_FALLBACK_START_DATA
-      ) {
-        depth++;
-      }
-    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      hook.baseState = true;
+    } // Reuse the previous value
 
-    node = nextNode;
-  } while (node); // TODO: Warn, we didn't find the end comment boundary.
-  // Retry if any event replaying was blocked on this.
+    return prevValue;
+  } else {
+    // This is not an urgent update, so we can use the latest value regardless
+    // of what it is. No need to defer it.
+    // However, if we're currently inside a spawned render, then we need to mark
+    // this as an update to prevent the fiber from bailing out.
+    //
+    // `baseState` is true when the current value is different from the rendered
+    // value. The name doesn't really match how we use it because we're reusing
+    // a state hook field instead of creating a new one.
+    if (hook.baseState) {
+      // Flip this back to false.
+      hook.baseState = false;
+      markWorkInProgressReceivedUpdate();
+    }
 
-  retryIfBlockedOn(suspenseInstance);
+    hook.memoizedState = value;
+    return value;
+  }
 }
-function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
-  if (container.nodeType === COMMENT_NODE) {
-    clearSuspenseBoundary(container.parentNode, suspenseInstance);
-  } else if (container.nodeType === ELEMENT_NODE) {
-    clearSuspenseBoundary(container, suspenseInstance);
-  } else; // Retry if any event replaying was blocked on this.
 
-  retryIfBlockedOn(container);
-}
-function hideInstance(instance) {
-  // TODO: Does this work for all element types? What about MathML? Should we
-  // pass host context to this method?
-  instance = instance;
-  var style = instance.style; // $FlowFixMe[method-unbinding]
+function startTransition(setPending, callback, options) {
+  var previousPriority = getCurrentUpdatePriority();
+  setCurrentUpdatePriority(
+    higherEventPriority(previousPriority, ContinuousEventPriority)
+  );
+  setPending(true);
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+  var currentTransition = ReactCurrentBatchConfig$3.transition;
 
-  if (typeof style.setProperty === "function") {
-    style.setProperty("display", "none", "important");
-  } else {
-    style.display = "none";
+  if (enableTransitionTracing) {
+    if (options !== undefined && options.name !== undefined) {
+      ReactCurrentBatchConfig$3.transition.name = options.name;
+      ReactCurrentBatchConfig$3.transition.startTime = now$1();
+    }
   }
-}
-function hideTextInstance(textInstance) {
-  textInstance.nodeValue = "";
-}
-function unhideInstance(instance, props) {
-  instance = instance;
-  var styleProp = props[STYLE];
-  var display =
-    styleProp !== undefined &&
-    styleProp !== null &&
-    styleProp.hasOwnProperty("display")
-      ? styleProp.display
-      : null;
-  instance.style.display = dangerousStyleValue("display", display);
-}
-function unhideTextInstance(textInstance, text) {
-  textInstance.nodeValue = text;
-}
-function clearContainer(container) {
+
   {
-    var nodeType = container.nodeType;
+    ReactCurrentBatchConfig$3.transition._updatedFibers = new Set();
+  }
 
-    if (nodeType === DOCUMENT_NODE) {
-      clearContainerSparingly(container);
-    } else if (nodeType === ELEMENT_NODE) {
-      switch (container.nodeName) {
-        case "HEAD":
-        case "HTML":
-        case "BODY":
-          clearContainerSparingly(container);
-          return;
+  try {
+    setPending(false);
+    callback();
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$3.transition = prevTransition;
 
-        default: {
-          container.textContent = "";
+    {
+      if (prevTransition === null && currentTransition._updatedFibers) {
+        var updatedFibersCount = currentTransition._updatedFibers.size;
+
+        currentTransition._updatedFibers.clear();
+
+        if (updatedFibersCount > 10) {
+          warn(
+            "Detected a large number of updates inside startTransition. " +
+              "If this is due to a subscription please re-write it to use React provided hooks. " +
+              "Otherwise concurrent mode guarantees are off the table."
+          );
         }
       }
     }
   }
 }
 
-function clearContainerSparingly(container) {
-  var node;
-  var nextNode = container.firstChild;
+function mountTransition() {
+  var _mountState = mountState(false),
+    isPending = _mountState[0],
+    setPending = _mountState[1]; // The `start` method never changes.
 
-  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
-    nextNode = nextNode.nextSibling;
-  }
+  var start = startTransition.bind(null, setPending);
+  var hook = mountWorkInProgressHook();
+  hook.memoizedState = start;
+  return [isPending, start];
+}
 
-  while (nextNode) {
-    node = nextNode;
-    nextNode = nextNode.nextSibling;
+function updateTransition() {
+  var _updateState = updateState(),
+    isPending = _updateState[0];
 
-    switch (node.nodeName) {
-      case "HTML":
-      case "HEAD":
-      case "BODY": {
-        var element = node;
-        clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
-        // may still hold on to references to the previous fiber tree. We detatch them
-        // prospectively to reset them to a baseline starting state since we cannot create
-        // new instances.
+  var hook = updateWorkInProgressHook();
+  var start = hook.memoizedState;
+  return [isPending, start];
+}
 
-        detachDeletedInstance(element);
-        continue;
-      }
+function rerenderTransition() {
+  var _rerenderState = rerenderState(),
+    isPending = _rerenderState[0];
 
-      case "STYLE": {
-        continue;
-      }
+  var hook = updateWorkInProgressHook();
+  var start = hook.memoizedState;
+  return [isPending, start];
+}
 
-      case "LINK": {
-        if (node.rel.toLowerCase() === "stylesheet") {
-          continue;
-        }
-      }
-    }
+function mountId() {
+  var hook = mountWorkInProgressHook();
+  var root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
+  // should do this in Fiber, too? Deferring this decision for now because
+  // there's no other place to store the prefix except for an internal field on
+  // the public createRoot object, which the fiber tree does not currently have
+  // a reference to.
 
-    container.removeChild(node);
-  }
+  var identifierPrefix = root.identifierPrefix;
+  var id;
 
-  return;
-} // Making this so we can eventually move all of the instance caching to the commit phase.
-// inserted without breaking hydration
+  if (getIsHydrating()) {
+    var treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
 
-function isHydratableType(type, props) {
-  {
-    if (type === "script") {
-      var async = props.async,
-        onLoad = props.onLoad,
-        onError = props.onError;
-      return !(async && (onLoad || onError));
+    id = ":" + identifierPrefix + "R" + treeId; // Unless this is the first id at this level, append a number at the end
+    // that represents the position of this useId hook among all the useId
+    // hooks for this fiber.
+
+    var localId = localIdCounter++;
+
+    if (localId > 0) {
+      id += "H" + localId.toString(32);
     }
 
-    return true;
+    id += ":";
+  } else {
+    // Use a lowercase r prefix for client-generated ids.
+    var globalClientId = globalClientIdCounter++;
+    id = ":" + identifierPrefix + "r" + globalClientId.toString(32) + ":";
   }
+
+  hook.memoizedState = id;
+  return id;
 }
-function isHydratableText(text) {
-  return text !== "";
+
+function updateId() {
+  var hook = updateWorkInProgressHook();
+  var id = hook.memoizedState;
+  return id;
 }
-function shouldSkipHydratableForInstance(instance, type, props) {
-  if (instance.nodeType !== ELEMENT_NODE) {
-    // This is a suspense boundary or Text node.
-    // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
-    // and this is a hydration error.
-    // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
-    // but it seems reasonable and conservative to reject this as a hydration error as well
-    return false;
-  } else if (
-    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
-    isMarkedHoistable(instance)
-  ) {
-    // We are either about to
-    return true;
-  } else {
-    // We have an Element with the right type.
-    var element = instance;
-    var anyProps = props; // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
-    // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
-    // using high entropy attributes for certain types. This technique will fail for strange insertions like
-    // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
 
-    switch (type) {
-      // case 'title':
-      //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
-      // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
-      case "meta": {
-        // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
-        // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
-        // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
-        // implications are minimal
-        if (!element.hasAttribute("itemprop")) {
-          // This is a Hoistable
-          return true;
-        }
-
-        break;
-      }
+function mountRefresh() {
+  var hook = mountWorkInProgressHook();
+  var refresh = (hook.memoizedState = refreshCache.bind(
+    null,
+    currentlyRenderingFiber$1
+  ));
+  return refresh;
+}
 
-      case "link": {
-        // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
-        // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
-        // matches.
-        var rel = element.getAttribute("rel");
+function updateRefresh() {
+  var hook = updateWorkInProgressHook();
+  return hook.memoizedState;
+}
 
-        if (rel === "stylesheet" && element.hasAttribute("data-precedence")) {
-          // This is a stylesheet resource
-          return true;
-        } else if (
-          rel !== anyProps.rel ||
-          element.getAttribute("href") !==
-            (anyProps.href == null ? null : anyProps.href) ||
-          element.getAttribute("crossorigin") !==
-            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) ||
-          element.getAttribute("title") !==
-            (anyProps.title == null ? null : anyProps.title)
-        ) {
-          // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
-          // and title could vary for rel alternate
-          return true;
-        }
+function refreshCache(fiber, seedKey, seedValue) {
+  // TODO: Consider warning if the refresh is at discrete priority, or if we
+  // otherwise suspect that it wasn't batched properly.
 
-        break;
-      }
+  var provider = fiber.return;
 
-      case "style": {
-        // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
-        // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
-        if (element.hasAttribute("data-precedence")) {
-          // This is a style resource
-          return true;
-        }
+  while (provider !== null) {
+    switch (provider.tag) {
+      case CacheComponent:
+      case HostRoot: {
+        // Schedule an update on the cache boundary to trigger a refresh.
+        var lane = requestUpdateLane(provider);
+        var refreshUpdate = createUpdate(lane);
+        var root = enqueueUpdate(provider, refreshUpdate, lane);
 
-        break;
-      }
+        if (root !== null) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, provider, lane, eventTime);
+          entangleTransitions(root, provider, lane);
+        } // TODO: If a refresh never commits, the new cache created here must be
+        // released. A simple case is start refreshing a cache boundary, but then
+        // unmount that boundary before the refresh completes.
 
-      case "script": {
-        // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
-        // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
-        // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
-        // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
-        // if we learn it is problematic
-        var srcAttr = element.getAttribute("src");
+        var seededCache = createCache();
 
-        if (
-          srcAttr &&
-          element.hasAttribute("async") &&
-          !element.hasAttribute("itemprop")
-        ) {
-          // This is an async script resource
-          return true;
-        } else if (
-          srcAttr !== (anyProps.src == null ? null : anyProps.src) ||
-          element.getAttribute("type") !==
-            (anyProps.type == null ? null : anyProps.type) ||
-          element.getAttribute("crossorigin") !==
-            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)
-        ) {
-          // This script is for a different src
-          return true;
+        if (seedKey !== null && seedKey !== undefined && root !== null) {
+          {
+            // Seed the cache with the value passed by the caller. This could be
+            // from a server mutation, or it could be a streaming response.
+            seededCache.data.set(seedKey, seedValue);
+          }
         }
 
-        break;
+        var payload = {
+          cache: seededCache
+        };
+        refreshUpdate.payload = payload;
+        return;
       }
-    } // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
-    // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
-    // that should work in the vast majority of cases.
+    }
 
-    return false;
-  }
-}
-function shouldSkipHydratableForTextInstance(instance) {
-  return instance.nodeType === ELEMENT_NODE;
-}
-function shouldSkipHydratableForSuspenseInstance(instance) {
-  return instance.nodeType === ELEMENT_NODE;
-}
-function canHydrateInstance(instance, type, props) {
-  if (
-    instance.nodeType !== ELEMENT_NODE ||
-    instance.nodeName.toLowerCase() !== type.toLowerCase()
-  ) {
-    return null;
-  } else {
-    return instance;
-  }
+    provider = provider.return;
+  } // TODO: Warn if unmounted?
 }
-function canHydrateTextInstance(instance, text) {
-  if (text === "") return null;
 
-  if (instance.nodeType !== TEXT_NODE) {
-    // Empty strings are not parsed by HTML so there won't be a correct match here.
-    return null;
-  } // This has now been refined to a text node.
-
-  return instance;
-}
-function canHydrateSuspenseInstance(instance) {
-  if (instance.nodeType !== COMMENT_NODE) {
-    return null;
-  } // This has now been refined to a suspense node.
+function dispatchReducerAction(fiber, queue, action) {
+  {
+    if (typeof arguments[3] === "function") {
+      error(
+        "State updates from the useState() and useReducer() Hooks don't support the " +
+          "second callback argument. To execute a side effect after " +
+          "rendering, declare it in the component body with useEffect()."
+      );
+    }
+  }
 
-  return instance;
-}
-function isSuspenseInstancePending(instance) {
-  return instance.data === SUSPENSE_PENDING_START_DATA;
-}
-function isSuspenseInstanceFallback(instance) {
-  return instance.data === SUSPENSE_FALLBACK_START_DATA;
-}
-function getSuspenseInstanceFallbackErrorDetails(instance) {
-  var dataset = instance.nextSibling && instance.nextSibling.dataset;
-  var digest, message, stack;
+  var lane = requestUpdateLane(fiber);
+  var update = {
+    lane: lane,
+    action: action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
 
-  if (dataset) {
-    digest = dataset.dgst;
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
 
-    {
-      message = dataset.msg;
-      stack = dataset.stck;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitionUpdate(root, queue, lane);
     }
   }
 
+  markUpdateInDevTools(fiber, lane, action);
+}
+
+function dispatchSetState(fiber, queue, action) {
   {
-    return {
-      message: message,
-      digest: digest,
-      stack: stack
-    };
+    if (typeof arguments[3] === "function") {
+      error(
+        "State updates from the useState() and useReducer() Hooks don't support the " +
+          "second callback argument. To execute a side effect after " +
+          "rendering, declare it in the component body with useEffect()."
+      );
+    }
   }
-}
-function registerSuspenseInstanceRetry(instance, callback) {
-  instance._reactRetry = callback;
-}
 
-function getNextHydratable(node) {
-  // Skip non-hydratable nodes.
-  for (; node != null; node = node.nextSibling) {
-    var nodeType = node.nodeType;
+  var lane = requestUpdateLane(fiber);
+  var update = {
+    lane: lane,
+    action: action,
+    hasEagerState: false,
+    eagerState: null,
+    next: null
+  };
 
-    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
-      break;
-    }
+  if (isRenderPhaseUpdate(fiber)) {
+    enqueueRenderPhaseUpdate(queue, update);
+  } else {
+    var alternate = fiber.alternate;
 
-    if (nodeType === COMMENT_NODE) {
-      var nodeData = node.data;
+    if (
+      fiber.lanes === NoLanes &&
+      (alternate === null || alternate.lanes === NoLanes)
+    ) {
+      // The queue is currently empty, which means we can eagerly compute the
+      // next state before entering the render phase. If the new state is the
+      // same as the current state, we may be able to bail out entirely.
+      var lastRenderedReducer = queue.lastRenderedReducer;
 
-      if (
-        nodeData === SUSPENSE_START_DATA ||
-        nodeData === SUSPENSE_FALLBACK_START_DATA ||
-        nodeData === SUSPENSE_PENDING_START_DATA
-      ) {
-        break;
-      }
+      if (lastRenderedReducer !== null) {
+        var prevDispatcher;
 
-      if (nodeData === SUSPENSE_END_DATA) {
-        return null;
-      }
-    }
-  }
+        {
+          prevDispatcher = ReactCurrentDispatcher$1.current;
+          ReactCurrentDispatcher$1.current =
+            InvalidNestedHooksDispatcherOnUpdateInDEV;
+        }
 
-  return node;
-}
+        try {
+          var currentState = queue.lastRenderedState;
+          var eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
+          // it, on the update object. If the reducer hasn't changed by the
+          // time we enter the render phase, then the eager state can be used
+          // without calling the reducer again.
 
-function getNextHydratableSibling(instance) {
-  return getNextHydratable(instance.nextSibling);
-}
-function getFirstHydratableChild(parentInstance) {
-  return getNextHydratable(parentInstance.firstChild);
-}
-function getFirstHydratableChildWithinContainer(parentContainer) {
-  return getNextHydratable(parentContainer.firstChild);
-}
-function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
-  return getNextHydratable(parentInstance.nextSibling);
-}
-function hydrateInstance(
-  instance,
-  type,
-  props,
-  hostContext,
-  internalInstanceHandle,
-  shouldWarnDev
-) {
-  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
-  // get attached.
+          update.hasEagerState = true;
+          update.eagerState = eagerState;
 
-  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
-  // when the legacy root API is removed.
+          if (objectIs(eagerState, currentState)) {
+            // Fast path. We can bail out without scheduling React to re-render.
+            // It's still possible that we'll need to rebase this update later,
+            // if the component re-renders for a different reason and by that
+            // time the reducer has changed.
+            // TODO: Do we still need to entangle transitions in this case?
+            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
+            return;
+          }
+        } catch (error) {
+          // Suppress the error. It will throw again in the render phase.
+        } finally {
+          {
+            ReactCurrentDispatcher$1.current = prevDispatcher;
+          }
+        }
+      }
+    }
 
-  var isConcurrentMode =
-    (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
-  var parentNamespace;
+    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
 
-  {
-    var hostContextDev = hostContext;
-    parentNamespace = hostContextDev.namespace;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitionUpdate(root, queue, lane);
+    }
   }
 
-  return diffHydratedProperties(
-    instance,
-    type,
-    props,
-    isConcurrentMode,
-    shouldWarnDev,
-    parentNamespace
-  );
-}
-function hydrateTextInstance(
-  textInstance,
-  text,
-  internalInstanceHandle,
-  shouldWarnDev
-) {
-  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
-  return diffHydratedText(textInstance, text);
-}
-function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
-  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+  markUpdateInDevTools(fiber, lane, action);
 }
-function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
-  var node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
-  // There might be nested nodes so we need to keep track of how
-  // deep we are and only break out when we're back on top.
 
-  var depth = 0;
+function isRenderPhaseUpdate(fiber) {
+  var alternate = fiber.alternate;
+  return (
+    fiber === currentlyRenderingFiber$1 ||
+    (alternate !== null && alternate === currentlyRenderingFiber$1)
+  );
+}
 
-  while (node) {
-    if (node.nodeType === COMMENT_NODE) {
-      var data = node.data;
+function enqueueRenderPhaseUpdate(queue, update) {
+  // This is a render phase update. Stash it in a lazily-created map of
+  // queue -> linked list of updates. After this render pass, we'll restart
+  // and apply the stashed updates on top of the work-in-progress hook.
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
+    true;
+  var pending = queue.pending;
 
-      if (data === SUSPENSE_END_DATA) {
-        if (depth === 0) {
-          return getNextHydratableSibling(node);
-        } else {
-          depth--;
-        }
-      } else if (
-        data === SUSPENSE_START_DATA ||
-        data === SUSPENSE_FALLBACK_START_DATA ||
-        data === SUSPENSE_PENDING_START_DATA
-      ) {
-        depth++;
-      }
-    }
+  if (pending === null) {
+    // This is the first update. Create a circular list.
+    update.next = update;
+  } else {
+    update.next = pending.next;
+    pending.next = update;
+  }
 
-    node = node.nextSibling;
-  } // TODO: Warn, we didn't find the end comment boundary.
+  queue.pending = update;
+} // TODO: Move to ReactFiberConcurrentUpdates?
 
-  return null;
-} // Returns the SuspenseInstance if this node is a direct child of a
-// SuspenseInstance. I.e. if its previous sibling is a Comment with
-// SUSPENSE_x_START_DATA. Otherwise, null.
+function entangleTransitionUpdate(root, queue, lane) {
+  if (isTransitionLane(lane)) {
+    var queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
+    // must have finished. We can remove them from the shared queue, which
+    // represents a superset of the actually pending lanes. In some cases we
+    // may entangle more than we need to, but that's OK. In fact it's worse if
+    // we *don't* entangle when we should.
 
-function getParentSuspenseInstance(targetInstance) {
-  var node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
-  // There might be nested nodes so we need to keep track of how
-  // deep we are and only break out when we're back on top.
+    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
 
-  var depth = 0;
+    var newQueueLanes = mergeLanes(queueLanes, lane);
+    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
+    // the lane finished since the last time we entangled it. So we need to
+    // entangle it again, just to be sure.
 
-  while (node) {
-    if (node.nodeType === COMMENT_NODE) {
-      var data = node.data;
+    markRootEntangled(root, newQueueLanes);
+  }
+}
 
-      if (
-        data === SUSPENSE_START_DATA ||
-        data === SUSPENSE_FALLBACK_START_DATA ||
-        data === SUSPENSE_PENDING_START_DATA
-      ) {
-        if (depth === 0) {
-          return node;
-        } else {
-          depth--;
-        }
-      } else if (data === SUSPENSE_END_DATA) {
-        depth++;
+function markUpdateInDevTools(fiber, lane, action) {
+  {
+    if (enableDebugTracing) {
+      if (fiber.mode & DebugTracingMode) {
+        var name = getComponentNameFromFiber(fiber) || "Unknown";
+        logStateUpdateScheduled(name, lane, action);
       }
     }
+  }
 
-    node = node.previousSibling;
+  if (enableSchedulingProfiler) {
+    markStateUpdateScheduled(fiber, lane);
   }
+}
 
-  return null;
+var ContextOnlyDispatcher = {
+  readContext: readContext,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useMutableSource: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+
+{
+  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
 }
-function commitHydratedContainer(container) {
-  // Retry if any event replaying was blocked on this.
-  retryIfBlockedOn(container);
+
+{
+  ContextOnlyDispatcher.use = throwInvalidHookError;
 }
-function commitHydratedSuspenseInstance(suspenseInstance) {
-  // Retry if any event replaying was blocked on this.
-  retryIfBlockedOn(suspenseInstance);
-} // @TODO remove this function once float lands and hydrated tail nodes
-function didNotMatchHydratedContainerTextInstance(
-  parentContainer,
-  textInstance,
-  text,
-  isConcurrentMode,
-  shouldWarnDev
-) {
-  checkForUnmatchedText(
-    textInstance.nodeValue,
-    text,
-    isConcurrentMode,
-    shouldWarnDev
-  );
+
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
 }
-function didNotMatchHydratedTextInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  textInstance,
-  text,
-  isConcurrentMode,
-  shouldWarnDev
-) {
-  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-    checkForUnmatchedText(
-      textInstance.nodeValue,
-      text,
-      isConcurrentMode,
-      shouldWarnDev
-    );
-  }
+
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
 }
-function didNotHydrateInstanceWithinContainer(parentContainer, instance) {
-  {
-    if (instance.nodeType === ELEMENT_NODE) {
-      warnForDeletedHydratableElement(parentContainer, instance);
-    } else if (instance.nodeType === COMMENT_NODE);
-    else {
-      warnForDeletedHydratableText(parentContainer, instance);
-    }
-  }
-}
-function didNotHydrateInstanceWithinSuspenseInstance(parentInstance, instance) {
-  {
-    // $FlowFixMe: Only Element or Document can be parent nodes.
-    var parentNode = parentInstance.parentNode;
 
-    if (parentNode !== null) {
-      if (instance.nodeType === ELEMENT_NODE) {
-        warnForDeletedHydratableElement(parentNode, instance);
-      } else if (instance.nodeType === COMMENT_NODE);
-      else {
-        warnForDeletedHydratableText(parentNode, instance);
-      }
-    }
-  }
-}
-function didNotHydrateInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  instance,
-  isConcurrentMode
-) {
-  {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      if (instance.nodeType === ELEMENT_NODE) {
-        warnForDeletedHydratableElement(parentInstance, instance);
-      } else if (instance.nodeType === COMMENT_NODE);
-      else {
-        warnForDeletedHydratableText(parentInstance, instance);
-      }
-    }
-  }
-}
-function didNotFindHydratableInstanceWithinContainer(
-  parentContainer,
-  type,
-  props
-) {
-  {
-    warnForInsertedHydratedElement(parentContainer, type);
-  }
-}
-function didNotFindHydratableTextInstanceWithinContainer(
-  parentContainer,
-  text
-) {
-  {
-    warnForInsertedHydratedText(parentContainer, text);
-  }
-}
-function didNotFindHydratableInstanceWithinSuspenseInstance(
-  parentInstance,
-  type,
-  props
-) {
-  {
-    // $FlowFixMe: Only Element or Document can be parent nodes.
-    var parentNode = parentInstance.parentNode;
-    if (parentNode !== null) warnForInsertedHydratedElement(parentNode, type);
-  }
-}
-function didNotFindHydratableTextInstanceWithinSuspenseInstance(
-  parentInstance,
-  text
-) {
-  {
-    // $FlowFixMe: Only Element or Document can be parent nodes.
-    var parentNode = parentInstance.parentNode;
-    if (parentNode !== null) warnForInsertedHydratedText(parentNode, text);
-  }
-}
-function didNotFindHydratableInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  type,
-  props,
-  isConcurrentMode
-) {
-  {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      warnForInsertedHydratedElement(parentInstance, type);
-    }
-  }
-}
-function didNotFindHydratableTextInstance(
-  parentType,
-  parentProps,
-  parentInstance,
-  text,
-  isConcurrentMode
-) {
-  {
-    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
-      warnForInsertedHydratedText(parentInstance, text);
-    }
-  }
-}
-function errorHydratingContainer(parentContainer) {
-  {
-    // TODO: This gets logged by onRecoverableError, too, so we should be
-    // able to remove it.
+var HooksDispatcherOnMountInDEV = null;
+var HooksDispatcherOnMountWithHookTypesInDEV = null;
+var HooksDispatcherOnUpdateInDEV = null;
+var HooksDispatcherOnRerenderInDEV = null;
+var InvalidNestedHooksDispatcherOnMountInDEV = null;
+var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
+var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
+
+{
+  var warnInvalidContextAccess = function () {
     error(
-      "An error occurred during hydration. The server HTML was replaced with client content in <%s>.",
-      parentContainer.nodeName.toLowerCase()
+      "Context can only be read while React is rendering. " +
+        "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+        "In function components, you can read it directly in the function body, but not " +
+        "inside Hooks like useReducer() or useMemo()."
     );
-  }
-} // -------------------
-function findFiberRoot(node) {
-  var stack = [node];
-  var index = 0;
-
-  while (index < stack.length) {
-    var current = stack[index++];
-
-    if (isContainerMarkedAsRoot(current)) {
-      return getInstanceFromNode$1(current);
-    }
-
-    stack.push.apply(stack, current.children);
-  }
+  };
 
-  return null;
-}
-function getBoundingRect(node) {
-  var rect = node.getBoundingClientRect();
-  return {
-    x: rect.left,
-    y: rect.top,
-    width: rect.width,
-    height: rect.height
+  var warnInvalidHookAccess = function () {
+    error(
+      "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " +
+        "You can only call Hooks at the top level of your React function. " +
+        "For more information, see " +
+        "https://reactjs.org/link/rules-of-hooks"
+    );
   };
-}
-function matchAccessibilityRole(node, role) {
-  if (hasRole(node, role)) {
-    return true;
-  }
 
-  return false;
-}
-function getTextContent(fiber) {
-  switch (fiber.tag) {
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent:
-      var textContent = "";
-      var childNodes = fiber.stateNode.childNodes;
+  HooksDispatcherOnMountInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      mountHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      mountHookTypesDev();
+      checkDepsAreArrayDev(deps);
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      for (var i = 0; i < childNodes.length; i++) {
-        var childNode = childNodes[i];
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-        if (childNode.nodeType === Node.TEXT_NODE) {
-          textContent += childNode.textContent;
-        }
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      mountHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-      return textContent;
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      mountHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      mountHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      mountHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      mountHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      mountHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      mountHookTypesDev();
+      return mountId();
+    }
+  };
 
-    case HostText:
-      return fiber.stateNode.textContent;
+  {
+    HooksDispatcherOnMountInDEV.useCacheRefresh = function useCacheRefresh() {
+      currentHookNameInDev = "useCacheRefresh";
+      mountHookTypesDev();
+      return mountRefresh();
+    };
   }
 
-  return null;
-}
-function isHiddenSubtree(fiber) {
-  return fiber.tag === HostComponent && fiber.memoizedProps.hidden === true;
-}
-function setFocusIfFocusable(node) {
-  // The logic for determining if an element is focusable is kind of complex,
-  // and since we want to actually change focus anyway- we can just skip it.
-  // Instead we'll just listen for a "focus" event to verify that focus was set.
-  //
-  // We could compare the node to document.activeElement after focus,
-  // but this would not handle the case where application code managed focus to automatically blur.
-  var didFocus = false;
-
-  var handleFocus = function () {
-    didFocus = true;
-  };
-
-  var element = node;
+  {
+    HooksDispatcherOnMountInDEV.use = use;
+  }
 
-  try {
-    element.addEventListener("focus", handleFocus); // $FlowFixMe[method-unbinding]
+  {
+    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
+  }
 
-    (element.focus || HTMLElement.prototype.focus).call(element);
-  } finally {
-    element.removeEventListener("focus", handleFocus);
+  {
+    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      mountHookTypesDev();
+      return mountEvent(callback);
+    };
   }
 
-  return didFocus;
-}
-function setupIntersectionObserver(targets, callback, options) {
-  var rectRatioCache = new Map();
-  targets.forEach(function (target) {
-    rectRatioCache.set(target, {
-      rect: getBoundingRect(target),
-      ratio: 0
-    });
-  });
+  HooksDispatcherOnMountWithHookTypesInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-  var handleIntersection = function (entries) {
-    entries.forEach(function (entry) {
-      var boundingClientRect = entry.boundingClientRect,
-        intersectionRatio = entry.intersectionRatio,
-        target = entry.target;
-      rectRatioCache.set(target, {
-        rect: {
-          x: boundingClientRect.left,
-          y: boundingClientRect.top,
-          width: boundingClientRect.width,
-          height: boundingClientRect.height
-        },
-        ratio: intersectionRatio
-      });
-    });
-    callback(Array.from(rectRatioCache.values()));
-  };
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-  var observer = new IntersectionObserver(handleIntersection, options);
-  targets.forEach(function (target) {
-    observer.observe(target);
-  });
-  return {
-    disconnect: function () {
-      return observer.disconnect();
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
     },
-    observe: function (target) {
-      rectRatioCache.set(target, {
-        rect: getBoundingRect(target),
-        ratio: 0
-      });
-      observer.observe(target);
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return mountRef(initialValue);
     },
-    unobserve: function (target) {
-      rectRatioCache.delete(target);
-      observer.unobserve(target);
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
+
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return mountId();
     }
   };
-}
-function requestPostPaintCallback(callback) {
-  localRequestAnimationFrame(function () {
-    localRequestAnimationFrame(function (time) {
-      return callback(time);
-    });
-  });
-} // -------------------
-function isHostHoistableType(type, props, hostContext) {
-  var outsideHostContainerContext;
-  var namespace;
 
   {
-    var hostContextDev = hostContext; // We can only render resources when we are not within the host container context
+    HooksDispatcherOnMountWithHookTypesInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return mountRefresh();
+      };
+  }
 
-    outsideHostContainerContext =
-      !hostContextDev.ancestorInfo.containerTagInScope;
-    namespace = hostContextDev.namespace;
-  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.use = use;
+  }
 
-  if (namespace === SVG_NAMESPACE || props.itemProp != null) {
-    {
-      if (
-        outsideHostContainerContext &&
-        props.itemProp != null &&
-        (type === "meta" ||
-          type === "title" ||
-          type === "style" ||
-          type === "link" ||
-          type === "script")
-      ) {
-        error(
-          "Cannot render a <%s> outside the main document if it has an `itemProp` prop. `itemProp` suggests the tag belongs to an" +
-            " `itemScope` which can appear anywhere in the DOM. If you were intending for React to hoist this <%s> remove the `itemProp` prop." +
-            " Otherwise, try moving this tag into the <head> or <body> of the Document.",
-          type,
-          type
-        );
-      }
-    }
-
-    return false;
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
   }
 
-  switch (type) {
-    case "meta":
-    case "title": {
-      return true;
-    }
-
-    case "style": {
-      if (
-        typeof props.precedence !== "string" ||
-        typeof props.href !== "string" ||
-        props.href === ""
-      ) {
-        {
-          if (outsideHostContainerContext) {
-            error(
-              "Cannot render a <style> outside the main document without knowing its precedence and a unique href key." +
-                " React can hoist and deduplicate <style> tags if you provide a `precedence` prop along with an `href` prop that" +
-                ' does not conflic with the `href` values used in any other hoisted <style> or <link rel="stylesheet" ...> tags. ' +
-                " Note that hoisting <style> tags is considered an advanced feature that most will not use directly." +
-                ' Consider moving the <style> tag to the <head> or consider adding a `precedence="default"` and `href="some unique resource identifier"`, or move the <style>' +
-                " to the <style> tag."
-            );
-          }
-        }
-
-        return false;
-      }
-
-      return true;
-    }
-
-    case "link": {
-      if (
-        typeof props.rel !== "string" ||
-        typeof props.href !== "string" ||
-        props.href === "" ||
-        props.onLoad ||
-        props.onError
-      ) {
-        {
-          if (
-            props.rel === "stylesheet" &&
-            typeof props.precedence === "string"
-          ) {
-            validateLinkPropsForStyleResource(props);
-          }
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        updateHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
 
-          if (outsideHostContainerContext) {
-            if (
-              typeof props.rel !== "string" ||
-              typeof props.href !== "string" ||
-              props.href === ""
-            ) {
-              error(
-                "Cannot render a <link> outside the main document without a `rel` and `href` prop." +
-                  " Try adding a `rel` and/or `href` prop to this <link> or moving the link into the <head> tag"
-              );
-            } else if (props.onError || props.onLoad) {
-              error(
-                "Cannot render a <link> with onLoad or onError listeners outside the main document." +
-                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
-                  " somewhere in the <body>."
-              );
-            }
-          }
-        }
+  HooksDispatcherOnUpdateInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-        return false;
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      switch (props.rel) {
-        case "stylesheet": {
-          var precedence = props.precedence,
-            disabled = props.disabled;
-
-          {
-            if (typeof precedence !== "string") {
-              if (outsideHostContainerContext) {
-                error(
-                  'Cannot render a <link rel="stylesheet" /> outside the main document without knowing its precedence.' +
-                    ' Consider adding precedence="default" or moving it into the root <head> tag.'
-                );
-              }
-            }
-          }
-
-          return typeof precedence === "string" && disabled == null;
-        }
-
-        default: {
-          return true;
-        }
+      try {
+        return updateReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-    }
-
-    case "script": {
-      if (
-        props.async !== true ||
-        props.onLoad ||
-        props.onError ||
-        typeof props.src !== "string" ||
-        !props.src
-      ) {
-        {
-          if (outsideHostContainerContext) {
-            if (props.async !== true) {
-              error(
-                "Cannot render a sync or defer <script> outside the main document without knowing its order." +
-                  ' Try adding async="" or moving it into the root <head> tag.'
-              );
-            } else if (props.onLoad || props.onError) {
-              error(
-                "Cannot render a <script> with onLoad or onError listeners outside the main document." +
-                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
-                  " somewhere in the <body>."
-              );
-            } else {
-              error(
-                "Cannot render a <script> outside the main document without `async={true}` and a non-empty `src` prop." +
-                  " Ensure there is a valid `src` and either make the script async or move it into the root <head> tag or" +
-                  " somewhere in the <body>."
-              );
-            }
-          }
-        }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-        return false;
+      try {
+        return updateState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-
-      return true;
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return updateDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return updateTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    case "noscript":
-    case "template": {
-      {
-        if (outsideHostContainerContext) {
-          error(
-            "Cannot render <%s> outside the main document. Try moving it into the root <head> tag.",
-            type
-          );
-        }
-      }
-
-      return false;
-    }
+  {
+    HooksDispatcherOnUpdateInDEV.useCacheRefresh = function useCacheRefresh() {
+      currentHookNameInDev = "useCacheRefresh";
+      updateHookTypesDev();
+      return updateRefresh();
+    };
   }
 
-  return false;
-}
-function prepareRendererToRender(rootContainer) {
   {
-    prepareToRenderResources(rootContainer);
+    HooksDispatcherOnUpdateInDEV.use = use;
   }
-}
-function resetRendererAfterRender() {
+
   {
-    cleanupAfterRenderResources();
+    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
   }
-}
-function isHostSingletonType(type) {
-  return type === "html" || type === "head" || type === "body";
-}
-function resolveSingletonInstance(
-  type,
-  props,
-  rootContainerInstance,
-  hostContext,
-  validateDOMNestingDev
-) {
-  {
-    var hostContextDev = hostContext;
 
-    if (validateDOMNestingDev) {
-      validateDOMNesting(type, null, hostContextDev.ancestorInfo);
-    }
+  {
+    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
   }
 
-  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
-
-  switch (type) {
-    case "html": {
-      var documentElement = ownerDocument.documentElement;
+  HooksDispatcherOnRerenderInDEV = {
+    readContext: function (context) {
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      if (!documentElement) {
-        throw new Error(
-          "React expected an <html> element (document.documentElement) to exist in the Document but one was" +
-            " not found. React never removes the documentElement for any Document it renders into so" +
-            " the cause is likely in some other script running on this page."
-        );
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      return documentElement;
-    }
-
-    case "head": {
-      var head = ownerDocument.head;
-
-      if (!head) {
-        throw new Error(
-          "React expected a <head> element (document.head) to exist in the Document but one was" +
-            " not found. React never removes the head for any Document it renders into so" +
-            " the cause is likely in some other script running on this page."
-        );
+      try {
+        return rerenderReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnRerenderInDEV;
 
-      return head;
-    }
-
-    case "body": {
-      var body = ownerDocument.body;
-
-      if (!body) {
-        throw new Error(
-          "React expected a <body> element (document.body) to exist in the Document but one was" +
-            " not found. React never removes the body for any Document it renders into so" +
-            " the cause is likely in some other script running on this page."
-        );
+      try {
+        return rerenderState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
-
-      return body;
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      updateHookTypesDev();
+      return rerenderDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      updateHookTypesDev();
+      return rerenderTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    default: {
-      throw new Error(
-        "resolveSingletonInstance was called with an element type that is not supported. This is a bug in React."
-      );
-    }
-  }
-}
-function acquireSingletonInstance(
-  type,
-  props,
-  instance,
-  internalInstanceHandle
-) {
   {
-    var currentInstanceHandle = getInstanceFromNode$1(instance);
-
-    if (currentInstanceHandle) {
-      var tagName = instance.tagName.toLowerCase();
-
-      error(
-        "You are mounting a new %s component when a previous one has not first unmounted. It is an" +
-          " error to render more than one %s component at a time and attributes and children of these" +
-          " components will likely fail in unpredictable ways. Please only render a single instance of" +
-          " <%s> and if you need to mount a new one, ensure any previous ones have unmounted first.",
-        tagName,
-        tagName,
-        tagName
-      );
-    }
-
-    switch (type) {
-      case "html":
-      case "head":
-      case "body": {
-        break;
-      }
-
-      default: {
-        error(
-          "acquireSingletonInstance was called with an element type that is not supported. This is a bug in React."
-        );
-      }
-    }
+    HooksDispatcherOnRerenderInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
   }
 
-  var attributes = instance.attributes;
-
-  while (attributes.length) {
-    instance.removeAttributeNode(attributes[0]);
+  {
+    HooksDispatcherOnRerenderInDEV.use = use;
   }
 
-  setInitialProperties(instance, type, props);
-  precacheFiberNode(internalInstanceHandle, instance);
-  updateFiberProps(instance, props);
-}
-function releaseSingletonInstance(instance) {
-  var attributes = instance.attributes;
-
-  while (attributes.length) {
-    instance.removeAttributeNode(attributes[0]);
+  {
+    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
   }
 
-  detachDeletedInstance(instance);
-}
-function clearSingleton(instance) {
-  var element = instance;
-  var node = element.firstChild;
-
-  while (node) {
-    var nextNode = node.nextSibling;
-    var nodeName = node.nodeName;
+  {
+    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
 
-    if (
-      isMarkedHoistable(node) ||
-      nodeName === "HEAD" ||
-      nodeName === "BODY" ||
-      nodeName === "STYLE" ||
-      (nodeName === "LINK" && node.rel.toLowerCase() === "stylesheet")
-    );
-    else {
-      element.removeChild(node);
-    }
+  InvalidNestedHooksDispatcherOnMountInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-    node = nextNode;
-  }
+      try {
+        return mountMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-  return;
-}
+      try {
+        return mountReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountRef(initialValue);
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnMountInDEV;
 
-var loggedTypeFailures = {};
-var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+      try {
+        return mountState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      mountHookTypesDev();
+      return mountId();
+    }
+  };
 
-function setCurrentlyValidatingElement(element) {
   {
-    if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(
-        element.type,
-        element._source,
-        owner ? owner.type : null
-      );
-      ReactDebugCurrentFrame.setExtraStackFrame(stack);
-    } else {
-      ReactDebugCurrentFrame.setExtraStackFrame(null);
-    }
+    InvalidNestedHooksDispatcherOnMountInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        mountHookTypesDev();
+        return mountRefresh();
+      };
   }
-}
 
-function checkPropTypes(typeSpecs, values, location, componentName, element) {
   {
-    // $FlowFixMe This is okay but Flow doesn't know it.
-    var has = Function.call.bind(hasOwnProperty);
-
-    for (var typeSpecName in typeSpecs) {
-      if (has(typeSpecs, typeSpecName)) {
-        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
-        // fail the render phase where it didn't fail before. So we log it.
-        // After these have been cleaned up, we'll let them throw.
-
-        try {
-          // This is intentionally an invariant that gets caught. It's the same
-          // behavior as without this statement except with a better message.
-          if (typeof typeSpecs[typeSpecName] !== "function") {
-            // eslint-disable-next-line react-internal/prod-error-codes
-            var err = Error(
-              (componentName || "React class") +
-                ": " +
-                location +
-                " type `" +
-                typeSpecName +
-                "` is invalid; " +
-                "it must be a function, usually from the `prop-types` package, but received `" +
-                typeof typeSpecs[typeSpecName] +
-                "`." +
-                "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
-            );
-            err.name = "Invariant Violation";
-            throw err;
-          }
-
-          error$1 = typeSpecs[typeSpecName](
-            values,
-            typeSpecName,
-            componentName,
-            location,
-            null,
-            "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
-          );
-        } catch (ex) {
-          error$1 = ex;
-        }
+    InvalidNestedHooksDispatcherOnMountInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
+  }
 
-        if (error$1 && !(error$1 instanceof Error)) {
-          setCurrentlyValidatingElement(element);
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
 
-          error(
-            "%s: type specification of %s" +
-              " `%s` is invalid; the type checker " +
-              "function must return `null` or an `Error` but returned a %s. " +
-              "You may have forgotten to pass an argument to the type checker " +
-              "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
-              "shape all require an argument).",
-            componentName || "React class",
-            location,
-            typeSpecName,
-            typeof error$1
-          );
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
 
-          setCurrentlyValidatingElement(null);
-        }
+  InvalidNestedHooksDispatcherOnUpdateInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-        if (
-          error$1 instanceof Error &&
-          !(error$1.message in loggedTypeFailures)
-        ) {
-          // Only monitor this failure once because there tends to be a lot of the
-          // same error.
-          loggedTypeFailures[error$1.message] = true;
-          setCurrentlyValidatingElement(element);
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-          error("Failed %s type: %s", location, error$1.message);
+      try {
+        return updateReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-          setCurrentlyValidatingElement(null);
-        }
+      try {
+        return updateState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateId();
     }
-  }
-}
-
-var emptyContextObject = {};
-
-{
-  Object.freeze(emptyContextObject);
-} // A cursor to the current merged context object on the stack.
+  };
 
-function hasContextChanged() {
   {
-    return false;
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
   }
-}
 
-function isContextProvider(type) {
   {
-    return false;
+    InvalidNestedHooksDispatcherOnUpdateInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
   }
-}
 
-function processChildContext(fiber, type, parentContext) {
   {
-    return parentContext;
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
   }
-}
 
-function findCurrentUnmaskedContext(fiber) {
   {
-    return emptyContextObject;
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
   }
-}
 
-var LegacyRoot = 0;
-var ConcurrentRoot = 1;
+  InvalidNestedHooksDispatcherOnRerenderInDEV = {
+    readContext: function (context) {
+      warnInvalidContextAccess();
+      return readContext(context);
+    },
+    useCallback: function (callback, deps) {
+      currentHookNameInDev = "useCallback";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateCallback(callback, deps);
+    },
+    useContext: function (context) {
+      currentHookNameInDev = "useContext";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return readContext(context);
+    },
+    useEffect: function (create, deps) {
+      currentHookNameInDev = "useEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateEffect(create, deps);
+    },
+    useImperativeHandle: function (ref, create, deps) {
+      currentHookNameInDev = "useImperativeHandle";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateImperativeHandle(ref, create, deps);
+    },
+    useInsertionEffect: function (create, deps) {
+      currentHookNameInDev = "useInsertionEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateInsertionEffect(create, deps);
+    },
+    useLayoutEffect: function (create, deps) {
+      currentHookNameInDev = "useLayoutEffect";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateLayoutEffect(create, deps);
+    },
+    useMemo: function (create, deps) {
+      currentHookNameInDev = "useMemo";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-// We use the existence of the state object as an indicator that the component
-// is hidden.
-var OffscreenVisible =
-  /*                     */
-  1;
-var OffscreenDetached =
-  /*                    */
-  2;
-var OffscreenPassiveEffectsConnected =
-  /*     */
-  4;
-function isOffscreenManual(offscreenFiber) {
-  return (
-    offscreenFiber.memoizedProps !== null &&
-    offscreenFiber.memoizedProps.mode === "manual"
-  );
-}
-
-var syncQueue = null;
-var includesLegacySyncCallbacks = false;
-var isFlushingSyncQueue = false;
-function scheduleSyncCallback(callback) {
-  // Push this callback into an internal queue. We'll flush these either in
-  // the next tick, or earlier if something calls `flushSyncCallbackQueue`.
-  if (syncQueue === null) {
-    syncQueue = [callback];
-  } else {
-    // Push onto existing queue. Don't need to schedule a callback because
-    // we already scheduled one when we created the queue.
-    syncQueue.push(callback);
-  }
-}
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = true;
-  scheduleSyncCallback(callback);
-}
-function flushSyncCallbacksOnlyInLegacyMode() {
-  // Only flushes the queue if there's a legacy sync callback scheduled.
-  // TODO: There's only a single type of callback: performSyncOnWorkOnRoot. So
-  // it might make more sense for the queue to be a list of roots instead of a
-  // list of generic callbacks. Then we can have two: one for legacy roots, one
-  // for concurrent roots. And this method would only flush the legacy ones.
-  if (includesLegacySyncCallbacks) {
-    flushSyncCallbacks();
-  }
-}
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && syncQueue !== null) {
-    // Prevent re-entrance.
-    isFlushingSyncQueue = true; // Set the event priority to discrete
-    // TODO: Is this necessary anymore? The only user code that runs in this
-    // queue is in the render or commit phases, which already set the
-    // event priority. Should be able to remove.
-
-    var previousUpdatePriority = getCurrentUpdatePriority$1();
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    var errors = null;
-    var queue = syncQueue; // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-    for (var i = 0; i < queue.length; i++) {
-      // $FlowFixMe[incompatible-use] found when upgrading Flow
-      var callback = queue[i];
+      try {
+        return updateMemo(create, deps);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useReducer: function (reducer, initialArg, init) {
+      currentHookNameInDev = "useReducer";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
       try {
-        do {
-          var isSync = true; // $FlowFixMe[incompatible-type] we bail out when we get a null
+        return rerenderReducer(reducer, initialArg, init);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
+      }
+    },
+    useRef: function (initialValue) {
+      currentHookNameInDev = "useRef";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateRef();
+    },
+    useState: function (initialState) {
+      currentHookNameInDev = "useState";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      var prevDispatcher = ReactCurrentDispatcher$1.current;
+      ReactCurrentDispatcher$1.current =
+        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-          callback = callback(isSync);
-        } while (callback !== null);
-      } catch (error) {
-        // Collect errors so we can rethrow them at the end
-        if (errors === null) {
-          errors = [error];
-        } else {
-          errors.push(error);
-        }
+      try {
+        return rerenderState(initialState);
+      } finally {
+        ReactCurrentDispatcher$1.current = prevDispatcher;
       }
+    },
+    useDebugValue: function (value, formatterFn) {
+      currentHookNameInDev = "useDebugValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateDebugValue();
+    },
+    useDeferredValue: function (value) {
+      currentHookNameInDev = "useDeferredValue";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return rerenderDeferredValue(value);
+    },
+    useTransition: function () {
+      currentHookNameInDev = "useTransition";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return rerenderTransition();
+    },
+    useMutableSource: function (source, getSnapshot, subscribe) {
+      currentHookNameInDev = "useMutableSource";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateMutableSource(source, getSnapshot, subscribe);
+    },
+    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+      currentHookNameInDev = "useSyncExternalStore";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateSyncExternalStore(subscribe, getSnapshot);
+    },
+    useId: function () {
+      currentHookNameInDev = "useId";
+      warnInvalidHookAccess();
+      updateHookTypesDev();
+      return updateId();
     }
+  };
 
-    syncQueue = null;
-    includesLegacySyncCallbacks = false;
-    setCurrentUpdatePriority(previousUpdatePriority);
-    isFlushingSyncQueue = false;
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useCacheRefresh =
+      function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateRefresh();
+      };
+  }
 
-    if (errors !== null) {
-      if (errors.length > 1) {
-        if (typeof AggregateError === "function") {
-          // eslint-disable-next-line no-undef
-          throw new AggregateError(errors);
-        } else {
-          for (var _i = 1; _i < errors.length; _i++) {
-            scheduleCallback$2(
-              ImmediatePriority,
-              throwError.bind(null, errors[_i])
-            );
-          }
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.use = function (usable) {
+      warnInvalidHookAccess();
+      return use(usable);
+    };
+  }
 
-          var firstError = errors[0];
-          throw firstError;
-        }
-      } else {
-        var error = errors[0];
-        throw error;
-      }
-    }
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
   }
 
-  return null;
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
+  }
 }
 
-function throwError(error) {
-  throw error;
-}
+var now = Scheduler.unstable_now;
+var commitTime = 0;
+var layoutEffectStartTime = -1;
+var profilerStartTime = -1;
+var passiveEffectStartTime = -1;
+/**
+ * Tracks whether the current update was a nested/cascading update (scheduled from a layout effect).
+ *
+ * The overall sequence is:
+ *   1. render
+ *   2. commit (and call `onRender`, `onCommit`)
+ *   3. check for nested updates
+ *   4. flush passive effects (and call `onPostCommit`)
+ *
+ * Nested updates are identified in step 3 above,
+ * but step 4 still applies to the work that was just committed.
+ * We use two flags to track nested updates then:
+ * one tracks whether the upcoming update is a nested update,
+ * and the other tracks whether the current update was a nested update.
+ * The first value gets synced to the second at the start of the render phase.
+ */
 
-var nativeConsole = console;
-var nativeConsoleLog = null;
-var pendingGroupArgs = [];
-var printedGroupIndex = -1;
+var currentUpdateIsNested = false;
+var nestedUpdateScheduled = false;
 
-function formatLanes(laneOrLanes) {
-  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
+function isCurrentUpdateNested() {
+  return currentUpdateIsNested;
 }
 
-function group() {
-  for (
-    var _len = arguments.length, groupArgs = new Array(_len), _key = 0;
-    _key < _len;
-    _key++
-  ) {
-    groupArgs[_key] = arguments[_key];
+function markNestedUpdateScheduled() {
+  {
+    nestedUpdateScheduled = true;
   }
+}
 
-  pendingGroupArgs.push(groupArgs);
-
-  if (nativeConsoleLog === null) {
-    nativeConsoleLog = nativeConsole.log;
-    nativeConsole.log = log;
+function resetNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = false;
+    nestedUpdateScheduled = false;
   }
 }
 
-function groupEnd() {
-  pendingGroupArgs.pop();
-
-  while (printedGroupIndex >= pendingGroupArgs.length) {
-    nativeConsole.groupEnd();
-    printedGroupIndex--;
+function syncNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = nestedUpdateScheduled;
+    nestedUpdateScheduled = false;
   }
+}
 
-  if (pendingGroupArgs.length === 0) {
-    nativeConsole.log = nativeConsoleLog;
-    nativeConsoleLog = null;
-  }
+function getCommitTime() {
+  return commitTime;
 }
 
-function log() {
-  if (printedGroupIndex < pendingGroupArgs.length - 1) {
-    for (var i = printedGroupIndex + 1; i < pendingGroupArgs.length; i++) {
-      var groupArgs = pendingGroupArgs[i];
-      nativeConsole.group.apply(nativeConsole, groupArgs);
-    }
+function recordCommitTime() {
+  commitTime = now();
+}
 
-    printedGroupIndex = pendingGroupArgs.length - 1;
-  }
+function startProfilerTimer(fiber) {
+  profilerStartTime = now();
 
-  if (typeof nativeConsoleLog === "function") {
-    nativeConsoleLog.apply(void 0, arguments);
-  } else {
-    nativeConsole.log.apply(nativeConsole, arguments);
+  if (fiber.actualStartTime < 0) {
+    fiber.actualStartTime = now();
   }
 }
 
-var REACT_LOGO_STYLE =
-  "background-color: #20232a; color: #61dafb; padding: 0 2px;";
-function logCommitStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c commit%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
+function stopProfilerTimerIfRunning(fiber) {
+  profilerStartTime = -1;
+}
+
+function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+  if (profilerStartTime >= 0) {
+    var elapsedTime = now() - profilerStartTime;
+    fiber.actualDuration += elapsedTime;
+
+    if (overrideBaseTime) {
+      fiber.selfBaseDuration = elapsedTime;
     }
+
+    profilerStartTime = -1;
   }
 }
-function logCommitStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
+
+function recordLayoutEffectDuration(fiber) {
+  if (layoutEffectStartTime >= 0) {
+    var elapsedTime = now() - layoutEffectStartTime;
+    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
+
+    var parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
+          root.effectDuration += elapsedTime;
+          return;
+
+        case Profiler:
+          var parentStateNode = parentFiber.stateNode;
+          parentStateNode.effectDuration += elapsedTime;
+          return;
+      }
+
+      parentFiber = parentFiber.return;
     }
   }
 }
-var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
 
-var wakeableIDs = new PossiblyWeakMap$1();
-var wakeableID = 0;
+function recordPassiveEffectDuration(fiber) {
+  if (passiveEffectStartTime >= 0) {
+    var elapsedTime = now() - passiveEffectStartTime;
+    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
+    // Or the root (for the DevTools Profiler to read)
 
-function getWakeableID(wakeable) {
-  if (!wakeableIDs.has(wakeable)) {
-    wakeableIDs.set(wakeable, wakeableID++);
-  }
+    var parentFiber = fiber.return;
 
-  return wakeableIDs.get(wakeable);
-}
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
 
-function logComponentSuspended(componentName, wakeable) {
-  {
-    if (enableDebugTracing) {
-      var id = getWakeableID(wakeable);
-      var display = wakeable.displayName || wakeable;
-      log(
-        "%c\u269B\uFE0F%c " + componentName + " suspended",
-        REACT_LOGO_STYLE,
-        "color: #80366d; font-weight: bold;",
-        id,
-        display
-      );
-      wakeable.then(
-        function () {
-          log(
-            "%c\u269B\uFE0F%c " + componentName + " resolved",
-            REACT_LOGO_STYLE,
-            "color: #80366d; font-weight: bold;",
-            id,
-            display
-          );
-        },
-        function () {
-          log(
-            "%c\u269B\uFE0F%c " + componentName + " rejected",
-            REACT_LOGO_STYLE,
-            "color: #80366d; font-weight: bold;",
-            id,
-            display
-          );
-        }
-      );
+          if (root !== null) {
+            root.passiveEffectDuration += elapsedTime;
+          }
+
+          return;
+
+        case Profiler:
+          var parentStateNode = parentFiber.stateNode;
+
+          if (parentStateNode !== null) {
+            // Detached fibers have their state node cleared out.
+            // In this case, the return pointer is also cleared out,
+            // so we won't be able to report the time spent in this Profiler's subtree.
+            parentStateNode.passiveEffectDuration += elapsedTime;
+          }
+
+          return;
+      }
+
+      parentFiber = parentFiber.return;
     }
   }
 }
-function logLayoutEffectsStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c layout effects%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
-      );
-    }
+
+function startLayoutEffectTimer() {
+  layoutEffectStartTime = now();
+}
+
+function startPassiveEffectTimer() {
+  passiveEffectStartTime = now();
+}
+
+function transferActualDuration(fiber) {
+  // Transfer time spent rendering these children so we don't lose it
+  // after we rerender. This is used as a helper in special cases
+  // where we should count the work of multiple passes.
+  var child = fiber.child;
+
+  while (child) {
+    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    fiber.actualDuration += child.actualDuration;
+    child = child.sibling;
   }
 }
-function logLayoutEffectsStopped() {
-  {
-    if (enableDebugTracing) {
-      groupEnd();
+
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    // Resolve default props. Taken from ReactElement
+    var props = assign({}, baseProps);
+    var defaultProps = Component.defaultProps;
+
+    for (var propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
     }
+
+    return props;
   }
+
+  return baseProps;
 }
-function logPassiveEffectsStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c passive effects%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
+
+var fakeInternalInstance = {};
+var didWarnAboutStateAssignmentForComponent;
+var didWarnAboutUninitializedState;
+var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
+var didWarnAboutLegacyLifecyclesAndDerivedState;
+var didWarnAboutUndefinedDerivedState;
+var didWarnAboutDirectlyAssigningPropsToState;
+var didWarnAboutInvalidateContextType;
+var didWarnOnInvalidCallback;
+
+{
+  didWarnAboutStateAssignmentForComponent = new Set();
+  didWarnAboutUninitializedState = new Set();
+  didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+  didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+  didWarnAboutDirectlyAssigningPropsToState = new Set();
+  didWarnAboutUndefinedDerivedState = new Set();
+  didWarnAboutInvalidateContextType = new Set();
+  didWarnOnInvalidCallback = new Set(); // This is so gross but it's at least non-critical and can be removed if
+  // it causes problems. This is meant to give a nicer error message for
+  // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
+  // ...)) which otherwise throws a "_processChildContext is not a function"
+  // exception.
+
+  Object.defineProperty(fakeInternalInstance, "_processChildContext", {
+    enumerable: false,
+    value: function () {
+      throw new Error(
+        "_processChildContext is not available in React 16+. This likely " +
+          "means you have multiple copies of React and are attempting to nest " +
+          "a React 15 tree inside a React 16 tree using " +
+          "unstable_renderSubtreeIntoContainer, which isn't supported. Try " +
+          "to make sure you have only one copy of React (and ideally, switch " +
+          "to ReactDOM.createPortal)."
       );
     }
-  }
+  });
+  Object.freeze(fakeInternalInstance);
 }
-function logPassiveEffectsStopped() {
+
+function warnOnInvalidCallback(callback, callerName) {
   {
-    if (enableDebugTracing) {
-      groupEnd();
+    if (callback === null || typeof callback === "function") {
+      return;
     }
-  }
-}
-function logRenderStarted(lanes) {
-  {
-    if (enableDebugTracing) {
-      group(
-        "%c\u269B\uFE0F%c render%c (" + formatLanes(lanes) + ")",
-        REACT_LOGO_STYLE,
-        "",
-        "font-weight: normal;"
+
+    var key = callerName + "_" + callback;
+
+    if (!didWarnOnInvalidCallback.has(key)) {
+      didWarnOnInvalidCallback.add(key);
+
+      error(
+        "%s(...): Expected the last optional `callback` argument to be a " +
+          "function. Instead received: %s.",
+        callerName,
+        callback
       );
     }
   }
 }
-function logRenderStopped() {
+
+function warnOnUndefinedDerivedState(type, partialState) {
   {
-    if (enableDebugTracing) {
-      groupEnd();
+    if (partialState === undefined) {
+      var componentName = getComponentNameFromType(type) || "Component";
+
+      if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
+        didWarnAboutUndefinedDerivedState.add(componentName);
+
+        error(
+          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
+            "You have returned undefined.",
+          componentName
+        );
+      }
     }
   }
 }
-function logForceUpdateScheduled(componentName, lane) {
-  {
-    if (enableDebugTracing) {
-      log(
-        "%c\u269B\uFE0F%c " +
-          componentName +
-          " forced update %c(" +
-          formatLanes(lane) +
-          ")",
-        REACT_LOGO_STYLE,
-        "color: #db2e1f; font-weight: bold;",
-        ""
-      );
-    }
-  }
-}
-function logStateUpdateScheduled(componentName, lane, payloadOrAction) {
+
+function applyDerivedStateFromProps(
+  workInProgress,
+  ctor,
+  getDerivedStateFromProps,
+  nextProps
+) {
+  var prevState = workInProgress.memoizedState;
+  var partialState = getDerivedStateFromProps(nextProps, prevState);
+
   {
-    if (enableDebugTracing) {
-      log(
-        "%c\u269B\uFE0F%c " +
-          componentName +
-          " updated state %c(" +
-          formatLanes(lane) +
-          ")",
-        REACT_LOGO_STYLE,
-        "color: #01a252; font-weight: bold;",
-        "",
-        payloadOrAction
-      );
+    if (workInProgress.mode & StrictLegacyMode) {
+      setIsStrictModeForDevtools(true);
+
+      try {
+        // Invoke the function an extra time to help detect side-effects.
+        partialState = getDerivedStateFromProps(nextProps, prevState);
+      } finally {
+        setIsStrictModeForDevtools(false);
+      }
     }
+
+    warnOnUndefinedDerivedState(ctor, partialState);
+  } // Merge the partial state and the previous state.
+
+  var memoizedState =
+    partialState === null || partialState === undefined
+      ? prevState
+      : assign({}, prevState, partialState);
+  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
+  // base state.
+
+  if (workInProgress.lanes === NoLanes) {
+    // Queue is always non-null for classes
+    var updateQueue = workInProgress.updateQueue;
+    updateQueue.baseState = memoizedState;
   }
 }
 
-// Intentionally not using it yet to derisk the initial implementation, because
-// the way we push/pop these values is a bit unusual. If there's a mistake, I'd
-// rather the ids be wrong than crash the whole reconciler.
+var classComponentUpdater = {
+  isMounted: isMounted,
+  // $FlowFixMe[missing-local-annot]
+  enqueueSetState: function (inst, payload, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.payload = payload;
 
-var forkStack = [];
-var forkStackIndex = 0;
-var treeForkProvider = null;
-var treeForkCount = 0;
-var idStack = [];
-var idStackIndex = 0;
-var treeContextProvider = null;
-var treeContextId = 1;
-var treeContextOverflow = "";
-function isForkedChild(workInProgress) {
-  warnIfNotHydrating();
-  return (workInProgress.flags & Forked) !== NoFlags$1;
-}
-function getForksAtLevel(workInProgress) {
-  warnIfNotHydrating();
-  return treeForkCount;
-}
-function getTreeId() {
-  var overflow = treeContextOverflow;
-  var idWithLeadingBit = treeContextId;
-  var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);
-  return id.toString(32) + overflow;
-}
-function pushTreeFork(workInProgress, totalChildren) {
-  // This is called right after we reconcile an array (or iterator) of child
-  // fibers, because that's the only place where we know how many children in
-  // the whole set without doing extra work later, or storing addtional
-  // information on the fiber.
-  //
-  // That's why this function is separate from pushTreeId — it's called during
-  // the render phase of the fork parent, not the child, which is where we push
-  // the other context values.
-  //
-  // In the Fizz implementation this is much simpler because the child is
-  // rendered in the same callstack as the parent.
-  //
-  // It might be better to just add a `forks` field to the Fiber type. It would
-  // make this module simpler.
-  warnIfNotHydrating();
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
-}
-function pushTreeId(workInProgress, totalChildren, index) {
-  warnIfNotHydrating();
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  var baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part
-  // of the id; we use it to account for leading 0s.
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback(callback, "setState");
+      }
 
-  var baseLength = getBitLength(baseIdWithLeadingBit) - 1;
-  var baseId = baseIdWithLeadingBit & ~(1 << baseLength);
-  var slot = index + 1;
-  var length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into
-  // consideration the leading 1 we use to mark the end of the sequence.
+      update.callback = callback;
+    }
 
-  if (length > 30) {
-    // We overflowed the bitwise-safe range. Fall back to slower algorithm.
-    // This branch assumes the length of the base id is greater than 5; it won't
-    // work for smaller ids, because you need 5 bits per character.
-    //
-    // We encode the id in multiple steps: first the base id, then the
-    // remaining digits.
-    //
-    // Each 5 bit sequence corresponds to a single base 32 character. So for
-    // example, if the current id is 23 bits long, we can convert 20 of those
-    // bits into a string of 4 characters, with 3 bits left over.
-    //
-    // First calculate how many bits in the base id represent a complete
-    // sequence of characters.
-    var numberOfOverflowBits = baseLength - (baseLength % 5); // Then create a bitmask that selects only those bits.
+    var root = enqueueUpdate(fiber, update, lane);
 
-    var newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
+    }
 
-    var newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
 
-    var restOfBaseId = baseId >> numberOfOverflowBits;
-    var restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because
-    // we made more room, this time it won't overflow.
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+  enqueueReplaceState: function (inst, payload, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.tag = ReplaceState;
+    update.payload = payload;
 
-    var restOfLength = getBitLength(totalChildren) + restOfBaseLength;
-    var restOfNewBits = slot << restOfBaseLength;
-    var id = restOfNewBits | restOfBaseId;
-    var overflow = newOverflow + baseOverflow;
-    treeContextId = (1 << restOfLength) | id;
-    treeContextOverflow = overflow;
-  } else {
-    // Normal path
-    var newBits = slot << baseLength;
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback(callback, "replaceState");
+      }
 
-    var _id = newBits | baseId;
+      update.callback = callback;
+    }
 
-    var _overflow = baseOverflow;
-    treeContextId = (1 << length) | _id;
-    treeContextOverflow = _overflow;
-  }
-}
-function pushMaterializedTreeId(workInProgress) {
-  warnIfNotHydrating(); // This component materialized an id. This will affect any ids that appear
-  // in its children.
+    var root = enqueueUpdate(fiber, update, lane);
 
-  var returnFiber = workInProgress.return;
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
+    }
 
-  if (returnFiber !== null) {
-    var numberOfForks = 1;
-    var slotIndex = 0;
-    pushTreeFork(workInProgress, numberOfForks);
-    pushTreeId(workInProgress, numberOfForks, slotIndex);
-  }
-}
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
 
-function getBitLength(number) {
-  return 32 - clz32(number);
-}
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
+  },
+  // $FlowFixMe[missing-local-annot]
+  enqueueForceUpdate: function (inst, callback) {
+    var fiber = get(inst);
+    var lane = requestUpdateLane(fiber);
+    var update = createUpdate(lane);
+    update.tag = ForceUpdate;
 
-function getLeadingBit(id) {
-  return 1 << (getBitLength(id) - 1);
-}
+    if (callback !== undefined && callback !== null) {
+      {
+        warnOnInvalidCallback(callback, "forceUpdate");
+      }
 
-function popTreeContext(workInProgress) {
-  // Restore the previous values.
-  // This is a bit more complicated than other context-like modules in Fiber
-  // because the same Fiber may appear on the stack multiple times and for
-  // different reasons. We have to keep popping until the work-in-progress is
-  // no longer at the top of the stack.
-  while (workInProgress === treeForkProvider) {
-    treeForkProvider = forkStack[--forkStackIndex];
-    forkStack[forkStackIndex] = null;
-    treeForkCount = forkStack[--forkStackIndex];
-    forkStack[forkStackIndex] = null;
-  }
+      update.callback = callback;
+    }
 
-  while (workInProgress === treeContextProvider) {
-    treeContextProvider = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-    treeContextOverflow = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-    treeContextId = idStack[--idStackIndex];
-    idStack[idStackIndex] = null;
-  }
-}
-function getSuspendedTreeContext() {
-  warnIfNotHydrating();
+    var root = enqueueUpdate(fiber, update, lane);
 
-  if (treeContextProvider !== null) {
-    return {
-      id: treeContextId,
-      overflow: treeContextOverflow
-    };
-  } else {
-    return null;
-  }
-}
-function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
-  warnIfNotHydrating();
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextId = suspendedContext.id;
-  treeContextOverflow = suspendedContext.overflow;
-  treeContextProvider = workInProgress;
-}
+    if (root !== null) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+      entangleTransitions(root, fiber, lane);
+    }
 
-function warnIfNotHydrating() {
-  {
-    if (!getIsHydrating()) {
-      error(
-        "Expected to be hydrating. This is a bug in React. Please file " +
-          "an issue."
-      );
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logForceUpdateScheduled(name, lane);
+        }
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markForceUpdateScheduled(fiber, lane);
     }
   }
-}
+};
 
-// This may have been an insertion or a hydration.
+function checkShouldComponentUpdate(
+  workInProgress,
+  ctor,
+  oldProps,
+  newProps,
+  oldState,
+  newState,
+  nextContext
+) {
+  var instance = workInProgress.stateNode;
 
-var hydrationParentFiber = null;
-var nextHydratableInstance = null;
-var isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches
-// due to earlier mismatches or a suspended fiber.
+  if (typeof instance.shouldComponentUpdate === "function") {
+    var shouldUpdate = instance.shouldComponentUpdate(
+      newProps,
+      newState,
+      nextContext
+    );
 
-var didSuspendOrErrorDEV = false; // Hydration errors that were thrown inside this boundary
+    {
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
 
-var hydrationErrors = null;
-var rootOrSingletonContext = false;
+        try {
+          // Invoke the function an extra time to help detect side-effects.
+          shouldUpdate = instance.shouldComponentUpdate(
+            newProps,
+            newState,
+            nextContext
+          );
+        } finally {
+          setIsStrictModeForDevtools(false);
+        }
+      }
 
-function warnIfHydrating() {
-  {
-    if (isHydrating) {
-      error(
-        "We should not be hydrating here. This is a bug in React. Please file a bug."
-      );
+      if (shouldUpdate === undefined) {
+        error(
+          "%s.shouldComponentUpdate(): Returned undefined instead of a " +
+            "boolean value. Make sure to return true or false.",
+          getComponentNameFromType(ctor) || "Component"
+        );
+      }
     }
-  }
-}
 
-function markDidThrowWhileHydratingDEV() {
-  {
-    didSuspendOrErrorDEV = true;
-  }
-}
-function didSuspendOrErrorWhileHydratingDEV() {
-  {
-    return didSuspendOrErrorDEV;
+    return shouldUpdate;
   }
-}
-
-function enterHydrationState(fiber) {
-  var parentInstance = fiber.stateNode.containerInfo;
-  nextHydratableInstance =
-    getFirstHydratableChildWithinContainer(parentInstance);
-  hydrationParentFiber = fiber;
-  isHydrating = true;
-  hydrationErrors = null;
-  didSuspendOrErrorDEV = false;
-  rootOrSingletonContext = true;
-  return true;
-}
-
-function reenterHydrationStateFromDehydratedSuspenseInstance(
-  fiber,
-  suspenseInstance,
-  treeContext
-) {
-  nextHydratableInstance =
-    getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);
-  hydrationParentFiber = fiber;
-  isHydrating = true;
-  hydrationErrors = null;
-  didSuspendOrErrorDEV = false;
-  rootOrSingletonContext = false;
 
-  if (treeContext !== null) {
-    restoreSuspendedTreeContext(fiber, treeContext);
+  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+    return (
+      !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
+    );
   }
 
   return true;
 }
 
-function warnUnhydratedInstance(returnFiber, instance) {
+function checkClassInstance(workInProgress, ctor, newProps) {
+  var instance = workInProgress.stateNode;
+
   {
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        didNotHydrateInstanceWithinContainer(
-          returnFiber.stateNode.containerInfo,
-          instance
-        );
-        break;
-      }
+    var name = getComponentNameFromType(ctor) || "Component";
+    var renderPresent = instance.render;
 
-      case HostSingleton:
-      case HostComponent: {
-        var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
-        didNotHydrateInstance(
-          returnFiber.type,
-          returnFiber.memoizedProps,
-          returnFiber.stateNode,
-          instance, // TODO: Delete this argument when we remove the legacy root API.
-          isConcurrentMode
+    if (!renderPresent) {
+      if (ctor.prototype && typeof ctor.prototype.render === "function") {
+        error(
+          "%s(...): No `render` method found on the returned component " +
+            "instance: did you accidentally return an object from the constructor?",
+          name
+        );
+      } else {
+        error(
+          "%s(...): No `render` method found on the returned component " +
+            "instance: you may have forgotten to define `render`.",
+          name
         );
-        break;
       }
+    }
 
-      case SuspenseComponent: {
-        var suspenseState = returnFiber.memoizedState;
-        if (suspenseState.dehydrated !== null)
-          didNotHydrateInstanceWithinSuspenseInstance(
-            suspenseState.dehydrated,
-            instance
-          );
-        break;
-      }
+    if (
+      instance.getInitialState &&
+      !instance.getInitialState.isReactClassApproved &&
+      !instance.state
+    ) {
+      error(
+        "getInitialState was defined on %s, a plain JavaScript class. " +
+          "This is only supported for classes created using React.createClass. " +
+          "Did you mean to define a state property instead?",
+        name
+      );
     }
-  }
-}
 
-function deleteHydratableInstance(returnFiber, instance) {
-  warnUnhydratedInstance(returnFiber, instance);
-  var childToDelete = createFiberFromHostInstanceForDeletion();
-  childToDelete.stateNode = instance;
-  childToDelete.return = returnFiber;
-  var deletions = returnFiber.deletions;
+    if (
+      instance.getDefaultProps &&
+      !instance.getDefaultProps.isReactClassApproved
+    ) {
+      error(
+        "getDefaultProps was defined on %s, a plain JavaScript class. " +
+          "This is only supported for classes created using React.createClass. " +
+          "Use a static property to define defaultProps instead.",
+        name
+      );
+    }
 
-  if (deletions === null) {
-    returnFiber.deletions = [childToDelete];
-    returnFiber.flags |= ChildDeletion;
-  } else {
-    deletions.push(childToDelete);
-  }
-}
+    if (instance.propTypes) {
+      error(
+        "propTypes was defined as an instance property on %s. Use a static " +
+          "property to define propTypes instead.",
+        name
+      );
+    }
 
-function warnNonhydratedInstance(returnFiber, fiber) {
-  {
-    if (didSuspendOrErrorDEV) {
-      // Inside a boundary that already suspended. We're currently rendering the
-      // siblings of a suspended node. The mismatch may be due to the missing
-      // data, so it's probably a false positive.
-      return;
+    if (instance.contextType) {
+      error(
+        "contextType was defined as an instance property on %s. Use a static " +
+          "property to define contextType instead.",
+        name
+      );
     }
 
-    switch (returnFiber.tag) {
-      case HostRoot: {
-        var parentContainer = returnFiber.stateNode.containerInfo;
-
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent:
-            var type = fiber.type;
-            didNotFindHydratableInstanceWithinContainer(parentContainer, type);
-            break;
-
-          case HostText:
-            var text = fiber.pendingProps;
-            didNotFindHydratableTextInstanceWithinContainer(
-              parentContainer,
-              text
-            );
-            break;
-        }
-
-        break;
+    {
+      if (ctor.childContextTypes) {
+        error(
+          "%s uses the legacy childContextTypes API which is no longer supported. " +
+            "Use React.createContext() instead.",
+          name
+        );
       }
 
-      case HostSingleton:
-      case HostComponent: {
-        var parentType = returnFiber.type;
-        var parentProps = returnFiber.memoizedProps;
-        var parentInstance = returnFiber.stateNode;
-
-        switch (fiber.tag) {
-          case HostSingleton:
-          case HostComponent: {
-            var _type = fiber.type;
-            var _props = fiber.pendingProps;
-            var isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
-            didNotFindHydratableInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              _type,
-              _props, // TODO: Delete this argument when we remove the legacy root API.
-              isConcurrentMode
-            );
-            break;
-          }
-
-          case HostText: {
-            var _text = fiber.pendingProps;
-
-            var _isConcurrentMode =
-              (returnFiber.mode & ConcurrentMode) !== NoMode;
+      if (ctor.contextTypes) {
+        error(
+          "%s uses the legacy contextTypes API which is no longer supported. " +
+            "Use React.createContext() with static contextType instead.",
+          name
+        );
+      }
+    }
 
-            didNotFindHydratableTextInstance(
-              parentType,
-              parentProps,
-              parentInstance,
-              _text, // TODO: Delete this argument when we remove the legacy root API.
-              _isConcurrentMode
-            );
-            break;
-          }
-        }
+    if (typeof instance.componentShouldUpdate === "function") {
+      error(
+        "%s has a method called " +
+          "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
+          "The name is phrased as a question because the function is " +
+          "expected to return a value.",
+        name
+      );
+    }
 
-        break;
-      }
+    if (
+      ctor.prototype &&
+      ctor.prototype.isPureReactComponent &&
+      typeof instance.shouldComponentUpdate !== "undefined"
+    ) {
+      error(
+        "%s has a method called shouldComponentUpdate(). " +
+          "shouldComponentUpdate should not be used when extending React.PureComponent. " +
+          "Please extend React.Component if shouldComponentUpdate is used.",
+        getComponentNameFromType(ctor) || "A pure component"
+      );
+    }
 
-      case SuspenseComponent: {
-        var suspenseState = returnFiber.memoizedState;
-        var _parentInstance = suspenseState.dehydrated;
-        if (_parentInstance !== null)
-          switch (fiber.tag) {
-            case HostSingleton:
-            case HostComponent:
-              var _type2 = fiber.type;
-              didNotFindHydratableInstanceWithinSuspenseInstance(
-                _parentInstance,
-                _type2
-              );
-              break;
+    if (typeof instance.componentDidUnmount === "function") {
+      error(
+        "%s has a method called " +
+          "componentDidUnmount(). But there is no such lifecycle method. " +
+          "Did you mean componentWillUnmount()?",
+        name
+      );
+    }
 
-            case HostText:
-              var _text2 = fiber.pendingProps;
-              didNotFindHydratableTextInstanceWithinSuspenseInstance(
-                _parentInstance,
-                _text2
-              );
-              break;
-          }
-        break;
-      }
+    if (typeof instance.componentDidReceiveProps === "function") {
+      error(
+        "%s has a method called " +
+          "componentDidReceiveProps(). But there is no such lifecycle method. " +
+          "If you meant to update the state in response to changing props, " +
+          "use componentWillReceiveProps(). If you meant to fetch data or " +
+          "run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
+        name
+      );
+    }
 
-      default:
-        return;
+    if (typeof instance.componentWillRecieveProps === "function") {
+      error(
+        "%s has a method called " +
+          "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
+        name
+      );
     }
-  }
-}
 
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-  warnNonhydratedInstance(returnFiber, fiber);
-}
+    if (typeof instance.UNSAFE_componentWillRecieveProps === "function") {
+      error(
+        "%s has a method called " +
+          "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
+        name
+      );
+    }
 
-function tryHydrateInstance(fiber, nextInstance) {
-  // fiber is a HostComponent Fiber
-  var instance = canHydrateInstance(nextInstance, fiber.type);
+    var hasMutatedProps = instance.props !== newProps;
 
-  if (instance !== null) {
-    fiber.stateNode = instance;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = getFirstHydratableChild(instance);
-    rootOrSingletonContext = false;
-    return true;
-  }
+    if (instance.props !== undefined && hasMutatedProps) {
+      error(
+        "%s(...): When calling super() in `%s`, make sure to pass " +
+          "up the same props that your component's constructor was passed.",
+        name,
+        name
+      );
+    }
 
-  return false;
-}
+    if (instance.defaultProps) {
+      error(
+        "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
+          " Instead, define defaultProps as a static property on %s.",
+        name,
+        name
+      );
+    }
 
-function tryHydrateText(fiber, nextInstance) {
-  // fiber is a HostText Fiber
-  var text = fiber.pendingProps;
-  var textInstance = canHydrateTextInstance(nextInstance, text);
+    if (
+      typeof instance.getSnapshotBeforeUpdate === "function" &&
+      typeof instance.componentDidUpdate !== "function" &&
+      !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)
+    ) {
+      didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
 
-  if (textInstance !== null) {
-    fiber.stateNode = textInstance;
-    hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.
+      error(
+        "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
+          "This component defines getSnapshotBeforeUpdate() only.",
+        getComponentNameFromType(ctor)
+      );
+    }
 
-    nextHydratableInstance = null;
-    return true;
-  }
+    if (typeof instance.getDerivedStateFromProps === "function") {
+      error(
+        "%s: getDerivedStateFromProps() is defined as an instance method " +
+          "and will be ignored. Instead, declare it as a static method.",
+        name
+      );
+    }
 
-  return false;
-}
+    if (typeof instance.getDerivedStateFromError === "function") {
+      error(
+        "%s: getDerivedStateFromError() is defined as an instance method " +
+          "and will be ignored. Instead, declare it as a static method.",
+        name
+      );
+    }
 
-function tryHydrateSuspense(fiber, nextInstance) {
-  // fiber is a SuspenseComponent Fiber
-  var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
+    if (typeof ctor.getSnapshotBeforeUpdate === "function") {
+      error(
+        "%s: getSnapshotBeforeUpdate() is defined as a static method " +
+          "and will be ignored. Instead, declare it as an instance method.",
+        name
+      );
+    }
 
-  if (suspenseInstance !== null) {
-    var suspenseState = {
-      dehydrated: suspenseInstance,
-      treeContext: getSuspendedTreeContext(),
-      retryLane: OffscreenLane
-    };
-    fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.
-    // This simplifies the code for getHostSibling and deleting nodes,
-    // since it doesn't have to consider all Suspense boundaries and
-    // check if they're dehydrated ones or not.
+    var state = instance.state;
 
-    var dehydratedFragment =
-      createFiberFromDehydratedFragment(suspenseInstance);
-    dehydratedFragment.return = fiber;
-    fiber.child = dehydratedFragment;
-    hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into
-    // it during the first pass. Instead, we'll reenter it later.
+    if (state && (typeof state !== "object" || isArray(state))) {
+      error("%s.state: must be set to an object or null", name);
+    }
 
-    nextHydratableInstance = null;
-    return true;
+    if (
+      typeof instance.getChildContext === "function" &&
+      typeof ctor.childContextTypes !== "object"
+    ) {
+      error(
+        "%s.getChildContext(): childContextTypes must be defined in order to " +
+          "use getChildContext().",
+        name
+      );
+    }
   }
-
-  return false;
 }
 
-function shouldClientRenderOnMismatch(fiber) {
-  return (
-    (fiber.mode & ConcurrentMode) !== NoMode &&
-    (fiber.flags & DidCapture) === NoFlags$1
-  );
-}
+function adoptClassInstance(workInProgress, instance) {
+  instance.updater = classComponentUpdater;
+  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
 
-function throwOnHydrationMismatch(fiber) {
-  throw new Error(
-    "Hydration failed because the initial UI does not match what was " +
-      "rendered on the server."
-  );
-}
+  set(instance, workInProgress);
 
-function claimHydratableSingleton(fiber) {
   {
-    if (!isHydrating) {
-      return;
-    }
-
-    var currentRootContainer = getRootHostContainer();
-    var currentHostContext = getHostContext();
-    var instance = (fiber.stateNode = resolveSingletonInstance(
-      fiber.type,
-      fiber.pendingProps,
-      currentRootContainer,
-      currentHostContext,
-      false
-    ));
-    hydrationParentFiber = fiber;
-    rootOrSingletonContext = true;
-    nextHydratableInstance = getFirstHydratableChild(instance);
+    instance._reactInternalInstance = fakeInternalInstance;
   }
 }
 
-function advanceToFirstAttemptableInstance(fiber) {
-  // fiber is HostComponent Fiber
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    )
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
-  }
-}
+function constructClassInstance(workInProgress, ctor, props) {
+  var context = emptyContextObject;
+  var contextType = ctor.contextType;
 
-function advanceToFirstAttemptableTextInstance() {
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForTextInstance(nextHydratableInstance)
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
-  }
-}
+  {
+    if ("contextType" in ctor) {
+      var isValid = // Allow null for conditional declaration
+        contextType === null ||
+        (contextType !== undefined &&
+          contextType.$$typeof === REACT_CONTEXT_TYPE &&
+          contextType._context === undefined); // Not a <Context.Consumer>
 
-function advanceToFirstAttemptableSuspenseInstance() {
-  while (
-    nextHydratableInstance &&
-    shouldSkipHydratableForSuspenseInstance(nextHydratableInstance)
-  ) {
-    // Flow doesn't understand that inside this block nextHydratableInstance is not null
-    var instance = nextHydratableInstance;
-    nextHydratableInstance = getNextHydratableSibling(instance);
-  }
-}
+      if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
+        didWarnAboutInvalidateContextType.add(ctor);
+        var addendum = "";
 
-function tryToClaimNextHydratableInstance(fiber) {
-  if (!isHydrating) {
-    return;
-  }
+        if (contextType === undefined) {
+          addendum =
+            " However, it is set to undefined. " +
+            "This can be caused by a typo or by mixing up named and default imports. " +
+            "This can also happen due to a circular dependency, so " +
+            "try moving the createContext() call to a separate file.";
+        } else if (typeof contextType !== "object") {
+          addendum = " However, it is set to a " + typeof contextType + ".";
+        } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
+          addendum = " Did you accidentally pass the Context.Provider instead?";
+        } else if (contextType._context !== undefined) {
+          // <Context.Consumer>
+          addendum = " Did you accidentally pass the Context.Consumer instead?";
+        } else {
+          addendum =
+            " However, it is set to an object with keys {" +
+            Object.keys(contextType).join(", ") +
+            "}.";
+        }
 
-  {
-    if (!isHydratableType(fiber.type, fiber.pendingProps)) {
-      // This fiber never hydrates from the DOM and always does an insert
-      fiber.flags = (fiber.flags & ~Hydrating) | Placement;
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      return;
+        error(
+          "%s defines an invalid contextType. " +
+            "contextType should point to the Context object returned by React.createContext().%s",
+          getComponentNameFromType(ctor) || "Component",
+          addendum
+        );
+      }
     }
   }
 
-  var initialInstance = nextHydratableInstance;
-
-  if (rootOrSingletonContext) {
-    // We may need to skip past certain nodes in these contexts
-    advanceToFirstAttemptableInstance(fiber);
+  if (typeof contextType === "object" && contextType !== null) {
+    context = readContext(contextType);
   }
 
-  var nextInstance = nextHydratableInstance;
+  var instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
 
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
+  {
+    if (workInProgress.mode & StrictLegacyMode) {
+      setIsStrictModeForDevtools(true);
 
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
+      try {
+        instance = new ctor(props, context); // eslint-disable-line no-new
+      } finally {
+        setIsStrictModeForDevtools(false);
+      }
+    }
   }
 
-  var firstAttemptedInstance = nextInstance;
+  var state = (workInProgress.memoizedState =
+    instance.state !== null && instance.state !== undefined
+      ? instance.state
+      : null);
+  adoptClassInstance(workInProgress, instance);
 
-  if (!tryHydrateInstance(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+  {
+    if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+      var componentName = getComponentNameFromType(ctor) || "Component";
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+      if (!didWarnAboutUninitializedState.has(componentName)) {
+        didWarnAboutUninitializedState.add(componentName);
 
-    if (rootOrSingletonContext) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableInstance(fiber);
-    }
+        error(
+          "`%s` uses `getDerivedStateFromProps` but its initial state is " +
+            "%s. This is not recommended. Instead, define the initial state by " +
+            "assigning an object to `this.state` in the constructor of `%s`. " +
+            "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
+          componentName,
+          instance.state === null ? "null" : "undefined",
+          componentName
+        );
+      }
+    } // If new component APIs are defined, "unsafe" lifecycles won't be called.
+    // Warn about these lifecycles if they are present.
+    // Don't warn about react-lifecycles-compat polyfilled methods though.
 
     if (
-      !nextHydratableInstance ||
-      !tryHydrateInstance(fiber, nextHydratableInstance)
+      typeof ctor.getDerivedStateFromProps === "function" ||
+      typeof instance.getSnapshotBeforeUpdate === "function"
     ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
-  }
-}
+      var foundWillMountName = null;
+      var foundWillReceivePropsName = null;
+      var foundWillUpdateName = null;
 
-function tryToClaimNextHydratableTextInstance(fiber) {
-  if (!isHydrating) {
-    return;
-  }
+      if (
+        typeof instance.componentWillMount === "function" &&
+        instance.componentWillMount.__suppressDeprecationWarning !== true
+      ) {
+        foundWillMountName = "componentWillMount";
+      } else if (typeof instance.UNSAFE_componentWillMount === "function") {
+        foundWillMountName = "UNSAFE_componentWillMount";
+      }
 
-  var text = fiber.pendingProps;
-  var isHydratable = isHydratableText(text);
-  var initialInstance = nextHydratableInstance;
+      if (
+        typeof instance.componentWillReceiveProps === "function" &&
+        instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
+      ) {
+        foundWillReceivePropsName = "componentWillReceiveProps";
+      } else if (
+        typeof instance.UNSAFE_componentWillReceiveProps === "function"
+      ) {
+        foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
+      }
 
-  if (rootOrSingletonContext && isHydratable) {
-    // We may need to skip past certain nodes in these contexts.
-    // We don't skip if the text is not hydratable because we know no hydratables
-    // exist which could match this Fiber
-    advanceToFirstAttemptableTextInstance();
-  }
+      if (
+        typeof instance.componentWillUpdate === "function" &&
+        instance.componentWillUpdate.__suppressDeprecationWarning !== true
+      ) {
+        foundWillUpdateName = "componentWillUpdate";
+      } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+        foundWillUpdateName = "UNSAFE_componentWillUpdate";
+      }
 
-  var nextInstance = nextHydratableInstance;
-
-  if (!nextInstance || !isHydratable) {
-    // We exclude non hydrabable text because we know there are no matching hydratables.
-    // We either throw or insert depending on the render mode.
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
-
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
-  }
-
-  var firstAttemptedInstance = nextInstance;
+      if (
+        foundWillMountName !== null ||
+        foundWillReceivePropsName !== null ||
+        foundWillUpdateName !== null
+      ) {
+        var _componentName = getComponentNameFromType(ctor) || "Component";
 
-  if (!tryHydrateText(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+        var newApiName =
+          typeof ctor.getDerivedStateFromProps === "function"
+            ? "getDerivedStateFromProps()"
+            : "getSnapshotBeforeUpdate()";
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+        if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
+          didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
 
-    if (rootOrSingletonContext && isHydratable) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableTextInstance();
+          error(
+            "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" +
+              "The above lifecycles should be removed. Learn more about this warning here:\n" +
+              "https://reactjs.org/link/unsafe-component-lifecycles",
+            _componentName,
+            newApiName,
+            foundWillMountName !== null ? "\n  " + foundWillMountName : "",
+            foundWillReceivePropsName !== null
+              ? "\n  " + foundWillReceivePropsName
+              : "",
+            foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : ""
+          );
+        }
+      }
     }
+  } // Cache unmasked context so we can avoid recreating masked context unless necessary.
 
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateText(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
+  return instance;
+}
 
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+function callComponentWillMount(workInProgress, instance) {
+  var oldState = instance.state;
+
+  if (typeof instance.componentWillMount === "function") {
+    instance.componentWillMount();
   }
-}
 
-function tryToClaimNextHydratableSuspenseInstance(fiber) {
-  if (!isHydrating) {
-    return;
+  if (typeof instance.UNSAFE_componentWillMount === "function") {
+    instance.UNSAFE_componentWillMount();
   }
 
-  var initialInstance = nextHydratableInstance;
+  if (oldState !== instance.state) {
+    {
+      error(
+        "%s.componentWillMount(): Assigning directly to this.state is " +
+          "deprecated (except inside a component's " +
+          "constructor). Use setState instead.",
+        getComponentNameFromFiber(workInProgress) || "Component"
+      );
+    }
 
-  if (rootOrSingletonContext) {
-    // We may need to skip past certain nodes in these contexts
-    advanceToFirstAttemptableSuspenseInstance();
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
   }
+}
 
-  var nextInstance = nextHydratableInstance;
-
-  if (!nextInstance) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // Nothing to hydrate. Make it an insertion.
+function callComponentWillReceiveProps(
+  workInProgress,
+  instance,
+  newProps,
+  nextContext
+) {
+  var oldState = instance.state;
 
-    insertNonHydratedInstance(hydrationParentFiber, fiber);
-    isHydrating = false;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = initialInstance;
-    return;
+  if (typeof instance.componentWillReceiveProps === "function") {
+    instance.componentWillReceiveProps(newProps, nextContext);
   }
 
-  var firstAttemptedInstance = nextInstance;
+  if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  }
 
-  if (!tryHydrateSuspense(fiber, nextInstance)) {
-    if (shouldClientRenderOnMismatch(fiber)) {
-      warnNonhydratedInstance(hydrationParentFiber, fiber);
-      throwOnHydrationMismatch();
-    } // If we can't hydrate this instance let's try the next one.
-    // We use this as a heuristic. It's based on intuition and not data so it
-    // might be flawed or unnecessary.
+  if (instance.state !== oldState) {
+    {
+      var componentName =
+        getComponentNameFromFiber(workInProgress) || "Component";
 
-    nextHydratableInstance = getNextHydratableSibling(nextInstance);
-    var prevHydrationParentFiber = hydrationParentFiber;
+      if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
+        didWarnAboutStateAssignmentForComponent.add(componentName);
 
-    if (rootOrSingletonContext) {
-      // We may need to skip past certain nodes in these contexts
-      advanceToFirstAttemptableSuspenseInstance();
+        error(
+          "%s.componentWillReceiveProps(): Assigning directly to " +
+            "this.state is deprecated (except inside a component's " +
+            "constructor). Use setState instead.",
+          componentName
+        );
+      }
     }
 
-    if (
-      !nextHydratableInstance ||
-      !tryHydrateSuspense(fiber, nextHydratableInstance)
-    ) {
-      // Nothing to hydrate. Make it an insertion.
-      insertNonHydratedInstance(hydrationParentFiber, fiber);
-      isHydrating = false;
-      hydrationParentFiber = fiber;
-      nextHydratableInstance = initialInstance;
-      return;
-    } // We matched the next one, we'll now assume that the first one was
-    // superfluous and we'll delete it. Since we can't eagerly delete it
-    // we'll have to schedule a deletion. To do that, this node needs a dummy
-    // fiber associated with it.
-
-    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
   }
-}
+} // Invokes the mount life-cycles on a previously never rendered instance.
 
-function prepareToHydrateHostInstance(fiber, hostContext) {
-  var instance = fiber.stateNode;
-  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  var updatePayload = hydrateInstance(
-    instance,
-    fiber.type,
-    fiber.memoizedProps,
-    hostContext,
-    fiber,
-    shouldWarnIfMismatchDev
-  ); // TODO: Type this specific to this type of component.
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  {
+    checkClassInstance(workInProgress, ctor, newProps);
+  }
 
-  fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
-  // is a new ref we mark this as an update.
+  var instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  var contextType = ctor.contextType;
 
-  if (updatePayload !== null) {
-    return true;
+  if (typeof contextType === "object" && contextType !== null) {
+    instance.context = readContext(contextType);
+  } else {
+    instance.context = emptyContextObject;
   }
 
-  return false;
-}
+  {
+    if (instance.state === newProps) {
+      var componentName = getComponentNameFromType(ctor) || "Component";
 
-function prepareToHydrateHostTextInstance(fiber) {
-  var textInstance = fiber.stateNode;
-  var textContent = fiber.memoizedProps;
-  var shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;
-  var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
+      if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
+        didWarnAboutDirectlyAssigningPropsToState.add(componentName);
 
-  if (shouldUpdate) {
-    // We assume that prepareToHydrateHostTextInstance is called in a context where the
-    // hydration parent is the parent host component of this host text.
-    var returnFiber = hydrationParentFiber;
+        error(
+          "%s: It is not recommended to assign props directly to state " +
+            "because updates to props won't be reflected in state. " +
+            "In most cases, it is better to use props directly.",
+          componentName
+        );
+      }
+    }
 
-    if (returnFiber !== null) {
-      switch (returnFiber.tag) {
-        case HostRoot: {
-          var parentContainer = returnFiber.stateNode.containerInfo;
-          var isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;
-          didNotMatchHydratedContainerTextInstance(
-            parentContainer,
-            textInstance,
-            textContent, // TODO: Delete this argument when we remove the legacy root API.
-            isConcurrentMode,
-            shouldWarnIfMismatchDev
-          );
-          break;
-        }
+    if (workInProgress.mode & StrictLegacyMode) {
+      ReactStrictModeWarnings.recordLegacyContextWarning(
+        workInProgress,
+        instance
+      );
+    }
 
-        case HostSingleton:
-        case HostComponent: {
-          var parentType = returnFiber.type;
-          var parentProps = returnFiber.memoizedProps;
-          var parentInstance = returnFiber.stateNode;
+    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
+      workInProgress,
+      instance
+    );
+  }
 
-          var _isConcurrentMode2 =
-            (returnFiber.mode & ConcurrentMode) !== NoMode;
+  instance.state = workInProgress.memoizedState;
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
 
-          didNotMatchHydratedTextInstance(
-            parentType,
-            parentProps,
-            parentInstance,
-            textInstance,
-            textContent, // TODO: Delete this argument when we remove the legacy root API.
-            _isConcurrentMode2,
-            shouldWarnIfMismatchDev
-          );
-          break;
-        }
-      }
-    }
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    instance.state = workInProgress.memoizedState;
+  } // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
+
+  if (
+    typeof ctor.getDerivedStateFromProps !== "function" &&
+    typeof instance.getSnapshotBeforeUpdate !== "function" &&
+    (typeof instance.UNSAFE_componentWillMount === "function" ||
+      typeof instance.componentWillMount === "function")
+  ) {
+    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
+    // process them now.
+
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+    instance.state = workInProgress.memoizedState;
   }
 
-  return shouldUpdate;
-}
+  if (typeof instance.componentDidMount === "function") {
+    var fiberFlags = Update | LayoutStatic;
 
-function prepareToHydrateHostSuspenseInstance(fiber) {
-  var suspenseState = fiber.memoizedState;
-  var suspenseInstance =
-    suspenseState !== null ? suspenseState.dehydrated : null;
+    if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+      fiberFlags |= MountLayoutDev;
+    }
 
-  if (!suspenseInstance) {
-    throw new Error(
-      "Expected to have a hydrated suspense instance. " +
-        "This error is likely caused by a bug in React. Please file an issue."
-    );
+    workInProgress.flags |= fiberFlags;
   }
-
-  hydrateSuspenseInstance(suspenseInstance, fiber);
 }
 
-function skipPastDehydratedSuspenseInstance(fiber) {
-  var suspenseState = fiber.memoizedState;
-  var suspenseInstance =
-    suspenseState !== null ? suspenseState.dehydrated : null;
+function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  var instance = workInProgress.stateNode;
+  var oldProps = workInProgress.memoizedProps;
+  instance.props = oldProps;
+  var oldContext = instance.context;
+  var contextType = ctor.contextType;
+  var nextContext = emptyContextObject;
 
-  if (!suspenseInstance) {
-    throw new Error(
-      "Expected to have a hydrated suspense instance. " +
-        "This error is likely caused by a bug in React. Please file an issue."
-    );
+  if (typeof contextType === "object" && contextType !== null) {
+    nextContext = readContext(contextType);
   }
 
-  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
-}
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  var hasNewLifecycles =
+    typeof getDerivedStateFromProps === "function" ||
+    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
 
-function popToNextHostParent(fiber) {
-  hydrationParentFiber = fiber.return;
+  if (
+    !hasNewLifecycles &&
+    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
+      typeof instance.componentWillReceiveProps === "function")
+  ) {
+    if (oldProps !== newProps || oldContext !== nextContext) {
+      callComponentWillReceiveProps(
+        workInProgress,
+        instance,
+        newProps,
+        nextContext
+      );
+    }
+  }
 
-  while (hydrationParentFiber) {
-    switch (hydrationParentFiber.tag) {
-      case HostRoot:
-      case HostSingleton:
-        rootOrSingletonContext = true;
-        return;
+  resetHasForceUpdateBeforeProcessing();
+  var oldState = workInProgress.memoizedState;
+  var newState = (instance.state = oldState);
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
 
-      case HostComponent:
-      case SuspenseComponent:
-        rootOrSingletonContext = false;
-        return;
+  if (
+    oldProps === newProps &&
+    oldState === newState &&
+    !hasContextChanged() &&
+    !checkHasForceUpdateAfterProcessing()
+  ) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === "function") {
+      var fiberFlags = Update | LayoutStatic;
 
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        fiberFlags |= MountLayoutDev;
+      }
+
+      workInProgress.flags |= fiberFlags;
     }
-  }
-}
 
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) {
-    // We're deeper than the current hydration context, inside an inserted
-    // tree.
     return false;
   }
 
-  if (!isHydrating) {
-    // If we're not currently hydrating but we're in a hydration context, then
-    // we were an insertion and now need to pop up reenter hydration of our
-    // siblings.
-    popToNextHostParent(fiber);
-    isHydrating = true;
-    return false;
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    newState = workInProgress.memoizedState;
   }
 
-  var shouldClear = false;
+  var shouldUpdate =
+    checkHasForceUpdateAfterProcessing() ||
+    checkShouldComponentUpdate(
+      workInProgress,
+      ctor,
+      oldProps,
+      newProps,
+      oldState,
+      newState,
+      nextContext
+    );
 
-  {
-    // With float we never clear the Root, or Singleton instances. We also do not clear Instances
-    // that have singleton text content
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
     if (
-      fiber.tag !== HostRoot &&
-      fiber.tag !== HostSingleton &&
-      !(
-        fiber.tag === HostComponent &&
-        shouldSetTextContent(fiber.type, fiber.memoizedProps)
-      )
+      !hasNewLifecycles &&
+      (typeof instance.UNSAFE_componentWillMount === "function" ||
+        typeof instance.componentWillMount === "function")
     ) {
-      shouldClear = true;
-    }
-  }
-
-  if (shouldClear) {
-    var nextInstance = nextHydratableInstance;
+      if (typeof instance.componentWillMount === "function") {
+        instance.componentWillMount();
+      }
 
-    if (nextInstance) {
-      if (shouldClientRenderOnMismatch(fiber)) {
-        warnIfUnhydratedTailNodes(fiber);
-        throwOnHydrationMismatch();
-      } else {
-        while (nextInstance) {
-          deleteHydratableInstance(fiber, nextInstance);
-          nextInstance = getNextHydratableSibling(nextInstance);
-        }
+      if (typeof instance.UNSAFE_componentWillMount === "function") {
+        instance.UNSAFE_componentWillMount();
       }
     }
-  }
 
-  popToNextHostParent(fiber);
+    if (typeof instance.componentDidMount === "function") {
+      var _fiberFlags = Update | LayoutStatic;
 
-  if (fiber.tag === SuspenseComponent) {
-    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);
-  } else {
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratableSibling(fiber.stateNode)
-      : null;
-  }
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        _fiberFlags |= MountLayoutDev;
+      }
 
-  return true;
-}
+      workInProgress.flags |= _fiberFlags;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidMount === "function") {
+      var _fiberFlags2 = Update | LayoutStatic;
 
-function hasUnhydratedTailNodes() {
-  return isHydrating && nextHydratableInstance !== null;
-}
+      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
+        _fiberFlags2 |= MountLayoutDev;
+      }
 
-function warnIfUnhydratedTailNodes(fiber) {
-  var nextInstance = nextHydratableInstance;
+      workInProgress.flags |= _fiberFlags2;
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized state to indicate that this work can be reused.
 
-  while (nextInstance) {
-    warnUnhydratedInstance(fiber, nextInstance);
-    nextInstance = getNextHydratableSibling(nextInstance);
-  }
-}
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
 
-function resetHydrationState() {
-  hydrationParentFiber = null;
-  nextHydratableInstance = null;
-  isHydrating = false;
-  didSuspendOrErrorDEV = false;
-}
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
+} // Invokes the update life-cycles and returns false if it shouldn't rerender.
 
-function upgradeHydrationErrorsToRecoverable() {
-  if (hydrationErrors !== null) {
-    // Successfully completed a forced client render. The errors that occurred
-    // during the hydration attempt are now recovered. We will log them in
-    // commit phase, once the entire tree has finished.
-    queueRecoverableErrors(hydrationErrors);
-    hydrationErrors = null;
+function updateClassInstance(
+  current,
+  workInProgress,
+  ctor,
+  newProps,
+  renderLanes
+) {
+  var instance = workInProgress.stateNode;
+  cloneUpdateQueue(current, workInProgress);
+  var unresolvedOldProps = workInProgress.memoizedProps;
+  var oldProps =
+    workInProgress.type === workInProgress.elementType
+      ? unresolvedOldProps
+      : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
+  instance.props = oldProps;
+  var unresolvedNewProps = workInProgress.pendingProps;
+  var oldContext = instance.context;
+  var contextType = ctor.contextType;
+  var nextContext = emptyContextObject;
+
+  if (typeof contextType === "object" && contextType !== null) {
+    nextContext = readContext(contextType);
   }
-}
 
-function getIsHydrating() {
-  return isHydrating;
-}
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+  var hasNewLifecycles =
+    typeof getDerivedStateFromProps === "function" ||
+    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
+  // ever the previously attempted to render - not the "current". However,
+  // during componentDidUpdate we pass the "current" props.
+  // In order to support react-lifecycles-compat polyfilled components,
+  // Unsafe lifecycles should not be invoked for components using the new APIs.
 
-function queueHydrationError(error) {
-  if (hydrationErrors === null) {
-    hydrationErrors = [error];
-  } else {
-    hydrationErrors.push(error);
+  if (
+    !hasNewLifecycles &&
+    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
+      typeof instance.componentWillReceiveProps === "function")
+  ) {
+    if (
+      unresolvedOldProps !== unresolvedNewProps ||
+      oldContext !== nextContext
+    ) {
+      callComponentWillReceiveProps(
+        workInProgress,
+        instance,
+        newProps,
+        nextContext
+      );
+    }
   }
-}
 
-// we wait until the current render is over (either finished or interrupted)
-// before adding it to the fiber/hook queue. Push to this array so we can
-// access the queue, fiber, update, et al later.
+  resetHasForceUpdateBeforeProcessing();
+  var oldState = workInProgress.memoizedState;
+  var newState = (instance.state = oldState);
+  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
+  newState = workInProgress.memoizedState;
 
-var concurrentQueues = [];
-var concurrentQueuesIndex = 0;
-var concurrentlyUpdatedLanes = NoLanes;
-function finishQueueingConcurrentUpdates() {
-  var endIndex = concurrentQueuesIndex;
-  concurrentQueuesIndex = 0;
-  concurrentlyUpdatedLanes = NoLanes;
-  var i = 0;
+  if (
+    unresolvedOldProps === unresolvedNewProps &&
+    oldState === newState &&
+    !hasContextChanged() &&
+    !checkHasForceUpdateAfterProcessing() &&
+    !(
+      enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies)
+    )
+  ) {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Update;
+      }
+    }
 
-  while (i < endIndex) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Snapshot;
+      }
+    }
 
-    if (queue !== null && update !== null) {
-      var pending = queue.pending;
+    return false;
+  }
 
-      if (pending === null) {
-        // This is the first update. Create a circular list.
-        update.next = update;
-      } else {
-        update.next = pending.next;
-        pending.next = update;
+  if (typeof getDerivedStateFromProps === "function") {
+    applyDerivedStateFromProps(
+      workInProgress,
+      ctor,
+      getDerivedStateFromProps,
+      newProps
+    );
+    newState = workInProgress.memoizedState;
+  }
+
+  var shouldUpdate =
+    checkHasForceUpdateAfterProcessing() ||
+    checkShouldComponentUpdate(
+      workInProgress,
+      ctor,
+      oldProps,
+      newProps,
+      oldState,
+      newState,
+      nextContext
+    ) || // TODO: In some cases, we'll end up checking if context has changed twice,
+    // both before and after `shouldComponentUpdate` has been called. Not ideal,
+    // but I'm loath to refactor this function. This only happens for memoized
+    // components so it's not that common.
+    (enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies));
+
+  if (shouldUpdate) {
+    // In order to support react-lifecycles-compat polyfilled components,
+    // Unsafe lifecycles should not be invoked for components using the new APIs.
+    if (
+      !hasNewLifecycles &&
+      (typeof instance.UNSAFE_componentWillUpdate === "function" ||
+        typeof instance.componentWillUpdate === "function")
+    ) {
+      if (typeof instance.componentWillUpdate === "function") {
+        instance.componentWillUpdate(newProps, newState, nextContext);
       }
 
-      queue.pending = update;
+      if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+      }
     }
 
-    if (lane !== NoLane) {
-      markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    if (typeof instance.componentDidUpdate === "function") {
+      workInProgress.flags |= Update;
     }
-  }
-}
-function getConcurrentlyUpdatedLanes() {
-  return concurrentlyUpdatedLanes;
-}
 
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  // Don't update the `childLanes` on the return path yet. If we already in
-  // the middle of rendering, wait until after it has completed.
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes = mergeLanes(concurrentlyUpdatedLanes, lane); // The fiber's `lane` field is used in some places to check if any work is
-  // scheduled, to perform an eager bailout, so we need to update it immediately.
-  // TODO: We should probably move this to the "shared" queue instead.
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      workInProgress.flags |= Snapshot;
+    }
+  } else {
+    // If an update was already in progress, we should schedule an Update
+    // effect even though we're bailing out, so that cWU/cDU are called.
+    if (typeof instance.componentDidUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Update;
+      }
+    }
 
-  fiber.lanes = mergeLanes(fiber.lanes, lane);
-  var alternate = fiber.alternate;
+    if (typeof instance.getSnapshotBeforeUpdate === "function") {
+      if (
+        unresolvedOldProps !== current.memoizedProps ||
+        oldState !== current.memoizedState
+      ) {
+        workInProgress.flags |= Snapshot;
+      }
+    } // If shouldComponentUpdate returned false, we should still update the
+    // memoized props/state to indicate that this work can be reused.
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, lane);
-  }
+    workInProgress.memoizedProps = newProps;
+    workInProgress.memoizedState = newState;
+  } // Update the existing instance's state, props, and context pointers even
+  // if shouldComponentUpdate returns false.
+
+  instance.props = newProps;
+  instance.state = newState;
+  instance.context = nextContext;
+  return shouldUpdate;
 }
 
-function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
-  return getRootForUpdatedFiber(fiber);
+function createCapturedValueAtFiber(value, source) {
+  // If the value is an error, call this function immediately after it is thrown
+  // so the stack is accurate.
+  return {
+    value: value,
+    source: source,
+    stack: getStackByFiberInDevAndProd(source),
+    digest: null
+  };
+}
+function createCapturedValue(value, digest, stack) {
+  return {
+    value: value,
+    source: null,
+    stack: stack != null ? stack : null,
+    digest: digest != null ? digest : null
+  };
 }
-function enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update) {
-  // This function is used to queue an update that doesn't need a rerender. The
-  // only reason we queue it is in case there's a subsequent higher priority
-  // update that causes it to be rebased.
-  var lane = NoLane;
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane); // Usually we can rely on the upcoming render phase to process the concurrent
-  // queue. However, since this is a bail out, we're not scheduling any work
-  // here. So the update we just queued will leak until something else happens
-  // to schedule work (if ever).
-  //
-  // Check if we're currently in the middle of rendering a tree, and if not,
-  // process the queue immediately to prevent a leak.
 
-  var isConcurrentlyRendering = getWorkInProgressRoot() !== null;
+var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
 
-  if (!isConcurrentlyRendering) {
-    finishQueueingConcurrentUpdates();
-  }
-}
-function enqueueConcurrentClassUpdate(fiber, queue, update, lane) {
-  var concurrentQueue = queue;
-  var concurrentUpdate = update;
-  enqueueUpdate$1(fiber, concurrentQueue, concurrentUpdate, lane);
-  return getRootForUpdatedFiber(fiber);
+if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== "function") {
+  throw new Error(
+    "Expected ReactFiberErrorDialog.showErrorDialog to be a function."
+  );
 }
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
-} // Calling this function outside this module should only be done for backwards
-// compatibility and should always be accompanied by a warning.
 
-function unsafe_markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
-  // NOTE: For Hyrum's Law reasons, if an infinite update loop is detected, it
-  // should throw before `markUpdateLaneFromFiberToRoot` is called. But this is
-  // undefined behavior and we can change it if we need to; it just so happens
-  // that, at the time of this writing, there's an internal product test that
-  // happens to rely on this.
-  var root = getRootForUpdatedFiber(sourceFiber);
-  markUpdateLaneFromFiberToRoot(sourceFiber, null, lane);
-  return root;
+function showErrorDialog(boundary, errorInfo) {
+  var capturedError = {
+    componentStack: errorInfo.stack !== null ? errorInfo.stack : "",
+    error: errorInfo.value,
+    errorBoundary:
+      boundary !== null && boundary.tag === ClassComponent
+        ? boundary.stateNode
+        : null
+  };
+  return ReactFiberErrorDialogWWW.showErrorDialog(capturedError);
 }
 
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  // Update the source fiber's lanes
-  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
-  var alternate = sourceFiber.alternate;
+function logCapturedError(boundary, errorInfo) {
+  try {
+    var logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
+    // This enables renderers like ReactNative to better manage redbox behavior.
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, lane);
-  } // Walk the parent path to the root and update the child lanes.
+    if (logError === false) {
+      return;
+    }
 
-  var isHidden = false;
-  var parent = sourceFiber.return;
-  var node = sourceFiber;
+    var error = errorInfo.value;
 
-  while (parent !== null) {
-    parent.childLanes = mergeLanes(parent.childLanes, lane);
-    alternate = parent.alternate;
+    if (true) {
+      var source = errorInfo.source;
+      var stack = errorInfo.stack;
+      var componentStack = stack !== null ? stack : ""; // Browsers support silencing uncaught errors by calling
+      // `preventDefault()` in window `error` handler.
+      // We record this information as an expando on the error.
 
-    if (alternate !== null) {
-      alternate.childLanes = mergeLanes(alternate.childLanes, lane);
-    }
+      if (error != null && error._suppressLogging) {
+        if (boundary.tag === ClassComponent) {
+          // The error is recoverable and was silenced.
+          // Ignore it and don't print the stack addendum.
+          // This is handy for testing error boundaries without noise.
+          return;
+        } // The error is fatal. Since the silencing might have
+        // been accidental, we'll surface it anyway.
+        // However, the browser would have silenced the original error
+        // so we'll print it first, and then print the stack addendum.
 
-    if (parent.tag === OffscreenComponent) {
-      // Check if this offscreen boundary is currently hidden.
-      //
-      // The instance may be null if the Offscreen parent was unmounted. Usually
-      // the parent wouldn't be reachable in that case because we disconnect
-      // fibers from the tree when they are deleted. However, there's a weird
-      // edge case where setState is called on a fiber that was interrupted
-      // before it ever mounted. Because it never mounts, it also never gets
-      // deleted. Because it never gets deleted, its return pointer never gets
-      // disconnected. Which means it may be attached to a deleted Offscreen
-      // parent node. (This discovery suggests it may be better for memory usage
-      // if we don't attach the `return` pointer until the commit phase, though
-      // in order to do that we'd need some other way to track the return
-      // pointer during the initial render, like on the stack.)
-      //
-      // This case is always accompanied by a warning, but we still need to
-      // account for it. (There may be other cases that we haven't discovered,
-      // too.)
-      var offscreenInstance = parent.stateNode;
+        console["error"](error); // Don't transform to our wrapper
+        // For a more detailed description of this block, see:
+        // https://github.com/facebook/react/pull/13384
+      }
 
-      if (
-        offscreenInstance !== null &&
-        !(offscreenInstance._visibility & OffscreenVisible)
-      ) {
-        isHidden = true;
+      var componentName = source ? getComponentNameFromFiber(source) : null;
+      var componentNameMessage = componentName
+        ? "The above error occurred in the <" + componentName + "> component:"
+        : "The above error occurred in one of your React components:";
+      var errorBoundaryMessage;
+
+      if (boundary.tag === HostRoot) {
+        errorBoundaryMessage =
+          "Consider adding an error boundary to your tree to customize error handling behavior.\n" +
+          "Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.";
+      } else {
+        var errorBoundaryName =
+          getComponentNameFromFiber(boundary) || "Anonymous";
+        errorBoundaryMessage =
+          "React will try to recreate this component tree from scratch " +
+          ("using the error boundary you provided, " + errorBoundaryName + ".");
       }
-    }
 
-    node = parent;
-    parent = parent.return;
-  }
+      var combinedMessage =
+        componentNameMessage +
+        "\n" +
+        componentStack +
+        "\n\n" +
+        ("" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.
+      // We don't include the original error message and JS stack because the browser
+      // has already printed it. Even if the application swallows the error, it is still
+      // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
 
-  if (isHidden && update !== null && node.tag === HostRoot) {
-    var root = node.stateNode;
-    markHiddenUpdate(root, update, lane);
+      console["error"](combinedMessage); // Don't transform to our wrapper
+    }
+  } catch (e) {
+    // This method must not throw, or React internal state will get messed up.
+    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
+    // we want to report this error outside of the normal stack as a last resort.
+    // https://github.com/facebook/react/issues/13188
+    setTimeout(function () {
+      throw e;
+    });
   }
 }
 
-function getRootForUpdatedFiber(sourceFiber) {
-  // TODO: We will detect and infinite update loop and throw even if this fiber
-  // has already unmounted. This isn't really necessary but it happens to be the
-  // current behavior we've used for several release cycles. Consider not
-  // performing this check if the updated fiber already unmounted, since it's
-  // not possible for that to cause an infinite update loop.
-  throwIfInfiniteUpdateLoopDetected(); // When a setState happens, we must ensure the root is scheduled. Because
-  // update queues do not have a backpointer to the root, the only way to do
-  // this currently is to walk up the return path. This used to not be a big
-  // deal because we would have to walk up the return path to set
-  // the `childLanes`, anyway, but now those two traversals happen at
-  // different times.
-  // TODO: Consider adding a `root` backpointer on the update queue.
-
-  detectUpdateOnUnmountedFiber(sourceFiber, sourceFiber);
-  var node = sourceFiber;
-  var parent = node.return;
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  var update = createUpdate(lane); // Unmount the root by rendering null.
 
-  while (parent !== null) {
-    detectUpdateOnUnmountedFiber(sourceFiber, node);
-    node = parent;
-    parent = node.return;
-  }
+  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-  return node.tag === HostRoot ? node.stateNode : null;
-}
+  update.payload = {
+    element: null
+  };
+  var error = errorInfo.value;
 
-function detectUpdateOnUnmountedFiber(sourceFiber, parent) {
-  {
-    var alternate = parent.alternate;
+  update.callback = function () {
+    onUncaughtError(error);
+    logCapturedError(fiber, errorInfo);
+  };
 
-    if (
-      alternate === null &&
-      (parent.flags & (Placement | Hydrating)) !== NoFlags$1
-    ) {
-      warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
-    }
-  }
+  return update;
 }
 
-var UpdateState = 0;
-var ReplaceState = 1;
-var ForceUpdate = 2;
-var CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.
-// It should only be read right after calling `processUpdateQueue`, via
-// `checkHasForceUpdateAfterProcessing`.
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  var update = createUpdate(lane);
+  update.tag = CaptureUpdate;
+  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
 
-var hasForceUpdate = false;
-var didWarnUpdateInsideUpdate;
-var currentlyProcessingQueue;
+  if (typeof getDerivedStateFromError === "function") {
+    var error$1 = errorInfo.value;
 
-{
-  didWarnUpdateInsideUpdate = false;
-  currentlyProcessingQueue = null;
-}
+    update.payload = function () {
+      return getDerivedStateFromError(error$1);
+    };
 
-function initializeUpdateQueue(fiber) {
-  var queue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: {
-      pending: null,
-      lanes: NoLanes,
-      hiddenCallbacks: null
-    },
-    callbacks: null
-  };
-  fiber.updateQueue = queue;
-}
-function cloneUpdateQueue(current, workInProgress) {
-  // Clone the update queue from current. Unless it's already a clone.
-  var queue = workInProgress.updateQueue;
-  var currentQueue = current.updateQueue;
+    update.callback = function () {
+      {
+        markFailedErrorBoundaryForHotReloading(fiber);
+      }
 
-  if (queue === currentQueue) {
-    var clone = {
-      baseState: currentQueue.baseState,
-      firstBaseUpdate: currentQueue.firstBaseUpdate,
-      lastBaseUpdate: currentQueue.lastBaseUpdate,
-      shared: currentQueue.shared,
-      callbacks: null
+      logCapturedError(fiber, errorInfo);
     };
-    workInProgress.updateQueue = clone;
   }
-}
-function createUpdate(lane) {
-  var update = {
-    lane: lane,
-    tag: UpdateState,
-    payload: null,
-    callback: null,
-    next: null
-  };
-  return update;
-}
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
-
-  if (updateQueue === null) {
-    // Only occurs if the fiber has been unmounted.
-    return null;
-  }
-
-  var sharedQueue = updateQueue.shared;
-
-  {
-    if (
-      currentlyProcessingQueue === sharedQueue &&
-      !didWarnUpdateInsideUpdate
-    ) {
-      var componentName = getComponentNameFromFiber(fiber);
 
-      error(
-        "An update (setState, replaceState, or forceUpdate) was scheduled " +
-          "from inside an update function. Update functions should be pure, " +
-          "with zero side-effects. Consider using componentDidUpdate or a " +
-          "callback.\n\nPlease update the following component: %s",
-        componentName
-      );
+  var inst = fiber.stateNode;
 
-      didWarnUpdateInsideUpdate = true;
-    }
-  }
+  if (inst !== null && typeof inst.componentDidCatch === "function") {
+    // $FlowFixMe[missing-this-annot]
+    update.callback = function callback() {
+      {
+        markFailedErrorBoundaryForHotReloading(fiber);
+      }
 
-  if (isUnsafeClassRenderPhaseUpdate(fiber)) {
-    // This is an unsafe render phase update. Add directly to the update
-    // queue so we can process it immediately during the current render.
-    var pending = sharedQueue.pending;
+      logCapturedError(fiber, errorInfo);
 
-    if (pending === null) {
-      // This is the first update. Create a circular list.
-      update.next = update;
-    } else {
-      update.next = pending.next;
-      pending.next = update;
-    }
+      if (typeof getDerivedStateFromError !== "function") {
+        // To preserve the preexisting retry behavior of error boundaries,
+        // we keep track of which ones already failed during this batch.
+        // This gets reset before we yield back to the browser.
+        // TODO: Warn in strict mode if getDerivedStateFromError is
+        // not defined.
+        markLegacyErrorBoundaryAsFailed(this);
+      }
 
-    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering
-    // this fiber. This is for backwards compatibility in the case where you
-    // update a different component during render phase than the one that is
-    // currently renderings (a pattern that is accompanied by a warning).
+      var error$1 = errorInfo.value;
+      var stack = errorInfo.stack;
+      this.componentDidCatch(error$1, {
+        componentStack: stack !== null ? stack : ""
+      });
 
-    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);
-  } else {
-    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);
+      {
+        if (typeof getDerivedStateFromError !== "function") {
+          // If componentDidCatch is the only error boundary method defined,
+          // then it needs to call setState to recover from errors.
+          // If no state update is scheduled then the boundary will swallow the error.
+          if (!includesSomeLane(fiber.lanes, SyncLane)) {
+            error(
+              "%s: Error boundaries should implement getDerivedStateFromError(). " +
+                "In that method, return a state update to display an error message or fallback UI.",
+              getComponentNameFromFiber(fiber) || "Unknown"
+            );
+          }
+        }
+      }
+    };
   }
-}
-function entangleTransitions(root, fiber, lane) {
-  var updateQueue = fiber.updateQueue;
 
-  if (updateQueue === null) {
-    // Only occurs if the fiber has been unmounted.
-    return;
-  }
+  return update;
+}
 
-  var sharedQueue = updateQueue.shared;
+function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
+  if (enableLazyContextPropagation) {
+    var currentSourceFiber = sourceFiber.alternate;
 
-  if (isTransitionLane(lane)) {
-    var queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must
-    // have finished. We can remove them from the shared queue, which represents
-    // a superset of the actually pending lanes. In some cases we may entangle
-    // more than we need to, but that's OK. In fact it's worse if we *don't*
-    // entangle when we should.
+    if (currentSourceFiber !== null) {
+      // Since we never visited the children of the suspended component, we
+      // need to propagate the context change now, to ensure that we visit
+      // them during the retry.
+      //
+      // We don't have to do this for errors because we retry errors without
+      // committing in between. So this is specific to Suspense.
+      propagateParentContextChangesToDeferredTree(
+        currentSourceFiber,
+        sourceFiber,
+        rootRenderLanes
+      );
+    }
+  } // Reset the memoizedState to what it was before we attempted to render it.
+  // A legacy mode Suspense quirk, only relevant to hook components.
 
-    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+  var tag = sourceFiber.tag;
 
-    var newQueueLanes = mergeLanes(queueLanes, lane);
-    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
-    // the lane finished since the last time we entangled it. So we need to
-    // entangle it again, just to be sure.
+  if (
+    (sourceFiber.mode & ConcurrentMode) === NoMode &&
+    (tag === FunctionComponent ||
+      tag === ForwardRef ||
+      tag === SimpleMemoComponent)
+  ) {
+    var currentSource = sourceFiber.alternate;
 
-    markRootEntangled(root, newQueueLanes);
+    if (currentSource) {
+      sourceFiber.updateQueue = currentSource.updateQueue;
+      sourceFiber.memoizedState = currentSource.memoizedState;
+      sourceFiber.lanes = currentSource.lanes;
+    } else {
+      sourceFiber.updateQueue = null;
+      sourceFiber.memoizedState = null;
+    }
   }
 }
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  // Captured updates are updates that are thrown by a child during the render
-  // phase. They should be discarded if the render is aborted. Therefore,
-  // we should only put them on the work-in-progress queue, not the current one.
-  var queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.
-
-  var current = workInProgress.alternate;
-
-  if (current !== null) {
-    var currentQueue = current.updateQueue;
-
-    if (queue === currentQueue) {
-      // The work-in-progress queue is the same as current. This happens when
-      // we bail out on a parent fiber that then captures an error thrown by
-      // a child. Since we want to append the update only to the work-in
-      // -progress queue, we need to clone the updates. We usually clone during
-      // processUpdateQueue, but that didn't happen in this case because we
-      // skipped over the parent when we bailed out.
-      var newFirst = null;
-      var newLast = null;
-      var firstBaseUpdate = queue.firstBaseUpdate;
-
-      if (firstBaseUpdate !== null) {
-        // Loop through the updates and clone them.
-        var update = firstBaseUpdate;
 
-        do {
-          var clone = {
-            lane: update.lane,
-            tag: update.tag,
-            payload: update.payload,
-            // When this update is rebased, we should not fire its
-            // callback again.
-            callback: null,
-            next: null
-          };
+function markSuspenseBoundaryShouldCapture(
+  suspenseBoundary,
+  returnFiber,
+  sourceFiber,
+  root,
+  rootRenderLanes
+) {
+  // This marks a Suspense boundary so that when we're unwinding the stack,
+  // it captures the suspended "exception" and does a second (fallback) pass.
+  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
+    // Legacy Mode Suspense
+    //
+    // If the boundary is in legacy mode, we should *not*
+    // suspend the commit. Pretend as if the suspended component rendered
+    // null and keep rendering. When the Suspense boundary completes,
+    // we'll do a second pass to render the fallback.
+    if (suspenseBoundary === returnFiber) {
+      // Special case where we suspended while reconciling the children of
+      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
+      // when a React.lazy component is a direct child of a
+      // Suspense boundary.
+      //
+      // Suspense boundaries are implemented as multiple fibers, but they
+      // are a single conceptual unit. The legacy mode behavior where we
+      // pretend the suspended fiber committed as `null` won't work,
+      // because in this case the "suspended" fiber is the inner
+      // Offscreen wrapper.
+      //
+      // Because the contents of the boundary haven't started rendering
+      // yet (i.e. nothing in the tree has partially rendered) we can
+      // switch to the regular, concurrent mode behavior: mark the
+      // boundary with ShouldCapture and enter the unwind phase.
+      suspenseBoundary.flags |= ShouldCapture;
+    } else {
+      suspenseBoundary.flags |= DidCapture;
+      sourceFiber.flags |= ForceUpdateForLegacySuspense; // 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.
 
-          if (newLast === null) {
-            newFirst = newLast = clone;
-          } else {
-            newLast.next = clone;
-            newLast = clone;
-          } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
 
-          update = update.next;
-        } while (update !== null); // Append the captured update the end of the cloned list.
+      if (sourceFiber.tag === ClassComponent) {
+        var currentSourceFiber = sourceFiber.alternate;
 
-        if (newLast === null) {
-          newFirst = newLast = capturedUpdate;
+        if (currentSourceFiber === null) {
+          // This is a new mount. Change the tag so it's not mistaken for a
+          // completed class component. For example, we should not call
+          // componentWillUnmount if it is deleted.
+          sourceFiber.tag = IncompleteClassComponent;
         } else {
-          newLast.next = capturedUpdate;
-          newLast = capturedUpdate;
+          // When we try rendering again, we should not reuse the current fiber,
+          // since it's known to be in an inconsistent state. Use a force update to
+          // prevent a bail out.
+          var update = createUpdate(SyncLane);
+          update.tag = ForceUpdate;
+          enqueueUpdate(sourceFiber, update, SyncLane);
         }
-      } else {
-        // There are no base updates.
-        newFirst = newLast = capturedUpdate;
-      }
+      } // The source fiber did not complete. Mark it with Sync priority to
+      // indicate that it still has pending work.
 
-      queue = {
-        baseState: currentQueue.baseState,
-        firstBaseUpdate: newFirst,
-        lastBaseUpdate: newLast,
-        shared: currentQueue.shared,
-        callbacks: currentQueue.callbacks
-      };
-      workInProgress.updateQueue = queue;
-      return;
+      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
     }
-  } // Append the update to the end of the list.
 
-  var lastBaseUpdate = queue.lastBaseUpdate;
+    return suspenseBoundary;
+  } // Confirmed that the boundary is in a concurrent mode tree. Continue
+  // with the normal suspend path.
+  //
+  // After this we'll use a set of heuristics to determine whether this
+  // render pass will run to completion or restart or "suspend" the commit.
+  // The actual logic for this is spread out in different places.
+  //
+  // This first principle is that if we're going to suspend when we complete
+  // a root, then we should also restart if we get an update or ping that
+  // might unsuspend it, and vice versa. The only reason to suspend is
+  // because you think you might want to restart before committing. However,
+  // it doesn't make sense to restart only while in the period we're suspended.
+  //
+  // Restarting too aggressively is also not good because it starves out any
+  // intermediate loading state. So we use heuristics to determine when.
+  // Suspense Heuristics
+  //
+  // If nothing threw a Promise or all the same fallbacks are already showing,
+  // then don't suspend/restart.
+  //
+  // If this is an initial render of a new tree of Suspense boundaries and
+  // those trigger a fallback, then don't suspend/restart. We want to ensure
+  // that we can show the initial loading state as quickly as possible.
+  //
+  // If we hit a "Delayed" case, such as when we'd switch from content back into
+  // a fallback, then we should always suspend/restart. Transitions apply
+  // to this case. If none is defined, JND is used instead.
+  //
+  // If we're already showing a fallback and it gets "retried", allowing us to show
+  // another level, but there's still an inner boundary that would show a fallback,
+  // then we suspend/restart for 500ms since the last time we showed a fallback
+  // anywhere in the tree. This effectively throttles progressive loading into a
+  // consistent train of commits. This also gives us an opportunity to restart to
+  // get to the completed state slightly earlier.
+  //
+  // If there's ambiguity due to batching it's resolved in preference of:
+  // 1) "delayed", 2) "initial render", 3) "retry".
+  //
+  // We want to ensure that a "busy" state doesn't get force committed. We want to
+  // ensure that new initial loading states can commit as soon as possible.
 
-  if (lastBaseUpdate === null) {
-    queue.firstBaseUpdate = capturedUpdate;
-  } else {
-    lastBaseUpdate.next = capturedUpdate;
-  }
+  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
+  // the begin phase to prevent an early bailout.
 
-  queue.lastBaseUpdate = capturedUpdate;
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
 }
 
-function getStateFromUpdate(
-  workInProgress,
-  queue,
-  update,
-  prevState,
-  nextProps,
-  instance
+function throwException(
+  root,
+  returnFiber,
+  sourceFiber,
+  value,
+  rootRenderLanes
 ) {
-  switch (update.tag) {
-    case ReplaceState: {
-      var payload = update.payload;
+  // The source fiber did not complete.
+  sourceFiber.flags |= Incomplete;
 
-      if (typeof payload === "function") {
-        // Updater function
-        {
-          enterDisallowedContextReadInDEV();
+  {
+    if (isDevToolsPresent) {
+      // If we have pending work still, restore the original updaters
+      restorePendingUpdaters(root, rootRenderLanes);
+    }
+  }
+
+  if (
+    value !== null &&
+    typeof value === "object" &&
+    typeof value.then === "function"
+  ) {
+    // This is a wakeable. The component suspended.
+    var wakeable = value;
+    resetSuspendedComponent(sourceFiber, rootRenderLanes);
+
+    {
+      if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+        markDidThrowWhileHydratingDEV();
+      }
+    }
+
+    {
+      if (enableDebugTracing) {
+        if (sourceFiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(sourceFiber) || "Unknown";
+          logComponentSuspended(name, wakeable);
         }
+      }
+    } // Mark the nearest Suspense boundary to switch to rendering a fallback.
 
-        var nextState = payload.call(instance, prevState, nextProps);
+    var suspenseBoundary = getSuspenseHandler();
 
-        {
-          if (workInProgress.mode & StrictLegacyMode) {
-            setIsStrictModeForDevtools(true);
+    if (suspenseBoundary !== null) {
+      switch (suspenseBoundary.tag) {
+        case SuspenseComponent: {
+          // If this suspense boundary is not already showing a fallback, mark
+          // the in-progress render as suspended. We try to perform this logic
+          // as soon as soon as possible during the render phase, so the work
+          // loop can know things like whether it's OK to switch to other tasks,
+          // or whether it can wait for data to resolve before continuing.
+          // TODO: Most of these checks are already performed when entering a
+          // Suspense boundary. We should track the information on the stack so
+          // we don't have to recompute it on demand. This would also allow us
+          // to unify with `use` which needs to perform this logic even sooner,
+          // before `throwException` is called.
+          if (sourceFiber.mode & ConcurrentMode) {
+            if (getShellBoundary() === null) {
+              // Suspended in the "shell" of the app. This is an undesirable
+              // loading state. We should avoid committing this tree.
+              renderDidSuspendDelayIfPossible();
+            } else {
+              // If we suspended deeper than the shell, we don't need to delay
+              // the commmit. However, we still call renderDidSuspend if this is
+              // a new boundary, to tell the work loop that a new fallback has
+              // appeared during this render.
+              // TODO: Theoretically we should be able to delete this branch.
+              // It's currently used for two things: 1) to throttle the
+              // appearance of successive loading states, and 2) in
+              // SuspenseList, to determine whether the children include any
+              // pending fallbacks. For 1, we should apply throttling to all
+              // retries, not just ones that render an additional fallback. For
+              // 2, we should check subtreeFlags instead. Then we can delete
+              // this branch.
+              var current = suspenseBoundary.alternate;
 
-            try {
-              payload.call(instance, prevState, nextProps);
-            } finally {
-              setIsStrictModeForDevtools(false);
+              if (current === null) {
+                renderDidSuspend();
+              }
             }
           }
 
-          exitDisallowedContextReadInDEV();
-        }
-
-        return nextState;
-      } // State object
-
-      return payload;
-    }
+          suspenseBoundary.flags &= ~ForceClientRender;
+          markSuspenseBoundaryShouldCapture(
+            suspenseBoundary,
+            returnFiber,
+            sourceFiber,
+            root,
+            rootRenderLanes
+          ); // Retry listener
+          //
+          // If the fallback does commit, we need to attach a different type of
+          // listener. This one schedules an update on the Suspense boundary to
+          // turn the fallback state off.
+          //
+          // Stash the wakeable on the boundary fiber so we can access it in the
+          // commit phase.
+          //
+          // When the wakeable resolves, we'll attempt to render the boundary
+          // again ("retry").
 
-    case CaptureUpdate: {
-      workInProgress.flags =
-        (workInProgress.flags & ~ShouldCapture) | DidCapture;
-    }
-    // Intentional fallthrough
+          var wakeables = suspenseBoundary.updateQueue;
 
-    case UpdateState: {
-      var _payload = update.payload;
-      var partialState;
+          if (wakeables === null) {
+            suspenseBoundary.updateQueue = new Set([wakeable]);
+          } else {
+            wakeables.add(wakeable);
+          }
 
-      if (typeof _payload === "function") {
-        // Updater function
-        {
-          enterDisallowedContextReadInDEV();
+          break;
         }
 
-        partialState = _payload.call(instance, prevState, nextProps);
+        case OffscreenComponent: {
+          if (suspenseBoundary.mode & ConcurrentMode) {
+            suspenseBoundary.flags |= ShouldCapture;
+            var offscreenQueue = suspenseBoundary.updateQueue;
 
-        {
-          if (workInProgress.mode & StrictLegacyMode) {
-            setIsStrictModeForDevtools(true);
+            if (offscreenQueue === null) {
+              var newOffscreenQueue = {
+                transitions: null,
+                markerInstances: null,
+                wakeables: new Set([wakeable])
+              };
+              suspenseBoundary.updateQueue = newOffscreenQueue;
+            } else {
+              var _wakeables = offscreenQueue.wakeables;
 
-            try {
-              _payload.call(instance, prevState, nextProps);
-            } finally {
-              setIsStrictModeForDevtools(false);
+              if (_wakeables === null) {
+                offscreenQueue.wakeables = new Set([wakeable]);
+              } else {
+                _wakeables.add(wakeable);
+              }
             }
-          }
 
-          exitDisallowedContextReadInDEV();
+            break;
+          }
         }
-      } else {
-        // Partial state object
-        partialState = _payload;
-      }
-
-      if (partialState === null || partialState === undefined) {
-        // Null and undefined are treated as no-ops.
-        return prevState;
-      } // Merge the partial state and the previous state.
+        // eslint-disable-next-line no-fallthrough
 
-      return assign({}, prevState, partialState);
-    }
+        default: {
+          throw new Error(
+            "Unexpected Suspense handler tag (" +
+              suspenseBoundary.tag +
+              "). This " +
+              "is a bug in React."
+          );
+        }
+      } // We only attach ping listeners in concurrent mode. Legacy Suspense always
+      // commits fallbacks synchronously, so there are no pings.
 
-    case ForceUpdate: {
-      hasForceUpdate = true;
-      return prevState;
-    }
-  }
+      if (suspenseBoundary.mode & ConcurrentMode) {
+        attachPingListener(root, wakeable, rootRenderLanes);
+      }
 
-  return prevState;
-}
-
-function processUpdateQueue(workInProgress, props, instance, renderLanes) {
-  // This is always non-null on a ClassComponent or HostRoot
-  var queue = workInProgress.updateQueue;
-  hasForceUpdate = false;
-
-  {
-    currentlyProcessingQueue = queue.shared;
-  }
-
-  var firstBaseUpdate = queue.firstBaseUpdate;
-  var lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.
+      return;
+    } else {
+      // No boundary was found. Unless this is a sync update, this is OK.
+      // We can suspend and wait for more data to arrive.
+      if (root.tag === ConcurrentRoot) {
+        // In a concurrent root, suspending without a Suspense boundary is
+        // allowed. It will suspend indefinitely without committing.
+        //
+        // TODO: Should we have different behavior for discrete updates? What
+        // about flushSync? Maybe it should put the tree into an inert state,
+        // and potentially log a warning. Revisit this for a future release.
+        attachPingListener(root, wakeable, rootRenderLanes);
+        renderDidSuspendDelayIfPossible();
+        return;
+      } else {
+        // In a legacy root, suspending without a boundary is always an error.
+        var uncaughtSuspenseError = new Error(
+          "A component suspended while responding to synchronous input. This " +
+            "will cause the UI to be replaced with a loading indicator. To " +
+            "fix, updates that suspend should be wrapped " +
+            "with startTransition."
+        );
+        value = uncaughtSuspenseError;
+      }
+    }
+  } else {
+    // This is a regular error, not a Suspense wakeable.
+    if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
+      markDidThrowWhileHydratingDEV();
 
-  var pendingQueue = queue.shared.pending;
+      var _suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
+      // discarding the dehydrated content and switching to a client render.
+      // Instead of surfacing the error, find the nearest Suspense boundary
+      // and render it again without hydration.
 
-  if (pendingQueue !== null) {
-    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first
-    // and last so that it's non-circular.
+      if (_suspenseBoundary !== null) {
+        if ((_suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
+          // Set a flag to indicate that we should try rendering the normal
+          // children again, not the fallback.
+          _suspenseBoundary.flags |= ForceClientRender;
+        }
 
-    var lastPendingUpdate = pendingQueue;
-    var firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null; // Append pending updates to base queue
+        markSuspenseBoundaryShouldCapture(
+          _suspenseBoundary,
+          returnFiber,
+          sourceFiber,
+          root,
+          rootRenderLanes
+        ); // Even though the user may not be affected by this error, we should
+        // still log it so it can be fixed.
 
-    if (lastBaseUpdate === null) {
-      firstBaseUpdate = firstPendingUpdate;
-    } else {
-      lastBaseUpdate.next = firstPendingUpdate;
+        queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
+        return;
+      }
     }
+  }
 
-    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then
-    // we need to transfer the updates to that queue, too. Because the base
-    // queue is a singly-linked list with no cycles, we can append to both
-    // lists and take advantage of structural sharing.
-    // TODO: Pass `current` as argument
+  value = createCapturedValueAtFiber(value, sourceFiber);
+  renderDidError(value); // 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.
 
-    var current = workInProgress.alternate;
+  var workInProgress = returnFiber;
 
-    if (current !== null) {
-      // This is always non-null on a ClassComponent or HostRoot
-      var currentQueue = current.updateQueue;
-      var currentLastBaseUpdate = currentQueue.lastBaseUpdate;
+  do {
+    switch (workInProgress.tag) {
+      case HostRoot: {
+        var _errorInfo = value;
+        workInProgress.flags |= ShouldCapture;
+        var lane = pickArbitraryLane(rootRenderLanes);
+        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
+        var update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
+        enqueueCapturedUpdate(workInProgress, update);
+        return;
+      }
 
-      if (currentLastBaseUpdate !== lastBaseUpdate) {
-        if (currentLastBaseUpdate === null) {
-          currentQueue.firstBaseUpdate = firstPendingUpdate;
-        } else {
-          currentLastBaseUpdate.next = firstPendingUpdate;
-        }
+      case ClassComponent:
+        // Capture and retry
+        var errorInfo = value;
+        var ctor = workInProgress.type;
+        var instance = workInProgress.stateNode;
 
-        currentQueue.lastBaseUpdate = lastPendingUpdate;
-      }
-    }
-  } // These values may change as we process the queue.
+        if (
+          (workInProgress.flags & DidCapture) === NoFlags$1 &&
+          (typeof ctor.getDerivedStateFromError === "function" ||
+            (instance !== null &&
+              typeof instance.componentDidCatch === "function" &&
+              !isAlreadyFailedLegacyErrorBoundary(instance)))
+        ) {
+          workInProgress.flags |= ShouldCapture;
 
-  if (firstBaseUpdate !== null) {
-    // Iterate through the list of updates to compute the result.
-    var newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes
-    // from the original lanes.
+          var _lane = pickArbitraryLane(rootRenderLanes);
 
-    var newLanes = NoLanes;
-    var newBaseState = null;
-    var newFirstBaseUpdate = null;
-    var newLastBaseUpdate = null;
-    var update = firstBaseUpdate;
+          workInProgress.lanes = mergeLanes(workInProgress.lanes, _lane); // Schedule the error boundary to re-render using updated state
 
-    do {
-      // An extra OffscreenLane bit is added to updates that were made to
-      // a hidden tree, so that we can distinguish them from updates that were
-      // already there when the tree was hidden.
-      var updateLane = removeLanes(update.lane, OffscreenLane);
-      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
-      // it's not a "base" update and we should disregard the extra base lanes
-      // that were added to renderLanes when we entered the Offscreen tree.
+          var _update = createClassErrorUpdate(
+            workInProgress,
+            errorInfo,
+            _lane
+          );
 
-      var shouldSkipUpdate = isHiddenUpdate
-        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
-        : !isSubsetOfLanes(renderLanes, updateLane);
+          enqueueCapturedUpdate(workInProgress, _update);
+          return;
+        }
 
-      if (shouldSkipUpdate) {
-        // Priority is insufficient. Skip this update. If this is the first
-        // skipped update, the previous update/state is the new base
-        // update/state.
-        var clone = {
-          lane: updateLane,
-          tag: update.tag,
-          payload: update.payload,
-          callback: update.callback,
-          next: null
-        };
+        break;
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-        if (newLastBaseUpdate === null) {
-          newFirstBaseUpdate = newLastBaseUpdate = clone;
-          newBaseState = newState;
-        } else {
-          newLastBaseUpdate = newLastBaseUpdate.next = clone;
-        } // Update the remaining priority in the queue.
+    workInProgress = workInProgress.return;
+  } while (workInProgress !== null);
+}
 
-        newLanes = mergeLanes(newLanes, updateLane);
-      } else {
-        // This update does have sufficient priority.
-        if (newLastBaseUpdate !== null) {
-          var _clone = {
-            // This update is going to be committed so we never want uncommit
-            // it. Using NoLane works because 0 is a subset of all bitmasks, so
-            // this will never be skipped by the check above.
-            lane: NoLane,
-            tag: update.tag,
-            payload: update.payload,
-            // When this update is rebased, we should not fire its
-            // callback again.
-            callback: null,
-            next: null
-          };
-          newLastBaseUpdate = newLastBaseUpdate.next = _clone;
-        } // Process this update.
+var TransitionRoot = 0;
+var TransitionTracingMarker = 1;
+function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
+  if (enableTransitionTracing) {
+    if (pendingTransitions !== null) {
+      var transitionStart = pendingTransitions.transitionStart;
+      var onTransitionStart = callbacks.onTransitionStart;
 
-        newState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          newState,
-          props,
-          instance
-        );
-        var callback = update.callback;
+      if (transitionStart !== null && onTransitionStart != null) {
+        transitionStart.forEach(function (transition) {
+          return onTransitionStart(transition.name, transition.startTime);
+        });
+      }
 
-        if (callback !== null) {
-          workInProgress.flags |= Callback;
+      var markerProgress = pendingTransitions.markerProgress;
+      var onMarkerProgress = callbacks.onMarkerProgress;
 
-          if (isHiddenUpdate) {
-            workInProgress.flags |= Visibility;
+      if (onMarkerProgress != null && markerProgress !== null) {
+        markerProgress.forEach(function (markerInstance, markerName) {
+          if (markerInstance.transitions !== null) {
+            // TODO: Clone the suspense object so users can't modify it
+            var pending =
+              markerInstance.pendingBoundaries !== null
+                ? Array.from(markerInstance.pendingBoundaries.values())
+                : [];
+            markerInstance.transitions.forEach(function (transition) {
+              onMarkerProgress(
+                transition.name,
+                markerName,
+                transition.startTime,
+                endTime,
+                pending
+              );
+            });
           }
+        });
+      }
 
-          var callbacks = queue.callbacks;
+      var markerComplete = pendingTransitions.markerComplete;
+      var onMarkerComplete = callbacks.onMarkerComplete;
 
-          if (callbacks === null) {
-            queue.callbacks = [callback];
-          } else {
-            callbacks.push(callback);
-          }
-        }
-      } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      if (markerComplete !== null && onMarkerComplete != null) {
+        markerComplete.forEach(function (transitions, markerName) {
+          transitions.forEach(function (transition) {
+            onMarkerComplete(
+              transition.name,
+              markerName,
+              transition.startTime,
+              endTime
+            );
+          });
+        });
+      }
 
-      update = update.next;
+      var markerIncomplete = pendingTransitions.markerIncomplete;
+      var onMarkerIncomplete = callbacks.onMarkerIncomplete;
 
-      if (update === null) {
-        pendingQueue = queue.shared.pending;
+      if (onMarkerIncomplete != null && markerIncomplete !== null) {
+        markerIncomplete.forEach(function (_ref, markerName) {
+          var transitions = _ref.transitions,
+            aborts = _ref.aborts;
+          transitions.forEach(function (transition) {
+            var filteredAborts = [];
+            aborts.forEach(function (abort) {
+              switch (abort.reason) {
+                case "marker": {
+                  filteredAborts.push({
+                    type: "marker",
+                    name: abort.name,
+                    endTime: endTime
+                  });
+                  break;
+                }
 
-        if (pendingQueue === null) {
-          break;
-        } else {
-          // An update was scheduled from inside a reducer. Add the new
-          // pending updates to the end of the list and keep processing.
-          var _lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we
-          // unravel them when transferring them to the base queue.
+                case "suspense": {
+                  filteredAborts.push({
+                    type: "suspense",
+                    name: abort.name,
+                    endTime: endTime
+                  });
+                  break;
+                }
+              }
+            });
 
-          var _firstPendingUpdate = _lastPendingUpdate.next;
-          _lastPendingUpdate.next = null;
-          update = _firstPendingUpdate;
-          queue.lastBaseUpdate = _lastPendingUpdate;
-          queue.shared.pending = null;
-        }
+            if (filteredAborts.length > 0) {
+              onMarkerIncomplete(
+                transition.name,
+                markerName,
+                transition.startTime,
+                filteredAborts
+              );
+            }
+          });
+        });
       }
-    } while (true);
 
-    if (newLastBaseUpdate === null) {
-      newBaseState = newState;
-    }
+      var transitionProgress = pendingTransitions.transitionProgress;
+      var onTransitionProgress = callbacks.onTransitionProgress;
 
-    queue.baseState = newBaseState;
-    queue.firstBaseUpdate = newFirstBaseUpdate;
-    queue.lastBaseUpdate = newLastBaseUpdate;
+      if (onTransitionProgress != null && transitionProgress !== null) {
+        transitionProgress.forEach(function (pending, transition) {
+          onTransitionProgress(
+            transition.name,
+            transition.startTime,
+            endTime,
+            Array.from(pending.values())
+          );
+        });
+      }
 
-    if (firstBaseUpdate === null) {
-      // `queue.lanes` is used for entangling transitions. We can set it back to
-      // zero once the queue is empty.
-      queue.shared.lanes = NoLanes;
-    } // 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.
+      var transitionComplete = pendingTransitions.transitionComplete;
+      var onTransitionComplete = callbacks.onTransitionComplete;
 
-    markSkippedUpdateLanes(newLanes);
-    workInProgress.lanes = newLanes;
-    workInProgress.memoizedState = newState;
+      if (transitionComplete !== null && onTransitionComplete != null) {
+        transitionComplete.forEach(function (transition) {
+          return onTransitionComplete(
+            transition.name,
+            transition.startTime,
+            endTime
+          );
+        });
+      }
+    }
   }
+} // For every tracing marker, store a pointer to it. We will later access it
+// to get the set of suspense boundaries that need to resolve before the
+// tracing marker can be logged as complete
+// This code lives separate from the ReactFiberTransition code because
+// we push and pop on the tracing marker, not the suspense boundary
 
-  {
-    currentlyProcessingQueue = null;
-  }
-}
+var markerInstanceStack = createCursor(null);
+function pushRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    // On the root, every transition gets mapped to it's own map of
+    // suspense boundaries. The transition is marked as complete when
+    // the suspense boundaries map is empty. We do this because every
+    // transition completes at different times and depends on different
+    // suspense boundaries to complete. We store all the transitions
+    // along with its map of suspense boundaries in the root incomplete
+    // transitions map. Each entry in this map functions like a tracing
+    // marker does, so we can push it onto the marker instance stack
+    var transitions = getWorkInProgressTransitions();
+    var root = workInProgress.stateNode;
 
-function callCallback(callback, context) {
-  if (typeof callback !== "function") {
-    throw new Error(
-      "Invalid argument passed as callback. Expected a function. Instead " +
-        ("received: " + callback)
-    );
-  }
+    if (transitions !== null) {
+      transitions.forEach(function (transition) {
+        if (!root.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: TransitionRoot,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root.incompleteTransitions.set(transition, markerInstance);
+        }
+      });
+    }
 
-  callback.call(context);
-}
+    var markerInstances = []; // For ever transition on the suspense boundary, we push the transition
+    // along with its map of pending suspense boundaries onto the marker
+    // instance stack.
 
-function resetHasForceUpdateBeforeProcessing() {
-  hasForceUpdate = false;
+    root.incompleteTransitions.forEach(function (markerInstance) {
+      markerInstances.push(markerInstance);
+    });
+    push(markerInstanceStack, markerInstances, workInProgress);
+  }
 }
-function checkHasForceUpdateAfterProcessing() {
-  return hasForceUpdate;
+function popRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
+  }
 }
-function deferHiddenCallbacks(updateQueue) {
-  // When an update finishes on a hidden component, its callback should not
-  // be fired until/unless the component is made visible again. Stash the
-  // callback on the shared queue object so it can be fired later.
-  var newHiddenCallbacks = updateQueue.callbacks;
-
-  if (newHiddenCallbacks !== null) {
-    var existingHiddenCallbacks = updateQueue.shared.hiddenCallbacks;
-
-    if (existingHiddenCallbacks === null) {
-      updateQueue.shared.hiddenCallbacks = newHiddenCallbacks;
+function pushMarkerInstance(workInProgress, markerInstance) {
+  if (enableTransitionTracing) {
+    if (markerInstanceStack.current === null) {
+      push(markerInstanceStack, [markerInstance], workInProgress);
     } else {
-      updateQueue.shared.hiddenCallbacks =
-        existingHiddenCallbacks.concat(newHiddenCallbacks);
+      push(
+        markerInstanceStack,
+        markerInstanceStack.current.concat(markerInstance),
+        workInProgress
+      );
     }
   }
 }
-function commitHiddenCallbacks(updateQueue, context) {
-  // This component is switching from hidden -> visible. Commit any callbacks
-  // that were previously deferred.
-  var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
-
-  if (hiddenCallbacks !== null) {
-    updateQueue.shared.hiddenCallbacks = null;
-
-    for (var i = 0; i < hiddenCallbacks.length; i++) {
-      var callback = hiddenCallbacks[i];
-      callCallback(callback, context);
-    }
+function popMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
   }
 }
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
-
-  if (callbacks !== null) {
-    updateQueue.callbacks = null;
-
-    for (var i = 0; i < callbacks.length; i++) {
-      var callback = callbacks[i];
-      callCallback(callback, context);
-    }
+function getMarkerInstances() {
+  if (enableTransitionTracing) {
+    return markerInstanceStack.current;
   }
-}
-
-var ReactStrictModeWarnings = {
-  recordUnsafeLifecycleWarnings: function (fiber, instance) {},
-  flushPendingUnsafeLifecycleWarnings: function () {},
-  recordLegacyContextWarning: function (fiber, instance) {},
-  flushLegacyContextWarning: function () {},
-  discardPendingWarnings: function () {}
-};
 
-{
-  var findStrictRoot = function (fiber) {
-    var maybeStrictRoot = null;
-    var node = fiber;
+  return null;
+}
 
-    while (node !== null) {
-      if (node.mode & StrictLegacyMode) {
-        maybeStrictRoot = node;
-      }
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
+// into a dehydrated boundary.
 
-      node = node.return;
-    }
+var SelectiveHydrationException = new Error(
+  "This is not a real error. It's an implementation detail of React's " +
+    "selective hydration feature. If this leaks into userspace, it's a bug in " +
+    "React. Please file an issue."
+);
+var didReceiveUpdate = false;
+var didWarnAboutBadClass;
+var didWarnAboutModulePatternComponent;
+var didWarnAboutContextTypeOnFunctionComponent;
+var didWarnAboutGetDerivedStateOnFunctionComponent;
+var didWarnAboutFunctionRefs;
+var didWarnAboutReassigningProps;
+var didWarnAboutRevealOrder;
+var didWarnAboutTailOptions;
+var didWarnAboutDefaultPropsOnFunctionComponent;
 
-    return maybeStrictRoot;
-  };
-
-  var setToSortedString = function (set) {
-    var array = [];
-    set.forEach(function (value) {
-      array.push(value);
-    });
-    return array.sort().join(", ");
-  };
+{
+  didWarnAboutBadClass = {};
+  didWarnAboutModulePatternComponent = {};
+  didWarnAboutContextTypeOnFunctionComponent = {};
+  didWarnAboutGetDerivedStateOnFunctionComponent = {};
+  didWarnAboutFunctionRefs = {};
+  didWarnAboutReassigningProps = false;
+  didWarnAboutRevealOrder = {};
+  didWarnAboutTailOptions = {};
+  didWarnAboutDefaultPropsOnFunctionComponent = {};
+}
 
-  var pendingComponentWillMountWarnings = [];
-  var pendingUNSAFE_ComponentWillMountWarnings = [];
-  var pendingComponentWillReceivePropsWarnings = [];
-  var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-  var pendingComponentWillUpdateWarnings = [];
-  var pendingUNSAFE_ComponentWillUpdateWarnings = []; // Tracks components we have already warned about.
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  if (current === 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
+    // we can optimize this reconciliation pass by not tracking side-effects.
+    workInProgress.child = mountChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    // If the current child is the same as the work in progress, it means that
+    // we haven't yet started any work on these children. Therefore, we use
+    // the clone algorithm to create a copy of all the current children.
+    // If we had any progressed work already, that is invalid at this point so
+    // let's throw it out.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      current.child,
+      nextChildren,
+      renderLanes
+    );
+  }
+}
 
-  var didWarnAboutUnsafeLifecycles = new Set();
+function forceUnmountCurrentAndReconcile(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes
+) {
+  // This function is fork of reconcileChildren. It's used in cases where we
+  // want to reconcile without matching against the existing set. This has the
+  // effect of all current children being unmounted; even if the type and key
+  // are the same, the old child is unmounted and a new child is created.
+  //
+  // To do this, we're going to go through the reconcile algorithm twice. In
+  // the first pass, we schedule a deletion for all the current children by
+  // passing null.
+  workInProgress.child = reconcileChildFibers(
+    workInProgress,
+    current.child,
+    null,
+    renderLanes
+  ); // In the second pass, we mount the new children. The trick here is that we
+  // pass null in place of where we usually pass the current child set. This has
+  // the effect of remounting all children regardless of whether their
+  // identities match.
 
-  ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (
-    fiber,
-    instance
-  ) {
-    // Dedupe strategy: Warn once per component.
-    if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
-      return;
-    }
+  workInProgress.child = reconcileChildFibers(
+    workInProgress,
+    null,
+    nextChildren,
+    renderLanes
+  );
+}
 
-    if (
-      typeof instance.componentWillMount === "function" && // Don't warn about react-lifecycles-compat polyfilled components.
-      instance.componentWillMount.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillMountWarnings.push(fiber);
-    }
+function updateForwardRef(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  // TODO: current can be non-null here even if the component
+  // hasn't yet mounted. This happens after the first render suspends.
+  // We'll need to figure out if this is fine or can cause issues.
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillMount === "function"
-    ) {
-      pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
+        );
+      }
     }
+  }
 
-    if (
-      typeof instance.componentWillReceiveProps === "function" &&
-      instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillReceivePropsWarnings.push(fiber);
-    }
+  var render = Component.render;
+  var ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillReceiveProps === "function"
-    ) {
-      pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
-    }
+  var nextChildren;
+  var hasId;
+  prepareToReadContext(workInProgress, renderLanes);
 
-    if (
-      typeof instance.componentWillUpdate === "function" &&
-      instance.componentWillUpdate.__suppressDeprecationWarning !== true
-    ) {
-      pendingComponentWillUpdateWarnings.push(fiber);
-    }
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-    if (
-      fiber.mode & StrictLegacyMode &&
-      typeof instance.UNSAFE_componentWillUpdate === "function"
-    ) {
-      pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
-    }
-  };
+  {
+    ReactCurrentOwner$1.current = workInProgress;
+    setIsRendering(true);
+    nextChildren = renderWithHooks(
+      current,
+      workInProgress,
+      render,
+      nextProps,
+      ref,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
+  }
 
-  ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
-    // We do an initial pass to gather component names
-    var componentWillMountUniqueNames = new Set();
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
 
-    if (pendingComponentWillMountWarnings.length > 0) {
-      pendingComponentWillMountWarnings.forEach(function (fiber) {
-        componentWillMountUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillMountWarnings = [];
-    }
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
 
-    var UNSAFE_componentWillMountUniqueNames = new Set();
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
 
-    if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillMountUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillMountWarnings = [];
-    }
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-    var componentWillReceivePropsUniqueNames = new Set();
+function updateMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (current === null) {
+    var type = Component.type;
 
-    if (pendingComponentWillReceivePropsWarnings.length > 0) {
-      pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
-        componentWillReceivePropsUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillReceivePropsWarnings = [];
-    }
+    if (
+      isSimpleFunctionComponent(type) &&
+      Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
+      Component.defaultProps === undefined
+    ) {
+      var resolvedType = type;
 
-    var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
+      {
+        resolvedType = resolveFunctionForHotReloading(type);
+      } // If this is a plain function component without default props,
+      // and with only the default shallow comparison, we upgrade it
+      // to a SimpleMemoComponent to allow fast path updates.
 
-    if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillReceivePropsUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-    }
+      workInProgress.tag = SimpleMemoComponent;
+      workInProgress.type = resolvedType;
 
-    var componentWillUpdateUniqueNames = new Set();
+      {
+        validateFunctionComponentInDev(workInProgress, type);
+      }
 
-    if (pendingComponentWillUpdateWarnings.length > 0) {
-      pendingComponentWillUpdateWarnings.forEach(function (fiber) {
-        componentWillUpdateUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
-        );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingComponentWillUpdateWarnings = [];
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        resolvedType,
+        nextProps,
+        renderLanes
+      );
     }
 
-    var UNSAFE_componentWillUpdateUniqueNames = new Set();
+    {
+      var innerPropTypes = type.propTypes;
 
-    if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
-      pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
-        UNSAFE_componentWillUpdateUniqueNames.add(
-          getComponentNameFromFiber(fiber) || "Component"
+      if (innerPropTypes) {
+        // Inner memo component props aren't currently validated in createElement.
+        // We could move it there, but we'd still need this for lazy code path.
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(type)
         );
-        didWarnAboutUnsafeLifecycles.add(fiber.type);
-      });
-      pendingUNSAFE_ComponentWillUpdateWarnings = [];
-    } // Finally, we flush all the warnings
-    // UNSAFE_ ones before the deprecated ones, since they'll be 'louder'
-
-    if (UNSAFE_componentWillMountUniqueNames.size > 0) {
-      var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
+      }
 
-      error(
-        "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
-          "\nPlease update the following components: %s",
-        sortedNames
-      );
-    }
+      if (Component.defaultProps !== undefined) {
+        var componentName = getComponentNameFromType(type) || "Unknown";
 
-    if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
-      var _sortedNames = setToSortedString(
-        UNSAFE_componentWillReceivePropsUniqueNames
-      );
+        if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
+          error(
+            "%s: Support for defaultProps will be removed from memo components " +
+              "in a future major release. Use JavaScript default parameters instead.",
+            componentName
+          );
 
-      error(
-        "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " +
-          "and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* If you're updating state whenever props change, " +
-          "refactor your code to use memoization techniques or move it to " +
-          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames
-      );
+          didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+        }
+      }
     }
 
-    if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
-      var _sortedNames2 = setToSortedString(
-        UNSAFE_componentWillUpdateUniqueNames
-      );
-
-      error(
-        "Using UNSAFE_componentWillUpdate in strict mode is not recommended " +
-          "and may indicate bugs in your code. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames2
-      );
-    }
+    var child = createFiberFromTypeAndProps(
+      Component.type,
+      null,
+      nextProps,
+      workInProgress,
+      workInProgress.mode,
+      renderLanes
+    );
+    child.ref = workInProgress.ref;
+    child.return = workInProgress;
+    workInProgress.child = child;
+    return child;
+  }
 
-    if (componentWillMountUniqueNames.size > 0) {
-      var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);
+  {
+    var _type = Component.type;
+    var _innerPropTypes = _type.propTypes;
 
-      warn(
-        "componentWillMount has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" +
-          "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames3
+    if (_innerPropTypes) {
+      // Inner memo component props aren't currently validated in createElement.
+      // We could move it there, but we'd still need this for lazy code path.
+      checkPropTypes(
+        _innerPropTypes,
+        nextProps, // Resolved props
+        "prop",
+        getComponentNameFromType(_type)
       );
     }
+  }
 
-    if (componentWillReceivePropsUniqueNames.size > 0) {
-      var _sortedNames4 = setToSortedString(
-        componentWillReceivePropsUniqueNames
-      );
+  var currentChild = current.child; // This is always exactly one child
 
-      warn(
-        "componentWillReceiveProps has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* If you're updating state whenever props change, refactor your " +
-          "code to use memoization techniques or move it to " +
-          "static getDerivedStateFromProps. Learn more at: https://reactjs.org/link/derived-state\n" +
-          "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames4
-      );
-    }
+  var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
+    current,
+    renderLanes
+  );
 
-    if (componentWillUpdateUniqueNames.size > 0) {
-      var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);
+  if (!hasScheduledUpdateOrContext) {
+    // This will be the props with resolved defaultProps,
+    // unlike current.memoizedProps which will be the unresolved ones.
+    var prevProps = currentChild.memoizedProps; // Default to shallow comparison
 
-      warn(
-        "componentWillUpdate has been renamed, and is not recommended for use. " +
-          "See https://reactjs.org/link/unsafe-component-lifecycles for details.\n\n" +
-          "* Move data fetching code or side effects to componentDidUpdate.\n" +
-          "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " +
-          "this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. " +
-          "To rename all deprecated lifecycles to their new names, you can run " +
-          "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" +
-          "\nPlease update the following components: %s",
-        _sortedNames5
-      );
+    var compare = Component.compare;
+    compare = compare !== null ? compare : shallowEqual;
+
+    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
     }
-  };
+  } // React DevTools reads this flag.
 
-  var pendingLegacyContextWarning = new Map(); // Tracks components we have already warned about.
+  workInProgress.flags |= PerformedWork;
+  var newChild = createWorkInProgress(currentChild, nextProps);
+  newChild.ref = workInProgress.ref;
+  newChild.return = workInProgress;
+  workInProgress.child = newChild;
+  return newChild;
+}
 
-  var didWarnAboutLegacyContext = new Set();
+function updateSimpleMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  // TODO: current can be non-null here even if the component
+  // hasn't yet mounted. This happens when the inner render suspends.
+  // We'll need to figure out if this is fine or can cause issues.
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var outerMemoType = workInProgress.elementType;
 
-  ReactStrictModeWarnings.recordLegacyContextWarning = function (
-    fiber,
-    instance
-  ) {
-    var strictRoot = findStrictRoot(fiber);
+      if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
+        // We warn when you define propTypes on lazy()
+        // so let's just skip over it to find memo() outer wrapper.
+        // Inner props for memo are validated later.
+        var lazyComponent = outerMemoType;
+        var payload = lazyComponent._payload;
+        var init = lazyComponent._init;
 
-    if (strictRoot === null) {
-      error(
-        "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."
-      );
+        try {
+          outerMemoType = init(payload);
+        } catch (x) {
+          outerMemoType = null;
+        } // Inner propTypes will be validated in the function component path.
 
-      return;
-    } // Dedup strategy: Warn once per component.
+        var outerPropTypes = outerMemoType && outerMemoType.propTypes;
 
-    if (didWarnAboutLegacyContext.has(fiber.type)) {
-      return;
+        if (outerPropTypes) {
+          checkPropTypes(
+            outerPropTypes,
+            nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
+            "prop",
+            getComponentNameFromType(outerMemoType)
+          );
+        }
+      }
     }
+  }
 
-    var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
+  if (current !== null) {
+    var prevProps = current.memoizedProps;
 
     if (
-      fiber.type.contextTypes != null ||
-      fiber.type.childContextTypes != null ||
-      (instance !== null && typeof instance.getChildContext === "function")
+      shallowEqual(prevProps, nextProps) &&
+      current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
+      workInProgress.type === current.type
     ) {
-      if (warningsForRoot === undefined) {
-        warningsForRoot = [];
-        pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
-      }
-
-      warningsForRoot.push(fiber);
-    }
-  };
-
-  ReactStrictModeWarnings.flushLegacyContextWarning = function () {
-    pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
-      if (fiberArray.length === 0) {
-        return;
-      }
-
-      var firstFiber = fiberArray[0];
-      var uniqueNames = new Set();
-      fiberArray.forEach(function (fiber) {
-        uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
-        didWarnAboutLegacyContext.add(fiber.type);
-      });
-      var sortedNames = setToSortedString(uniqueNames);
+      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
+      // would during a normal fiber bailout.
+      //
+      // We don't have strong guarantees that the props object is referentially
+      // equal during updates where we can't bail out anyway — like if the props
+      // are shallowly equal, but there's a local state or context update in the
+      // same batch.
+      //
+      // However, as a principle, we should aim to make the behavior consistent
+      // across different ways of memoizing a component. For example, React.memo
+      // has a different internal Fiber layout if you pass a normal function
+      // component (SimpleMemoComponent) versus if you pass a different type
+      // like forwardRef (MemoComponent). But this is an implementation detail.
+      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
+      // affect whether the props object is reused during a bailout.
 
-      try {
-        setCurrentFiber(firstFiber);
+      workInProgress.pendingProps = nextProps = prevProps;
 
-        error(
-          "Legacy context API has been detected within a strict-mode tree." +
-            "\n\nThe old API will be supported in all 16.x releases, but applications " +
-            "using it should migrate to the new version." +
-            "\n\nPlease update the following components: %s" +
-            "\n\nLearn more about this warning here: https://reactjs.org/link/legacy-context",
-          sortedNames
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        // The pending lanes were cleared at the beginning of beginWork. We're
+        // about to bail out, but there might be other lanes that weren't
+        // included in the current render. Usually, the priority level of the
+        // remaining updates is accumulated during the evaluation of the
+        // component (i.e. when processing the update queue). But since since
+        // we're bailing out early *without* evaluating the component, we need
+        // to account for it here, too. Reset to the value of the current fiber.
+        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
+        // because a MemoComponent fiber does not have hooks or an update queue;
+        // rather, it wraps around an inner component, which may or may not
+        // contains hooks.
+        // TODO: Move the reset at in beginWork out of the common path so that
+        // this is no longer necessary.
+        workInProgress.lanes = current.lanes;
+        return bailoutOnAlreadyFinishedWork(
+          current,
+          workInProgress,
+          renderLanes
         );
-      } finally {
-        resetCurrentFiber();
+      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
       }
-    });
-  };
+    }
+  }
 
-  ReactStrictModeWarnings.discardPendingWarnings = function () {
-    pendingComponentWillMountWarnings = [];
-    pendingUNSAFE_ComponentWillMountWarnings = [];
-    pendingComponentWillReceivePropsWarnings = [];
-    pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
-    pendingComponentWillUpdateWarnings = [];
-    pendingUNSAFE_ComponentWillUpdateWarnings = [];
-    pendingLegacyContextWarning = new Map();
-  };
+  return updateFunctionComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    renderLanes
+  );
 }
 
-var ReactCurrentActQueue$2 = ReactSharedInternals.ReactCurrentActQueue; // An error that is thrown (e.g. by `use`) to trigger Suspense. If we
-// detect this is caught by userspace, we'll log a warning in development.
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  var nextIsDetached =
+    (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
+  var prevState = current !== null ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
 
-var SuspenseException = new Error(
-  "Suspense Exception: This is not a real error! It's an implementation " +
-    "detail of `use` to interrupt the current render. You must either " +
-    "rethrow it immediately, or move the `use` call outside of the " +
-    "`try/catch` block. Capturing without rethrowing will lead to " +
-    "unexpected behavior.\n\n" +
-    "To handle async errors, wrap your component in an error boundary, or " +
-    "call the promise's `.catch` method and pass the result to `use`"
-);
-function createThenableState() {
-  // The ThenableState is created the first time a component suspends. If it
-  // suspends again, we'll reuse the same state.
-  return [];
-}
-function isThenableResolved(thenable) {
-  var status = thenable.status;
-  return status === "fulfilled" || status === "rejected";
-}
+  if (
+    nextProps.mode === "hidden" ||
+    nextProps.mode === "unstable-defer-without-hiding" ||
+    nextIsDetached
+  ) {
+    // Rendering a hidden tree.
+    var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-function noop() {}
+    if (didSuspend) {
+      // Something suspended inside a hidden tree
+      // Include the base lanes from the last render
+      var nextBaseLanes =
+        prevState !== null
+          ? mergeLanes(prevState.baseLanes, renderLanes)
+          : renderLanes;
 
-function trackUsedThenable(thenableState, thenable, index) {
-  if (ReactCurrentActQueue$2.current !== null) {
-    ReactCurrentActQueue$2.didUsePromise = true;
-  }
+      if (current !== null) {
+        // Reset to the current children
+        var currentChild = (workInProgress.child = current.child); // The current render suspended, but there may be other lanes with
+        // pending work. We can't read `childLanes` from the current Offscreen
+        // fiber because we reset it when it was deferred; however, we can read
+        // the pending lanes from the child fibers.
 
-  var previous = thenableState[index];
+        var currentChildLanes = NoLanes;
 
-  if (previous === undefined) {
-    thenableState.push(thenable);
-  } else {
-    if (previous !== thenable) {
-      // Reuse the previous thenable, and drop the new one. We can assume
-      // they represent the same value, because components are idempotent.
-      // Avoid an unhandled rejection errors for the Promises that we'll
-      // intentionally ignore.
-      thenable.then(noop, noop);
-      thenable = previous;
-    }
-  } // We use an expando to track the status and result of a thenable so that we
-  // can synchronously unwrap the value. Think of this as an extension of the
-  // Promise API, or a custom interface that is a superset of Thenable.
-  //
-  // If the thenable doesn't have a status, set it to "pending" and attach
-  // a listener that will update its status and result when it resolves.
+        while (currentChild !== null) {
+          currentChildLanes = mergeLanes(
+            mergeLanes(currentChildLanes, currentChild.lanes),
+            currentChild.childLanes
+          );
+          currentChild = currentChild.sibling;
+        }
 
-  switch (thenable.status) {
-    case "fulfilled": {
-      var fulfilledValue = thenable.value;
-      return fulfilledValue;
-    }
+        var lanesWeJustAttempted = nextBaseLanes;
+        var remainingChildLanes = removeLanes(
+          currentChildLanes,
+          lanesWeJustAttempted
+        );
+        workInProgress.childLanes = remainingChildLanes;
+      } else {
+        workInProgress.childLanes = NoLanes;
+        workInProgress.child = null;
+      }
 
-    case "rejected": {
-      var rejectedError = thenable.reason;
-      throw rejectedError;
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        nextBaseLanes,
+        renderLanes
+      );
     }
 
-    default: {
-      if (typeof thenable.status === "string") {
-        // Only instrument the thenable if the status if not defined. If
-        // it's defined, but an unknown value, assume it's been instrumented by
-        // some custom userspace implementation. We treat it as "pending".
-        // Attach a dummy listener, to ensure that any lazy initialization can
-        // happen. Flight lazily parses JSON when the value is actually awaited.
-        thenable.then(noop, noop);
-      } else {
-        var pendingThenable = thenable;
-        pendingThenable.status = "pending";
-        pendingThenable.then(
-          function (fulfilledValue) {
-            if (thenable.status === "pending") {
-              var fulfilledThenable = thenable;
-              fulfilledThenable.status = "fulfilled";
-              fulfilledThenable.value = fulfilledValue;
-            }
-          },
-          function (error) {
-            if (thenable.status === "pending") {
-              var rejectedThenable = thenable;
-              rejectedThenable.status = "rejected";
-              rejectedThenable.reason = error;
-            }
-          }
-        );
-      } // Check one more time in case the thenable resolved synchronously.
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      // In legacy sync mode, don't defer the subtree. Render it now.
+      // TODO: Consider how Offscreen should work with transitions in the future
+      var nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = nextState;
 
-      switch (thenable.status) {
-        case "fulfilled": {
-          var fulfilledThenable = thenable;
-          return fulfilledThenable.value;
+      {
+        // push the cache pool even though we're going to bail out
+        // because otherwise there'd be a context mismatch
+        if (current !== null) {
+          pushTransition(workInProgress, null, null);
         }
+      }
 
-        case "rejected": {
-          var rejectedThenable = thenable;
-          throw rejectedThenable.reason;
-        }
-      } // Suspend.
-      //
-      // Throwing here is an implementation detail that allows us to unwind the
-      // call stack. But we shouldn't allow it to leak into userspace. Throw an
-      // opaque placeholder value instead of the actual thenable. If it doesn't
-      // get captured by the work loop, log a warning, because that means
-      // something in userspace must have caught it.
+      reuseHiddenContextOnStack(workInProgress);
+      pushOffscreenSuspenseHandler(workInProgress);
+    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
+      // We're hidden, and we're not rendering at Offscreen. We will bail out
+      // and resume this tree later.
+      // Schedule this fiber to re-render at Offscreen priority
+      workInProgress.lanes = workInProgress.childLanes =
+        laneToLanes(OffscreenLane); // Include the base lanes from the last render
 
-      suspendedThenable = thenable;
+      var _nextBaseLanes =
+        prevState !== null
+          ? mergeLanes(prevState.baseLanes, renderLanes)
+          : renderLanes;
 
-      {
-        needsToResetSuspendedThenableDEV = true;
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        _nextBaseLanes,
+        renderLanes
+      );
+    } else {
+      // This is the second render. The surrounding visible content has already
+      // committed. Now we resume rendering the hidden tree.
+      // Rendering at offscreen, so we can clear the base lanes.
+      var _nextState = {
+        baseLanes: NoLanes,
+        cachePool: null
+      };
+      workInProgress.memoizedState = _nextState;
+
+      if (current !== null) {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        var prevCachePool = prevState !== null ? prevState.cachePool : null; // TODO: Consider if and how Offscreen pre-rendering should
+        // be attributed to the transition that spawned it
+
+        pushTransition(workInProgress, prevCachePool, null);
+      } // Push the lanes that were skipped when we bailed out.
+
+      if (prevState !== null) {
+        pushHiddenContext(workInProgress, prevState);
+      } else {
+        reuseHiddenContextOnStack(workInProgress);
       }
 
-      throw SuspenseException;
+      pushOffscreenSuspenseHandler(workInProgress);
     }
-  }
-} // This is used to track the actual thenable that suspended so it can be
-// passed to the rest of the Suspense implementation — which, for historical
-// reasons, expects to receive a thenable.
+  } else {
+    // Rendering a visible tree.
+    if (prevState !== null) {
+      // We're going from hidden -> visible.
+      var _prevCachePool = null;
 
-var suspendedThenable = null;
-var needsToResetSuspendedThenableDEV = false;
-function getSuspendedThenable() {
-  // This is called right after `use` suspends by throwing an exception. `use`
-  // throws an opaque value instead of the thenable itself so that it can't be
-  // caught in userspace. Then the work loop accesses the actual thenable using
-  // this function.
-  if (suspendedThenable === null) {
-    throw new Error(
-      "Expected a suspended thenable. This is a bug in React. Please file " +
-        "an issue."
-    );
-  }
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        _prevCachePool = prevState.cachePool;
+      }
 
-  var thenable = suspendedThenable;
-  suspendedThenable = null;
+      var transitions = null;
 
-  {
-    needsToResetSuspendedThenableDEV = false;
-  }
+      if (enableTransitionTracing) {
+        // We have now gone from hidden to visible, so any transitions should
+        // be added to the stack to get added to any Offscreen/suspense children
+        var instance = workInProgress.stateNode;
 
-  return thenable;
-}
-function checkIfUseWrappedInTryCatch() {
-  {
-    // This was set right before SuspenseException was thrown, and it should
-    // have been cleared when the exception was handled. If it wasn't,
-    // it must have been caught by userspace.
-    if (needsToResetSuspendedThenableDEV) {
-      needsToResetSuspendedThenableDEV = false;
-      return true;
+        if (instance !== null && instance._transitions != null) {
+          transitions = Array.from(instance._transitions);
+        }
+      }
+
+      pushTransition(workInProgress, _prevCachePool, transitions); // Push the lanes that were skipped when we bailed out.
+
+      pushHiddenContext(workInProgress, prevState);
+      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+
+      workInProgress.memoizedState = null;
+    } else {
+      // We weren't previously hidden, and we still aren't, so there's nothing
+      // special to do. Need to push to the stack regardless, though, to avoid
+      // a push/pop misalignment.
+      {
+        // If the render that spawned this one accessed the cache pool, resume
+        // using the same cache. Unless the parent changed, since that means
+        // there was a refresh.
+        if (current !== null) {
+          pushTransition(workInProgress, null, null);
+        }
+      } // We're about to bail out, but we need to push this to the stack anyway
+      // to avoid a push/pop misalignment.
+
+      reuseHiddenContextOnStack(workInProgress);
+      reuseSuspenseHandlerOnStack(workInProgress);
     }
   }
 
-  return false;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
 
-var thenableState$1 = null;
-var thenableIndexCounter$1 = 0;
-var didWarnAboutMaps;
-var didWarnAboutGenerators;
-var didWarnAboutStringRefs;
-var ownerHasKeyUseWarning;
-var ownerHasFunctionTypeWarning;
-
-var warnForMissingKey = function (child, returnFiber) {};
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
+  var nextState = {
+    baseLanes: nextBaseLanes,
+    // Save the cache pool so we can resume later.
+    cachePool: getOffscreenDeferredCache()
+  };
+  workInProgress.memoizedState = nextState;
 
-{
-  didWarnAboutMaps = false;
-  didWarnAboutGenerators = false;
-  didWarnAboutStringRefs = {};
-  /**
-   * Warn if there's no key explicitly set on dynamic arrays of children or
-   * object keys are not valid. This allows us to keep track of children between
-   * updates.
-   */
+  {
+    // push the cache pool even though we're going to bail out
+    // because otherwise there'd be a context mismatch
+    if (current !== null) {
+      pushTransition(workInProgress, null, null);
+    }
+  } // We're about to bail out, but we need to push this to the stack anyway
+  // to avoid a push/pop misalignment.
 
-  ownerHasKeyUseWarning = {};
-  ownerHasFunctionTypeWarning = {};
+  reuseHiddenContextOnStack(workInProgress);
+  pushOffscreenSuspenseHandler(workInProgress);
 
-  warnForMissingKey = function (child, returnFiber) {
-    if (child === null || typeof child !== "object") {
-      return;
-    }
+  if (enableLazyContextPropagation && current !== null) {
+    // Since this tree will resume rendering in a separate render, we need
+    // to propagate parent contexts now so we don't lose track of which
+    // ones changed.
+    propagateParentContextChangesToDeferredTree(
+      current,
+      workInProgress,
+      renderLanes
+    );
+  }
 
-    if (!child._store || child._store.validated || child.key != null) {
-      return;
-    }
+  return null;
+} // Note: These happen to have identical begin phases, for now. We shouldn't hold
+// ourselves to this constraint, though. If the behavior diverges, we should
+// fork the function.
 
-    if (typeof child._store !== "object") {
-      throw new Error(
-        "React Component in warnForMissingKey should have a _store. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
-    } // $FlowFixMe unable to narrow type from mixed to writable object
+var updateLegacyHiddenComponent = updateOffscreenComponent;
 
-    child._store.validated = true;
-    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
+function updateCacheComponent(current, workInProgress, renderLanes) {
+  prepareToReadContext(workInProgress, renderLanes);
+  var parentCache = readContext(CacheContext);
 
-    if (ownerHasKeyUseWarning[componentName]) {
-      return;
+  if (current === null) {
+    // Initial mount. Request a fresh cache from the pool.
+    var freshCache = requestCacheFromPool(renderLanes);
+    var initialState = {
+      parent: parentCache,
+      cache: freshCache
+    };
+    workInProgress.memoizedState = initialState;
+    initializeUpdateQueue(workInProgress);
+    pushCacheProvider(workInProgress, freshCache);
+  } else {
+    // Check for updates
+    if (includesSomeLane(current.lanes, renderLanes)) {
+      cloneUpdateQueue(current, workInProgress);
+      processUpdateQueue(workInProgress, null, null, renderLanes);
     }
 
-    ownerHasKeyUseWarning[componentName] = true;
+    var prevState = current.memoizedState;
+    var nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
+    // a refresh.
 
-    error(
-      "Each child in a list should have a unique " +
-        '"key" prop. See https://reactjs.org/link/warning-keys for ' +
-        "more information."
-    );
-  };
-}
+    if (prevState.parent !== parentCache) {
+      // Refresh in parent. Update the parent.
+      var derivedState = {
+        parent: parentCache,
+        cache: parentCache
+      }; // Copied from getDerivedStateFromProps implementation. Once the update
+      // queue is empty, persist the derived state onto the base state.
 
-function isReactClass(type) {
-  return type.prototype && type.prototype.isReactComponent;
-}
+      workInProgress.memoizedState = derivedState;
 
-function unwrapThenable(thenable) {
-  var index = thenableIndexCounter$1;
-  thenableIndexCounter$1 += 1;
+      if (workInProgress.lanes === NoLanes) {
+        var updateQueue = workInProgress.updateQueue;
+        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+      }
 
-  if (thenableState$1 === null) {
-    thenableState$1 = createThenableState();
+      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
+      // already did.
+    } else {
+      // The parent didn't refresh. Now check if this cache did.
+      var nextCache = nextState.cache;
+      pushCacheProvider(workInProgress, nextCache);
+
+      if (nextCache !== prevState.cache) {
+        // This cache refreshed. Propagate a context change.
+        propagateContextChange(workInProgress, CacheContext, renderLanes);
+      }
+    }
   }
 
-  return trackUsedThenable(thenableState$1, thenable, index);
-}
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+} // This should only be called if the name changes
 
-function coerceRef(returnFiber, current, element) {
-  var mixedRef = element.ref;
+function updateTracingMarkerComponent(current, workInProgress, renderLanes) {
+  if (!enableTransitionTracing) {
+    return null;
+  } // TODO: (luna) Only update the tracing marker if it's newly rendered or it's name changed.
+  // A tracing marker is only associated with the transitions that rendered
+  // or updated it, so we can create a new set of transitions each time
 
-  if (
-    mixedRef !== null &&
-    typeof mixedRef !== "function" &&
-    typeof mixedRef !== "object"
-  ) {
-    {
-      if (
-        // We warn in ReactElement.js if owner and self are equal for string refs
-        // because these cannot be automatically converted to an arrow function
-        // using a codemod. Therefore, we don't have to warn about string refs again.
-        !(
-          element._owner &&
-          element._self &&
-          element._owner.stateNode !== element._self
-        ) && // Will already throw with "Function components cannot have string refs"
-        !(element._owner && element._owner.tag !== ClassComponent) && // Will already warn with "Function components cannot be given refs"
-        !(typeof element.type === "function" && !isReactClass(element.type)) && // Will already throw with "Element ref was specified as a string (someStringRef) but no owner was set"
-        element._owner
-      ) {
-        var componentName =
-          getComponentNameFromFiber(returnFiber) || "Component";
+  if (current === null) {
+    var currentTransitions = getPendingTransitions();
 
-        if (!didWarnAboutStringRefs[componentName]) {
-          error(
-            'Component "%s" contains the string ref "%s". Support for string refs ' +
-              "will be removed in a future major release. We recommend using " +
-              "useRef() or createRef() instead. " +
-              "Learn more about using refs safely here: " +
-              "https://reactjs.org/link/strict-mode-string-ref",
-            componentName,
-            mixedRef
-          );
+    if (currentTransitions !== null) {
+      var markerInstance = {
+        tag: TransitionTracingMarker,
+        transitions: new Set(currentTransitions),
+        pendingBoundaries: null,
+        name: workInProgress.pendingProps.name,
+        aborts: null
+      };
+      workInProgress.stateNode = markerInstance; // We call the marker complete callback when all child suspense boundaries resolve.
+      // We do this in the commit phase on Offscreen. If the marker has no child suspense
+      // boundaries, we need to schedule a passive effect to make sure we call the marker
+      // complete callback.
 
-          didWarnAboutStringRefs[componentName] = true;
-        }
+      workInProgress.flags |= Passive$1;
+    }
+  } else {
+    {
+      if (current.memoizedProps.name !== workInProgress.pendingProps.name) {
+        error(
+          "Changing the name of a tracing marker after mount is not supported. " +
+            "To remount the tracing marker, pass it a new key."
+        );
       }
     }
+  }
 
-    if (element._owner) {
-      var owner = element._owner;
-      var inst;
-
-      if (owner) {
-        var ownerFiber = owner;
+  var instance = workInProgress.stateNode;
 
-        if (ownerFiber.tag !== ClassComponent) {
-          throw new Error(
-            "Function components cannot have string refs. " +
-              "We recommend using useRef() instead. " +
-              "Learn more about using refs safely here: " +
-              "https://reactjs.org/link/strict-mode-string-ref"
-          );
-        }
+  if (instance !== null) {
+    pushMarkerInstance(workInProgress, instance);
+  }
 
-        inst = ownerFiber.stateNode;
-      }
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-      if (!inst) {
-        throw new Error(
-          "Missing owner for string ref " +
-            mixedRef +
-            ". This error is likely caused by a " +
-            "bug in React. Please file an issue."
-        );
-      } // Assigning this to a const so Flow knows it won't change in the closure
+function updateFragment(current, workInProgress, renderLanes) {
+  var nextChildren = workInProgress.pendingProps;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-      var resolvedInst = inst;
+function updateMode(current, workInProgress, renderLanes) {
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-      {
-        checkPropStringCoercion(mixedRef, "ref");
-      }
+function updateProfiler(current, workInProgress, renderLanes) {
+  {
+    workInProgress.flags |= Update;
 
-      var stringRef = "" + mixedRef; // Check if previous string ref matches new string ref
+    {
+      // Reset effect durations for the next eventual effect phase.
+      // These are reset during render to allow the DevTools commit hook a chance to read them,
+      var stateNode = workInProgress.stateNode;
+      stateNode.effectDuration = 0;
+      stateNode.passiveEffectDuration = 0;
+    }
+  }
 
-      if (
-        current !== null &&
-        current.ref !== null &&
-        typeof current.ref === "function" &&
-        current.ref._stringRef === stringRef
-      ) {
-        return current.ref;
-      }
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-      var ref = function (value) {
-        var refs = resolvedInst.refs;
+function markRef$1(current, workInProgress) {
+  var ref = workInProgress.ref;
 
-        if (value === null) {
-          delete refs[stringRef];
-        } else {
-          refs[stringRef] = value;
-        }
-      };
+  if (
+    (current === null && ref !== null) ||
+    (current !== null && current.ref !== ref)
+  ) {
+    // Schedule a Ref effect
+    workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
+  }
+}
 
-      ref._stringRef = stringRef;
-      return ref;
-    } else {
-      if (typeof mixedRef !== "string") {
-        throw new Error(
-          "Expected ref to be a function, a string, an object returned by React.createRef(), or null."
-        );
-      }
+function updateFunctionComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  {
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
 
-      if (!element._owner) {
-        throw new Error(
-          "Element ref was specified as a string (" +
-            mixedRef +
-            ") but no owner was set. This could happen for one of" +
-            " the following reasons:\n" +
-            "1. You may be adding a ref to a function component\n" +
-            "2. You may be adding a ref to a component that was not created inside a component's render method\n" +
-            "3. You have multiple copies of React loaded\n" +
-            "See https://reactjs.org/link/refs-must-have-owner for more information."
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
         );
       }
     }
   }
 
-  return mixedRef;
-}
+  var context;
 
-function throwOnInvalidObjectType(returnFiber, newChild) {
-  // $FlowFixMe[method-unbinding]
-  var childString = Object.prototype.toString.call(newChild);
-  throw new Error(
-    "Objects are not valid as a React child (found: " +
-      (childString === "[object Object]"
-        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
-        : childString) +
-      "). " +
-      "If you meant to render a collection of children, use an array " +
-      "instead."
-  );
-}
+  var nextChildren;
+  var hasId;
+  prepareToReadContext(workInProgress, renderLanes);
 
-function warnOnFunctionType(returnFiber) {
-  {
-    var componentName = getComponentNameFromFiber(returnFiber) || "Component";
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-    if (ownerHasFunctionTypeWarning[componentName]) {
-      return;
-    }
+  {
+    ReactCurrentOwner$1.current = workInProgress;
+    setIsRendering(true);
+    nextChildren = renderWithHooks(
+      current,
+      workInProgress,
+      Component,
+      nextProps,
+      context,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
+  }
 
-    ownerHasFunctionTypeWarning[componentName] = true;
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
 
-    error(
-      "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."
-    );
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
+
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function resolveLazy(lazyType) {
-  var payload = lazyType._payload;
-  var init = lazyType._init;
-  return init(payload);
-} // This wrapper function exists because I expect to clone the code in each path
-// to be able to optimize each path individually by branching early. This needs
-// a compiler or we can do it manually. Helpers that don't need this branching
-// live outside of this function.
+function replayFunctionComponent(
+  current,
+  workInProgress,
+  nextProps,
+  Component,
+  renderLanes
+) {
+  // This function is used to replay a component that previously suspended,
+  // after its data resolves. It's a simplified version of
+  // updateFunctionComponent that reuses the hooks from the previous attempt.
+  var context;
 
-function createChildReconciler(shouldTrackSideEffects) {
-  function deleteChild(returnFiber, childToDelete) {
-    if (!shouldTrackSideEffects) {
-      // Noop.
-      return;
-    }
+  prepareToReadContext(workInProgress, renderLanes);
 
-    var deletions = returnFiber.deletions;
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-    if (deletions === null) {
-      returnFiber.deletions = [childToDelete];
-      returnFiber.flags |= ChildDeletion;
-    } else {
-      deletions.push(childToDelete);
-    }
+  var nextChildren = replaySuspendedComponentWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    context
+  );
+  var hasId = checkDidRenderIdHook();
+
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
   }
 
-  function deleteRemainingChildren(returnFiber, currentFirstChild) {
-    if (!shouldTrackSideEffects) {
-      // Noop.
-      return null;
-    } // TODO: For the shouldClone case, this could be micro-optimized a bit by
-    // assuming that after the first child we've already added everything.
+  if (current !== null && !didReceiveUpdate) {
+    bailoutHooks(current, workInProgress, renderLanes);
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
 
-    var childToDelete = currentFirstChild;
+  if (getIsHydrating() && hasId) {
+    pushMaterializedTreeId(workInProgress);
+  } // React DevTools reads this flag.
 
-    while (childToDelete !== null) {
-      deleteChild(returnFiber, childToDelete);
-      childToDelete = childToDelete.sibling;
-    }
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-    return null;
-  }
+function updateClassComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  {
+    // This is used by DevTools to force a boundary to error.
+    switch (shouldError(workInProgress)) {
+      case false: {
+        var _instance = workInProgress.stateNode;
+        var ctor = workInProgress.type; // TODO This way of resetting the error boundary state is a hack.
+        // Is there a better way to do this?
 
-  function mapRemainingChildren(returnFiber, currentFirstChild) {
-    // Add the remaining children to a temporary map so that we can find them by
-    // keys quickly. Implicit (null) keys get added to this set with their index
-    // instead.
-    var existingChildren = new Map();
-    var existingChild = currentFirstChild;
+        var tempInstance = new ctor(
+          workInProgress.memoizedProps,
+          _instance.context
+        );
+        var state = tempInstance.state;
 
-    while (existingChild !== null) {
-      if (existingChild.key !== null) {
-        existingChildren.set(existingChild.key, existingChild);
-      } else {
-        existingChildren.set(existingChild.index, existingChild);
+        _instance.updater.enqueueSetState(_instance, state, null);
+
+        break;
       }
 
-      existingChild = existingChild.sibling;
+      case true: {
+        workInProgress.flags |= DidCapture;
+        workInProgress.flags |= ShouldCapture; // eslint-disable-next-line react-internal/prod-error-codes
+
+        var error$1 = new Error("Simulated error coming from DevTools");
+        var lane = pickArbitraryLane(renderLanes);
+        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+
+        var update = createClassErrorUpdate(
+          workInProgress,
+          createCapturedValueAtFiber(error$1, workInProgress),
+          lane
+        );
+        enqueueCapturedUpdate(workInProgress, update);
+        break;
+      }
     }
 
-    return existingChildren;
-  }
+    if (workInProgress.type !== workInProgress.elementType) {
+      // Lazy component props can't be validated in createElement
+      // because they're only guaranteed to be resolved here.
+      var innerPropTypes = Component.propTypes;
 
-  function useFiber(fiber, pendingProps) {
-    // We currently set sibling to null and index to 0 here because it is easy
-    // to forget to do before returning it. E.g. for the single child case.
-    var clone = createWorkInProgress(fiber, pendingProps);
-    clone.index = 0;
-    clone.sibling = null;
-    return clone;
+      if (innerPropTypes) {
+        checkPropTypes(
+          innerPropTypes,
+          nextProps, // Resolved props
+          "prop",
+          getComponentNameFromType(Component)
+        );
+      }
+    }
+  } // 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;
+
+  if (isContextProvider()) {
+    hasContext = true;
+  } else {
+    hasContext = false;
   }
 
-  function placeChild(newFiber, lastPlacedIndex, newIndex) {
-    newFiber.index = newIndex;
+  prepareToReadContext(workInProgress, renderLanes);
+  var instance = workInProgress.stateNode;
+  var shouldUpdate;
 
-    if (!shouldTrackSideEffects) {
-      // During hydration, the useId algorithm needs to know which fibers are
-      // part of a list of children (arrays, iterators).
-      newFiber.flags |= Forked;
-      return lastPlacedIndex;
-    }
+  if (instance === null) {
+    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
 
-    var current = newFiber.alternate;
+    constructClassInstance(workInProgress, Component, nextProps);
+    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+    shouldUpdate = true;
+  } else if (current === null) {
+    // In a resume, we'll already have an instance we can reuse.
+    shouldUpdate = resumeMountClassInstance(
+      workInProgress,
+      Component,
+      nextProps,
+      renderLanes
+    );
+  } else {
+    shouldUpdate = updateClassInstance(
+      current,
+      workInProgress,
+      Component,
+      nextProps,
+      renderLanes
+    );
+  }
 
-    if (current !== null) {
-      var oldIndex = current.index;
+  var nextUnitOfWork = finishClassComponent(
+    current,
+    workInProgress,
+    Component,
+    shouldUpdate,
+    hasContext,
+    renderLanes
+  );
 
-      if (oldIndex < lastPlacedIndex) {
-        // This is a move.
-        newFiber.flags |= Placement | PlacementDEV;
-        return lastPlacedIndex;
-      } else {
-        // This item can stay in place.
-        return oldIndex;
+  {
+    var inst = workInProgress.stateNode;
+
+    if (shouldUpdate && inst.props !== nextProps) {
+      if (!didWarnAboutReassigningProps) {
+        error(
+          "It looks like %s is reassigning its own `this.props` while rendering. " +
+            "This is not supported and can lead to confusing bugs.",
+          getComponentNameFromFiber(workInProgress) || "a component"
+        );
       }
-    } else {
-      // This is an insertion.
-      newFiber.flags |= Placement | PlacementDEV;
-      return lastPlacedIndex;
+
+      didWarnAboutReassigningProps = true;
     }
   }
 
-  function placeSingleChild(newFiber) {
-    // This is simpler for the single child case. We only need to do a
-    // placement for inserting new children.
-    if (shouldTrackSideEffects && newFiber.alternate === null) {
-      newFiber.flags |= Placement | PlacementDEV;
-    }
+  return nextUnitOfWork;
+}
 
-    return newFiber;
-  }
+function finishClassComponent(
+  current,
+  workInProgress,
+  Component,
+  shouldUpdate,
+  hasContext,
+  renderLanes
+) {
+  // Refs should update even if shouldComponentUpdate returns false
+  markRef$1(current, workInProgress);
+  var didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-  function updateTextNode(returnFiber, current, textContent, lanes) {
-    if (current === null || current.tag !== HostText) {
-      // Insert
-      var created = createFiberFromText(textContent, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, textContent);
-      existing.return = returnFiber;
-      return existing;
-    }
+  if (!shouldUpdate && !didCaptureError) {
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
 
-  function updateElement(returnFiber, current, element, lanes) {
-    var elementType = element.type;
+  var instance = workInProgress.stateNode; // Rerender
 
-    if (elementType === REACT_FRAGMENT_TYPE) {
-      return updateFragment(
-        returnFiber,
-        current,
-        element.props.children,
-        lanes,
-        element.key
-      );
-    }
+  ReactCurrentOwner$1.current = workInProgress;
+  var nextChildren;
 
-    if (current !== null) {
-      if (
-        current.elementType === elementType || // Keep this check inline so it only runs on the false path:
-        isCompatibleFamilyForHotReloading(current, element) || // Lazy types should reconcile their resolved type.
-        // We need to do this after the Hot Reloading check above,
-        // because hot reloading has different semantics than prod because
-        // it doesn't resuspend. So we can't let the call below suspend.
-        (typeof elementType === "object" &&
-          elementType !== null &&
-          elementType.$$typeof === REACT_LAZY_TYPE &&
-          resolveLazy(elementType) === current.type)
-      ) {
-        // Move based on index
-        var existing = useFiber(current, element.props);
-        existing.ref = coerceRef(returnFiber, current, element);
-        existing.return = returnFiber;
-
-        {
-          existing._debugSource = element._source;
-          existing._debugOwner = element._owner;
-        }
-
-        return existing;
-      }
-    } // Insert
-
-    var created = createFiberFromElement(element, returnFiber.mode, lanes);
-    created.ref = coerceRef(returnFiber, current, element);
-    created.return = returnFiber;
-    return created;
-  }
-
-  function updatePortal(returnFiber, current, portal, lanes) {
-    if (
-      current === null ||
-      current.tag !== HostPortal ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
-    ) {
-      // Insert
-      var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, portal.children || []);
-      existing.return = returnFiber;
-      return existing;
-    }
-  }
+  if (
+    didCaptureError &&
+    typeof Component.getDerivedStateFromError !== "function"
+  ) {
+    // If we captured an error, but getDerivedStateFromError is not defined,
+    // unmount all the children. componentDidCatch will schedule an update to
+    // re-render a fallback. This is temporary until we migrate everyone to
+    // the new API.
+    // TODO: Warn in a future release.
+    nextChildren = null;
 
-  function updateFragment(returnFiber, current, fragment, lanes, key) {
-    if (current === null || current.tag !== Fragment) {
-      // Insert
-      var created = createFiberFromFragment(
-        fragment,
-        returnFiber.mode,
-        lanes,
-        key
-      );
-      created.return = returnFiber;
-      return created;
-    } else {
-      // Update
-      var existing = useFiber(current, fragment);
-      existing.return = returnFiber;
-      return existing;
+    {
+      stopProfilerTimerIfRunning();
     }
-  }
-
-  function createChild(returnFiber, newChild, lanes) {
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys. If the previous node is implicitly keyed
-      // we can continue to replace it without aborting even if it is not a text
-      // node.
-      var created = createFiberFromText("" + newChild, returnFiber.mode, lanes);
-      created.return = returnFiber;
-      return created;
+  } else {
+    if (enableSchedulingProfiler) {
+      markComponentRenderStarted(workInProgress);
     }
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          var _created = createFiberFromElement(
-            newChild,
-            returnFiber.mode,
-            lanes
-          );
-
-          _created.ref = coerceRef(returnFiber, null, newChild);
-          _created.return = returnFiber;
-          return _created;
-        }
-
-        case REACT_PORTAL_TYPE: {
-          var _created2 = createFiberFromPortal(
-            newChild,
-            returnFiber.mode,
-            lanes
-          );
+    {
+      setIsRendering(true);
+      nextChildren = instance.render();
 
-          _created2.return = returnFiber;
-          return _created2;
-        }
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
 
-        case REACT_LAZY_TYPE: {
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return createChild(returnFiber, init(payload), lanes);
+        try {
+          instance.render();
+        } finally {
+          setIsStrictModeForDevtools(false);
         }
       }
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        var _created3 = createFiberFromFragment(
-          newChild,
-          returnFiber.mode,
-          lanes,
-          null
-        );
-
-        _created3.return = returnFiber;
-        return _created3;
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
-
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return createChild(returnFiber, unwrapThenable(thenable), lanes);
-      }
-
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return createChild(
-          returnFiber,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
-
-      throwOnInvalidObjectType(returnFiber, newChild);
+      setIsRendering(false);
     }
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
+    if (enableSchedulingProfiler) {
+      markComponentRenderStopped();
     }
+  } // React DevTools reads this flag.
 
-    return null;
-  }
+  workInProgress.flags |= PerformedWork;
 
-  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
-    // Update the fiber if the keys match, otherwise return null.
-    var key = oldFiber !== null ? oldFiber.key : null;
+  if (current !== null && didCaptureError) {
+    // If we're recovering from an error, reconcile without reusing any of
+    // the existing children. Conceptually, the normal children and the children
+    // that are shown on error are two different sets, so we shouldn't reuse
+    // normal children even if their identities match.
+    forceUnmountCurrentAndReconcile(
+      current,
+      workInProgress,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  } // Memoize state using the values we just used to render.
+  // TODO: Restructure so we never read values from the instance.
 
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys. If the previous node is implicitly keyed
-      // we can continue to replace it without aborting even if it is not a text
-      // node.
-      if (key !== null) {
-        return null;
-      }
+  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
 
-      return updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
-    }
+  return workInProgress.child;
+}
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          if (newChild.key === key) {
-            return updateElement(returnFiber, oldFiber, newChild, lanes);
-          } else {
-            return null;
-          }
-        }
+function pushHostRootContext(workInProgress) {
+  var root = workInProgress.stateNode;
 
-        case REACT_PORTAL_TYPE: {
-          if (newChild.key === key) {
-            return updatePortal(returnFiber, oldFiber, newChild, lanes);
-          } else {
-            return null;
-          }
-        }
+  pushHostContainer(workInProgress, root.containerInfo);
+}
 
-        case REACT_LAZY_TYPE: {
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return updateSlot(returnFiber, oldFiber, init(payload), lanes);
-        }
-      }
+function updateHostRoot(current, workInProgress, renderLanes) {
+  pushHostRootContext(workInProgress);
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        if (key !== null) {
-          return null;
-        }
+  if (current === null) {
+    throw new Error("Should have a current fiber. This is a bug in React.");
+  }
 
-        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
+  var nextProps = workInProgress.pendingProps;
+  var prevState = workInProgress.memoizedState;
+  var prevChildren = prevState.element;
+  cloneUpdateQueue(current, workInProgress);
+  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+  var nextState = workInProgress.memoizedState;
+  var root = workInProgress.stateNode;
+  pushRootTransition(workInProgress);
 
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+  if (enableTransitionTracing) {
+    pushRootMarkerInstance(workInProgress);
+  }
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+  {
+    var nextCache = nextState.cache;
+    pushCacheProvider(workInProgress, nextCache);
 
-      throwOnInvalidObjectType(returnFiber, newChild);
+    if (nextCache !== prevState.cache) {
+      // The root cache refreshed.
+      propagateContextChange(workInProgress, CacheContext, renderLanes);
     }
+  } // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
-    }
+  var nextChildren = nextState.element;
 
-    return null;
-  }
+  if (prevState.isDehydrated) {
+    // This is a hydration root whose shell has not yet hydrated. We should
+    // attempt to hydrate.
+    // Flip isDehydrated to false to indicate that when this render
+    // finishes, the root will no longer be dehydrated.
+    var overrideState = {
+      element: nextChildren,
+      isDehydrated: false,
+      cache: nextState.cache
+    };
+    var updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
+    // have reducer functions so it doesn't need rebasing.
 
-  function updateFromMap(
-    existingChildren,
-    returnFiber,
-    newIdx,
-    newChild,
-    lanes
-  ) {
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      // Text nodes don't have keys, so we neither have to check the old nor
-      // new node for the key. If both are text nodes, they match.
-      var matchedFiber = existingChildren.get(newIdx) || null;
-      return updateTextNode(returnFiber, matchedFiber, "" + newChild, lanes);
-    }
+    updateQueue.baseState = overrideState;
+    workInProgress.memoizedState = overrideState;
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE: {
-          var _matchedFiber =
-            existingChildren.get(
-              newChild.key === null ? newIdx : newChild.key
-            ) || null;
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during a previous attempt to hydrate the shell, so we
+      // forced a client render.
+      var recoverableError = createCapturedValueAtFiber(
+        new Error(
+          "There was an error while hydrating. Because the error happened outside " +
+            "of a Suspense boundary, the entire root will switch to " +
+            "client rendering."
+        ),
+        workInProgress
+      );
+      return mountHostRootWithoutHydrating(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes,
+        recoverableError
+      );
+    } else if (nextChildren !== prevChildren) {
+      var _recoverableError = createCapturedValueAtFiber(
+        new Error(
+          "This root received an early update, before anything was able " +
+            "hydrate. Switched the entire root to client rendering."
+        ),
+        workInProgress
+      );
 
-          return updateElement(returnFiber, _matchedFiber, newChild, lanes);
-        }
+      return mountHostRootWithoutHydrating(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes,
+        _recoverableError
+      );
+    } else {
+      // The outermost shell has not hydrated yet. Start hydrating.
+      enterHydrationState(workInProgress);
 
-        case REACT_PORTAL_TYPE: {
-          var _matchedFiber2 =
-            existingChildren.get(
-              newChild.key === null ? newIdx : newChild.key
-            ) || null;
+      {
+        var mutableSourceEagerHydrationData =
+          root.mutableSourceEagerHydrationData;
 
-          return updatePortal(returnFiber, _matchedFiber2, newChild, lanes);
+        if (mutableSourceEagerHydrationData != null) {
+          for (var i = 0; i < mutableSourceEagerHydrationData.length; i += 2) {
+            var mutableSource = mutableSourceEagerHydrationData[i];
+            var version = mutableSourceEagerHydrationData[i + 1];
+            setWorkInProgressVersion(mutableSource, version);
+          }
         }
-
-        case REACT_LAZY_TYPE:
-          var payload = newChild._payload;
-          var init = newChild._init;
-          return updateFromMap(
-            existingChildren,
-            returnFiber,
-            newIdx,
-            init(payload),
-            lanes
-          );
       }
 
-      if (isArray(newChild) || getIteratorFn(newChild)) {
-        var _matchedFiber3 = existingChildren.get(newIdx) || null;
-
-        return updateFragment(
-          returnFiber,
-          _matchedFiber3,
-          newChild,
-          lanes,
-          null
-        );
-      } // Usable node types
-      //
-      // Unwrap the inner value and recursively call this function again.
-
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+      var child = mountChildFibers(
+        workInProgress,
+        null,
+        nextChildren,
+        renderLanes
+      );
+      workInProgress.child = child;
+      var node = child;
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
+      while (node) {
+        // Mark each child as hydrating. This is a fast path to know whether this
+        // tree is part of a hydrating tree. This is used to determine if a child
+        // node has fully mounted yet, and for scheduling event replaying.
+        // Conceptually this is similar to Placement in that a new subtree is
+        // inserted into the React tree here. It just happens to not need DOM
+        // mutations because it already exists.
+        node.flags = (node.flags & ~Placement) | Hydrating;
+        node = node.sibling;
       }
-
-      throwOnInvalidObjectType(returnFiber, newChild);
     }
+  } else {
+    // Root is not dehydrated. Either this is a client-only root, or it
+    // already hydrated.
+    resetHydrationState();
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
-      }
+    if (nextChildren === prevChildren) {
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
     }
 
-    return null;
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
   }
-  /**
-   * Warns if there is a duplicate or missing key
-   */
 
-  function warnOnInvalidKey(child, knownKeys, returnFiber) {
-    {
-      if (typeof child !== "object" || child === null) {
-        return knownKeys;
-      }
+  return workInProgress.child;
+}
 
-      switch (child.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-        case REACT_PORTAL_TYPE:
-          warnForMissingKey(child, returnFiber);
-          var key = child.key;
+function mountHostRootWithoutHydrating(
+  current,
+  workInProgress,
+  nextChildren,
+  renderLanes,
+  recoverableError
+) {
+  // Revert to client rendering.
+  resetHydrationState();
+  queueHydrationError(recoverableError);
+  workInProgress.flags |= ForceClientRender;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-          if (typeof key !== "string") {
-            break;
-          }
+function updateHostComponent$1(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
 
-          if (knownKeys === null) {
-            knownKeys = new Set();
-            knownKeys.add(key);
-            break;
-          }
+  if (current === null) {
+    tryToClaimNextHydratableInstance(workInProgress);
+  }
 
-          if (!knownKeys.has(key)) {
-            knownKeys.add(key);
-            break;
-          }
+  var type = workInProgress.type;
+  var nextProps = workInProgress.pendingProps;
+  var prevProps = current !== null ? current.memoizedProps : null;
+  var nextChildren = nextProps.children;
+  var isDirectTextChild = shouldSetTextContent(type, nextProps);
 
-          error(
-            "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.",
-            key
-          );
+  if (isDirectTextChild) {
+    // We special case a direct text child of a host node. This is a common
+    // case. We won't handle it as a reified child. We will instead handle
+    // this in the host environment that also has access to this prop. That
+    // avoids allocating another HostText fiber and traversing it.
+    nextChildren = null;
+  } 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.flags |= ContentReset;
+  }
 
-          break;
+  markRef$1(current, workInProgress);
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-        case REACT_LAZY_TYPE:
-          var payload = child._payload;
-          var init = child._init;
-          warnOnInvalidKey(init(payload), knownKeys, returnFiber);
-          break;
-      }
+function updateHostHoistable(current, workInProgress, renderLanes) {
+  markRef$1(current, workInProgress);
+  var currentProps = current === null ? null : current.memoizedProps;
+  var resource = (workInProgress.memoizedState = getResource(
+    workInProgress.type,
+    currentProps,
+    workInProgress.pendingProps
+  ));
+
+  if (current === null) {
+    if (!getIsHydrating() && resource === null) {
+      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
+      workInProgress.stateNode = createHoistableInstance(
+        workInProgress.type,
+        workInProgress.pendingProps,
+        getRootHostContainer(),
+        workInProgress
+      );
     }
+  } // Resources never have reconciler managed children. It is possible for
+  // the host implementation of getResource to consider children in the
+  // resource construction but they will otherwise be discarded. In practice
+  // this precludes all but the simplest children and Host specific warnings
+  // should be implemented to warn when children are passsed when otherwise not
+  // expected
 
-    return knownKeys;
+  return null;
+}
+
+function updateHostSingleton(current, workInProgress, renderLanes) {
+  pushHostContext(workInProgress);
+
+  if (current === null) {
+    claimHydratableSingleton(workInProgress);
   }
 
-  function reconcileChildrenArray(
-    returnFiber,
-    currentFirstChild,
-    newChildren,
-    lanes
-  ) {
-    // This algorithm can't optimize by searching from both ends since we
-    // don't have backpointers on fibers. I'm trying to see how far we can get
-    // with that model. If it ends up not being worth the tradeoffs, we can
-    // add it later.
-    // Even with a two ended optimization, we'd want to optimize for the case
-    // where there are few changes and brute force the comparison instead of
-    // going for the Map. It'd like to explore hitting that path first in
-    // forward-only mode and only go for the Map once we notice that we need
-    // lots of look ahead. This doesn't handle reversal as well as two ended
-    // search but that's unusual. Besides, for the two ended optimization to
-    // work on Iterables, we'd need to copy the whole set.
-    // In this first iteration, we'll just live with hitting the bad case
-    // (adding everything to a Map) in for every insert/move.
-    // If you change this code, also update reconcileChildrenIterator() which
-    // uses the same algorithm.
-    {
-      // First, validate keys.
-      var knownKeys = null;
+  var nextChildren = workInProgress.pendingProps.children;
 
-      for (var i = 0; i < newChildren.length; i++) {
-        var child = newChildren[i];
-        knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
-      }
-    }
+  if (current === null && !getIsHydrating()) {
+    // Similar to Portals we append Singleton children in the commit phase. So we
+    // Track insertions even on mount.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
+  } else {
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  }
 
-    var resultingFirstChild = null;
-    var previousNewFiber = null;
-    var oldFiber = currentFirstChild;
-    var lastPlacedIndex = 0;
-    var newIdx = 0;
-    var nextOldFiber = null;
+  markRef$1(current, workInProgress);
+  return workInProgress.child;
+}
 
-    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
-      if (oldFiber.index > newIdx) {
-        nextOldFiber = oldFiber;
-        oldFiber = null;
-      } else {
-        nextOldFiber = oldFiber.sibling;
-      }
+function updateHostText$1(current, workInProgress) {
+  if (current === null) {
+    tryToClaimNextHydratableTextInstance(workInProgress);
+  } // Nothing to do here. This is terminal. We'll do the completion step
+  // immediately after.
 
-      var newFiber = updateSlot(
-        returnFiber,
-        oldFiber,
-        newChildren[newIdx],
-        lanes
-      );
+  return null;
+}
 
-      if (newFiber === null) {
-        // TODO: This breaks on empty slots like null children. That's
-        // unfortunate because it triggers the slow path all the time. We need
-        // a better way to communicate whether this was a miss or null,
-        // boolean, undefined, etc.
-        if (oldFiber === null) {
-          oldFiber = nextOldFiber;
-        }
+function mountLazyComponent(
+  _current,
+  workInProgress,
+  elementType,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  var props = workInProgress.pendingProps;
+  var lazyComponent = elementType;
+  var payload = lazyComponent._payload;
+  var init = lazyComponent._init;
+  var Component = init(payload); // Store the unwrapped component in the type.
 
-        break;
-      }
+  workInProgress.type = Component;
+  var resolvedTag = (workInProgress.tag = resolveLazyComponentTag(Component));
+  var resolvedProps = resolveDefaultProps(Component, props);
+  var child;
 
-      if (shouldTrackSideEffects) {
-        if (oldFiber && newFiber.alternate === null) {
-          // We matched the slot, but we didn't reuse the existing fiber, so we
-          // need to delete the existing child.
-          deleteChild(returnFiber, oldFiber);
-        }
+  switch (resolvedTag) {
+    case FunctionComponent: {
+      {
+        validateFunctionComponentInDev(workInProgress, Component);
+        workInProgress.type = Component =
+          resolveFunctionForHotReloading(Component);
       }
 
-      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+      child = updateFunctionComponent(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
+    }
 
-      if (previousNewFiber === null) {
-        // TODO: Move out of the loop. This only happens for the first run.
-        resultingFirstChild = newFiber;
-      } else {
-        // TODO: Defer siblings if we're not at the right index for this slot.
-        // I.e. if we had null values before, then we want to defer this
-        // for each null value. However, we also don't want to call updateSlot
-        // with the previous one.
-        previousNewFiber.sibling = newFiber;
+    case ClassComponent: {
+      {
+        workInProgress.type = Component =
+          resolveClassForHotReloading(Component);
       }
 
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
+      child = updateClassComponent(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
     }
 
-    if (newIdx === newChildren.length) {
-      // We've reached the end of the new children. We can delete the rest.
-      deleteRemainingChildren(returnFiber, oldFiber);
-
-      if (getIsHydrating()) {
-        var numberOfForks = newIdx;
-        pushTreeFork(returnFiber, numberOfForks);
+    case ForwardRef: {
+      {
+        workInProgress.type = Component =
+          resolveForwardRefForHotReloading(Component);
       }
 
-      return resultingFirstChild;
+      child = updateForwardRef(
+        null,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+      return child;
     }
 
-    if (oldFiber === null) {
-      // If we don't have any more existing children we can choose a fast path
-      // since the rest will all be insertions.
-      for (; newIdx < newChildren.length; newIdx++) {
-        var _newFiber = createChild(returnFiber, newChildren[newIdx], lanes);
+    case MemoComponent: {
+      {
+        if (workInProgress.type !== workInProgress.elementType) {
+          var outerPropTypes = Component.propTypes;
 
-        if (_newFiber === null) {
-          continue;
+          if (outerPropTypes) {
+            checkPropTypes(
+              outerPropTypes,
+              resolvedProps, // Resolved for outer only
+              "prop",
+              getComponentNameFromType(Component)
+            );
+          }
         }
+      }
 
-        lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);
+      child = updateMemoComponent(
+        null,
+        workInProgress,
+        Component,
+        resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
+        renderLanes
+      );
+      return child;
+    }
+  }
 
-        if (previousNewFiber === null) {
-          // TODO: Move out of the loop. This only happens for the first run.
-          resultingFirstChild = _newFiber;
-        } else {
-          previousNewFiber.sibling = _newFiber;
-        }
+  var hint = "";
 
-        previousNewFiber = _newFiber;
-      }
+  {
+    if (
+      Component !== null &&
+      typeof Component === "object" &&
+      Component.$$typeof === REACT_LAZY_TYPE
+    ) {
+      hint = " Did you wrap a component in React.lazy() more than once?";
+    }
+  } // This message intentionally doesn't mention ForwardRef or MemoComponent
+  // because the fact that it's a separate type of work is an
+  // implementation detail.
 
-      if (getIsHydrating()) {
-        var _numberOfForks = newIdx;
-        pushTreeFork(returnFiber, _numberOfForks);
-      }
+  throw new Error(
+    "Element type is invalid. Received a promise that resolves to: " +
+      Component +
+      ". " +
+      ("Lazy element type must resolve to a class or function." + hint)
+  );
+}
 
-      return resultingFirstChild;
-    } // Add all children to a key map for quick lookups.
+function mountIncompleteClassComponent(
+  _current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
 
-    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
+  // 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.
 
-    for (; newIdx < newChildren.length; newIdx++) {
-      var _newFiber2 = updateFromMap(
-        existingChildren,
-        returnFiber,
-        newIdx,
-        newChildren[newIdx],
-        lanes
-      );
+  var hasContext;
 
-      if (_newFiber2 !== null) {
-        if (shouldTrackSideEffects) {
-          if (_newFiber2.alternate !== null) {
-            // The new fiber is a work in progress, but if there exists a
-            // current, that means that we reused the fiber. We need to delete
-            // it from the child list so that we don't add it to the deletion
-            // list.
-            existingChildren.delete(
-              _newFiber2.key === null ? newIdx : _newFiber2.key
-            );
-          }
-        }
+  if (isContextProvider()) {
+    hasContext = true;
+  } else {
+    hasContext = false;
+  }
 
-        lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);
+  prepareToReadContext(workInProgress, renderLanes);
+  constructClassInstance(workInProgress, Component, nextProps);
+  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
+  return finishClassComponent(
+    null,
+    workInProgress,
+    Component,
+    true,
+    hasContext,
+    renderLanes
+  );
+}
 
-        if (previousNewFiber === null) {
-          resultingFirstChild = _newFiber2;
-        } else {
-          previousNewFiber.sibling = _newFiber2;
-        }
+function mountIndeterminateComponent(
+  _current,
+  workInProgress,
+  Component,
+  renderLanes
+) {
+  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
+  var props = workInProgress.pendingProps;
+  var context;
 
-        previousNewFiber = _newFiber2;
-      }
-    }
+  prepareToReadContext(workInProgress, renderLanes);
+  var value;
+  var hasId;
 
-    if (shouldTrackSideEffects) {
-      // Any existing children that weren't consumed above were deleted. We need
-      // to add them to the deletion list.
-      existingChildren.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    }
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-    if (getIsHydrating()) {
-      var _numberOfForks2 = newIdx;
-      pushTreeFork(returnFiber, _numberOfForks2);
-    }
+  {
+    if (
+      Component.prototype &&
+      typeof Component.prototype.render === "function"
+    ) {
+      var componentName = getComponentNameFromType(Component) || "Unknown";
 
-    return resultingFirstChild;
-  }
+      if (!didWarnAboutBadClass[componentName]) {
+        error(
+          "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
+            "This is likely to cause errors. Change %s to extend React.Component instead.",
+          componentName,
+          componentName
+        );
 
-  function reconcileChildrenIterator(
-    returnFiber,
-    currentFirstChild,
-    newChildrenIterable,
-    lanes
-  ) {
-    // This is the same implementation as reconcileChildrenArray(),
-    // but using the iterator instead.
-    var iteratorFn = getIteratorFn(newChildrenIterable);
+        didWarnAboutBadClass[componentName] = true;
+      }
+    }
 
-    if (typeof iteratorFn !== "function") {
-      throw new Error(
-        "An object is not an iterable. This error is likely caused by a bug in " +
-          "React. Please file an issue."
-      );
+    if (workInProgress.mode & StrictLegacyMode) {
+      ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
     }
 
-    {
-      // We don't support rendering Generators because it's a mutation.
-      // See https://github.com/facebook/react/issues/12995
-      if (
-        typeof Symbol === "function" && // $FlowFixMe Flow doesn't know about toStringTag
-        newChildrenIterable[Symbol.toStringTag] === "Generator"
-      ) {
-        if (!didWarnAboutGenerators) {
-          error(
-            "Using Generators as children is unsupported and will likely yield " +
-              "unexpected results because enumerating a generator mutates it. " +
-              "You may convert it to an array with `Array.from()` or the " +
-              "`[...spread]` operator before rendering. Keep in mind " +
-              "you might need to polyfill these features for older browsers."
-          );
-        }
+    setIsRendering(true);
+    ReactCurrentOwner$1.current = workInProgress;
+    value = renderWithHooks(
+      null,
+      workInProgress,
+      Component,
+      props,
+      context,
+      renderLanes
+    );
+    hasId = checkDidRenderIdHook();
+    setIsRendering(false);
+  }
 
-        didWarnAboutGenerators = true;
-      } // Warn about using Maps as children
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
 
-      if (newChildrenIterable.entries === iteratorFn) {
-        if (!didWarnAboutMaps) {
-          error(
-            "Using Maps as children is not supported. " +
-              "Use an array of keyed ReactElements instead."
-          );
-        }
+  workInProgress.flags |= PerformedWork;
 
-        didWarnAboutMaps = true;
-      } // First, validate keys.
-      // We'll get a different iterator later for the main pass.
+  {
+    // Support for module components is deprecated and is removed behind a flag.
+    // Whether or not it would crash later, we want to show a good message in DEV first.
+    if (
+      typeof value === "object" &&
+      value !== null &&
+      typeof value.render === "function" &&
+      value.$$typeof === undefined
+    ) {
+      var _componentName = getComponentNameFromType(Component) || "Unknown";
 
-      var _newChildren = iteratorFn.call(newChildrenIterable);
+      if (!didWarnAboutModulePatternComponent[_componentName]) {
+        error(
+          "The <%s /> component appears to be a function component that returns a class instance. " +
+            "Change %s to a class that extends React.Component instead. " +
+            "If you can't use a class try assigning the prototype on the function as a workaround. " +
+            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
+            "cannot be called with `new` by React.",
+          _componentName,
+          _componentName,
+          _componentName
+        );
 
-      if (_newChildren) {
-        var knownKeys = null;
+        didWarnAboutModulePatternComponent[_componentName] = true;
+      }
+    }
+  }
 
-        var _step = _newChildren.next();
+  {
+    // Proceed under the assumption that this is a function component
+    workInProgress.tag = FunctionComponent;
 
-        for (; !_step.done; _step = _newChildren.next()) {
-          var child = _step.value;
-          knownKeys = warnOnInvalidKey(child, knownKeys, returnFiber);
-        }
+    {
+      if (Component.contextTypes) {
+        error(
+          "%s uses the legacy contextTypes API which is no longer supported. " +
+            "Use React.createContext() with React.useContext() instead.",
+          getComponentNameFromType(Component) || "Unknown"
+        );
       }
     }
 
-    var newChildren = iteratorFn.call(newChildrenIterable);
-
-    if (newChildren == null) {
-      throw new Error("An iterable object provided no iterator.");
+    if (getIsHydrating() && hasId) {
+      pushMaterializedTreeId(workInProgress);
     }
 
-    var resultingFirstChild = null;
-    var previousNewFiber = null;
-    var oldFiber = currentFirstChild;
-    var lastPlacedIndex = 0;
-    var newIdx = 0;
-    var nextOldFiber = null;
-    var step = newChildren.next();
+    reconcileChildren(null, workInProgress, value, renderLanes);
 
-    for (
-      ;
-      oldFiber !== null && !step.done;
-      newIdx++, step = newChildren.next()
-    ) {
-      if (oldFiber.index > newIdx) {
-        nextOldFiber = oldFiber;
-        oldFiber = null;
-      } else {
-        nextOldFiber = oldFiber.sibling;
-      }
-
-      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+    {
+      validateFunctionComponentInDev(workInProgress, Component);
+    }
 
-      if (newFiber === null) {
-        // TODO: This breaks on empty slots like null children. That's
-        // unfortunate because it triggers the slow path all the time. We need
-        // a better way to communicate whether this was a miss or null,
-        // boolean, undefined, etc.
-        if (oldFiber === null) {
-          oldFiber = nextOldFiber;
-        }
+    return workInProgress.child;
+  }
+}
 
-        break;
+function validateFunctionComponentInDev(workInProgress, Component) {
+  {
+    if (Component) {
+      if (Component.childContextTypes) {
+        error(
+          "%s(...): childContextTypes cannot be defined on a function component.",
+          Component.displayName || Component.name || "Component"
+        );
       }
+    }
 
-      if (shouldTrackSideEffects) {
-        if (oldFiber && newFiber.alternate === null) {
-          // We matched the slot, but we didn't reuse the existing fiber, so we
-          // need to delete the existing child.
-          deleteChild(returnFiber, oldFiber);
-        }
+    if (workInProgress.ref !== null) {
+      var info = "";
+      var ownerName = getCurrentFiberOwnerNameInDevOrNull();
+
+      if (ownerName) {
+        info += "\n\nCheck the render method of `" + ownerName + "`.";
       }
 
-      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+      var warningKey = ownerName || "";
+      var debugSource = workInProgress._debugSource;
 
-      if (previousNewFiber === null) {
-        // TODO: Move out of the loop. This only happens for the first run.
-        resultingFirstChild = newFiber;
-      } else {
-        // TODO: Defer siblings if we're not at the right index for this slot.
-        // I.e. if we had null values before, then we want to defer this
-        // for each null value. However, we also don't want to call updateSlot
-        // with the previous one.
-        previousNewFiber.sibling = newFiber;
+      if (debugSource) {
+        warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
       }
 
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
+      if (!didWarnAboutFunctionRefs[warningKey]) {
+        didWarnAboutFunctionRefs[warningKey] = true;
+
+        error(
+          "Function components cannot be given refs. " +
+            "Attempts to access this ref will fail. " +
+            "Did you mean to use React.forwardRef()?%s",
+          info
+        );
+      }
     }
 
-    if (step.done) {
-      // We've reached the end of the new children. We can delete the rest.
-      deleteRemainingChildren(returnFiber, oldFiber);
+    if (Component.defaultProps !== undefined) {
+      var componentName = getComponentNameFromType(Component) || "Unknown";
 
-      if (getIsHydrating()) {
-        var numberOfForks = newIdx;
-        pushTreeFork(returnFiber, numberOfForks);
-      }
+      if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
+        error(
+          "%s: Support for defaultProps will be removed from function components " +
+            "in a future major release. Use JavaScript default parameters instead.",
+          componentName
+        );
 
-      return resultingFirstChild;
+        didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+      }
     }
 
-    if (oldFiber === null) {
-      // If we don't have any more existing children we can choose a fast path
-      // since the rest will all be insertions.
-      for (; !step.done; newIdx++, step = newChildren.next()) {
-        var _newFiber3 = createChild(returnFiber, step.value, lanes);
+    if (typeof Component.getDerivedStateFromProps === "function") {
+      var _componentName3 = getComponentNameFromType(Component) || "Unknown";
 
-        if (_newFiber3 === null) {
-          continue;
-        }
+      if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
+        error(
+          "%s: Function components do not support getDerivedStateFromProps.",
+          _componentName3
+        );
 
-        lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);
+        didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
+      }
+    }
 
-        if (previousNewFiber === null) {
-          // TODO: Move out of the loop. This only happens for the first run.
-          resultingFirstChild = _newFiber3;
-        } else {
-          previousNewFiber.sibling = _newFiber3;
-        }
+    if (
+      typeof Component.contextType === "object" &&
+      Component.contextType !== null
+    ) {
+      var _componentName4 = getComponentNameFromType(Component) || "Unknown";
 
-        previousNewFiber = _newFiber3;
-      }
+      if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
+        error(
+          "%s: Function components do not support contextType.",
+          _componentName4
+        );
 
-      if (getIsHydrating()) {
-        var _numberOfForks3 = newIdx;
-        pushTreeFork(returnFiber, _numberOfForks3);
+        didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
       }
+    }
+  }
+}
 
-      return resultingFirstChild;
-    } // Add all children to a key map for quick lookups.
-
-    var existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.
+var SUSPENDED_MARKER = {
+  dehydrated: null,
+  treeContext: null,
+  retryLane: NoLane
+};
 
-    for (; !step.done; newIdx++, step = newChildren.next()) {
-      var _newFiber4 = updateFromMap(
-        existingChildren,
-        returnFiber,
-        newIdx,
-        step.value,
-        lanes
-      );
+function mountSuspenseOffscreenState(renderLanes) {
+  return {
+    baseLanes: renderLanes,
+    cachePool: getSuspendedCache()
+  };
+}
 
-      if (_newFiber4 !== null) {
-        if (shouldTrackSideEffects) {
-          if (_newFiber4.alternate !== null) {
-            // The new fiber is a work in progress, but if there exists a
-            // current, that means that we reused the fiber. We need to delete
-            // it from the child list so that we don't add it to the deletion
-            // list.
-            existingChildren.delete(
-              _newFiber4.key === null ? newIdx : _newFiber4.key
-            );
-          }
-        }
+function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
+  var cachePool = null;
 
-        lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);
+  {
+    var prevCachePool = prevOffscreenState.cachePool;
 
-        if (previousNewFiber === null) {
-          resultingFirstChild = _newFiber4;
-        } else {
-          previousNewFiber.sibling = _newFiber4;
-        }
+    if (prevCachePool !== null) {
+      var parentCache = CacheContext._currentValue;
 
-        previousNewFiber = _newFiber4;
+      if (prevCachePool.parent !== parentCache) {
+        // Detected a refresh in the parent. This overrides any previously
+        // suspended cache.
+        cachePool = {
+          parent: parentCache,
+          pool: parentCache
+        };
+      } else {
+        // We can reuse the cache from last time. The only thing that would have
+        // overridden it is a parent refresh, which we checked for above.
+        cachePool = prevCachePool;
       }
+    } else {
+      // If there's no previous cache pool, grab the current one.
+      cachePool = getSuspendedCache();
     }
+  }
 
-    if (shouldTrackSideEffects) {
-      // Any existing children that weren't consumed above were deleted. We need
-      // to add them to the deletion list.
-      existingChildren.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    }
-
-    if (getIsHydrating()) {
-      var _numberOfForks4 = newIdx;
-      pushTreeFork(returnFiber, _numberOfForks4);
-    }
+  return {
+    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
+    cachePool: cachePool
+  };
+} // TODO: Probably should inline this back
 
-    return resultingFirstChild;
-  }
+function shouldRemainOnFallback(current, workInProgress, renderLanes) {
+  // If we're already showing a fallback, there are cases where we need to
+  // remain on that fallback regardless of whether the content has resolved.
+  // For example, SuspenseList coordinates when nested content appears.
+  if (current !== null) {
+    var suspenseState = current.memoizedState;
 
-  function reconcileSingleTextNode(
-    returnFiber,
-    currentFirstChild,
-    textContent,
-    lanes
-  ) {
-    // There's no need to check for keys on text nodes since we don't have a
-    // way to define them.
-    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
-      // We already have an existing node so let's just update it and delete
-      // the rest.
-      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
-      var existing = useFiber(currentFirstChild, textContent);
-      existing.return = returnFiber;
-      return existing;
-    } // The existing first child is not a text node so we need to create one
-    // and delete the existing ones.
+    if (suspenseState === null) {
+      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
+      // is true. More precise name might be "ForceRemainSuspenseFallback".
+      // Note: This is a factoring smell. Can't remain on a fallback if there's
+      // no fallback to remain on.
+      return false;
+    }
+  } // Not currently showing content. Consult the Suspense context.
 
-    deleteRemainingChildren(returnFiber, currentFirstChild);
-    var created = createFiberFromText(textContent, returnFiber.mode, lanes);
-    created.return = returnFiber;
-    return created;
-  }
+  var suspenseContext = suspenseStackCursor.current;
+  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
+}
 
-  function reconcileSingleElement(
-    returnFiber,
-    currentFirstChild,
-    element,
-    lanes
-  ) {
-    var key = element.key;
-    var child = currentFirstChild;
+function getRemainingWorkInPrimaryTree(current, renderLanes) {
+  // TODO: Should not remove render lanes that were pinged during this render
+  return removeLanes(current.childLanes, renderLanes);
+}
 
-    while (child !== null) {
-      // TODO: If key === null and child.key === null, then this only applies to
-      // the first item in the list.
-      if (child.key === key) {
-        var elementType = element.type;
+function updateSuspenseComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
 
-        if (elementType === REACT_FRAGMENT_TYPE) {
-          if (child.tag === Fragment) {
-            deleteRemainingChildren(returnFiber, child.sibling);
-            var existing = useFiber(child, element.props.children);
-            existing.return = returnFiber;
+  {
+    if (shouldSuspend(workInProgress)) {
+      workInProgress.flags |= DidCapture;
+    }
+  }
 
-            {
-              existing._debugSource = element._source;
-              existing._debugOwner = element._owner;
-            }
+  var showFallback = false;
+  var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
-            return existing;
-          }
-        } else {
-          if (
-            child.elementType === elementType || // Keep this check inline so it only runs on the false path:
-            isCompatibleFamilyForHotReloading(child, element) || // Lazy types should reconcile their resolved type.
-            // We need to do this after the Hot Reloading check above,
-            // because hot reloading has different semantics than prod because
-            // it doesn't resuspend. So we can't let the call below suspend.
-            (typeof elementType === "object" &&
-              elementType !== null &&
-              elementType.$$typeof === REACT_LAZY_TYPE &&
-              resolveLazy(elementType) === child.type)
-          ) {
-            deleteRemainingChildren(returnFiber, child.sibling);
+  if (didSuspend || shouldRemainOnFallback(current)) {
+    // Something in this boundary's subtree already suspended. Switch to
+    // rendering the fallback children.
+    showFallback = true;
+    workInProgress.flags &= ~DidCapture;
+  } // OK, the next part is confusing. We're about to reconcile the Suspense
+  // boundary's children. This involves some custom reconciliation logic. Two
+  // main reasons this is so complicated.
+  //
+  // First, Legacy Mode has different semantics for backwards compatibility. The
+  // primary tree will commit in an inconsistent state, so when we do the
+  // second pass to render the fallback, we do some exceedingly, uh, clever
+  // hacks to make that not totally break. Like transferring effects and
+  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
+  // because we bailout on the primary tree completely and leave it in its old
+  // state, no effects. Same as what we do for Offscreen (except that
+  // Offscreen doesn't have the first render pass).
+  //
+  // Second is hydration. During hydration, the Suspense fiber has a slightly
+  // different layout, where the child points to a dehydrated fragment, which
+  // contains the DOM rendered by the server.
+  //
+  // Third, even if you set all that aside, Suspense is like error boundaries in
+  // that we first we try to render one tree, and if that fails, we render again
+  // and switch to a different tree. Like a try/catch block. So we have to track
+  // which branch we're currently rendering. Ideally we would model this using
+  // a stack.
 
-            var _existing = useFiber(child, element.props);
+  if (current === null) {
+    // Initial mount
+    // Special path for hydration
+    // If we're currently hydrating, try to hydrate this boundary.
+    if (getIsHydrating()) {
+      // We must push the suspense handler context *before* attempting to
+      // hydrate, to avoid a mismatch in case it errors.
+      if (showFallback) {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+      } else {
+        pushFallbackTreeSuspenseHandler(workInProgress);
+      }
 
-            _existing.ref = coerceRef(returnFiber, child, element);
-            _existing.return = returnFiber;
+      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
 
-            {
-              _existing._debugSource = element._source;
-              _existing._debugOwner = element._owner;
-            }
+      var suspenseState = workInProgress.memoizedState;
 
-            return _existing;
-          }
-        } // Didn't match.
+      if (suspenseState !== null) {
+        var dehydrated = suspenseState.dehydrated;
 
-        deleteRemainingChildren(returnFiber, child);
-        break;
-      } else {
-        deleteChild(returnFiber, child);
-      }
+        if (dehydrated !== null) {
+          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
+        }
+      } // If hydration didn't succeed, fall through to the normal Suspense path.
+      // To avoid a stack mismatch we need to pop the Suspense handler that we
+      // pushed above. This will become less awkward when move the hydration
+      // logic to its own fiber.
 
-      child = child.sibling;
+      popSuspenseHandler(workInProgress);
     }
 
-    if (element.type === REACT_FRAGMENT_TYPE) {
-      var created = createFiberFromFragment(
-        element.props.children,
-        returnFiber.mode,
-        lanes,
-        element.key
+    var nextPrimaryChildren = nextProps.children;
+    var nextFallbackChildren = nextProps.fallback;
+
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var fallbackFragment = mountSuspenseFallbackChildren(
+        workInProgress,
+        nextPrimaryChildren,
+        nextFallbackChildren,
+        renderLanes
       );
-      created.return = returnFiber;
-      return created;
-    } else {
-      var _created4 = createFiberFromElement(element, returnFiber.mode, lanes);
+      var primaryChildFragment = workInProgress.child;
+      primaryChildFragment.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
 
-      _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
-      _created4.return = returnFiber;
-      return _created4;
-    }
-  }
+      if (enableTransitionTracing) {
+        var currentTransitions = getPendingTransitions();
 
-  function reconcileSinglePortal(
-    returnFiber,
-    currentFirstChild,
-    portal,
-    lanes
-  ) {
-    var key = portal.key;
-    var child = currentFirstChild;
+        if (currentTransitions !== null) {
+          var parentMarkerInstances = getMarkerInstances();
+          var offscreenQueue = primaryChildFragment.updateQueue;
 
-    while (child !== null) {
-      // TODO: If key === null and child.key === null, then this only applies to
-      // the first item in the list.
-      if (child.key === key) {
-        if (
-          child.tag === HostPortal &&
-          child.stateNode.containerInfo === portal.containerInfo &&
-          child.stateNode.implementation === portal.implementation
-        ) {
-          deleteRemainingChildren(returnFiber, child.sibling);
-          var existing = useFiber(child, portal.children || []);
-          existing.return = returnFiber;
-          return existing;
-        } else {
-          deleteRemainingChildren(returnFiber, child);
-          break;
+          if (offscreenQueue === null) {
+            var newOffscreenQueue = {
+              transitions: currentTransitions,
+              markerInstances: parentMarkerInstances,
+              wakeables: null
+            };
+            primaryChildFragment.updateQueue = newOffscreenQueue;
+          } else {
+            offscreenQueue.transitions = currentTransitions;
+            offscreenQueue.markerInstances = parentMarkerInstances;
+          }
         }
-      } else {
-        deleteChild(returnFiber, child);
       }
 
-      child = child.sibling;
-    }
+      return fallbackFragment;
+    } else if (typeof nextProps.unstable_expectedLoadTime === "number") {
+      // This is a CPU-bound tree. Skip this tree and show a placeholder to
+      // unblock the surrounding content. Then immediately retry after the
+      // initial commit.
+      pushFallbackTreeSuspenseHandler(workInProgress);
 
-    var created = createFiberFromPortal(portal, returnFiber.mode, lanes);
-    created.return = returnFiber;
-    return created;
-  } // This API will tag the children with the side-effect of the reconciliation
-  // itself. They will be added to the side-effect list as we pass through the
-  // children and the parent.
+      var _fallbackFragment = mountSuspenseFallbackChildren(
+        workInProgress,
+        nextPrimaryChildren,
+        nextFallbackChildren,
+        renderLanes
+      );
 
-  function reconcileChildFibersImpl(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    // This function is not recursive.
-    // If the top level item is an array, we treat it as a set of children,
-    // not as a fragment. Nested arrays on the other hand will be treated as
-    // fragment nodes. Recursion happens at the normal flow.
-    // Handle top level unkeyed fragments as if they were arrays.
-    // This leads to an ambiguity between <>{[...]}</> and <>...</>.
-    // We treat the ambiguous cases above the same.
-    // TODO: Let's use recursion like we do for Usable nodes?
-    var isUnkeyedTopLevelFragment =
-      typeof newChild === "object" &&
-      newChild !== null &&
-      newChild.type === REACT_FRAGMENT_TYPE &&
-      newChild.key === null;
+      var _primaryChildFragment = workInProgress.child;
+      _primaryChildFragment.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
+      // Since nothing actually suspended, there will nothing to ping this to
+      // get it started back up to attempt the next item. While in terms of
+      // priority this work has the same priority as this current render, it's
+      // not part of the same transition once the transition has committed. If
+      // it's sync, we still want to yield so that it can be painted.
+      // Conceptually, this is really the same as pinging. We can use any
+      // RetryLane even if it's the one currently rendering since we're leaving
+      // it behind on this node.
 
-    if (isUnkeyedTopLevelFragment) {
-      newChild = newChild.props.children;
-    } // Handle object types
+      workInProgress.lanes = SomeRetryLane;
+      return _fallbackFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+  } else {
+    // This is an update.
+    // Special path for hydration
+    var prevState = current.memoizedState;
 
-    if (typeof newChild === "object" && newChild !== null) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return placeSingleChild(
-            reconcileSingleElement(
-              returnFiber,
-              currentFirstChild,
-              newChild,
-              lanes
-            )
-          );
-
-        case REACT_PORTAL_TYPE:
-          return placeSingleChild(
-            reconcileSinglePortal(
-              returnFiber,
-              currentFirstChild,
-              newChild,
-              lanes
-            )
-          );
-
-        case REACT_LAZY_TYPE:
-          var payload = newChild._payload;
-          var init = newChild._init; // TODO: This function is supposed to be non-recursive.
-
-          return reconcileChildFibers(
-            returnFiber,
-            currentFirstChild,
-            init(payload),
-            lanes
-          );
-      }
+    if (prevState !== null) {
+      var _dehydrated = prevState.dehydrated;
 
-      if (isArray(newChild)) {
-        return reconcileChildrenArray(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
+      if (_dehydrated !== null) {
+        return updateDehydratedSuspenseComponent(
+          current,
+          workInProgress,
+          didSuspend,
+          nextProps,
+          _dehydrated,
+          prevState,
+          renderLanes
         );
       }
+    }
 
-      if (getIteratorFn(newChild)) {
-        return reconcileChildrenIterator(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      } // Usables are a valid React node type. When React encounters a Usable in
-      // a child position, it unwraps it using the same algorithm as `use`. For
-      // example, for promises, React will throw an exception to unwind the
-      // stack, then replay the component once the promise resolves.
-      //
-      // A difference from `use` is that React will keep unwrapping the value
-      // until it reaches a non-Usable type.
-      //
-      // e.g. Usable<Usable<Usable<T>>> should resolve to T
-      //
-      // The structure is a bit unfortunate. Ideally, we shouldn't need to
-      // replay the entire begin phase of the parent fiber in order to reconcile
-      // the children again. This would require a somewhat significant refactor,
-      // because reconcilation happens deep within the begin phase, and
-      // depending on the type of work, not always at the end. We should
-      // consider as an future improvement.
-
-      if (typeof newChild.then === "function") {
-        var thenable = newChild;
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          unwrapThenable(thenable),
-          lanes
-        );
-      }
+    if (showFallback) {
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var _nextFallbackChildren = nextProps.fallback;
+      var _nextPrimaryChildren = nextProps.children;
+      var fallbackChildFragment = updateSuspenseFallbackChildren(
+        current,
+        workInProgress,
+        _nextPrimaryChildren,
+        _nextFallbackChildren,
+        renderLanes
+      );
+      var _primaryChildFragment2 = workInProgress.child;
+      var prevOffscreenState = current.child.memoizedState;
+      _primaryChildFragment2.memoizedState =
+        prevOffscreenState === null
+          ? mountSuspenseOffscreenState(renderLanes)
+          : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
 
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      ) {
-        var context = newChild;
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          readContextDuringReconcilation(returnFiber, context, lanes),
-          lanes
-        );
-      }
+      if (enableTransitionTracing) {
+        var _currentTransitions = getPendingTransitions();
 
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
+        if (_currentTransitions !== null) {
+          var _parentMarkerInstances = getMarkerInstances();
 
-    if (
-      (typeof newChild === "string" && newChild !== "") ||
-      typeof newChild === "number"
-    ) {
-      return placeSingleChild(
-        reconcileSingleTextNode(
-          returnFiber,
-          currentFirstChild,
-          "" + newChild,
-          lanes
-        )
-      );
-    }
+          var _offscreenQueue = _primaryChildFragment2.updateQueue;
+          var currentOffscreenQueue = current.updateQueue;
 
-    {
-      if (typeof newChild === "function") {
-        warnOnFunctionType(returnFiber);
+          if (_offscreenQueue === null) {
+            var _newOffscreenQueue = {
+              transitions: _currentTransitions,
+              markerInstances: _parentMarkerInstances,
+              wakeables: null
+            };
+            _primaryChildFragment2.updateQueue = _newOffscreenQueue;
+          } else if (_offscreenQueue === currentOffscreenQueue) {
+            // If the work-in-progress queue is the same object as current, we
+            // can't modify it without cloning it first.
+            var _newOffscreenQueue2 = {
+              transitions: _currentTransitions,
+              markerInstances: _parentMarkerInstances,
+              wakeables:
+                currentOffscreenQueue !== null
+                  ? currentOffscreenQueue.wakeables
+                  : null
+            };
+            _primaryChildFragment2.updateQueue = _newOffscreenQueue2;
+          } else {
+            _offscreenQueue.transitions = _currentTransitions;
+            _offscreenQueue.markerInstances = _parentMarkerInstances;
+          }
+        }
       }
-    } // Remaining cases are all treated as empty.
 
-    return deleteRemainingChildren(returnFiber, currentFirstChild);
-  }
+      _primaryChildFragment2.childLanes = getRemainingWorkInPrimaryTree(
+        current,
+        renderLanes
+      );
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
+    } else {
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      var _nextPrimaryChildren2 = nextProps.children;
 
-  function reconcileChildFibers(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    // This indirection only exists so we can reset `thenableState` at the end.
-    // It should get inlined by Closure.
-    thenableIndexCounter$1 = 0;
-    var firstChildFiber = reconcileChildFibersImpl(
-      returnFiber,
-      currentFirstChild,
-      newChild,
-      lanes
-    );
-    thenableState$1 = null; // Don't bother to reset `thenableIndexCounter` to 0 because it always gets
-    // set at the beginning.
+      var _primaryChildFragment3 = updateSuspensePrimaryChildren(
+        current,
+        workInProgress,
+        _nextPrimaryChildren2,
+        renderLanes
+      );
 
-    return firstChildFiber;
+      workInProgress.memoizedState = null;
+      return _primaryChildFragment3;
+    }
   }
-
-  return reconcileChildFibers;
 }
 
-var reconcileChildFibers = createChildReconciler(true);
-var mountChildFibers = createChildReconciler(false);
-function resetChildReconcilerOnUnwind() {
-  // On unwind, clear any pending thenables that were used.
-  thenableState$1 = null;
-  thenableIndexCounter$1 = 0;
+function mountSuspensePrimaryChildren(
+  workInProgress,
+  primaryChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var primaryChildProps = {
+    mode: "visible",
+    children: primaryChildren
+  };
+  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
+    primaryChildProps,
+    mode
+  );
+  primaryChildFragment.return = workInProgress;
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
 }
-function cloneChildFibers(current, workInProgress) {
-  if (current !== null && workInProgress.child !== current.child) {
-    throw new Error("Resuming work not yet implemented.");
-  }
 
-  if (workInProgress.child === null) {
-    return;
-  }
+function mountSuspenseFallbackChildren(
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var progressedPrimaryFragment = workInProgress.child;
+  var primaryChildProps = {
+    mode: "hidden",
+    children: primaryChildren
+  };
+  var primaryChildFragment;
+  var fallbackChildFragment;
 
-  var currentChild = workInProgress.child;
-  var newChild = createWorkInProgress(currentChild, currentChild.pendingProps);
-  workInProgress.child = newChild;
-  newChild.return = workInProgress;
+  if (
+    (mode & ConcurrentMode) === NoMode &&
+    progressedPrimaryFragment !== null
+  ) {
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
 
-  while (currentChild.sibling !== null) {
-    currentChild = currentChild.sibling;
-    newChild = newChild.sibling = createWorkInProgress(
-      currentChild,
-      currentChild.pendingProps
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration = 0;
+      primaryChildFragment.treeBaseDuration = 0;
+    }
+
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    );
+  } else {
+    primaryChildFragment = mountWorkInProgressOffscreenFiber(
+      primaryChildProps,
+      mode
+    );
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
     );
-    newChild.return = workInProgress;
   }
 
-  newChild.sibling = null;
-} // Reset a workInProgress child set to prepare it for a second pass.
-
-function resetChildFibers(workInProgress, lanes) {
-  var child = workInProgress.child;
-
-  while (child !== null) {
-    resetWorkInProgress(child, lanes);
-    child = child.sibling;
-  }
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
 }
 
-// TODO: This isn't being used yet, but it's intended to replace the
-// InvisibleParentContext that is currently managed by SuspenseContext.
-
-var currentTreeHiddenStackCursor = createCursor(null);
-var prevRenderLanesStackCursor = createCursor(NoLanes);
-function pushHiddenContext(fiber, context) {
-  var prevRenderLanes = getRenderLanes();
-  push(prevRenderLanesStackCursor, prevRenderLanes, fiber);
-  push(currentTreeHiddenStackCursor, context, fiber); // When rendering a subtree that's currently hidden, we must include all
-  // lanes that would have rendered if the hidden subtree hadn't been deferred.
-  // That is, in order to reveal content from hidden -> visible, we must commit
-  // all the updates that we skipped when we originally hid the tree.
-
-  setRenderLanes(mergeLanes(prevRenderLanes, context.baseLanes));
-}
-function reuseHiddenContextOnStack(fiber) {
-  // This subtree is not currently hidden, so we don't need to add any lanes
-  // to the render lanes. But we still need to push something to avoid a
-  // context mismatch. Reuse the existing context on the stack.
-  push(prevRenderLanesStackCursor, getRenderLanes(), fiber);
-  push(
-    currentTreeHiddenStackCursor,
-    currentTreeHiddenStackCursor.current,
-    fiber
-  );
-}
-function popHiddenContext(fiber) {
-  // Restore the previous render lanes from the stack
-  setRenderLanes(prevRenderLanesStackCursor.current);
-  pop(currentTreeHiddenStackCursor, fiber);
-  pop(prevRenderLanesStackCursor, fiber);
-}
-function isCurrentTreeHidden() {
-  return currentTreeHiddenStackCursor.current !== null;
+function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
+  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
+  // this wrapper function to constrain it.
+  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
 }
 
-// suspends, i.e. it's the nearest `catch` block on the stack.
-
-var suspenseHandlerStackCursor = createCursor(null); // Represents the outermost boundary that is not visible in the current tree.
-// Everything above this is the "shell". When this is null, it means we're
-// rendering in the shell of the app. If it's non-null, it means we're rendering
-// deeper than the shell, inside a new tree that wasn't already visible.
-//
-// The main way we use this concept is to determine whether showing a fallback
-// would result in a desirable or undesirable loading state. Activing a fallback
-// in the shell is considered an undersirable loading state, because it would
-// mean hiding visible (albeit stale) content in the current tree — we prefer to
-// show the stale content, rather than switch to a fallback. But showing a
-// fallback in a new tree is fine, because there's no stale content to
-// prefer instead.
-
-var shellBoundary = null;
-function getShellBoundary() {
-  return shellBoundary;
+function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
+  // The props argument to `createWorkInProgress` is `any` typed, so we use this
+  // wrapper function to constrain it.
+  return createWorkInProgress(current, offscreenProps);
 }
-function pushPrimaryTreeSuspenseHandler(handler) {
-  // TODO: Pass as argument
-  var current = handler.alternate;
-  var props = handler.pendingProps; // Experimental feature: Some Suspense boundaries are marked as having an
-  // undesirable fallback state. These have special behavior where we only
-  // activate the fallback if there's no other boundary on the stack that we can
-  // use instead.
 
-  if (
-    props.unstable_avoidThisFallback === true && // If an avoided boundary is already visible, it behaves identically to
-    // a regular Suspense boundary.
-    (current === null || isCurrentTreeHidden())
-  ) {
-    if (shellBoundary === null) {
-      // We're rendering in the shell. There's no parent Suspense boundary that
-      // can provide a desirable fallback state. We'll use this boundary.
-      push(suspenseHandlerStackCursor, handler, handler); // However, because this is not a desirable fallback, the children are
-      // still considered part of the shell. So we intentionally don't assign
-      // to `shellBoundary`.
-    } else {
-      // There's already a parent Suspense boundary that can provide a desirable
-      // fallback state. Prefer that one.
-      var handlerOnStack = suspenseHandlerStackCursor.current;
-      push(suspenseHandlerStackCursor, handlerOnStack, handler);
+function updateSuspensePrimaryChildren(
+  current,
+  workInProgress,
+  primaryChildren,
+  renderLanes
+) {
+  var currentPrimaryChildFragment = current.child;
+  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  var primaryChildFragment = updateWorkInProgressOffscreenFiber(
+    currentPrimaryChildFragment,
+    {
+      mode: "visible",
+      children: primaryChildren
     }
+  );
 
-    return;
-  } // TODO: If the parent Suspense handler already suspended, there's no reason
-  // to push a nested Suspense handler, because it will get replaced by the
-  // outer fallback, anyway. Consider this as a future optimization.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    primaryChildFragment.lanes = renderLanes;
+  }
 
-  push(suspenseHandlerStackCursor, handler, handler);
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = null;
 
-  if (shellBoundary === null) {
-    if (current === null || isCurrentTreeHidden()) {
-      // This boundary is not visible in the current UI.
-      shellBoundary = handler;
-    } else {
-      var prevState = current.memoizedState;
+  if (currentFallbackChildFragment !== null) {
+    // Delete the fallback child fragment
+    var deletions = workInProgress.deletions;
 
-      if (prevState !== null) {
-        // This boundary is showing a fallback in the current UI.
-        shellBoundary = handler;
-      }
+    if (deletions === null) {
+      workInProgress.deletions = [currentFallbackChildFragment];
+      workInProgress.flags |= ChildDeletion;
+    } else {
+      deletions.push(currentFallbackChildFragment);
     }
   }
+
+  workInProgress.child = primaryChildFragment;
+  return primaryChildFragment;
 }
-function pushFallbackTreeSuspenseHandler(fiber) {
-  // We're about to render the fallback. If something in the fallback suspends,
-  // it's akin to throwing inside of a `catch` block. This boundary should not
-  // capture. Reuse the existing handler on the stack.
-  reuseSuspenseHandlerOnStack(fiber);
-}
-function pushOffscreenSuspenseHandler(fiber) {
-  if (fiber.tag === OffscreenComponent) {
-    push(suspenseHandlerStackCursor, fiber, fiber);
 
-    if (shellBoundary !== null);
-    else {
-      var current = fiber.alternate;
+function updateSuspenseFallbackChildren(
+  current,
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var mode = workInProgress.mode;
+  var currentPrimaryChildFragment = current.child;
+  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+  var primaryChildProps = {
+    mode: "hidden",
+    children: primaryChildren
+  };
+  var primaryChildFragment;
 
-      if (current !== null) {
-        var prevState = current.memoizedState;
+  if (
+    // In legacy mode, we commit the primary tree as if it successfully
+    // completed, even though it's in an inconsistent state.
+    (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
+    // already cloned. In legacy mode, the only case where this isn't true is
+    // when DevTools forces us to display a fallback; we skip the first render
+    // pass entirely and go straight to rendering the fallback. (In Concurrent
+    // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
+    // only codepath.)
+    workInProgress.child !== currentPrimaryChildFragment
+  ) {
+    var progressedPrimaryFragment = workInProgress.child;
+    primaryChildFragment = progressedPrimaryFragment;
+    primaryChildFragment.childLanes = NoLanes;
+    primaryChildFragment.pendingProps = primaryChildProps;
 
-        if (prevState !== null) {
-          // This is the first boundary in the stack that's already showing
-          // a fallback. So everything outside is considered the shell.
-          shellBoundary = fiber;
-        }
-      }
-    }
+    if (workInProgress.mode & ProfileMode) {
+      // Reset the durations from the first pass so they aren't included in the
+      // final amounts. This seems counterintuitive, since we're intentionally
+      // not measuring part of the render phase, but this makes it match what we
+      // do in Concurrent Mode.
+      primaryChildFragment.actualDuration = 0;
+      primaryChildFragment.actualStartTime = -1;
+      primaryChildFragment.selfBaseDuration =
+        currentPrimaryChildFragment.selfBaseDuration;
+      primaryChildFragment.treeBaseDuration =
+        currentPrimaryChildFragment.treeBaseDuration;
+    } // The fallback fiber was added as a deletion during the first pass.
+    // However, since we're going to remain on the fallback, we no longer want
+    // to delete it.
+
+    workInProgress.deletions = null;
   } else {
-    // This is a LegacyHidden component.
-    reuseSuspenseHandlerOnStack(fiber);
+    primaryChildFragment = updateWorkInProgressOffscreenFiber(
+      currentPrimaryChildFragment,
+      primaryChildProps
+    ); // Since we're reusing a current tree, we need to reuse the flags, too.
+    // (We don't do this in legacy mode, because in legacy mode we don't re-use
+    // the current tree; see previous branch.)
+
+    primaryChildFragment.subtreeFlags =
+      currentPrimaryChildFragment.subtreeFlags & StaticMask;
   }
-}
-function reuseSuspenseHandlerOnStack(fiber) {
-  push(suspenseHandlerStackCursor, getSuspenseHandler(), fiber);
-}
-function getSuspenseHandler() {
-  return suspenseHandlerStackCursor.current;
-}
-function popSuspenseHandler(fiber) {
-  pop(suspenseHandlerStackCursor, fiber);
 
-  if (shellBoundary === fiber) {
-    // Popping back into the shell.
-    shellBoundary = null;
-  }
-} // SuspenseList context
-// TODO: Move to a separate module? We may change the SuspenseList
-// implementation to hide/show in the commit phase, anyway.
+  var fallbackChildFragment;
 
-var DefaultSuspenseContext = 0;
-var SubtreeSuspenseContextMask = 1; // ForceSuspenseFallback can be used by SuspenseList to force newly added
-// items into their fallback state during one of the render passes.
+  if (currentFallbackChildFragment !== null) {
+    fallbackChildFragment = createWorkInProgress(
+      currentFallbackChildFragment,
+      fallbackChildren
+    );
+  } else {
+    fallbackChildFragment = createFiberFromFragment(
+      fallbackChildren,
+      mode,
+      renderLanes,
+      null
+    ); // Needs a placement effect because the parent (the Suspense boundary) already
+    // mounted but this is a new fiber.
 
-var ForceSuspenseFallback = 2;
-var suspenseStackCursor = createCursor(DefaultSuspenseContext);
-function hasSuspenseListContext(parentContext, flag) {
-  return (parentContext & flag) !== 0;
-}
-function setDefaultShallowSuspenseListContext(parentContext) {
-  return parentContext & SubtreeSuspenseContextMask;
-}
-function setShallowSuspenseListContext(parentContext, shallowContext) {
-  return (parentContext & SubtreeSuspenseContextMask) | shallowContext;
-}
-function pushSuspenseListContext(fiber, newContext) {
-  push(suspenseStackCursor, newContext, fiber);
-}
-function popSuspenseListContext(fiber) {
-  pop(suspenseStackCursor, fiber);
+    fallbackChildFragment.flags |= Placement;
+  }
+
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
+  return fallbackChildFragment;
 }
 
-// A non-null SuspenseState means that it is blocked for one reason or another.
-// - A non-null dehydrated field means it's blocked pending hydration.
-//   - A non-null dehydrated field can use isSuspenseInstancePending or
-//     isSuspenseInstanceFallback to query the reason for being dehydrated.
-// - A null dehydrated field means it's blocked by something suspending and
-//   we're currently showing a fallback instead.
+function retrySuspenseComponentWithoutHydrating(
+  current,
+  workInProgress,
+  renderLanes,
+  recoverableError
+) {
+  // Falling back to client rendering. Because this has performance
+  // implications, it's considered a recoverable error, even though the user
+  // likely won't observe anything wrong with the UI.
+  //
+  // The error is passed in as an argument to enforce that every caller provide
+  // a custom message, or explicitly opt out (currently the only path that opts
+  // out is legacy mode; every concurrent path provides an error).
+  if (recoverableError !== null) {
+    queueHydrationError(recoverableError);
+  } // This will add the old fiber to the deletion list
 
-function findFirstSuspended(row) {
-  var node = row;
+  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
 
-  while (node !== null) {
-    if (node.tag === SuspenseComponent) {
-      var state = node.memoizedState;
+  var nextProps = workInProgress.pendingProps;
+  var primaryChildren = nextProps.children;
+  var primaryChildFragment = mountSuspensePrimaryChildren(
+    workInProgress,
+    primaryChildren
+  ); // Needs a placement effect because the parent (the Suspense boundary) already
+  // mounted but this is a new fiber.
 
-      if (state !== null) {
-        var dehydrated = state.dehydrated;
+  primaryChildFragment.flags |= Placement;
+  workInProgress.memoizedState = null;
+  return primaryChildFragment;
+}
 
-        if (
-          dehydrated === null ||
-          isSuspenseInstancePending(dehydrated) ||
-          isSuspenseInstanceFallback(dehydrated)
-        ) {
-          return node;
-        }
-      }
-    } else if (
-      node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't
-      // keep track of whether it suspended or not.
-      node.memoizedProps.revealOrder !== undefined
-    ) {
-      var didSuspend = (node.flags & DidCapture) !== NoFlags$1;
+function mountSuspenseFallbackAfterRetryWithoutHydrating(
+  current,
+  workInProgress,
+  primaryChildren,
+  fallbackChildren,
+  renderLanes
+) {
+  var fiberMode = workInProgress.mode;
+  var primaryChildProps = {
+    mode: "visible",
+    children: primaryChildren
+  };
+  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
+    primaryChildProps,
+    fiberMode
+  );
+  var fallbackChildFragment = createFiberFromFragment(
+    fallbackChildren,
+    fiberMode,
+    renderLanes,
+    null
+  ); // Needs a placement effect because the parent (the Suspense
+  // boundary) already mounted but this is a new fiber.
 
-      if (didSuspend) {
-        return node;
-      }
-    } else if (node.child !== null) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
+  fallbackChildFragment.flags |= Placement;
+  primaryChildFragment.return = workInProgress;
+  fallbackChildFragment.return = workInProgress;
+  primaryChildFragment.sibling = fallbackChildFragment;
+  workInProgress.child = primaryChildFragment;
 
-    if (node === row) {
-      return null;
-    }
+  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
+    // We will have dropped the effect list which contains the
+    // deletion. We need to reconcile to delete the current child.
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+  }
 
-    while (node.sibling === null) {
-      if (node.return === null || node.return === row) {
-        return null;
-      }
+  return fallbackChildFragment;
+}
 
-      node = node.return;
+function mountDehydratedSuspenseComponent(
+  workInProgress,
+  suspenseInstance,
+  renderLanes
+) {
+  // During the first pass, we'll bail out and not drill into the children.
+  // Instead, we'll leave the content in place and try to hydrate it later.
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    {
+      error(
+        "Cannot hydrate Suspense in legacy mode. Switch from " +
+          "ReactDOM.hydrate(element, container) to " +
+          "ReactDOMClient.hydrateRoot(container, <App />)" +
+          ".render(element) or remove the Suspense components from " +
+          "the server rendered components."
+      );
     }
 
-    node.sibling.return = node.return;
-    node = node.sibling;
+    workInProgress.lanes = laneToLanes(SyncLane);
+  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
+    // This is a client-only boundary. Since we won't get any content from the server
+    // for this, we need to schedule that at a higher priority based on when it would
+    // have timed out. In theory we could render it in this pass but it would have the
+    // wrong priority associated with it and will prevent hydration of parent path.
+    // Instead, we'll leave work left on it to render it in a separate commit.
+    // TODO This time should be the time at which the server rendered response that is
+    // a parent to this boundary was displayed. However, since we currently don't have
+    // a protocol to transfer that time, we'll just estimate it by using the current
+    // time. This will mean that Suspense timeouts are slightly shifted to later than
+    // they should be.
+    // Schedule a normal pri update to render this content.
+    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
+  } else {
+    // We'll continue hydrating the rest at offscreen priority since we'll already
+    // be showing the right content coming from the server, it is no rush.
+    workInProgress.lanes = laneToLanes(OffscreenLane);
   }
 
   return null;
 }
 
-var NoFlags =
-  /*   */
-  0; // Represents whether effect should fire.
-
-var HasEffect =
-  /* */
-  1; // Represents the phase in which the effect (not the clean-up) fires.
-
-var Insertion =
-  /* */
-  2;
-var Layout =
-  /*    */
-  4;
-var Passive =
-  /*   */
-  8;
+function updateDehydratedSuspenseComponent(
+  current,
+  workInProgress,
+  didSuspend,
+  nextProps,
+  suspenseInstance,
+  suspenseState,
+  renderLanes
+) {
+  if (!didSuspend) {
+    // This is the first render pass. Attempt to hydrate.
+    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
+    // but after we've already committed once.
 
-// and should be reset before starting a new render.
-// This tracks which mutable sources need to be reset after a render.
+    warnIfHydrating();
 
-var workInProgressSources = [];
-var rendererSigil$1;
+    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        null
+      );
+    }
 
-{
-  // Used to detect multiple renderers using the same mutable source.
-  rendererSigil$1 = {};
-}
+    if (isSuspenseInstanceFallback(suspenseInstance)) {
+      // This boundary is in a permanent fallback state. In this case, we'll never
+      // get an update and we'll never be able to hydrate the final content. Let's just try the
+      // client side render instead.
+      var digest, message, stack;
 
-function markSourceAsDirty(mutableSource) {
-  workInProgressSources.push(mutableSource);
-}
-function resetWorkInProgressVersions() {
-  for (var i = 0; i < workInProgressSources.length; i++) {
-    var mutableSource = workInProgressSources[i];
+      {
+        var _getSuspenseInstanceF =
+          getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
 
-    {
-      mutableSource._workInProgressVersionPrimary = null;
-    }
-  }
+        digest = _getSuspenseInstanceF.digest;
+        message = _getSuspenseInstanceF.message;
+        stack = _getSuspenseInstanceF.stack;
+      }
 
-  workInProgressSources.length = 0;
-}
-function getWorkInProgressVersion(mutableSource) {
-  {
-    return mutableSource._workInProgressVersionPrimary;
-  }
-}
-function setWorkInProgressVersion(mutableSource, version) {
-  {
-    mutableSource._workInProgressVersionPrimary = version;
-  }
+      var error;
 
-  workInProgressSources.push(mutableSource);
-}
-function warnAboutMultipleRenderersDEV(mutableSource) {
-  {
-    {
-      if (mutableSource._currentPrimaryRenderer == null) {
-        mutableSource._currentPrimaryRenderer = rendererSigil$1;
-      } else if (mutableSource._currentPrimaryRenderer !== rendererSigil$1) {
-        error(
-          "Detected multiple renderers concurrently rendering the " +
-            "same mutable source. This is currently unsupported."
+      if (message) {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        error = new Error(message);
+      } else {
+        error = new Error(
+          "The server could not finish this Suspense boundary, likely " +
+            "due to an error during server rendering. Switched to " +
+            "client rendering."
         );
       }
-    }
-  }
-} // Eager reads the version of a mutable source and stores it on the root.
-// This ensures that the version used for server rendering matches the one
-// that is eventually read during hydration.
-// If they don't match there's a potential tear and a full deopt render is required.
-
-function registerMutableSourceForHydration(root, mutableSource) {
-  var getVersion = mutableSource._getVersion;
-  var version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.
-  // Retaining it forever may interfere with GC.
-
-  if (root.mutableSourceEagerHydrationData == null) {
-    root.mutableSourceEagerHydrationData = [mutableSource, version];
-  } else {
-    root.mutableSourceEagerHydrationData.push(mutableSource, version);
-  }
-}
-
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
-var didWarnAboutMismatchedHooksForComponent;
-var didWarnUncachedGetSnapshot;
-var didWarnAboutUseWrappedInTryCatch;
 
-{
-  didWarnAboutMismatchedHooksForComponent = new Set();
-  didWarnAboutUseWrappedInTryCatch = new Set();
-} // These are set right before calling the component.
-
-var renderLanes$1 = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from
-// the work-in-progress hook.
-
-var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The
-// current hook list is the list that belongs to the current fiber. The
-// work-in-progress hook list is a new list that will be added to the
-// work-in-progress fiber.
-
-var currentHook = null;
-var workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This
-// does not get reset if we do another render pass; only when we're completely
-// finished evaluating this component. This is an optimization so we know
-// whether we need to clear render phase updates after a throw.
+      error.digest = digest;
+      var capturedValue = createCapturedValue(error, digest, stack);
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        capturedValue
+      );
+    }
 
-var didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This
-// gets reset after each attempt.
-// TODO: Maybe there's some way to consolidate this with
-// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
+    if (
+      enableLazyContextPropagation && // TODO: Factoring is a little weird, since we check this right below, too.
+      // But don't want to re-arrange the if-else chain until/unless this
+      // feature lands.
+      !didReceiveUpdate
+    ) {
+      // We need to check if any children have context before we decide to bail
+      // out, so propagate the changes now.
+      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
+    } // We use lanes to indicate that a child might depend on context, so if
+    // any context has changed, we need to treat is as if the input might have changed.
 
-var didScheduleRenderPhaseUpdateDuringThisPass = false;
-var shouldDoubleInvokeUserFnsInHooksDEV = false; // Counts the number of useId hooks in this component.
+    var hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
 
-var localIdCounter = 0; // Counts number of `use`-d thenables
+    if (didReceiveUpdate || hasContextChanged) {
+      // This boundary has changed since the first render. This means that we are now unable to
+      // hydrate it. We might still be able to hydrate it using a higher priority lane.
+      var root = getWorkInProgressRoot();
 
-var thenableIndexCounter = 0;
-var thenableState = null; // Used for ids that are generated completely client-side (i.e. not during
-// hydration). This counter is global, so client ids are not stable across
-// render attempts.
+      if (root !== null) {
+        var attemptHydrationAtLane = getBumpedLaneForHydration(
+          root,
+          renderLanes
+        );
 
-var globalClientIdCounter = 0;
-var RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook
+        if (
+          attemptHydrationAtLane !== NoLane &&
+          attemptHydrationAtLane !== suspenseState.retryLane
+        ) {
+          // Intentionally mutating since this render will get interrupted. This
+          // is one of the very rare times where we mutate the current tree
+          // during the render phase.
+          suspenseState.retryLane = attemptHydrationAtLane; // TODO: Ideally this would inherit the event time of the current render
 
-var currentHookNameInDev = null; // In DEV, this list ensures that hooks are called in the same order between renders.
-// The list stores the order of hooks used during the initial render (mount).
-// Subsequent renders (updates) reference this list.
+          var eventTime = NoTimestamp;
+          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
+          scheduleUpdateOnFiber(
+            root,
+            current,
+            attemptHydrationAtLane,
+            eventTime
+          ); // Throw a special object that signals to the work loop that it should
+          // interrupt the current render.
+          //
+          // Because we're inside a React-only execution stack, we don't
+          // strictly need to throw here — we could instead modify some internal
+          // work loop state. But using an exception means we don't need to
+          // check for this case on every iteration of the work loop. So doing
+          // it this way moves the check out of the fast path.
 
-var hookTypesDev = null;
-var hookTypesUpdateIndexDev = -1; // In DEV, this tracks whether currently rendering component needs to ignore
-// the dependencies for Hooks that need them (e.g. useEffect or useMemo).
-// When true, such Hooks will always be "remounted". Only used during hot reload.
+          throw SelectiveHydrationException;
+        }
+      } // If we did not selectively hydrate, we'll continue rendering without
+      // hydrating. Mark this tree as suspended to prevent it from committing
+      // outside a transition.
+      //
+      // This path should only happen if the hydration lane already suspended.
+      // Currently, it also happens during sync updates because there is no
+      // hydration lane for sync updates.
+      // TODO: We should ideally have a sync hydration lane that we can apply to do
+      // a pass where we hydrate this subtree in place using the previous Context and then
+      // reapply the update afterwards.
 
-var ignorePreviousDependencies = false;
+      renderDidSuspendDelayIfPossible();
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        null
+      );
+    } else if (isSuspenseInstancePending(suspenseInstance)) {
+      // This component is still pending more data from the server, so we can't hydrate its
+      // content. We treat it as if this component suspended itself. It might seem as if
+      // we could just try to render it client-side instead. However, this will perform a
+      // lot of unnecessary work and is unlikely to complete since it often will suspend
+      // on missing data anyway. Additionally, the server might be able to render more
+      // than we can on the client yet. In that case we'd end up with more fallback states
+      // on the client than if we just leave it alone. If the server times out or errors
+      // these should update this boundary to the permanent Fallback state instead.
+      // Mark it as having captured (i.e. suspended).
+      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
 
-function mountHookTypesDev() {
-  {
-    var hookName = currentHookNameInDev;
+      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
 
-    if (hookTypesDev === null) {
-      hookTypesDev = [hookName];
+      var retry = retryDehydratedSuspenseBoundary.bind(null, current);
+      registerSuspenseInstanceRetry(suspenseInstance, retry);
+      return null;
     } else {
-      hookTypesDev.push(hookName);
-    }
-  }
-}
-
-function updateHookTypesDev() {
-  {
-    var hookName = currentHookNameInDev;
-
-    if (hookTypesDev !== null) {
-      hookTypesUpdateIndexDev++;
+      // This is the first attempt.
+      reenterHydrationStateFromDehydratedSuspenseInstance(
+        workInProgress,
+        suspenseInstance,
+        suspenseState.treeContext
+      );
+      var primaryChildren = nextProps.children;
+      var primaryChildFragment = mountSuspensePrimaryChildren(
+        workInProgress,
+        primaryChildren
+      ); // Mark the children as hydrating. This is a fast path to know whether this
+      // tree is part of a hydrating tree. This is used to determine if a child
+      // node has fully mounted yet, and for scheduling event replaying.
+      // Conceptually this is similar to Placement in that a new subtree is
+      // inserted into the React tree here. It just happens to not need DOM
+      // mutations because it already exists.
 
-      if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
-        warnOnHookMismatchInDev(hookName);
-      }
+      primaryChildFragment.flags |= Hydrating;
+      return primaryChildFragment;
     }
-  }
-}
+  } else {
+    // This is the second render pass. We already attempted to hydrated, but
+    // something either suspended or errored.
+    if (workInProgress.flags & ForceClientRender) {
+      // Something errored during hydration. Try again without hydrating.
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      workInProgress.flags &= ~ForceClientRender;
 
-function checkDepsAreArrayDev(deps) {
-  {
-    if (deps !== undefined && deps !== null && !isArray(deps)) {
-      // Verify deps, but only on mount to avoid extra checks.
-      // It's unlikely their type would change as usually you define them inline.
-      error(
-        "%s received a final argument that is not an array (instead, received `%s`). When " +
-          "specified, the final argument must be an array.",
-        currentHookNameInDev,
-        typeof deps
+      var _capturedValue = createCapturedValue(
+        new Error(
+          "There was an error while hydrating this Suspense boundary. " +
+            "Switched to client rendering."
+        )
       );
-    }
-  }
-}
 
-function warnOnHookMismatchInDev(currentHookName) {
-  {
-    var componentName = getComponentNameFromFiber(currentlyRenderingFiber$1);
-
-    if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
-      didWarnAboutMismatchedHooksForComponent.add(componentName);
-
-      if (hookTypesDev !== null) {
-        var table = "";
-        var secondColumnStart = 30;
-
-        for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
-          var oldHookName = hookTypesDev[i];
-          var newHookName =
-            i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
-          var row = i + 1 + ". " + oldHookName; // Extra space so second column lines up
-          // lol @ IE not supporting String#repeat
-
-          while (row.length < secondColumnStart) {
-            row += " ";
-          }
-
-          row += newHookName + "\n";
-          table += row;
-        }
+      return retrySuspenseComponentWithoutHydrating(
+        current,
+        workInProgress,
+        renderLanes,
+        _capturedValue
+      );
+    } else if (workInProgress.memoizedState !== null) {
+      // Something suspended and we should still be in dehydrated mode.
+      // Leave the existing child in place.
+      // Push to avoid a mismatch
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
+      // but the normal suspense pass doesn't.
 
-        error(
-          "React has detected a change in the order of Hooks called by %s. " +
-            "This will lead to bugs and errors if not fixed. " +
-            "For more information, read the Rules of Hooks: https://reactjs.org/link/rules-of-hooks\n\n" +
-            "   Previous render            Next render\n" +
-            "   ------------------------------------------------------\n" +
-            "%s" +
-            "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-          componentName,
-          table
+      workInProgress.flags |= DidCapture;
+      return null;
+    } else {
+      // Suspended but we should no longer be in dehydrated mode.
+      // Therefore we now have to render the fallback.
+      pushFallbackTreeSuspenseHandler(workInProgress);
+      var nextPrimaryChildren = nextProps.children;
+      var nextFallbackChildren = nextProps.fallback;
+      var fallbackChildFragment =
+        mountSuspenseFallbackAfterRetryWithoutHydrating(
+          current,
+          workInProgress,
+          nextPrimaryChildren,
+          nextFallbackChildren,
+          renderLanes
         );
-      }
+      var _primaryChildFragment4 = workInProgress.child;
+      _primaryChildFragment4.memoizedState =
+        mountSuspenseOffscreenState(renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return fallbackChildFragment;
     }
   }
 }
 
-function throwInvalidHookError() {
-  throw new Error(
-    "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for" +
-      " one of the following reasons:\n" +
-      "1. You might have mismatching versions of React and the renderer (such as React DOM)\n" +
-      "2. You might be breaking the Rules of Hooks\n" +
-      "3. You might have more than one copy of React in the same app\n" +
-      "See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."
-  );
-}
-
-function areHookInputsEqual(nextDeps, prevDeps) {
-  {
-    if (ignorePreviousDependencies) {
-      // Only true when this component is being hot reloaded.
-      return false;
-    }
-  }
-
-  if (prevDeps === null) {
-    {
-      error(
-        "%s received a final argument during this render, but not during " +
-          "the previous render. Even though the final argument is optional, " +
-          "its type cannot change between renders.",
-        currentHookNameInDev
-      );
-    }
-
-    return false;
-  }
-
-  {
-    // Don't bother comparing lengths in prod because these arrays should be
-    // passed inline.
-    if (nextDeps.length !== prevDeps.length) {
-      error(
-        "The final argument passed to %s changed size between renders. The " +
-          "order and size of this array must remain constant.\n\n" +
-          "Previous: %s\n" +
-          "Incoming: %s",
-        currentHookNameInDev,
-        "[" + prevDeps.join(", ") + "]",
-        "[" + nextDeps.join(", ") + "]"
-      );
-    }
-  } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
-    // $FlowFixMe[incompatible-use] found when upgrading Flow
-    if (objectIs(nextDeps[i], prevDeps[i])) {
-      continue;
-    }
+function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+  var alternate = fiber.alternate;
 
-    return false;
+  if (alternate !== null) {
+    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
   }
 
-  return true;
+  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
 }
 
-function renderWithHooks(
-  current,
+function propagateSuspenseContextChange(
   workInProgress,
-  Component,
-  props,
-  secondArg,
-  nextRenderLanes
+  firstChild,
+  renderLanes
 ) {
-  renderLanes$1 = nextRenderLanes;
-  currentlyRenderingFiber$1 = workInProgress;
+  // Mark any Suspense boundaries with fallbacks as having work to do.
+  // If they were previously forced into fallbacks, they may now be able
+  // to unblock.
+  var node = firstChild;
 
-  {
-    hookTypesDev = current !== null ? current._debugHookTypes : null;
-    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
+  while (node !== null) {
+    if (node.tag === SuspenseComponent) {
+      var state = node.memoizedState;
 
-    ignorePreviousDependencies =
-      current !== null && current.type !== workInProgress.type;
-  }
+      if (state !== null) {
+        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+      }
+    } else if (node.tag === SuspenseListComponent) {
+      // If the tail is hidden there might not be an Suspense boundaries
+      // to schedule work on. In this case we have to schedule it on the
+      // list itself.
+      // We don't have to traverse to the children of the list since
+      // the list will propagate the change when it rerenders.
+      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+    } else if (node.child !== null) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
 
-  workInProgress.memoizedState = null;
-  workInProgress.updateQueue = null;
-  workInProgress.lanes = NoLanes; // The following should have already been reset
-  // currentHook = null;
-  // workInProgressHook = null;
-  // didScheduleRenderPhaseUpdate = false;
-  // localIdCounter = 0;
-  // thenableIndexCounter = 0;
-  // thenableState = null;
-  // TODO Warn if no hooks are used at all during mount, then some are used during update.
-  // Currently we will identify the update render as a mount because memoizedState === null.
-  // This is tricky because it's valid for certain types of components (e.g. React.lazy)
-  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.
-  // Non-stateful hooks (e.g. context) don't get added to memoizedState,
-  // so memoizedState would be null during updates and mounts.
+    if (node === workInProgress) {
+      return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-  {
-    if (current !== null && current.memoizedState !== null) {
-      ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
-    } else if (hookTypesDev !== null) {
-      // This dispatcher handles an edge case where a component is updating,
-      // but no stateful hooks have been used.
-      // We want to match the production code behavior (which will use HooksDispatcherOnMount),
-      // but with the extra DEV validation to ensure hooks ordering hasn't changed.
-      // This dispatcher does that.
-      ReactCurrentDispatcher$1.current =
-        HooksDispatcherOnMountWithHookTypesInDEV;
-    } else {
-      ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
-    }
-  } // In Strict Mode, during development, user functions are double invoked to
-  // help detect side effects. The logic for how this is implemented for in
-  // hook components is a bit complex so let's break it down.
-  //
-  // We will invoke the entire component function twice. However, during the
-  // second invocation of the component, the hook state from the first
-  // invocation will be reused. That means things like `useMemo` functions won't
-  // run again, because the deps will match and the memoized result will
-  // be reused.
-  //
-  // We want memoized functions to run twice, too, so account for this, user
-  // functions are double invoked during the *first* invocation of the component
-  // function, and are *not* double invoked during the second incovation:
-  //
-  // - First execution of component function: user functions are double invoked
-  // - Second execution of component function (in Strict Mode, during
-  //   development): user functions are not double invoked.
-  //
-  // This is intentional for a few reasons; most importantly, it's because of
-  // how `use` works when something suspends: it reuses the promise that was
-  // passed during the first attempt. This is itself a form of memoization.
-  // We need to be able to memoize the reactive inputs to the `use` call using
-  // a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
-  // come from the same component invocation as the output.
-  //
-  // There are plenty of tests to ensure this behavior is correct.
+    while (node.sibling === null) {
+      // $FlowFixMe[incompatible-use] found when upgrading Flow
+      if (node.return === null || node.return === workInProgress) {
+        return;
+      }
 
-  var shouldDoubleRenderDEV =
-    (workInProgress.mode & StrictLegacyMode) !== NoMode;
-  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
-  var children = Component(props, secondArg);
-  shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
+      node = node.return;
+    } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-  if (didScheduleRenderPhaseUpdateDuringThisPass) {
-    // Keep rendering until the component stabilizes (there are no more render
-    // phase updates).
-    children = renderWithHooksAgain(
-      workInProgress,
-      Component,
-      props,
-      secondArg
-    );
+    node.sibling.return = node.return;
+    node = node.sibling;
   }
+}
 
-  if (shouldDoubleRenderDEV) {
-    // In development, components are invoked twice to help detect side effects.
-    setIsStrictModeForDevtools(true);
+function findLastContentRow(firstChild) {
+  // This is going to find the last row among these children that is already
+  // showing content on the screen, as opposed to being in fallback state or
+  // new. If a row has multiple Suspense boundaries, any of them being in the
+  // fallback state, counts as the whole row being in a fallback state.
+  // Note that the "rows" will be workInProgress, but any nested children
+  // will still be current since we haven't rendered them yet. The mounted
+  // order may not be the same as the new order. We use the new order.
+  var row = firstChild;
+  var lastContentRow = null;
 
-    try {
-      children = renderWithHooksAgain(
-        workInProgress,
-        Component,
-        props,
-        secondArg
-      );
-    } finally {
-      setIsStrictModeForDevtools(false);
+  while (row !== null) {
+    var currentRow = row.alternate; // New rows can't be content rows.
+
+    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+      lastContentRow = row;
     }
+
+    row = row.sibling;
   }
 
-  finishRenderingHooks(current, workInProgress);
-  return children;
+  return lastContentRow;
 }
 
-function finishRenderingHooks(current, workInProgress) {
-  // We can assume the previous dispatcher is always this one, since we set it
-  // at the beginning of the render phase and there's no re-entrance.
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-
-  {
-    workInProgress._debugHookTypes = hookTypesDev;
-  } // This check uses currentHook so that it works the same in DEV and prod bundles.
-  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.
-
-  var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
-  renderLanes$1 = NoLanes;
-  currentlyRenderingFiber$1 = null;
-  currentHook = null;
-  workInProgressHook = null;
-
+function validateRevealOrder(revealOrder) {
   {
-    currentHookNameInDev = null;
-    hookTypesDev = null;
-    hookTypesUpdateIndexDev = -1; // Confirm that a static flag was not added or removed since the last
-    // render. If this fires, it suggests that we incorrectly reset the static
-    // flags in some other part of the codebase. This has happened before, for
-    // example, in the SuspenseList implementation.
-
     if (
-      current !== null &&
-      (current.flags & StaticMask) !== (workInProgress.flags & StaticMask) && // Disable this warning in legacy mode, because legacy Suspense is weird
-      // and creates false positives. To make this work in legacy mode, we'd
-      // need to mark fibers that commit in an incomplete state, somehow. For
-      // now I'll disable the warning that most of the bugs that would trigger
-      // it are either exclusive to concurrent mode or exist in both.
-      (current.mode & ConcurrentMode) !== NoMode
+      revealOrder !== undefined &&
+      revealOrder !== "forwards" &&
+      revealOrder !== "backwards" &&
+      revealOrder !== "together" &&
+      !didWarnAboutRevealOrder[revealOrder]
     ) {
-      error(
-        "Internal React error: Expected static flag was missing. Please " +
-          "notify the React team."
-      );
-    }
-  }
+      didWarnAboutRevealOrder[revealOrder] = true;
 
-  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook
-  // localIdCounter = 0;
+      if (typeof revealOrder === "string") {
+        switch (revealOrder.toLowerCase()) {
+          case "together":
+          case "forwards":
+          case "backwards": {
+            error(
+              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
+                'Use lowercase "%s" instead.',
+              revealOrder,
+              revealOrder.toLowerCase()
+            );
 
-  thenableIndexCounter = 0;
-  thenableState = null;
+            break;
+          }
 
-  if (didRenderTooFewHooks) {
-    throw new Error(
-      "Rendered fewer hooks than expected. This may be caused by an accidental " +
-        "early return statement."
-    );
-  }
+          case "forward":
+          case "backward": {
+            error(
+              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
+                'React uses the -s suffix in the spelling. Use "%ss" instead.',
+              revealOrder,
+              revealOrder.toLowerCase()
+            );
 
-  if (enableLazyContextPropagation) {
-    if (current !== null) {
-      if (!checkIfWorkInProgressReceivedUpdate()) {
-        // If there were no changes to props or state, we need to check if there
-        // was a context change. We didn't already do this because there's no
-        // 1:1 correspondence between dependencies and hooks. Although, because
-        // there almost always is in the common case (`readContext` is an
-        // internal API), we could compare in there. OTOH, we only hit this case
-        // if everything else bails out, so on the whole it might be better to
-        // keep the comparison out of the common path.
-        var currentDependencies = current.dependencies;
+            break;
+          }
 
-        if (
-          currentDependencies !== null &&
-          checkIfContextChanged(currentDependencies)
-        ) {
-          markWorkInProgressReceivedUpdate();
+          default:
+            error(
+              '"%s" is not a supported revealOrder on <SuspenseList />. ' +
+                'Did you mean "together", "forwards" or "backwards"?',
+              revealOrder
+            );
+
+            break;
         }
+      } else {
+        error(
+          "%s is not a supported value for revealOrder on <SuspenseList />. " +
+            'Did you mean "together", "forwards" or "backwards"?',
+          revealOrder
+        );
       }
     }
   }
+}
 
+function validateTailOptions(tailMode, revealOrder) {
   {
-    if (checkIfUseWrappedInTryCatch()) {
-      var componentName =
-        getComponentNameFromFiber(workInProgress) || "Unknown";
+    if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
+      if (tailMode !== "collapsed" && tailMode !== "hidden") {
+        didWarnAboutTailOptions[tailMode] = true;
 
-      if (!didWarnAboutUseWrappedInTryCatch.has(componentName)) {
-        didWarnAboutUseWrappedInTryCatch.add(componentName);
+        error(
+          '"%s" is not a supported value for tail on <SuspenseList />. ' +
+            'Did you mean "collapsed" or "hidden"?',
+          tailMode
+        );
+      } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
+        didWarnAboutTailOptions[tailMode] = true;
 
         error(
-          "`use` was called from inside a try/catch block. This is not allowed " +
-            "and can lead to unexpected behavior. To handle errors triggered " +
-            "by `use`, wrap your component in a error boundary."
+          '<SuspenseList tail="%s" /> is only valid if revealOrder is ' +
+            '"forwards" or "backwards". ' +
+            'Did you mean to specify revealOrder="forwards"?',
+          tailMode
         );
       }
     }
   }
 }
 
-function replaySuspendedComponentWithHooks(
-  current,
-  workInProgress,
-  Component,
-  props,
-  secondArg
-) {
-  // This function is used to replay a component that previously suspended,
-  // after its data resolves.
-  //
-  // It's a simplified version of renderWithHooks, but it doesn't need to do
-  // most of the set up work because they weren't reset when we suspended; they
-  // only get reset when the component either completes (finishRenderingHooks)
-  // or unwinds (resetHooksOnUnwind).
+function validateSuspenseListNestedChild(childSlot, index) {
   {
-    hookTypesUpdateIndexDev = -1; // Used for hot reloading:
-
-    ignorePreviousDependencies =
-      current !== null && current.type !== workInProgress.type;
-  }
+    var isAnArray = isArray(childSlot);
+    var isIterable =
+      !isAnArray && typeof getIteratorFn(childSlot) === "function";
 
-  var children = renderWithHooksAgain(
-    workInProgress,
-    Component,
-    props,
-    secondArg
-  );
-  finishRenderingHooks(current, workInProgress);
-  return children;
-}
+    if (isAnArray || isIterable) {
+      var type = isAnArray ? "array" : "iterable";
 
-function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
-  // This is used to perform another render pass. It's used when setState is
-  // called during render, and for double invoking components in Strict Mode
-  // during development.
-  //
-  // The state from the previous pass is reused whenever possible. So, state
-  // updates that were already processed are not processed again, and memoized
-  // functions (`useMemo`) are not invoked again.
-  //
-  // Keep rendering in a loop for as long as render phase updates continue to
-  // be scheduled. Use a counter to prevent infinite loops.
-  var numberOfReRenders = 0;
-  var children;
+      error(
+        "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " +
+          "an additional SuspenseList to configure its revealOrder: " +
+          "<SuspenseList revealOrder=...> ... " +
+          "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " +
+          "</SuspenseList>",
+        type,
+        index,
+        type
+      );
 
-  do {
-    if (didScheduleRenderPhaseUpdateDuringThisPass) {
-      // It's possible that a use() value depended on a state that was updated in
-      // this rerender, so we need to watch for different thenables this time.
-      thenableState = null;
+      return false;
     }
+  }
 
-    thenableIndexCounter = 0;
-    didScheduleRenderPhaseUpdateDuringThisPass = false;
+  return true;
+}
 
-    if (numberOfReRenders >= RE_RENDER_LIMIT) {
-      throw new Error(
-        "Too many re-renders. React limits the number of renders to prevent " +
-          "an infinite loop."
-      );
-    }
+function validateSuspenseListChildren(children, revealOrder) {
+  {
+    if (
+      (revealOrder === "forwards" || revealOrder === "backwards") &&
+      children !== undefined &&
+      children !== null &&
+      children !== false
+    ) {
+      if (isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+          if (!validateSuspenseListNestedChild(children[i], i)) {
+            return;
+          }
+        }
+      } else {
+        var iteratorFn = getIteratorFn(children);
 
-    numberOfReRenders += 1;
+        if (typeof iteratorFn === "function") {
+          var childrenIterator = iteratorFn.call(children);
 
-    {
-      // Even when hot reloading, allow dependencies to stabilize
-      // after first render to prevent infinite render phase updates.
-      ignorePreviousDependencies = false;
-    } // Start over from the beginning of the list
+          if (childrenIterator) {
+            var step = childrenIterator.next();
+            var _i = 0;
 
-    currentHook = null;
-    workInProgressHook = null;
-    workInProgress.updateQueue = null;
+            for (; !step.done; step = childrenIterator.next()) {
+              if (!validateSuspenseListNestedChild(step.value, _i)) {
+                return;
+              }
 
-    {
-      // Also validate hook order for cascading updates.
-      hookTypesUpdateIndexDev = -1;
+              _i++;
+            }
+          }
+        } else {
+          error(
+            'A single row was passed to a <SuspenseList revealOrder="%s" />. ' +
+              "This is not useful since it needs multiple rows. " +
+              "Did you mean to pass multiple children or an array?",
+            revealOrder
+          );
+        }
+      }
     }
+  }
+}
 
-    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerenderInDEV;
-    children = Component(props, secondArg);
-  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+function initSuspenseListRenderState(
+  workInProgress,
+  isBackwards,
+  tail,
+  lastContentRow,
+  tailMode
+) {
+  var renderState = workInProgress.memoizedState;
 
-  return children;
-}
+  if (renderState === null) {
+    workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    };
+  } else {
+    // We can reuse the existing object from previous renders.
+    renderState.isBackwards = isBackwards;
+    renderState.rendering = null;
+    renderState.renderingStartTime = 0;
+    renderState.last = lastContentRow;
+    renderState.tail = tail;
+    renderState.tailMode = tailMode;
+  }
+} // This can end up rendering this component multiple passes.
+// The first pass splits the children fibers into two sets. A head and tail.
+// We first render the head. If anything is in fallback state, we do another
+// pass through beginWork to rerender all children (including the tail) with
+// the force suspend context. If the first render didn't have anything in
+// in fallback state. Then we render each row in the tail one-by-one.
+// That happens in the completeWork phase without going back to beginWork.
 
-function checkDidRenderIdHook() {
-  // This should be called immediately after every renderWithHooks call.
-  // Conceptually, it's part of the return value of renderWithHooks; it's only a
-  // separate function to avoid using an array tuple.
-  var didRenderIdHook = localIdCounter !== 0;
-  localIdCounter = 0;
-  return didRenderIdHook;
-}
-function bailoutHooks(current, workInProgress, lanes) {
-  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the
-  // complete phase (bubbleProperties).
+function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var revealOrder = nextProps.revealOrder;
+  var tailMode = nextProps.tail;
+  var newChildren = nextProps.children;
+  validateRevealOrder(revealOrder);
+  validateTailOptions(tailMode, revealOrder);
+  validateSuspenseListChildren(newChildren, revealOrder);
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  var suspenseContext = suspenseStackCursor.current;
+  var shouldForceFallback = hasSuspenseListContext(
+    suspenseContext,
+    ForceSuspenseFallback
+  );
 
-  if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-    workInProgress.flags &= ~(
-      MountPassiveDev |
-      MountLayoutDev |
-      Passive$1 |
-      Update
+  if (shouldForceFallback) {
+    suspenseContext = setShallowSuspenseListContext(
+      suspenseContext,
+      ForceSuspenseFallback
     );
+    workInProgress.flags |= DidCapture;
   } else {
-    workInProgress.flags &= ~(Passive$1 | Update);
+    var didSuspendBefore =
+      current !== null && (current.flags & DidCapture) !== NoFlags$1;
+
+    if (didSuspendBefore) {
+      // If we previously forced a fallback, we need to schedule work
+      // on any nested boundaries to let them know to try to render
+      // again. This is the same as context updating.
+      propagateSuspenseContextChange(
+        workInProgress,
+        workInProgress.child,
+        renderLanes
+      );
+    }
+
+    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
   }
 
-  current.lanes = removeLanes(current.lanes, lanes);
-}
-function resetHooksAfterThrow() {
-  // This is called immediaetly after a throw. It shouldn't reset the entire
-  // module state, because the work loop might decide to replay the component
-  // again without rewinding.
-  //
-  // It should only reset things like the current dispatcher, to prevent hooks
-  // from being called outside of a component.
-  // We can assume the previous dispatcher is always this one, since we set it
-  // at the beginning of the render phase and there's no re-entrance.
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-}
-function resetHooksOnUnwind() {
-  if (didScheduleRenderPhaseUpdate) {
-    // There were render phase updates. These are only valid for this render
-    // phase, which we are now aborting. Remove the updates from the queues so
-    // they do not persist to the next render. Do not remove updates from hooks
-    // that weren't processed.
-    //
-    // Only reset the updates from the queue if it has a clone. If it does
-    // not have a clone, that means it wasn't processed, and the updates were
-    // scheduled before we entered the render phase.
-    var hook = currentlyRenderingFiber$1.memoizedState;
+  pushSuspenseListContext(workInProgress, suspenseContext);
 
-    while (hook !== null) {
-      var queue = hook.queue;
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    // In legacy mode, SuspenseList doesn't work so we just
+    // use make it a noop by treating it as the default revealOrder.
+    workInProgress.memoizedState = null;
+  } else {
+    switch (revealOrder) {
+      case "forwards": {
+        var lastContentRow = findLastContentRow(workInProgress.child);
+        var tail;
 
-      if (queue !== null) {
-        queue.pending = null;
+        if (lastContentRow === null) {
+          // The whole list is part of the tail.
+          // TODO: We could fast path by just rendering the tail now.
+          tail = workInProgress.child;
+          workInProgress.child = null;
+        } else {
+          // Disconnect the tail rows after the content row.
+          // We're going to render them separately later.
+          tail = lastContentRow.sibling;
+          lastContentRow.sibling = null;
+        }
+
+        initSuspenseListRenderState(
+          workInProgress,
+          false, // isBackwards
+          tail,
+          lastContentRow,
+          tailMode
+        );
+        break;
       }
 
-      hook = hook.next;
-    }
+      case "backwards": {
+        // We're going to find the first row that has existing content.
+        // At the same time we're going to reverse the list of everything
+        // we pass in the meantime. That's going to be our tail in reverse
+        // order.
+        var _tail = null;
+        var row = workInProgress.child;
+        workInProgress.child = null;
 
-    didScheduleRenderPhaseUpdate = false;
-  }
+        while (row !== null) {
+          var currentRow = row.alternate; // New rows can't be content rows.
 
-  renderLanes$1 = NoLanes;
-  currentlyRenderingFiber$1 = null;
-  currentHook = null;
-  workInProgressHook = null;
+          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
+            // This is the beginning of the main content.
+            workInProgress.child = row;
+            break;
+          }
 
-  {
-    hookTypesDev = null;
-    hookTypesUpdateIndexDev = -1;
-    currentHookNameInDev = null;
-  }
+          var nextRow = row.sibling;
+          row.sibling = _tail;
+          _tail = row;
+          row = nextRow;
+        } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
 
-  didScheduleRenderPhaseUpdateDuringThisPass = false;
-  localIdCounter = 0;
-  thenableIndexCounter = 0;
-  thenableState = null;
-}
+        initSuspenseListRenderState(
+          workInProgress,
+          true, // isBackwards
+          _tail,
+          null, // last
+          tailMode
+        );
+        break;
+      }
 
-function mountWorkInProgressHook() {
-  var hook = {
-    memoizedState: null,
-    baseState: null,
-    baseQueue: null,
-    queue: null,
-    next: null
-  };
+      case "together": {
+        initSuspenseListRenderState(
+          workInProgress,
+          false, // isBackwards
+          null, // tail
+          null, // last
+          undefined
+        );
+        break;
+      }
 
-  if (workInProgressHook === null) {
-    // This is the first hook in the list
-    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;
-  } else {
-    // Append to the end of the list
-    workInProgressHook = workInProgressHook.next = hook;
+      default: {
+        // The default reveal order is the same as not having
+        // a boundary.
+        workInProgress.memoizedState = null;
+      }
+    }
   }
 
-  return workInProgressHook;
+  return workInProgress.child;
 }
 
-function updateWorkInProgressHook() {
-  // This function is used both for updates and for re-renders triggered by a
-  // render phase update. It assumes there is either a current hook we can
-  // clone, or a work-in-progress hook from a previous render pass that we can
-  // use as a base.
-  var nextCurrentHook;
-
-  if (currentHook === null) {
-    var current = currentlyRenderingFiber$1.alternate;
+function updatePortalComponent(current, workInProgress, renderLanes) {
+  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+  var nextChildren = workInProgress.pendingProps;
 
-    if (current !== null) {
-      nextCurrentHook = current.memoizedState;
-    } else {
-      nextCurrentHook = null;
-    }
+  if (current === 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
+    // the root always starts with a "current" with a null child.
+    // TODO: Consider unifying this with how the root works.
+    workInProgress.child = reconcileChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderLanes
+    );
   } else {
-    nextCurrentHook = currentHook.next;
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
   }
 
-  var nextWorkInProgressHook;
+  return workInProgress.child;
+}
 
-  if (workInProgressHook === null) {
-    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;
-  } else {
-    nextWorkInProgressHook = workInProgressHook.next;
-  }
+var hasWarnedAboutUsingNoValuePropOnContextProvider = false;
 
-  if (nextWorkInProgressHook !== null) {
-    // There's already a work-in-progress. Reuse it.
-    workInProgressHook = nextWorkInProgressHook;
-    nextWorkInProgressHook = workInProgressHook.next;
-    currentHook = nextCurrentHook;
-  } else {
-    // Clone from the current hook.
-    if (nextCurrentHook === null) {
-      var currentFiber = currentlyRenderingFiber$1.alternate;
+function updateContextProvider(current, workInProgress, renderLanes) {
+  var providerType = workInProgress.type;
+  var context = providerType._context;
+  var newProps = workInProgress.pendingProps;
+  var oldProps = workInProgress.memoizedProps;
+  var newValue = newProps.value;
 
-      if (currentFiber === null) {
-        // This is the initial render. This branch is reached when the component
-        // suspends, resumes, then renders an additional hook.
-        // Should never be reached because we should switch to the mount dispatcher first.
-        throw new Error(
-          "Update hook called on initial render. This is likely a bug in React. Please file an issue."
+  {
+    if (!("value" in newProps)) {
+      if (!hasWarnedAboutUsingNoValuePropOnContextProvider) {
+        hasWarnedAboutUsingNoValuePropOnContextProvider = true;
+
+        error(
+          "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
         );
-      } else {
-        // This is an update. We should always have a current hook.
-        throw new Error("Rendered more hooks than during the previous render.");
       }
     }
 
-    currentHook = nextCurrentHook;
-    var newHook = {
-      memoizedState: currentHook.memoizedState,
-      baseState: currentHook.baseState,
-      baseQueue: currentHook.baseQueue,
-      queue: currentHook.queue,
-      next: null
-    };
+    var providerPropTypes = workInProgress.type.propTypes;
 
-    if (workInProgressHook === null) {
-      // This is the first hook in the list.
-      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;
-    } else {
-      // Append to the end of the list.
-      workInProgressHook = workInProgressHook.next = newHook;
+    if (providerPropTypes) {
+      checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider");
     }
   }
 
-  return workInProgressHook;
-} // NOTE: defining two versions of this function to avoid size impact when this feature is disabled.
-// Previously this function was inlined, the additional `memoCache` property makes it not inlined.
-
-var createFunctionComponentUpdateQueue;
-
-{
-  createFunctionComponentUpdateQueue = function () {
-    return {
-      lastEffect: null,
-      events: null,
-      stores: null,
-      memoCache: null
-    };
-  };
-}
-
-function use(usable) {
-  if (usable !== null && typeof usable === "object") {
-    // $FlowFixMe[method-unbinding]
-    if (typeof usable.then === "function") {
-      // This is a thenable.
-      var thenable = usable; // Track the position of the thenable within this fiber.
-
-      var index = thenableIndexCounter;
-      thenableIndexCounter += 1;
-
-      if (thenableState === null) {
-        thenableState = createThenableState();
-      }
+  pushProvider(workInProgress, context, newValue);
 
-      var result = trackUsedThenable(thenableState, thenable, index);
+  if (enableLazyContextPropagation);
+  else {
+    if (oldProps !== null) {
+      var oldValue = oldProps.value;
 
-      if (
-        currentlyRenderingFiber$1.alternate === null &&
-        (workInProgressHook === null
-          ? currentlyRenderingFiber$1.memoizedState === null
-          : workInProgressHook.next === null)
-      ) {
-        // Initial render, and either this is the first time the component is
-        // called, or there were no Hooks called after this use() the previous
-        // time (perhaps because it threw). Subsequent Hook calls should use the
-        // mount dispatcher.
-        {
-          ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
+      if (objectIs(oldValue, newValue)) {
+        // No change. Bailout early if children are the same.
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
+          return bailoutOnAlreadyFinishedWork(
+            current,
+            workInProgress,
+            renderLanes
+          );
         }
+      } else {
+        // The context value changed. Search for matching consumers and schedule
+        // them to update.
+        propagateContextChange(workInProgress, context, renderLanes);
       }
-
-      return result;
-    } else if (
-      usable.$$typeof === REACT_CONTEXT_TYPE ||
-      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
-    ) {
-      var context = usable;
-      return readContext(context);
     }
-  } // eslint-disable-next-line react-internal/safe-string-coercion
+  }
 
-  throw new Error("An unsupported type was passed to use(): " + String(usable));
+  var newChildren = newProps.children;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function useMemoCache(size) {
-  var memoCache = null; // Fast-path, load memo cache from wip fiber if already prepared
-
-  var updateQueue = currentlyRenderingFiber$1.updateQueue;
-
-  if (updateQueue !== null) {
-    memoCache = updateQueue.memoCache;
-  } // Otherwise clone from the current fiber
-
-  if (memoCache == null) {
-    var current = currentlyRenderingFiber$1.alternate;
+var hasWarnedAboutUsingContextAsConsumer = false;
 
-    if (current !== null) {
-      var currentUpdateQueue = current.updateQueue;
+function updateContextConsumer(current, workInProgress, renderLanes) {
+  var context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
+  // DEV mode, we create a separate object for Context.Consumer that acts
+  // like a proxy to Context. This proxy object adds unnecessary code in PROD
+  // so we use the old behaviour (Context.Consumer references Context) to
+  // reduce size and overhead. The separate object references context via
+  // a property called "_context", which also gives us the ability to check
+  // in DEV mode if this property exists or not and warn if it does not.
 
-      if (currentUpdateQueue !== null) {
-        var currentMemoCache = currentUpdateQueue.memoCache;
+  {
+    if (context._context === undefined) {
+      // This may be because it's a Context (rather than a Consumer).
+      // Or it may be because it's older React where they're the same thing.
+      // We only want to warn if we're sure it's a new React.
+      if (context !== context.Consumer) {
+        if (!hasWarnedAboutUsingContextAsConsumer) {
+          hasWarnedAboutUsingContextAsConsumer = true;
 
-        if (currentMemoCache != null) {
-          memoCache = {
-            data: currentMemoCache.data.map(function (array) {
-              return array.slice();
-            }),
-            index: 0
-          };
+          error(
+            "Rendering <Context> directly is not supported and will be removed in " +
+              "a future major release. Did you mean to render <Context.Consumer> instead?"
+          );
         }
       }
+    } else {
+      context = context._context;
     }
-  } // Finally fall back to allocating a fresh instance of the cache
-
-  if (memoCache == null) {
-    memoCache = {
-      data: [],
-      index: 0
-    };
-  }
-
-  if (updateQueue === null) {
-    updateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = updateQueue;
   }
 
-  updateQueue.memoCache = memoCache;
-  var data = memoCache.data[memoCache.index];
-
-  if (data === undefined) {
-    data = memoCache.data[memoCache.index] = new Array(size);
+  var newProps = workInProgress.pendingProps;
+  var render = newProps.children;
 
-    for (var i = 0; i < size; i++) {
-      data[i] = REACT_MEMO_CACHE_SENTINEL;
-    }
-  } else if (data.length !== size) {
-    // TODO: consider warning or throwing here
-    {
+  {
+    if (typeof render !== "function") {
       error(
-        "Expected a constant size argument for each invocation of useMemoCache. " +
-          "The previous cache was allocated with size %s but size %s was requested.",
-        data.length,
-        size
+        "A context consumer was rendered with multiple children, or a child " +
+          "that isn't a function. A context consumer expects a single child " +
+          "that is a function. If you did pass a function, make sure there " +
+          "is no trailing or leading whitespace around it."
       );
     }
   }
 
-  memoCache.index++;
-  return data;
-}
+  prepareToReadContext(workInProgress, renderLanes);
+  var newValue = readContext(context);
 
-function basicStateReducer(state, action) {
-  // $FlowFixMe: Flow doesn't like mixed types
-  return typeof action === "function" ? action(state) : action;
-}
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
 
-function mountReducer(reducer, initialArg, init) {
-  var hook = mountWorkInProgressHook();
-  var initialState;
+  var newChildren;
 
-  if (init !== undefined) {
-    initialState = init(initialArg);
-  } else {
-    initialState = initialArg;
+  {
+    ReactCurrentOwner$1.current = workInProgress;
+    setIsRendering(true);
+    newChildren = render(newValue);
+    setIsRendering(false);
   }
 
-  hook.memoizedState = hook.baseState = initialState;
-  var queue = {
-    pending: null,
-    lanes: NoLanes,
-    dispatch: null,
-    lastRenderedReducer: reducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = queue;
-  var dispatch = (queue.dispatch = dispatchReducerAction.bind(
-    null,
-    currentlyRenderingFiber$1,
-    queue
-  ));
-  return [hook.memoizedState, dispatch];
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
+  workInProgress.flags |= PerformedWork;
+  reconcileChildren(current, workInProgress, newChildren, renderLanes);
+  return workInProgress.child;
 }
 
-function updateReducer(reducer, initialArg, init) {
-  var hook = updateWorkInProgressHook();
-  var queue = hook.queue;
+function updateScopeComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps;
+  var nextChildren = nextProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
 
-  if (queue === null) {
-    throw new Error(
-      "Should have a queue. This is likely a bug in React. Please file an issue."
-    );
+function markWorkInProgressReceivedUpdate() {
+  didReceiveUpdate = true;
+}
+function checkIfWorkInProgressReceivedUpdate() {
+  return didReceiveUpdate;
+}
+
+function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
+    if (current !== null) {
+      // A lazy component only mounts if it suspended inside a non-
+      // concurrent tree, in an inconsistent state. We want to treat it like
+      // a new mount, even though an empty version of it already committed.
+      // Disconnect the alternate pointers.
+      current.alternate = null;
+      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+
+      workInProgress.flags |= Placement;
+    }
   }
+}
 
-  queue.lastRenderedReducer = reducer;
-  var current = currentHook; // The last rebase update that is NOT part of the base state.
+function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+  if (current !== null) {
+    // Reuse previous dependencies
+    workInProgress.dependencies = current.dependencies;
+  }
 
-  var baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.
+  {
+    // Don't update "base" render times for bailouts.
+    stopProfilerTimerIfRunning();
+  }
 
-  var pendingQueue = queue.pending;
+  markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.
 
-  if (pendingQueue !== null) {
-    // We have new updates that haven't been processed yet.
-    // We'll add them to the base queue.
-    if (baseQueue !== null) {
-      // Merge the pending queue and the base queue.
-      var baseFirst = baseQueue.next;
-      var pendingFirst = pendingQueue.next;
-      baseQueue.next = pendingFirst;
-      pendingQueue.next = baseFirst;
-    }
+  if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+    // 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.
+    if (enableLazyContextPropagation && current !== null) {
+      // Before bailing out, check if there are any context changes in
+      // the children.
+      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
 
-    {
-      if (current.baseQueue !== baseQueue) {
-        // Internal invariant that should never happen, but feasibly could in
-        // the future if we implement resuming, or some form of that.
-        error(
-          "Internal error: Expected work-in-progress queue to be a clone. " +
-            "This is a bug in React."
-        );
+      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+        return null;
       }
+    } else {
+      return null;
     }
+  } // This fiber doesn't have work, but its subtree does. Clone the child
+  // fibers and continue.
 
-    current.baseQueue = baseQueue = pendingQueue;
-    queue.pending = null;
-  }
+  cloneChildFibers(current, workInProgress);
+  return workInProgress.child;
+}
 
-  if (baseQueue !== null) {
-    // We have a queue to process.
-    var first = baseQueue.next;
-    var newState = current.baseState;
-    var newBaseState = null;
-    var newBaseQueueFirst = null;
-    var newBaseQueueLast = null;
-    var update = first;
+function remountFiber(current, oldWorkInProgress, newWorkInProgress) {
+  {
+    var returnFiber = oldWorkInProgress.return;
 
-    do {
-      // An extra OffscreenLane bit is added to updates that were made to
-      // a hidden tree, so that we can distinguish them from updates that were
-      // already there when the tree was hidden.
-      var updateLane = removeLanes(update.lane, OffscreenLane);
-      var isHiddenUpdate = updateLane !== update.lane; // Check if this update was made while the tree was hidden. If so, then
-      // it's not a "base" update and we should disregard the extra base lanes
-      // that were added to renderLanes when we entered the Offscreen tree.
+    if (returnFiber === null) {
+      // eslint-disable-next-line react-internal/prod-error-codes
+      throw new Error("Cannot swap the root fiber.");
+    } // Disconnect from the old current.
+    // It will get deleted.
 
-      var shouldSkipUpdate = isHiddenUpdate
-        ? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)
-        : !isSubsetOfLanes(renderLanes$1, updateLane);
+    current.alternate = null;
+    oldWorkInProgress.alternate = null; // Connect to the new tree.
 
-      if (shouldSkipUpdate) {
-        // Priority is insufficient. Skip this update. If this is the first
-        // skipped update, the previous update/state is the new base
-        // update/state.
-        var clone = {
-          lane: updateLane,
-          action: update.action,
-          hasEagerState: update.hasEagerState,
-          eagerState: update.eagerState,
-          next: null
-        };
+    newWorkInProgress.index = oldWorkInProgress.index;
+    newWorkInProgress.sibling = oldWorkInProgress.sibling;
+    newWorkInProgress.return = oldWorkInProgress.return;
+    newWorkInProgress.ref = oldWorkInProgress.ref; // Replace the child/sibling pointers above it.
 
-        if (newBaseQueueLast === null) {
-          newBaseQueueFirst = newBaseQueueLast = clone;
-          newBaseState = newState;
-        } else {
-          newBaseQueueLast = newBaseQueueLast.next = clone;
-        } // Update the remaining priority in the queue.
-        // TODO: Don't need to accumulate this. Instead, we can remove
-        // renderLanes from the original lanes.
+    if (oldWorkInProgress === returnFiber.child) {
+      returnFiber.child = newWorkInProgress;
+    } else {
+      var prevSibling = returnFiber.child;
 
-        currentlyRenderingFiber$1.lanes = mergeLanes(
-          currentlyRenderingFiber$1.lanes,
-          updateLane
-        );
-        markSkippedUpdateLanes(updateLane);
-      } else {
-        // This update does have sufficient priority.
-        if (newBaseQueueLast !== null) {
-          var _clone = {
-            // This update is going to be committed so we never want uncommit
-            // it. Using NoLane works because 0 is a subset of all bitmasks, so
-            // this will never be skipped by the check above.
-            lane: NoLane,
-            action: update.action,
-            hasEagerState: update.hasEagerState,
-            eagerState: update.eagerState,
-            next: null
-          };
-          newBaseQueueLast = newBaseQueueLast.next = _clone;
-        } // Process this update.
+      if (prevSibling === null) {
+        // eslint-disable-next-line react-internal/prod-error-codes
+        throw new Error("Expected parent to have a child.");
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-        var action = update.action;
+      while (prevSibling.sibling !== oldWorkInProgress) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        prevSibling = prevSibling.sibling;
 
-        if (shouldDoubleInvokeUserFnsInHooksDEV) {
-          reducer(newState, action);
+        if (prevSibling === null) {
+          // eslint-disable-next-line react-internal/prod-error-codes
+          throw new Error("Expected to find the previous sibling.");
         }
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-        if (update.hasEagerState) {
-          // If this update is a state update (not a reducer) and was processed eagerly,
-          // we can use the eagerly computed state
-          newState = update.eagerState;
-        } else {
-          newState = reducer(newState, action);
-        }
-      }
+      prevSibling.sibling = newWorkInProgress;
+    } // Delete the old fiber and place the new one.
+    // Since the old fiber is disconnected, we have to schedule it manually.
 
-      update = update.next;
-    } while (update !== null && update !== first);
+    var deletions = returnFiber.deletions;
 
-    if (newBaseQueueLast === null) {
-      newBaseState = newState;
+    if (deletions === null) {
+      returnFiber.deletions = [current];
+      returnFiber.flags |= ChildDeletion;
     } else {
-      newBaseQueueLast.next = newBaseQueueFirst;
-    } // Mark that the fiber performed work, but only if the new state is
-    // different from the current state.
-
-    if (!objectIs(newState, hook.memoizedState)) {
-      markWorkInProgressReceivedUpdate();
+      deletions.push(current);
     }
 
-    hook.memoizedState = newState;
-    hook.baseState = newBaseState;
-    hook.baseQueue = newBaseQueueLast;
-    queue.lastRenderedState = newState;
-  }
+    newWorkInProgress.flags |= Placement; // Restart work from the new fiber.
 
-  if (baseQueue === null) {
-    // `queue.lanes` is used for entangling transitions. We can set it back to
-    // zero once the queue is empty.
-    queue.lanes = NoLanes;
+    return newWorkInProgress;
   }
-
-  var dispatch = queue.dispatch;
-  return [hook.memoizedState, dispatch];
 }
 
-function rerenderReducer(reducer, initialArg, init) {
-  var hook = updateWorkInProgressHook();
-  var queue = hook.queue;
-
-  if (queue === null) {
-    throw new Error(
-      "Should have a queue. This is likely a bug in React. Please file an issue."
-    );
-  }
-
-  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous
-  // work-in-progress hook.
-
-  var dispatch = queue.dispatch;
-  var lastRenderPhaseUpdate = queue.pending;
-  var newState = hook.memoizedState;
-
-  if (lastRenderPhaseUpdate !== null) {
-    // The queue doesn't persist past this render pass.
-    queue.pending = null;
-    var firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;
-    var update = firstRenderPhaseUpdate;
-
-    do {
-      // Process this render phase update. We don't have to check the
-      // priority because it will always be the same as the current
-      // render's.
-      var action = update.action;
-      newState = reducer(newState, action);
-      update = update.next;
-    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is
-    // different from the current state.
+function checkScheduledUpdateOrContext(current, renderLanes) {
+  // Before performing an early bailout, we must check if there are pending
+  // updates or context.
+  var updateLanes = current.lanes;
 
-    if (!objectIs(newState, hook.memoizedState)) {
-      markWorkInProgressReceivedUpdate();
-    }
+  if (includesSomeLane(updateLanes, renderLanes)) {
+    return true;
+  } // No pending update, but because context is propagated lazily, we need
+  // to check for a context change before we bail out.
 
-    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to
-    // the base state unless the queue is empty.
-    // TODO: Not sure if this is the desired semantics, but it's what we
-    // do for gDSFP. I can't remember why.
+  if (enableLazyContextPropagation) {
+    var dependencies = current.dependencies;
 
-    if (hook.baseQueue === null) {
-      hook.baseState = newState;
+    if (dependencies !== null && checkIfContextChanged(dependencies)) {
+      return true;
     }
-
-    queue.lastRenderedState = newState;
   }
 
-  return [newState, dispatch];
+  return false;
 }
 
-function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
-  {
-    warnAboutMultipleRenderersDEV(source);
-  }
+function attemptEarlyBailoutIfNoScheduledUpdate(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  // 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);
+      pushRootTransition(workInProgress);
 
-  var getVersion = source._getVersion;
-  var version = getVersion(source._source); // Is it safe for this component to read from this source during the current render?
+      if (enableTransitionTracing) {
+        pushRootMarkerInstance(workInProgress);
+      }
 
-  var isSafeToReadFromSource = false; // Check the version first.
-  // If this render has already been started with a specific version,
-  // we can use it alone to determine if we can safely read from the source.
+      {
+        var cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, cache);
+      }
 
-  var currentRenderVersion = getWorkInProgressVersion(source);
+      resetHydrationState();
+      break;
 
-  if (currentRenderVersion !== null) {
-    // It's safe to read if the store hasn't been mutated since the last time
-    // we read something.
-    isSafeToReadFromSource = currentRenderVersion === version;
-  } else {
-    // If there's no version, then this is the first time we've read from the
-    // source during the current render pass, so we need to do a bit more work.
-    // What we need to determine is if there are any hooks that already
-    // subscribed to the source, and if so, whether there are any pending
-    // mutations that haven't been synchronized yet.
-    //
-    // If there are no pending mutations, then `root.mutableReadLanes` will be
-    // empty, and we know we can safely read.
-    //
-    // If there *are* pending mutations, we may still be able to safely read
-    // if the currently rendering lanes are inclusive of the pending mutation
-    // lanes, since that guarantees that the value we're about to read from
-    // the source is consistent with the values that we read during the most
-    // recent mutation.
-    isSafeToReadFromSource = isSubsetOfLanes(
-      renderLanes$1,
-      root.mutableReadLanes
-    );
+    case HostSingleton:
+    case HostComponent:
+      pushHostContext(workInProgress);
+      break;
 
-    if (isSafeToReadFromSource) {
-      // If it's safe to read from this source during the current render,
-      // store the version in case other components read from it.
-      // A changed version number will let those components know to throw and restart the render.
-      setWorkInProgressVersion(source, version);
+    case ClassComponent: {
+      break;
     }
-  }
 
-  if (isSafeToReadFromSource) {
-    var snapshot = getSnapshot(source._source);
+    case HostPortal:
+      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+      break;
 
-    {
-      if (typeof snapshot === "function") {
-        error(
-          "Mutable source should not return a function as the snapshot value. " +
-            "Functions may close over mutable values and cause tearing."
-        );
-      }
+    case ContextProvider: {
+      var newValue = workInProgress.memoizedProps.value;
+      var context = workInProgress.type._context;
+      pushProvider(workInProgress, context, newValue);
+      break;
     }
 
-    return snapshot;
-  } else {
-    // This handles the special case of a mutable source being shared between renderers.
-    // In that case, if the source is mutated between the first and second renderer,
-    // The second renderer don't know that it needs to reset the WIP version during unwind,
-    // (because the hook only marks sources as dirty if it's written to their WIP version).
-    // That would cause this tear check to throw again and eventually be visible to the user.
-    // We can avoid this infinite loop by explicitly marking the source as dirty.
-    //
-    // This can lead to tearing in the first renderer when it resumes,
-    // but there's nothing we can do about that (short of throwing here and refusing to continue the render).
-    markSourceAsDirty(source); // Intentioally throw an error to force React to retry synchronously. During
-    // the synchronous retry, it will block interleaved mutations, so we should
-    // get a consistent read. Therefore, the following error should never be
-    // visible to the user.
-    // We expect this error not to be thrown during the synchronous retry,
-    // because we blocked interleaved mutations.
-
-    throw new Error(
-      "Cannot read from mutable source during the current render without tearing. This may be a bug in React. Please file an issue."
-    );
-  }
-}
+    case Profiler:
+      {
+        // Profiler should only call onRender when one of its descendants actually rendered.
+        var hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
 
-function useMutableSource(hook, source, getSnapshot, subscribe) {
-  var root = getWorkInProgressRoot();
+        if (hasChildWork) {
+          workInProgress.flags |= Update;
+        }
 
-  if (root === null) {
-    throw new Error(
-      "Expected a work-in-progress root. This is a bug in React. Please file an issue."
-    );
-  }
+        {
+          // Reset effect durations for the next eventual effect phase.
+          // These are reset during render to allow the DevTools commit hook a chance to read them,
+          var stateNode = workInProgress.stateNode;
+          stateNode.effectDuration = 0;
+          stateNode.passiveEffectDuration = 0;
+        }
+      }
 
-  var getVersion = source._getVersion;
-  var version = getVersion(source._source);
-  var dispatcher = ReactCurrentDispatcher$1.current; // eslint-disable-next-line prefer-const
+      break;
 
-  var _dispatcher$useState = dispatcher.useState(function () {
-      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    }),
-    currentSnapshot = _dispatcher$useState[0],
-    setSnapshot = _dispatcher$useState[1];
+    case SuspenseComponent: {
+      var state = workInProgress.memoizedState;
 
-  var snapshot = currentSnapshot; // Grab a handle to the state hook as well.
-  // We use it to clear the pending update queue if we have a new source.
+      if (state !== null) {
+        if (state.dehydrated !== null) {
+          // We're not going to render the children, so this is just to maintain
+          // push/pop symmetry
+          pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
+          // been unsuspended it has committed as a resolved Suspense component.
+          // If it needs to be retried, it should have work scheduled on it.
 
-  var stateHook = workInProgressHook;
-  var memoizedState = hook.memoizedState;
-  var refs = memoizedState.refs;
-  var prevGetSnapshot = refs.getSnapshot;
-  var prevSource = memoizedState.source;
-  var prevSubscribe = memoizedState.subscribe;
-  var fiber = currentlyRenderingFiber$1;
-  hook.memoizedState = {
-    refs: refs,
-    source: source,
-    subscribe: subscribe
-  }; // Sync the values needed by our subscription handler after each commit.
+          workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
+          // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
 
-  dispatcher.useEffect(
-    function () {
-      refs.getSnapshot = getSnapshot; // Normally the dispatch function for a state hook never changes,
-      // but this hook recreates the queue in certain cases  to avoid updates from stale sources.
-      // handleChange() below needs to reference the dispatch function without re-subscribing,
-      // so we use a ref to ensure that it always has the latest version.
+          return null;
+        } // If this boundary is currently timed out, we need to decide
+        // whether to retry the primary children, or to skip over it and
+        // go straight to the fallback. Check the priority of the primary
+        // child fragment.
 
-      refs.setSnapshot = setSnapshot; // Check for a possible change between when we last rendered now.
+        var primaryChildFragment = workInProgress.child;
+        var primaryChildLanes = primaryChildFragment.childLanes;
 
-      var maybeNewVersion = getVersion(source._source);
+        if (includesSomeLane(renderLanes, primaryChildLanes)) {
+          // The primary children have pending work. Use the normal path
+          // to attempt to render the primary children again.
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        } else {
+          // The primary child fragment does not have pending work marked
+          // on it
+          pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
+          // priority. Bailout.
 
-      if (!objectIs(version, maybeNewVersion)) {
-        var maybeNewSnapshot = getSnapshot(source._source);
+          var child = bailoutOnAlreadyFinishedWork(
+            current,
+            workInProgress,
+            renderLanes
+          );
 
-        {
-          if (typeof maybeNewSnapshot === "function") {
-            error(
-              "Mutable source should not return a function as the snapshot value. " +
-                "Functions may close over mutable values and cause tearing."
-            );
+          if (child !== null) {
+            // The fallback children have pending work. Skip over the
+            // primary children and work on the fallback.
+            return child.sibling;
+          } else {
+            // Note: We can return `null` here because we already checked
+            // whether there were nested context consumers, via the call to
+            // `bailoutOnAlreadyFinishedWork` above.
+            return null;
           }
         }
-
-        if (!objectIs(snapshot, maybeNewSnapshot)) {
-          setSnapshot(maybeNewSnapshot);
-          var lane = requestUpdateLane(fiber);
-          markRootMutableRead(root, lane);
-        } // If the source mutated between render and now,
-        // there may be state updates already scheduled from the old source.
-        // Entangle the updates so that they render in the same batch.
-
-        markRootEntangled(root, root.mutableReadLanes);
+      } else {
+        pushPrimaryTreeSuspenseHandler(workInProgress);
       }
-    },
-    [getSnapshot, source, subscribe]
-  ); // If we got a new source or subscribe function, re-subscribe in a passive effect.
-
-  dispatcher.useEffect(
-    function () {
-      var handleChange = function () {
-        var latestGetSnapshot = refs.getSnapshot;
-        var latestSetSnapshot = refs.setSnapshot;
 
-        try {
-          latestSetSnapshot(latestGetSnapshot(source._source)); // Record a pending mutable source update with the same expiration time.
+      break;
+    }
 
-          var lane = requestUpdateLane(fiber);
-          markRootMutableRead(root, lane);
-        } catch (error) {
-          // A selector might throw after a source mutation.
-          // e.g. it might try to read from a part of the store that no longer exists.
-          // In this case we should still schedule an update with React.
-          // Worst case the selector will throw again and then an error boundary will handle it.
-          latestSetSnapshot(function () {
-            throw error;
-          });
-        }
-      };
+    case SuspenseListComponent: {
+      var didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
 
-      var unsubscribe = subscribe(source._source, handleChange);
+      var _hasChildWork = includesSomeLane(
+        renderLanes,
+        workInProgress.childLanes
+      );
 
-      {
-        if (typeof unsubscribe !== "function") {
-          error(
-            "Mutable source subscribe function must return an unsubscribe function."
-          );
-        }
+      if (enableLazyContextPropagation && !_hasChildWork) {
+        // Context changes may not have been propagated yet. We need to do
+        // that now, before we can decide whether to bail out.
+        // TODO: We use `childLanes` as a heuristic for whether there is
+        // remaining work in a few places, including
+        // `bailoutOnAlreadyFinishedWork` and
+        // `updateDehydratedSuspenseComponent`. We should maybe extract this
+        // into a dedicated function.
+        lazilyPropagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes
+        );
+        _hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
       }
 
-      return unsubscribe;
-    },
-    [source, subscribe]
-  ); // If any of the inputs to useMutableSource change, reading is potentially unsafe.
-  //
-  // If either the source or the subscription have changed we can't can't trust the update queue.
-  // Maybe the source changed in a way that the old subscription ignored but the new one depends on.
-  //
-  // If the getSnapshot function changed, we also shouldn't rely on the update queue.
-  // It's possible that the underlying source was mutated between the when the last "change" event fired,
-  // and when the current render (with the new getSnapshot function) is processed.
-  //
-  // In both cases, we need to throw away pending updates (since they are no longer relevant)
-  // and treat reading from the source as we do in the mount case.
-
-  if (
-    !objectIs(prevGetSnapshot, getSnapshot) ||
-    !objectIs(prevSource, source) ||
-    !objectIs(prevSubscribe, subscribe)
-  ) {
-    // Create a new queue and setState method,
-    // So if there are interleaved updates, they get pushed to the older queue.
-    // When this becomes current, the previous queue and dispatch method will be discarded,
-    // including any interleaving updates that occur.
-    var newQueue = {
-      pending: null,
-      lanes: NoLanes,
-      dispatch: null,
-      lastRenderedReducer: basicStateReducer,
-      lastRenderedState: snapshot
-    };
-    newQueue.dispatch = setSnapshot = dispatchSetState.bind(
-      null,
-      currentlyRenderingFiber$1,
-      newQueue
-    );
-    stateHook.queue = newQueue;
-    stateHook.baseQueue = null;
-    snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    stateHook.memoizedState = stateHook.baseState = snapshot;
-  }
+      if (didSuspendBefore) {
+        if (_hasChildWork) {
+          // If something was in fallback state last time, and we have all the
+          // same children then we're still in progressive loading state.
+          // Something might get unblocked by state updates or retries in the
+          // tree which will affect the tail. So we need to use the normal
+          // path to compute the correct tail.
+          return updateSuspenseListComponent(
+            current,
+            workInProgress,
+            renderLanes
+          );
+        } // If none of the children had any work, that means that none of
+        // them got retried so they'll still be blocked in the same way
+        // as before. We can fast bail out.
 
-  return snapshot;
-}
+        workInProgress.flags |= DidCapture;
+      } // If nothing suspended before and we're rendering the same children,
+      // then the tail doesn't matter. Anything new that suspends will work
+      // in the "together" mode, so we can continue from the state we had.
 
-function mountMutableSource(source, getSnapshot, subscribe) {
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = {
-    refs: {
-      getSnapshot: getSnapshot,
-      setSnapshot: null
-    },
-    source: source,
-    subscribe: subscribe
-  };
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
+      var renderState = workInProgress.memoizedState;
 
-function updateMutableSource(source, getSnapshot, subscribe) {
-  var hook = updateWorkInProgressHook();
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
+      if (renderState !== null) {
+        // Reset to the "together" mode in case we've started a different
+        // update in the past but didn't complete it.
+        renderState.rendering = null;
+        renderState.tail = null;
+        renderState.lastEffect = null;
+      }
 
-function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-  var fiber = currentlyRenderingFiber$1;
-  var hook = mountWorkInProgressHook();
-  var nextSnapshot;
-  var isHydrating = getIsHydrating();
+      pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
 
-  if (isHydrating) {
-    if (getServerSnapshot === undefined) {
-      throw new Error(
-        "Missing getServerSnapshot, which is required for " +
-          "server-rendered content. Will revert to client rendering."
-      );
+      if (_hasChildWork) {
+        break;
+      } else {
+        // If none of the children had any work, that means that none of
+        // them got retried so they'll still be blocked in the same way
+        // as before. We can fast bail out.
+        return null;
+      }
     }
 
-    nextSnapshot = getServerSnapshot();
-
-    {
-      if (!didWarnUncachedGetSnapshot) {
-        if (nextSnapshot !== getServerSnapshot()) {
-          error(
-            "The result of getServerSnapshot should be cached to avoid an infinite loop"
-          );
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      // Need to check if the tree still needs to be deferred. This is
+      // almost identical to the logic used in the normal update path,
+      // so we'll just enter that. The only difference is we'll bail out
+      // at the next level instead of this one, because the child props
+      // have not changed. Which is fine.
+      // TODO: Probably should refactor `beginWork` to split the bailout
+      // path from the normal path. I'm tempted to do a labeled break here
+      // but I won't :)
+      workInProgress.lanes = NoLanes;
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    }
 
-          didWarnUncachedGetSnapshot = true;
-        }
+    case CacheComponent: {
+      {
+        var _cache = current.memoizedState.cache;
+        pushCacheProvider(workInProgress, _cache);
       }
-    }
-  } else {
-    nextSnapshot = getSnapshot();
 
-    {
-      if (!didWarnUncachedGetSnapshot) {
-        var cachedSnapshot = getSnapshot();
+      break;
+    }
 
-        if (!objectIs(nextSnapshot, cachedSnapshot)) {
-          error(
-            "The result of getSnapshot should be cached to avoid an infinite loop"
-          );
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var instance = workInProgress.stateNode;
 
-          didWarnUncachedGetSnapshot = true;
+        if (instance !== null) {
+          pushMarkerInstance(workInProgress, instance);
         }
       }
-    } // Unless we're rendering a blocking lane, schedule a consistency check.
-    // Right before committing, we will walk the tree and check if any of the
-    // stores were mutated.
-    //
-    // We won't do this if we're hydrating server-rendered content, because if
-    // the content is stale, it's already visible anyway. Instead we'll patch
-    // it up in a passive effect.
-
-    var root = getWorkInProgressRoot();
-
-    if (root === null) {
-      throw new Error(
-        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
-      );
-    }
-
-    if (!includesBlockingLane(root, renderLanes$1)) {
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
     }
-  } // Read the current snapshot from the store on every render. This breaks the
-  // normal rules of React, and only works because store updates are
-  // always synchronous.
-
-  hook.memoizedState = nextSnapshot;
-  var inst = {
-    value: nextSnapshot,
-    getSnapshot: getSnapshot
-  };
-  hook.queue = inst; // Schedule an effect to subscribe to the store.
-
-  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update
-  // this whenever subscribe, getSnapshot, or value changes. Because there's no
-  // clean-up function, and we track the deps correctly, we can call pushEffect
-  // directly, without storing any additional state. For the same reason, we
-  // don't need to set a static flag, either.
-  // TODO: We can move this to the passive phase once we add a pre-commit
-  // consistency check. See the next comment.
+  }
 
-  fiber.flags |= Passive$1;
-  pushEffect(
-    HasEffect | Passive,
-    updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
-    undefined,
-    null
-  );
-  return nextSnapshot;
+  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
 }
 
-function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-  var fiber = currentlyRenderingFiber$1;
-  var hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the
-  // normal rules of React, and only works because store updates are
-  // always synchronous.
+function beginWork$1(current, workInProgress, renderLanes) {
+  {
+    if (workInProgress._debugNeedsRemount && current !== null) {
+      // This will restart the begin phase with a new fiber.
+      return remountFiber(
+        current,
+        workInProgress,
+        createFiberFromTypeAndProps(
+          workInProgress.type,
+          workInProgress.key,
+          workInProgress.pendingProps,
+          workInProgress._debugOwner || null,
+          workInProgress.mode,
+          workInProgress.lanes
+        )
+      );
+    }
+  }
 
-  var nextSnapshot = getSnapshot();
+  if (current !== null) {
+    var oldProps = current.memoizedProps;
+    var newProps = workInProgress.pendingProps;
 
-  {
-    if (!didWarnUncachedGetSnapshot) {
-      var cachedSnapshot = getSnapshot();
+    if (
+      oldProps !== newProps ||
+      hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
+      workInProgress.type !== current.type
+    ) {
+      // If props or context changed, mark the fiber as having performed work.
+      // This may be unset if the props are determined to be equal later (memo).
+      didReceiveUpdate = true;
+    } else {
+      // Neither props nor legacy context changes. Check if there's a pending
+      // update or context change.
+      var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
+        current,
+        renderLanes
+      );
 
-      if (!objectIs(nextSnapshot, cachedSnapshot)) {
-        error(
-          "The result of getSnapshot should be cached to avoid an infinite loop"
+      if (
+        !hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
+        // may not be work scheduled on `current`, so we check for this flag.
+        (workInProgress.flags & DidCapture) === NoFlags$1
+      ) {
+        // No pending updates or context. Bail out now.
+        didReceiveUpdate = false;
+        return attemptEarlyBailoutIfNoScheduledUpdate(
+          current,
+          workInProgress,
+          renderLanes
         );
+      }
 
-        didWarnUncachedGetSnapshot = true;
+      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
+        // This is a special case that only exists for legacy mode.
+        // See https://github.com/facebook/react/pull/19216.
+        didReceiveUpdate = true;
+      } else {
+        // An update was scheduled on this fiber, but there are no new props
+        // nor legacy context. Set this to false. If an update queue or context
+        // consumer produces a changed value, it will set this to true. Otherwise,
+        // the component will assume the children have not changed and bail out.
+        didReceiveUpdate = false;
       }
     }
-  }
-
-  var prevSnapshot = (currentHook || hook).memoizedState;
-  var snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);
-
-  if (snapshotChanged) {
-    hook.memoizedState = nextSnapshot;
-    markWorkInProgressReceivedUpdate();
-  }
-
-  var inst = hook.queue;
-  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [
-    subscribe
-  ]); // Whenever getSnapshot or subscribe changes, we need to check in the
-  // commit phase if there was an interleaved mutation. In concurrent mode
-  // this can happen all the time, but even in synchronous mode, an earlier
-  // effect may have mutated the store.
+  } else {
+    didReceiveUpdate = false;
 
-  if (
-    inst.getSnapshot !== getSnapshot ||
-    snapshotChanged || // Check if the susbcribe function changed. We can save some memory by
-    // checking whether we scheduled a subscription effect above.
-    (workInProgressHook !== null &&
-      workInProgressHook.memoizedState.tag & HasEffect)
-  ) {
-    fiber.flags |= Passive$1;
-    pushEffect(
-      HasEffect | Passive,
-      updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot),
-      undefined,
-      null
-    ); // Unless we're rendering a blocking lane, schedule a consistency check.
-    // Right before committing, we will walk the tree and check if any of the
-    // stores were mutated.
+    if (getIsHydrating() && isForkedChild(workInProgress)) {
+      // Check if this child belongs to a list of muliple children in
+      // its parent.
+      //
+      // In a true multi-threaded implementation, we would render children on
+      // parallel threads. This would represent the beginning of a new render
+      // thread for this subtree.
+      //
+      // We only use this for id generation during hydration, which is why the
+      // logic is located in this special branch.
+      var slotIndex = workInProgress.index;
+      var numberOfForks = getForksAtLevel();
+      pushTreeId(workInProgress, numberOfForks, slotIndex);
+    }
+  } // Before entering the begin phase, clear pending update priority.
+  // TODO: This assumes that we're about to evaluate the component and process
+  // the update queue. However, there's an exception: SimpleMemoComponent
+  // sometimes bails out later in the begin phase. This indicates that we should
+  // move this assignment out of the common path and into each branch.
 
-    var root = getWorkInProgressRoot();
+  workInProgress.lanes = NoLanes;
 
-    if (root === null) {
-      throw new Error(
-        "Expected a work-in-progress root. This is a bug in React. Please file an issue."
+  switch (workInProgress.tag) {
+    case IndeterminateComponent: {
+      return mountIndeterminateComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        renderLanes
       );
     }
 
-    if (!includesBlockingLane(root, renderLanes$1)) {
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    case LazyComponent: {
+      var elementType = workInProgress.elementType;
+      return mountLazyComponent(
+        current,
+        workInProgress,
+        elementType,
+        renderLanes
+      );
     }
-  }
 
-  return nextSnapshot;
-}
+    case FunctionComponent: {
+      var Component = workInProgress.type;
+      var unresolvedProps = workInProgress.pendingProps;
+      var resolvedProps =
+        workInProgress.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      return updateFunctionComponent(
+        current,
+        workInProgress,
+        Component,
+        resolvedProps,
+        renderLanes
+      );
+    }
 
-function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
-  fiber.flags |= StoreConsistency;
-  var check = {
-    getSnapshot: getSnapshot,
-    value: renderedSnapshot
-  };
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+    case ClassComponent: {
+      var _Component = workInProgress.type;
+      var _unresolvedProps = workInProgress.pendingProps;
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.stores = [check];
-  } else {
-    var stores = componentUpdateQueue.stores;
+      var _resolvedProps =
+        workInProgress.elementType === _Component
+          ? _unresolvedProps
+          : resolveDefaultProps(_Component, _unresolvedProps);
 
-    if (stores === null) {
-      componentUpdateQueue.stores = [check];
-    } else {
-      stores.push(check);
+      return updateClassComponent(
+        current,
+        workInProgress,
+        _Component,
+        _resolvedProps,
+        renderLanes
+      );
     }
-  }
-}
 
-function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
-  // These are updated in the passive phase
-  inst.value = nextSnapshot;
-  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could
-  // have been in an event that fired before the passive effects, or it could
-  // have been in a layout effect. In that case, we would have used the old
-  // snapsho and getSnapshot values to bail out. We need to check one more time.
+    case HostRoot:
+      return updateHostRoot(current, workInProgress, renderLanes);
 
-  if (checkIfSnapshotChanged(inst)) {
-    // Force a re-render.
-    forceStoreRerender(fiber);
-  }
-}
+    case HostHoistable: {
+      return updateHostHoistable(current, workInProgress);
+    }
 
-function subscribeToStore(fiber, inst, subscribe) {
-  var handleStoreChange = function () {
-    // The store changed. Check if the snapshot changed since the last time we
-    // read from the store.
-    if (checkIfSnapshotChanged(inst)) {
-      // Force a re-render.
-      forceStoreRerender(fiber);
+    // eslint-disable-next-line no-fallthrough
+
+    case HostSingleton: {
+      return updateHostSingleton(current, workInProgress, renderLanes);
     }
-  }; // Subscribe to the store and return a clean-up function.
 
-  return subscribe(handleStoreChange);
-}
+    // eslint-disable-next-line no-fallthrough
 
-function checkIfSnapshotChanged(inst) {
-  var latestGetSnapshot = inst.getSnapshot;
-  var prevValue = inst.value;
+    case HostComponent:
+      return updateHostComponent$1(current, workInProgress, renderLanes);
 
-  try {
-    var nextValue = latestGetSnapshot();
-    return !objectIs(prevValue, nextValue);
-  } catch (error) {
-    return true;
-  }
-}
+    case HostText:
+      return updateHostText$1(current, workInProgress);
 
-function forceStoreRerender(fiber) {
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    case SuspenseComponent:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
 
-  if (root !== null) {
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-  }
-}
-
-function mountState(initialState) {
-  var hook = mountWorkInProgressHook();
-
-  if (typeof initialState === "function") {
-    // $FlowFixMe: Flow doesn't like mixed types
-    initialState = initialState();
-  }
-
-  hook.memoizedState = hook.baseState = initialState;
-  var queue = {
-    pending: null,
-    lanes: NoLanes,
-    dispatch: null,
-    lastRenderedReducer: basicStateReducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = queue;
-  var dispatch = (queue.dispatch = dispatchSetState.bind(
-    null,
-    currentlyRenderingFiber$1,
-    queue
-  ));
-  return [hook.memoizedState, dispatch];
-}
-
-function updateState(initialState) {
-  return updateReducer(basicStateReducer);
-}
-
-function rerenderState(initialState) {
-  return rerenderReducer(basicStateReducer);
-}
+    case HostPortal:
+      return updatePortalComponent(current, workInProgress, renderLanes);
 
-function pushEffect(tag, create, destroy, deps) {
-  var effect = {
-    tag: tag,
-    create: create,
-    destroy: destroy,
-    deps: deps,
-    // Circular
-    next: null
-  };
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+    case ForwardRef: {
+      var type = workInProgress.type;
+      var _unresolvedProps2 = workInProgress.pendingProps;
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.lastEffect = effect.next = effect;
-  } else {
-    var lastEffect = componentUpdateQueue.lastEffect;
+      var _resolvedProps2 =
+        workInProgress.elementType === type
+          ? _unresolvedProps2
+          : resolveDefaultProps(type, _unresolvedProps2);
 
-    if (lastEffect === null) {
-      componentUpdateQueue.lastEffect = effect.next = effect;
-    } else {
-      var firstEffect = lastEffect.next;
-      lastEffect.next = effect;
-      effect.next = firstEffect;
-      componentUpdateQueue.lastEffect = effect;
+      return updateForwardRef(
+        current,
+        workInProgress,
+        type,
+        _resolvedProps2,
+        renderLanes
+      );
     }
-  }
-
-  return effect;
-}
-
-var stackContainsErrorMessage = null;
-
-function getCallerStackFrame() {
-  // eslint-disable-next-line react-internal/prod-error-codes
-  var stackFrames = new Error("Error message").stack.split("\n"); // Some browsers (e.g. Chrome) include the error message in the stack
-  // but others (e.g. Firefox) do not.
 
-  if (stackContainsErrorMessage === null) {
-    stackContainsErrorMessage = stackFrames[0].includes("Error message");
-  }
+    case Fragment:
+      return updateFragment(current, workInProgress, renderLanes);
 
-  return stackContainsErrorMessage
-    ? stackFrames.slice(3, 4).join("\n")
-    : stackFrames.slice(2, 3).join("\n");
-}
+    case Mode:
+      return updateMode(current, workInProgress, renderLanes);
 
-function mountRef(initialValue) {
-  var hook = mountWorkInProgressHook();
+    case Profiler:
+      return updateProfiler(current, workInProgress, renderLanes);
 
-  if (enableUseRefAccessWarning) {
-    {
-      // Support lazy initialization pattern shown in docs.
-      // We need to store the caller stack frame so that we don't warn on subsequent renders.
-      var hasBeenInitialized = initialValue != null;
-      var lazyInitGetterStack = null;
-      var didCheckForLazyInit = false; // Only warn once per component+hook.
+    case ContextProvider:
+      return updateContextProvider(current, workInProgress, renderLanes);
 
-      var didWarnAboutRead = false;
-      var didWarnAboutWrite = false;
-      var current = initialValue;
-      var ref = {
-        get current() {
-          if (!hasBeenInitialized) {
-            didCheckForLazyInit = true;
-            lazyInitGetterStack = getCallerStackFrame();
-          } else if (currentlyRenderingFiber$1 !== null && !didWarnAboutRead) {
-            if (
-              lazyInitGetterStack === null ||
-              lazyInitGetterStack !== getCallerStackFrame()
-            ) {
-              didWarnAboutRead = true;
+    case ContextConsumer:
+      return updateContextConsumer(current, workInProgress, renderLanes);
 
-              warn(
-                "%s: Unsafe read of a mutable value during render.\n\n" +
-                  "Reading from a ref during render is only safe if:\n" +
-                  "1. The ref value has not been updated, or\n" +
-                  "2. The ref holds a lazily-initialized value that is only set once.\n",
-                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
-                  "Unknown"
-              );
-            }
-          }
+    case MemoComponent: {
+      var _type2 = workInProgress.type;
+      var _unresolvedProps3 = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
 
-          return current;
-        },
+      var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
 
-        set current(value) {
-          if (currentlyRenderingFiber$1 !== null && !didWarnAboutWrite) {
-            if (hasBeenInitialized || !didCheckForLazyInit) {
-              didWarnAboutWrite = true;
+      {
+        if (workInProgress.type !== workInProgress.elementType) {
+          var outerPropTypes = _type2.propTypes;
 
-              warn(
-                "%s: Unsafe write of a mutable value during render.\n\n" +
-                  "Writing to a ref during render is only safe if the ref holds " +
-                  "a lazily-initialized value that is only set once.\n",
-                getComponentNameFromFiber(currentlyRenderingFiber$1) ||
-                  "Unknown"
-              );
-            }
+          if (outerPropTypes) {
+            checkPropTypes(
+              outerPropTypes,
+              _resolvedProps3, // Resolved for outer only
+              "prop",
+              getComponentNameFromType(_type2)
+            );
           }
-
-          hasBeenInitialized = true;
-          current = value;
         }
-      };
-      Object.seal(ref);
-      hook.memoizedState = ref;
-      return ref;
+      }
+
+      _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
+      return updateMemoComponent(
+        current,
+        workInProgress,
+        _type2,
+        _resolvedProps3,
+        renderLanes
+      );
     }
-  } else {
-    var _ref2 = {
-      current: initialValue
-    };
-    hook.memoizedState = _ref2;
-    return _ref2;
-  }
-}
 
-function updateRef(initialValue) {
-  var hook = updateWorkInProgressHook();
-  return hook.memoizedState;
-}
+    case SimpleMemoComponent: {
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        workInProgress.pendingProps,
+        renderLanes
+      );
+    }
 
-function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    HasEffect | hookFlags,
-    create,
-    undefined,
-    nextDeps
-  );
-}
+    case IncompleteClassComponent: {
+      var _Component2 = workInProgress.type;
+      var _unresolvedProps4 = workInProgress.pendingProps;
 
-function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var destroy = undefined; // currentHook is null when rerendering after a render phase state update.
+      var _resolvedProps4 =
+        workInProgress.elementType === _Component2
+          ? _unresolvedProps4
+          : resolveDefaultProps(_Component2, _unresolvedProps4);
 
-  if (currentHook !== null) {
-    var prevEffect = currentHook.memoizedState;
-    destroy = prevEffect.destroy;
+      return mountIncompleteClassComponent(
+        current,
+        workInProgress,
+        _Component2,
+        _resolvedProps4,
+        renderLanes
+      );
+    }
 
-    if (nextDeps !== null) {
-      var prevDeps = prevEffect.deps;
+    case SuspenseListComponent: {
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    }
 
-      if (areHookInputsEqual(nextDeps, prevDeps)) {
-        hook.memoizedState = pushEffect(hookFlags, create, destroy, nextDeps);
-        return;
+    case ScopeComponent: {
+      {
+        return updateScopeComponent(current, workInProgress, renderLanes);
       }
     }
-  }
-
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    HasEffect | hookFlags,
-    create,
-    destroy,
-    nextDeps
-  );
-}
 
-function mountEffect(create, deps) {
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    mountEffectImpl(
-      MountPassiveDev | Passive$1 | PassiveStatic,
-      Passive,
-      create,
-      deps
-    );
-  } else {
-    mountEffectImpl(Passive$1 | PassiveStatic, Passive, create, deps);
-  }
-}
-
-function updateEffect(create, deps) {
-  updateEffectImpl(Passive$1, Passive, create, deps);
-}
-
-function useEffectEventImpl(payload) {
-  currentlyRenderingFiber$1.flags |= Update;
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+    case OffscreenComponent: {
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    }
 
-  if (componentUpdateQueue === null) {
-    componentUpdateQueue = createFunctionComponentUpdateQueue();
-    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
-    componentUpdateQueue.events = [payload];
-  } else {
-    var events = componentUpdateQueue.events;
+    case LegacyHiddenComponent: {
+      {
+        return updateLegacyHiddenComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
+    }
 
-    if (events === null) {
-      componentUpdateQueue.events = [payload];
-    } else {
-      events.push(payload);
+    case CacheComponent: {
+      {
+        return updateCacheComponent(current, workInProgress, renderLanes);
+      }
     }
-  }
-}
 
-function mountEvent(callback) {
-  var hook = mountWorkInProgressHook();
-  var ref = {
-    impl: callback
-  };
-  hook.memoizedState = ref; // $FlowIgnore[incompatible-return]
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        return updateTracingMarkerComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
 
-  return function eventFn() {
-    if (isInvalidExecutionContextForEventFunction()) {
-      throw new Error(
-        "A function wrapped in useEffectEvent can't be called during rendering."
-      );
+      break;
     }
+  }
 
-    return ref.impl.apply(undefined, arguments);
-  };
+  throw new Error(
+    "Unknown unit of work tag (" +
+      workInProgress.tag +
+      "). This error is likely caused by a bug in " +
+      "React. Please file an issue."
+  );
 }
 
-function updateEvent(callback) {
-  var hook = updateWorkInProgressHook();
-  var ref = hook.memoizedState;
-  useEffectEventImpl({
-    ref: ref,
-    nextImpl: callback
-  }); // $FlowIgnore[incompatible-return]
-
-  return function eventFn() {
-    if (isInvalidExecutionContextForEventFunction()) {
-      throw new Error(
-        "A function wrapped in useEffectEvent can't be called during rendering."
-      );
-    }
+var valueCursor = createCursor(null);
+var rendererCursorDEV;
 
-    return ref.impl.apply(undefined, arguments);
-  };
+{
+  rendererCursorDEV = createCursor(null);
 }
 
-function mountInsertionEffect(create, deps) {
-  mountEffectImpl(Update, Insertion, create, deps);
-}
+var rendererSigil;
 
-function updateInsertionEffect(create, deps) {
-  return updateEffectImpl(Update, Insertion, create, deps);
+{
+  // Use this to detect multiple renderers using the same context
+  rendererSigil = {};
 }
 
-function mountLayoutEffect(create, deps) {
-  var fiberFlags = Update | LayoutStatic;
+var currentlyRenderingFiber = null;
+var lastContextDependency = null;
+var lastFullyObservedContext = null;
+var isDisallowedContextReadInDEV = false;
+function resetContextDependencies() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
 
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    fiberFlags |= MountLayoutDev;
+  {
+    isDisallowedContextReadInDEV = false;
   }
-
-  return mountEffectImpl(fiberFlags, Layout, create, deps);
 }
-
-function updateLayoutEffect(create, deps) {
-  return updateEffectImpl(Update, Layout, create, deps);
+function enterDisallowedContextReadInDEV() {
+  {
+    isDisallowedContextReadInDEV = true;
+  }
 }
-
-function imperativeHandleEffect(create, ref) {
-  if (typeof ref === "function") {
-    var refCallback = ref;
-    var inst = create();
-    refCallback(inst);
-    return function () {
-      refCallback(null);
-    };
-  } else if (ref !== null && ref !== undefined) {
-    var refObject = ref;
+function exitDisallowedContextReadInDEV() {
+  {
+    isDisallowedContextReadInDEV = false;
+  }
+}
+function pushProvider(providerFiber, context, nextValue) {
+  {
+    push(valueCursor, context._currentValue, providerFiber);
+    context._currentValue = nextValue;
 
     {
-      if (!refObject.hasOwnProperty("current")) {
+      push(rendererCursorDEV, context._currentRenderer, providerFiber);
+
+      if (
+        context._currentRenderer !== undefined &&
+        context._currentRenderer !== null &&
+        context._currentRenderer !== rendererSigil
+      ) {
         error(
-          "Expected useImperativeHandle() first argument to either be a " +
-            "ref callback or React.createRef() object. Instead received: %s.",
-          "an object with keys {" + Object.keys(refObject).join(", ") + "}"
+          "Detected multiple renderers concurrently rendering the " +
+            "same context provider. This is currently unsupported."
         );
       }
-    }
-
-    var _inst = create();
 
-    refObject.current = _inst;
-    return function () {
-      refObject.current = null;
-    };
+      context._currentRenderer = rendererSigil;
+    }
   }
 }
+function popProvider(context, providerFiber) {
+  var currentValue = valueCursor.current;
 
-function mountImperativeHandle(ref, create, deps) {
   {
-    if (typeof create !== "function") {
-      error(
-        "Expected useImperativeHandle() second argument to be a function " +
-          "that creates a handle. Instead received: %s.",
-        create !== null ? typeof create : "null"
-      );
+    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
+      context._currentValue = context._defaultValue;
+    } else {
+      context._currentValue = currentValue;
     }
-  } // TODO: If deps are provided, should we skip comparing the ref itself?
-
-  var effectDeps =
-    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-  var fiberFlags = Update | LayoutStatic;
 
-  if ((currentlyRenderingFiber$1.mode & StrictEffectsMode) !== NoMode) {
-    fiberFlags |= MountLayoutDev;
+    {
+      var currentRenderer = rendererCursorDEV.current;
+      pop(rendererCursorDEV, providerFiber);
+      context._currentRenderer = currentRenderer;
+    }
   }
 
-  mountEffectImpl(
-    fiberFlags,
-    Layout,
-    imperativeHandleEffect.bind(null, create, ref),
-    effectDeps
-  );
+  pop(valueCursor, providerFiber);
 }
+function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+  // Update the child lanes of all the ancestors, including the alternates.
+  var node = parent;
+
+  while (node !== null) {
+    var alternate = node.alternate;
+
+    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
+      node.childLanes = mergeLanes(node.childLanes, renderLanes);
+
+      if (alternate !== null) {
+        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+      }
+    } else if (
+      alternate !== null &&
+      !isSubsetOfLanes(alternate.childLanes, renderLanes)
+    ) {
+      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
+    } else;
+
+    if (node === propagationRoot) {
+      break;
+    }
+
+    node = node.return;
+  }
 
-function updateImperativeHandle(ref, create, deps) {
   {
-    if (typeof create !== "function") {
+    if (node !== propagationRoot) {
       error(
-        "Expected useImperativeHandle() second argument to be a function " +
-          "that creates a handle. Instead received: %s.",
-        create !== null ? typeof create : "null"
+        "Expected to find the propagation root when scheduling context work. " +
+          "This error is likely caused by a bug in React. Please file an issue."
       );
     }
-  } // TODO: If deps are provided, should we skip comparing the ref itself?
-
-  var effectDeps =
-    deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-  updateEffectImpl(
-    Update,
-    Layout,
-    imperativeHandleEffect.bind(null, create, ref),
-    effectDeps
-  );
-}
-
-function mountDebugValue(value, formatterFn) {
-  // This hook is normally a no-op.
-  // The react-debug-hooks package injects its own implementation
-  // so that e.g. DevTools can display custom hook values.
+  }
 }
-
-var updateDebugValue = mountDebugValue;
-
-function mountCallback(callback, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  hook.memoizedState = [callback, nextDeps];
-  return callback;
-}
-
-function updateCallback(callback, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var prevState = hook.memoizedState;
-
-  if (nextDeps !== null) {
-    var prevDeps = prevState[1];
-
-    if (areHookInputsEqual(nextDeps, prevDeps)) {
-      return prevState[0];
-    }
+function propagateContextChange(workInProgress, context, renderLanes) {
+  if (enableLazyContextPropagation) {
+    // TODO: This path is only used by Cache components. Update
+    // lazilyPropagateParentContextChanges to look for Cache components so they
+    // can take advantage of lazy propagation.
+    var forcePropagateEntireTree = true;
+    propagateContextChanges(
+      workInProgress,
+      [context],
+      renderLanes,
+      forcePropagateEntireTree
+    );
+  } else {
+    propagateContextChange_eager(workInProgress, context, renderLanes);
   }
-
-  hook.memoizedState = [callback, nextDeps];
-  return callback;
 }
 
-function mountMemo(nextCreate, deps) {
-  var hook = mountWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-
-  if (shouldDoubleInvokeUserFnsInHooksDEV) {
-    nextCreate();
+function propagateContextChange_eager(workInProgress, context, renderLanes) {
+  // Only used by eager implementation
+  if (enableLazyContextPropagation) {
+    return;
   }
 
-  var nextValue = nextCreate();
-  hook.memoizedState = [nextValue, nextDeps];
-  return nextValue;
-}
-
-function updateMemo(nextCreate, deps) {
-  var hook = updateWorkInProgressHook();
-  var nextDeps = deps === undefined ? null : deps;
-  var prevState = hook.memoizedState; // Assume these are defined. If they're not, areHookInputsEqual will warn.
-
-  if (nextDeps !== null) {
-    var prevDeps = prevState[1];
+  var fiber = workInProgress.child;
 
-    if (areHookInputsEqual(nextDeps, prevDeps)) {
-      return prevState[0];
-    }
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
   }
 
-  if (shouldDoubleInvokeUserFnsInHooksDEV) {
-    nextCreate();
-  }
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
 
-  var nextValue = nextCreate();
-  hook.memoizedState = [nextValue, nextDeps];
-  return nextValue;
-}
+    var list = fiber.dependencies;
 
-function mountDeferredValue(value) {
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = value;
-  return value;
-}
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dependency = list.firstContext;
 
-function updateDeferredValue(value) {
-  var hook = updateWorkInProgressHook();
-  var resolvedCurrentHook = currentHook;
-  var prevValue = resolvedCurrentHook.memoizedState;
-  return updateDeferredValueImpl(hook, prevValue, value);
-}
+      while (dependency !== null) {
+        // Check if the context matches.
+        if (dependency.context === context) {
+          // Match! Schedule an update on this fiber.
+          if (fiber.tag === ClassComponent) {
+            // Schedule a force update on the work-in-progress.
+            var lane = pickArbitraryLane(renderLanes);
+            var update = createUpdate(lane);
+            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
+            // update to the current fiber, too, which means it will persist even if
+            // this render is thrown away. Since it's a race condition, not sure it's
+            // worth fixing.
+            // Inlined `enqueueUpdate` to remove interleaved update check
 
-function rerenderDeferredValue(value) {
-  var hook = updateWorkInProgressHook();
+            var updateQueue = fiber.updateQueue;
 
-  if (currentHook === null) {
-    // This is a rerender during a mount.
-    hook.memoizedState = value;
-    return value;
-  } else {
-    // This is a rerender during an update.
-    var prevValue = currentHook.memoizedState;
-    return updateDeferredValueImpl(hook, prevValue, value);
-  }
-}
+            if (updateQueue === null);
+            else {
+              var sharedQueue = updateQueue.shared;
+              var pending = sharedQueue.pending;
 
-function updateDeferredValueImpl(hook, prevValue, value) {
-  var shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes$1);
+              if (pending === null) {
+                // This is the first update. Create a circular list.
+                update.next = update;
+              } else {
+                update.next = pending.next;
+                pending.next = update;
+              }
 
-  if (shouldDeferValue) {
-    // This is an urgent update. If the value has changed, keep using the
-    // previous value and spawn a deferred render to update it later.
-    if (!objectIs(value, prevValue)) {
-      // Schedule a deferred render
-      var deferredLane = claimNextTransitionLane();
-      currentlyRenderingFiber$1.lanes = mergeLanes(
-        currentlyRenderingFiber$1.lanes,
-        deferredLane
-      );
-      markSkippedUpdateLanes(deferredLane); // Set this to true to indicate that the rendered value is inconsistent
-      // from the latest value. The name "baseState" doesn't really match how we
-      // use it because we're reusing a state hook field instead of creating a
-      // new one.
+              sharedQueue.pending = update;
+            }
+          }
 
-      hook.baseState = true;
-    } // Reuse the previous value
+          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
+          var alternate = fiber.alternate;
 
-    return prevValue;
-  } else {
-    // This is not an urgent update, so we can use the latest value regardless
-    // of what it is. No need to defer it.
-    // However, if we're currently inside a spawned render, then we need to mark
-    // this as an update to prevent the fiber from bailing out.
-    //
-    // `baseState` is true when the current value is different from the rendered
-    // value. The name doesn't really match how we use it because we're reusing
-    // a state hook field instead of creating a new one.
-    if (hook.baseState) {
-      // Flip this back to false.
-      hook.baseState = false;
-      markWorkInProgressReceivedUpdate();
-    }
+          if (alternate !== null) {
+            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+          }
 
-    hook.memoizedState = value;
-    return value;
-  }
-}
+          scheduleContextWorkOnParentPath(
+            fiber.return,
+            renderLanes,
+            workInProgress
+          ); // Mark the updated lanes on the list, too.
 
-function startTransition(setPending, callback, options) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  setCurrentUpdatePriority(
-    higherEventPriority(previousPriority, ContinuousEventPriority)
-  );
-  setPending(true);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
-  var currentTransition = ReactCurrentBatchConfig$2.transition;
+          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
+          // dependency list.
 
-  if (enableTransitionTracing) {
-    if (options !== undefined && options.name !== undefined) {
-      ReactCurrentBatchConfig$2.transition.name = options.name;
-      ReactCurrentBatchConfig$2.transition.startTime = now$1();
-    }
-  }
+          break;
+        }
 
-  {
-    ReactCurrentBatchConfig$2.transition._updatedFibers = new Set();
-  }
+        dependency = dependency.next;
+      }
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      var parentSuspense = fiber.return;
 
-  try {
-    setPending(false);
-    callback();
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig$2.transition = prevTransition;
+      if (parentSuspense === null) {
+        throw new Error(
+          "We just came from a parent so we must have had a parent. This is a bug in React."
+        );
+      }
 
-    {
-      if (prevTransition === null && currentTransition._updatedFibers) {
-        var updatedFibersCount = currentTransition._updatedFibers.size;
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      var _alternate = parentSuspense.alternate;
 
-        currentTransition._updatedFibers.clear();
+      if (_alternate !== null) {
+        _alternate.lanes = mergeLanes(_alternate.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
 
-        if (updatedFibersCount > 10) {
-          warn(
-            "Detected a large number of updates inside startTransition. " +
-              "If this is due to a subscription please re-write it to use React provided hooks. " +
-              "Otherwise concurrent mode guarantees are off the table."
-          );
-        }
-      }
+      scheduleContextWorkOnParentPath(
+        parentSuspense,
+        renderLanes,
+        workInProgress
+      );
+      nextFiber = fiber.sibling;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
     }
-  }
-}
 
-function mountTransition() {
-  var _mountState = mountState(false),
-    isPending = _mountState[0],
-    setPending = _mountState[1]; // The `start` method never changes.
+    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;
 
-  var start = startTransition.bind(null, setPending);
-  var hook = mountWorkInProgressHook();
-  hook.memoizedState = start;
-  return [isPending, start];
-}
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
 
-function updateTransition() {
-  var _updateState = updateState(),
-    isPending = _updateState[0];
+        var sibling = nextFiber.sibling;
 
-  var hook = updateWorkInProgressHook();
-  var start = hook.memoizedState;
-  return [isPending, start];
-}
+        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.
 
-function rerenderTransition() {
-  var _rerenderState = rerenderState(),
-    isPending = _rerenderState[0];
+        nextFiber = nextFiber.return;
+      }
+    }
 
-  var hook = updateWorkInProgressHook();
-  var start = hook.memoizedState;
-  return [isPending, start];
+    fiber = nextFiber;
+  }
 }
 
-function mountId() {
-  var hook = mountWorkInProgressHook();
-  var root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we
-  // should do this in Fiber, too? Deferring this decision for now because
-  // there's no other place to store the prefix except for an internal field on
-  // the public createRoot object, which the fiber tree does not currently have
-  // a reference to.
-
-  var identifierPrefix = root.identifierPrefix;
-  var id;
-
-  if (getIsHydrating()) {
-    var treeId = getTreeId(); // Use a captial R prefix for server-generated ids.
-
-    id = ":" + identifierPrefix + "R" + treeId; // Unless this is the first id at this level, append a number at the end
-    // that represents the position of this useId hook among all the useId
-    // hooks for this fiber.
-
-    var localId = localIdCounter++;
+function propagateContextChanges(
+  workInProgress,
+  contexts,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  // Only used by lazy implementation
+  if (!enableLazyContextPropagation) {
+    return;
+  }
 
-    if (localId > 0) {
-      id += "H" + localId.toString(32);
-    }
+  var fiber = workInProgress.child;
 
-    id += ":";
-  } else {
-    // Use a lowercase r prefix for client-generated ids.
-    var globalClientId = globalClientIdCounter++;
-    id = ":" + identifierPrefix + "r" + globalClientId.toString(32) + ":";
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
   }
 
-  hook.memoizedState = id;
-  return id;
-}
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
 
-function updateId() {
-  var hook = updateWorkInProgressHook();
-  var id = hook.memoizedState;
-  return id;
-}
+    var list = fiber.dependencies;
 
-function mountRefresh() {
-  var hook = mountWorkInProgressHook();
-  var refresh = (hook.memoizedState = refreshCache.bind(
-    null,
-    currentlyRenderingFiber$1
-  ));
-  return refresh;
-}
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dep = list.firstContext;
 
-function updateRefresh() {
-  var hook = updateWorkInProgressHook();
-  return hook.memoizedState;
-}
+      findChangedDep: while (dep !== null) {
+        // Assigning these to constants to help Flow
+        var dependency = dep;
+        var consumer = fiber;
 
-function refreshCache(fiber, seedKey, seedValue) {
-  // TODO: Consider warning if the refresh is at discrete priority, or if we
-  // otherwise suspect that it wasn't batched properly.
+        for (var i = 0; i < contexts.length; i++) {
+          var context = contexts[i]; // Check if the context matches.
+          // TODO: Compare selected values to bail out early.
 
-  var provider = fiber.return;
+          if (dependency.context === context) {
+            // Match! Schedule an update on this fiber.
+            // In the lazy implementation, don't mark a dirty flag on the
+            // dependency itself. Not all changes are propagated, so we can't
+            // rely on the propagation function alone to determine whether
+            // something has changed; the consumer will check. In the future, we
+            // could add back a dirty flag as an optimization to avoid double
+            // checking, but until we have selectors it's not really worth
+            // the trouble.
+            consumer.lanes = mergeLanes(consumer.lanes, renderLanes);
+            var alternate = consumer.alternate;
 
-  while (provider !== null) {
-    switch (provider.tag) {
-      case CacheComponent:
-      case HostRoot: {
-        // Schedule an update on the cache boundary to trigger a refresh.
-        var lane = requestUpdateLane(provider);
-        var refreshUpdate = createUpdate(lane);
-        var root = enqueueUpdate(provider, refreshUpdate, lane);
+            if (alternate !== null) {
+              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+            }
 
-        if (root !== null) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, provider, lane, eventTime);
-          entangleTransitions(root, provider, lane);
-        } // TODO: If a refresh never commits, the new cache created here must be
-        // released. A simple case is start refreshing a cache boundary, but then
-        // unmount that boundary before the refresh completes.
+            scheduleContextWorkOnParentPath(
+              consumer.return,
+              renderLanes,
+              workInProgress
+            );
 
-        var seededCache = createCache();
+            if (!forcePropagateEntireTree) {
+              // During lazy propagation, when we find a match, we can defer
+              // propagating changes to the children, because we're going to
+              // visit them during render. We should continue propagating the
+              // siblings, though
+              nextFiber = null;
+            } // Since we already found a match, we can stop traversing the
+            // dependency list.
 
-        if (seedKey !== null && seedKey !== undefined && root !== null) {
-          {
-            // Seed the cache with the value passed by the caller. This could be
-            // from a server mutation, or it could be a streaming response.
-            seededCache.data.set(seedKey, seedValue);
+            break findChangedDep;
           }
         }
 
-        var payload = {
-          cache: seededCache
-        };
-        refreshUpdate.payload = payload;
-        return;
+        dep = dependency.next;
       }
-    }
+    } else if (fiber.tag === DehydratedFragment) {
+      // If a dehydrated suspense boundary is in this subtree, we don't know
+      // if it will have any context consumers in it. The best we can do is
+      // mark it as having updates.
+      var parentSuspense = fiber.return;
 
-    provider = provider.return;
-  } // TODO: Warn if unmounted?
-}
+      if (parentSuspense === null) {
+        throw new Error(
+          "We just came from a parent so we must have had a parent. This is a bug in React."
+        );
+      }
 
-function dispatchReducerAction(fiber, queue, action) {
-  {
-    if (typeof arguments[3] === "function") {
-      error(
-        "State updates from the useState() and useReducer() Hooks don't support the " +
-          "second callback argument. To execute a side effect after " +
-          "rendering, declare it in the component body with useEffect()."
+      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
+      var _alternate2 = parentSuspense.alternate;
+
+      if (_alternate2 !== null) {
+        _alternate2.lanes = mergeLanes(_alternate2.lanes, renderLanes);
+      } // This is intentionally passing this fiber as the parent
+      // because we want to schedule this fiber as having work
+      // on its children. We'll use the childLanes on
+      // this fiber to indicate that a context has changed.
+
+      scheduleContextWorkOnParentPath(
+        parentSuspense,
+        renderLanes,
+        workInProgress
       );
+      nextFiber = null;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
     }
-  }
 
-  var lane = requestUpdateLane(fiber);
-  var update = {
-    lane: lane,
-    action: action,
-    hasEagerState: false,
-    eagerState: null,
-    next: null
-  };
+    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;
 
-  if (isRenderPhaseUpdate(fiber)) {
-    enqueueRenderPhaseUpdate(queue, update);
-  } else {
-    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitionUpdate(root, queue, lane);
+        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;
+      }
     }
-  }
 
-  markUpdateInDevTools(fiber, lane, action);
+    fiber = nextFiber;
+  }
 }
 
-function dispatchSetState(fiber, queue, action) {
-  {
-    if (typeof arguments[3] === "function") {
-      error(
-        "State updates from the useState() and useReducer() Hooks don't support the " +
-          "second callback argument. To execute a side effect after " +
-          "rendering, declare it in the component body with useEffect()."
-      );
-    }
-  }
+function lazilyPropagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = false;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
+} // Used for propagating a deferred tree (Suspense, Offscreen). We must propagate
+// to the entire subtree, because we won't revisit it until after the current
+// render has completed, at which point we'll have lost track of which providers
+// have changed.
 
-  var lane = requestUpdateLane(fiber);
-  var update = {
-    lane: lane,
-    action: action,
-    hasEagerState: false,
-    eagerState: null,
-    next: null
-  };
+function propagateParentContextChangesToDeferredTree(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = true;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
+}
 
-  if (isRenderPhaseUpdate(fiber)) {
-    enqueueRenderPhaseUpdate(queue, update);
-  } else {
-    var alternate = fiber.alternate;
+function propagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (!enableLazyContextPropagation) {
+    return;
+  } // Collect all the parent providers that changed. Since this is usually small
+  // number, we use an Array instead of Set.
 
-    if (
-      fiber.lanes === NoLanes &&
-      (alternate === null || alternate.lanes === NoLanes)
-    ) {
-      // The queue is currently empty, which means we can eagerly compute the
-      // next state before entering the render phase. If the new state is the
-      // same as the current state, we may be able to bail out entirely.
-      var lastRenderedReducer = queue.lastRenderedReducer;
+  var contexts = null;
+  var parent = workInProgress;
+  var isInsidePropagationBailout = false;
 
-      if (lastRenderedReducer !== null) {
-        var prevDispatcher;
+  while (parent !== null) {
+    if (!isInsidePropagationBailout) {
+      if ((parent.flags & NeedsPropagation) !== NoFlags$1) {
+        isInsidePropagationBailout = true;
+      } else if ((parent.flags & DidPropagateContext) !== NoFlags$1) {
+        break;
+      }
+    }
 
-        {
-          prevDispatcher = ReactCurrentDispatcher$1.current;
-          ReactCurrentDispatcher$1.current =
-            InvalidNestedHooksDispatcherOnUpdateInDEV;
-        }
+    if (parent.tag === ContextProvider) {
+      var currentParent = parent.alternate;
 
-        try {
-          var currentState = queue.lastRenderedState;
-          var eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute
-          // it, on the update object. If the reducer hasn't changed by the
-          // time we enter the render phase, then the eager state can be used
-          // without calling the reducer again.
+      if (currentParent === null) {
+        throw new Error("Should have a current fiber. This is a bug in React.");
+      }
 
-          update.hasEagerState = true;
-          update.eagerState = eagerState;
+      var oldProps = currentParent.memoizedProps;
 
-          if (objectIs(eagerState, currentState)) {
-            // Fast path. We can bail out without scheduling React to re-render.
-            // It's still possible that we'll need to rebase this update later,
-            // if the component re-renders for a different reason and by that
-            // time the reducer has changed.
-            // TODO: Do we still need to entangle transitions in this case?
-            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
-            return;
-          }
-        } catch (error) {
-          // Suppress the error. It will throw again in the render phase.
-        } finally {
-          {
-            ReactCurrentDispatcher$1.current = prevDispatcher;
+      if (oldProps !== null) {
+        var providerType = parent.type;
+        var context = providerType._context;
+        var newProps = parent.pendingProps;
+        var newValue = newProps.value;
+        var oldValue = oldProps.value;
+
+        if (!objectIs(newValue, oldValue)) {
+          if (contexts !== null) {
+            contexts.push(context);
+          } else {
+            contexts = [context];
           }
         }
       }
     }
 
-    var root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
-
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitionUpdate(root, queue, lane);
-    }
+    parent = parent.return;
   }
 
-  markUpdateInDevTools(fiber, lane, action);
-}
+  if (contexts !== null) {
+    // If there were any changed providers, search through the children and
+    // propagate their changes.
+    propagateContextChanges(
+      workInProgress,
+      contexts,
+      renderLanes,
+      forcePropagateEntireTree
+    );
+  } // This is an optimization so that we only propagate once per subtree. If a
+  // deeply nested child bails out, and it calls this propagation function, it
+  // uses this flag to know that the remaining ancestor providers have already
+  // been propagated.
+  //
+  // NOTE: This optimization is only necessary because we sometimes enter the
+  // begin phase of nodes that don't have any work scheduled on them —
+  // specifically, the siblings of a node that _does_ have scheduled work. The
+  // siblings will bail out and call this function again, even though we already
+  // propagated content changes to it and its subtree. So we use this flag to
+  // mark that the parent providers already propagated.
+  //
+  // Unfortunately, though, we need to ignore this flag when we're inside a
+  // tree whose context propagation was deferred — that's what the
+  // `NeedsPropagation` flag is for.
+  //
+  // If we could instead bail out before entering the siblings' begin phase,
+  // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
+  // Consider this as part of the next refactor to the fiber tree structure.
 
-function isRenderPhaseUpdate(fiber) {
-  var alternate = fiber.alternate;
-  return (
-    fiber === currentlyRenderingFiber$1 ||
-    (alternate !== null && alternate === currentlyRenderingFiber$1)
-  );
+  workInProgress.flags |= DidPropagateContext;
 }
 
-function enqueueRenderPhaseUpdate(queue, update) {
-  // This is a render phase update. Stash it in a lazily-created map of
-  // queue -> linked list of updates. After this render pass, we'll restart
-  // and apply the stashed updates on top of the work-in-progress hook.
-  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
-    true;
-  var pending = queue.pending;
+function checkIfContextChanged(currentDependencies) {
+  if (!enableLazyContextPropagation) {
+    return false;
+  } // Iterate over the current dependencies to see if something changed. This
+  // only gets called if props and state has already bailed out, so it's a
+  // relatively uncommon path, except at the root of a changed subtree.
+  // Alternatively, we could move these comparisons into `readContext`, but
+  // that's a much hotter path, so I think this is an appropriate trade off.
 
-  if (pending === null) {
-    // This is the first update. Create a circular list.
-    update.next = update;
-  } else {
-    update.next = pending.next;
-    pending.next = update;
+  var dependency = currentDependencies.firstContext;
+
+  while (dependency !== null) {
+    var context = dependency.context;
+    var newValue = context._currentValue;
+    var oldValue = dependency.memoizedValue;
+
+    if (!objectIs(newValue, oldValue)) {
+      return true;
+    }
+
+    dependency = dependency.next;
   }
 
-  queue.pending = update;
-} // TODO: Move to ReactFiberConcurrentUpdates?
+  return false;
+}
+function prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastFullyObservedContext = null;
+  var dependencies = workInProgress.dependencies;
 
-function entangleTransitionUpdate(root, queue, lane) {
-  if (isTransitionLane(lane)) {
-    var queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they
-    // must have finished. We can remove them from the shared queue, which
-    // represents a superset of the actually pending lanes. In some cases we
-    // may entangle more than we need to, but that's OK. In fact it's worse if
-    // we *don't* entangle when we should.
+  if (dependencies !== null) {
+    if (enableLazyContextPropagation) {
+      // Reset the work-in-progress list
+      dependencies.firstContext = null;
+    } else {
+      var firstContext = dependencies.firstContext;
 
-    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.
+      if (firstContext !== null) {
+        if (includesSomeLane(dependencies.lanes, renderLanes)) {
+          // Context list has a pending update. Mark that this fiber performed work.
+          markWorkInProgressReceivedUpdate();
+        } // Reset the work-in-progress list
 
-    var newQueueLanes = mergeLanes(queueLanes, lane);
-    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if
-    // the lane finished since the last time we entangled it. So we need to
-    // entangle it again, just to be sure.
+        dependencies.firstContext = null;
+      }
+    }
+  }
+}
+function readContext(context) {
+  {
+    // This warning would fire if you read context inside a Hook like useMemo.
+    // Unlike the class check below, it's not enforced in production for perf.
+    if (isDisallowedContextReadInDEV) {
+      error(
+        "Context can only be read while React is rendering. " +
+          "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+          "In function components, you can read it directly in the function body, but not " +
+          "inside Hooks like useReducer() or useMemo()."
+      );
+    }
+  }
 
-    markRootEntangled(root, newQueueLanes);
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  if (currentlyRenderingFiber === null) {
+    prepareToReadContext(consumer, renderLanes);
   }
+
+  return readContextForConsumer(consumer, context);
 }
 
-function markUpdateInDevTools(fiber, lane, action) {
-  {
-    if (enableDebugTracing) {
-      if (fiber.mode & DebugTracingMode) {
-        var name = getComponentNameFromFiber(fiber) || "Unknown";
-        logStateUpdateScheduled(name, lane, action);
+function readContextForConsumer(consumer, context) {
+  var value = isPrimaryRenderer
+    ? context._currentValue
+    : context._currentValue2;
+
+  if (lastFullyObservedContext === context);
+  else {
+    var contextItem = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      if (consumer === null) {
+        throw new Error(
+          "Context can only be read while React is rendering. " +
+            "In classes, you can read it in the render method or getDerivedStateFromProps. " +
+            "In function components, you can read it directly in the function body, but not " +
+            "inside Hooks like useReducer() or useMemo()."
+        );
+      } // This is the first dependency for this component. Create a new list.
+
+      lastContextDependency = contextItem;
+      consumer.dependencies = {
+        lanes: NoLanes,
+        firstContext: contextItem
+      };
+
+      if (enableLazyContextPropagation) {
+        consumer.flags |= NeedsPropagation;
       }
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
     }
   }
 
-  if (enableSchedulingProfiler) {
-    markStateUpdateScheduled(fiber, lane);
-  }
+  return value;
 }
 
-var ContextOnlyDispatcher = {
-  readContext: readContext,
-  useCallback: throwInvalidHookError,
-  useContext: throwInvalidHookError,
-  useEffect: throwInvalidHookError,
-  useImperativeHandle: throwInvalidHookError,
-  useInsertionEffect: throwInvalidHookError,
-  useLayoutEffect: throwInvalidHookError,
-  useMemo: throwInvalidHookError,
-  useReducer: throwInvalidHookError,
-  useRef: throwInvalidHookError,
-  useState: throwInvalidHookError,
-  useDebugValue: throwInvalidHookError,
-  useDeferredValue: throwInvalidHookError,
-  useTransition: throwInvalidHookError,
-  useMutableSource: throwInvalidHookError,
-  useSyncExternalStore: throwInvalidHookError,
-  useId: throwInvalidHookError
+// replace it with a lightweight shim that only has the features we use.
+
+var AbortControllerLocal =
+  typeof AbortController !== "undefined"
+    ? AbortController // $FlowFixMe[missing-this-annot]
+    : function AbortControllerShim() {
+        var listeners = [];
+        var signal = (this.signal = {
+          aborted: false,
+          addEventListener: function (type, listener) {
+            listeners.push(listener);
+          }
+        });
+
+        this.abort = function () {
+          signal.aborted = true;
+          listeners.forEach(function (listener) {
+            return listener();
+          });
+        };
+      }; // Intentionally not named imports because Rollup would
+// use dynamic dispatch for CommonJS interop named imports.
+
+var scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+  NormalPriority = Scheduler.unstable_NormalPriority;
+var CacheContext = {
+  $$typeof: REACT_CONTEXT_TYPE,
+  // We don't use Consumer/Provider for Cache components. So we'll cheat.
+  Consumer: null,
+  Provider: null,
+  // We'll initialize these at the root.
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0,
+  _defaultValue: null,
+  _globalName: null
 };
 
 {
-  ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
-}
+  CacheContext._currentRenderer = null;
+  CacheContext._currentRenderer2 = null;
+} // Creates a new empty Cache instance with a ref-count of 0. The caller is responsible
+// for retaining the cache once it is in use (retainCache), and releasing the cache
+// once it is no longer needed (releaseCache).
 
-{
-  ContextOnlyDispatcher.use = throwInvalidHookError;
+function createCache() {
+  var cache = {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+  return cache;
 }
+function retainCache(cache) {
+  {
+    if (cache.controller.signal.aborted) {
+      warn(
+        "A cache instance was retained after it was already freed. " +
+          "This likely indicates a bug in React."
+      );
+    }
+  }
 
-{
-  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
-}
+  cache.refCount++;
+} // Cleanup a cache instance, potentially freeing it if there are no more references
 
-{
-  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+function releaseCache(cache) {
+  cache.refCount--;
+
+  {
+    if (cache.refCount < 0) {
+      warn(
+        "A cache instance was released after it was already freed. " +
+          "This likely indicates a bug in React."
+      );
+    }
+  }
+
+  if (cache.refCount === 0) {
+    scheduleCallback$1(NormalPriority, function () {
+      cache.controller.abort();
+    });
+  }
+}
+function pushCacheProvider(workInProgress, cache) {
+  pushProvider(workInProgress, CacheContext, cache);
+}
+function popCacheProvider(workInProgress, cache) {
+  popProvider(CacheContext, workInProgress);
 }
 
-var HooksDispatcherOnMountInDEV = null;
-var HooksDispatcherOnMountWithHookTypesInDEV = null;
-var HooksDispatcherOnUpdateInDEV = null;
-var HooksDispatcherOnRerenderInDEV = null;
-var InvalidNestedHooksDispatcherOnMountInDEV = null;
-var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
-var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;
+var NoTransition = null;
+function requestCurrentTransition() {
+  return ReactCurrentBatchConfig$2.transition;
+} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
+// used during the previous render by placing it here, on the stack.
 
-{
-  var warnInvalidContextAccess = function () {
-    error(
-      "Context can only be read while React is rendering. " +
-        "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-        "In function components, you can read it directly in the function body, but not " +
-        "inside Hooks like useReducer() or useMemo()."
-    );
-  };
+var resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
+// transitions. Therefore, we want to lazily combine transitions. Instead of
+// comparing the arrays of transitions when we combine them and storing them
+// and filtering out the duplicates, we will instead store the unprocessed transitions
+// in an array and actually filter them in the passive phase.
 
-  var warnInvalidHookAccess = function () {
-    error(
-      "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " +
-        "You can only call Hooks at the top level of your React function. " +
-        "For more information, see " +
-        "https://reactjs.org/link/rules-of-hooks"
-    );
-  };
+var transitionStack = createCursor(null);
 
-  HooksDispatcherOnMountInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      mountHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      mountHookTypesDev();
-      checkDepsAreArrayDev(deps);
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+function peekCacheFromPool() {
+  // If we're rendering inside a Suspense boundary that is currently hidden,
+  // we should use the same cache that we used during the previous render, if
+  // one exists.
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  var cacheResumedFromPreviousRender = resumedCache.current;
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      mountHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  if (cacheResumedFromPreviousRender !== null) {
+    return cacheResumedFromPreviousRender;
+  } // Otherwise, check the root's cache pool.
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      mountHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      mountHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      mountHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      mountHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      mountHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      mountHookTypesDev();
-      return mountId();
-    }
-  };
+  var root = getWorkInProgressRoot();
+  var cacheFromRootCachePool = root.pooledCache;
+  return cacheFromRootCachePool;
+}
 
-  {
-    HooksDispatcherOnMountInDEV.useCacheRefresh = function useCacheRefresh() {
-      currentHookNameInDev = "useCacheRefresh";
-      mountHookTypesDev();
-      return mountRefresh();
-    };
+function requestCacheFromPool(renderLanes) {
+  // Similar to previous function, except if there's not already a cache in the
+  // pool, we allocate a new one.
+  var cacheFromPool = peekCacheFromPool();
+
+  if (cacheFromPool !== null) {
+    return cacheFromPool;
+  } // Create a fresh cache and add it to the root cache pool. A cache can have
+  // multiple owners:
+  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
+  //   are originally created (TODO: except during refreshes, until we implement
+  //   this correctly). The root takes ownership immediately when the cache is
+  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
+  //   and the return value of this function is a &Arc<Cache> (borrowed).
+  // - One of several fiber types: host root, cache boundary, suspense
+  //   component. These retain and release in the commit phase.
+
+  var root = getWorkInProgressRoot();
+  var freshCache = createCache();
+  root.pooledCache = freshCache;
+  retainCache(freshCache);
+
+  if (freshCache !== null) {
+    root.pooledCacheLanes |= renderLanes;
   }
 
+  return freshCache;
+}
+function pushRootTransition(workInProgress, root, renderLanes) {
+  if (enableTransitionTracing) {
+    var rootTransitions = getWorkInProgressTransitions();
+    push(transitionStack, rootTransitions, workInProgress);
+  }
+}
+function popRootTransition(workInProgress, root, renderLanes) {
+  if (enableTransitionTracing) {
+    pop(transitionStack, workInProgress);
+  }
+}
+function pushTransition(
+  offscreenWorkInProgress,
+  prevCachePool,
+  newTransitions
+) {
   {
-    HooksDispatcherOnMountInDEV.use = use;
+    if (prevCachePool === null) {
+      push(resumedCache, resumedCache.current, offscreenWorkInProgress);
+    } else {
+      push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
+    }
   }
 
-  {
-    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
+  if (enableTransitionTracing) {
+    if (transitionStack.current === null) {
+      push(transitionStack, newTransitions, offscreenWorkInProgress);
+    } else if (newTransitions === null) {
+      push(transitionStack, transitionStack.current, offscreenWorkInProgress);
+    } else {
+      push(
+        transitionStack,
+        transitionStack.current.concat(newTransitions),
+        offscreenWorkInProgress
+      );
+    }
   }
+}
+function popTransition(workInProgress, current) {
+  if (current !== null) {
+    if (enableTransitionTracing) {
+      pop(transitionStack, workInProgress);
+    }
 
-  {
-    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      mountHookTypesDev();
-      return mountEvent(callback);
-    };
+    {
+      pop(resumedCache, workInProgress);
+    }
+  }
+}
+function getPendingTransitions() {
+  if (!enableTransitionTracing) {
+    return null;
   }
 
-  HooksDispatcherOnMountWithHookTypesInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  return transitionStack.current;
+}
+function getSuspendedCache() {
+  // cache that would have been used to render fresh data during this render,
+  // if there was any, so that we can resume rendering with the same cache when
+  // we receive more data.
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  var cacheFromPool = peekCacheFromPool();
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  if (cacheFromPool === null) {
+    return null;
+  }
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return mountId();
-    }
+  return {
+    // We must also save the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue,
+    pool: cacheFromPool
   };
+}
+function getOffscreenDeferredCache() {
+  var cacheFromPool = peekCacheFromPool();
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return mountRefresh();
-      };
+  if (cacheFromPool === null) {
+    return null;
   }
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.use = use;
-  }
+  return {
+    // We must also store the parent, so that when we resume we can detect
+    // a refresh.
+    parent: CacheContext._currentValue,
+    pool: cacheFromPool
+  };
+}
 
-  {
-    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
-  }
+function getSuspenseFallbackChild(fiber) {
+  return fiber.child.sibling.child;
+}
+
+var emptyObject = {};
 
+function collectScopedNodes(node, fn, scopedNodes) {
   {
-    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        updateHookTypesDev();
-        return mountEvent(callback);
-      };
+    if (node.tag === HostComponent) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        stateNode = node.stateNode;
+      var instance = getPublicInstance(stateNode);
+
+      if (
+        instance !== null &&
+        fn(type, memoizedProps || emptyObject, instance) === true
+      ) {
+        scopedNodes.push(instance);
+      }
+    }
+
+    var child = node.child;
+
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
+    }
+
+    if (child !== null) {
+      collectScopedNodesFromChildren(child, fn, scopedNodes);
+    }
   }
+}
 
-  HooksDispatcherOnUpdateInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+function collectFirstScopedNode(node, fn) {
+  {
+    if (node.tag === HostComponent) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        stateNode = node.stateNode;
+      var instance = getPublicInstance(stateNode);
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      if (instance !== null && fn(type, memoizedProps, instance) === true) {
+        return instance;
       }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+    }
 
-      try {
-        return updateReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+    var child = node.child;
 
-      try {
-        return updateState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return updateDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return updateTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return updateId();
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
     }
-  };
 
-  {
-    HooksDispatcherOnUpdateInDEV.useCacheRefresh = function useCacheRefresh() {
-      currentHookNameInDev = "useCacheRefresh";
-      updateHookTypesDev();
-      return updateRefresh();
-    };
+    if (child !== null) {
+      return collectFirstScopedNodeFromChildren(child, fn);
+    }
   }
 
-  {
-    HooksDispatcherOnUpdateInDEV.use = use;
+  return null;
+}
+
+function collectScopedNodesFromChildren(startingChild, fn, scopedNodes) {
+  var child = startingChild;
+
+  while (child !== null) {
+    collectScopedNodes(child, fn, scopedNodes);
+    child = child.sibling;
   }
+}
 
-  {
-    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
+function collectFirstScopedNodeFromChildren(startingChild, fn) {
+  var child = startingChild;
+
+  while (child !== null) {
+    var scopedNode = collectFirstScopedNode(child, fn);
+
+    if (scopedNode !== null) {
+      return scopedNode;
+    }
+
+    child = child.sibling;
   }
 
-  {
-    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      updateHookTypesDev();
-      return updateEvent(callback);
-    };
+  return null;
+}
+
+function collectNearestContextValues(node, context, childContextValues) {
+  if (node.tag === ContextProvider && node.type._context === context) {
+    var contextValue = node.memoizedProps.value;
+    childContextValues.push(contextValue);
+  } else {
+    var child = node.child;
+
+    if (isFiberSuspenseAndTimedOut(node)) {
+      child = getSuspenseFallbackChild(node);
+    }
+
+    if (child !== null) {
+      collectNearestChildContextValues(child, context, childContextValues);
+    }
   }
+}
 
-  HooksDispatcherOnRerenderInDEV = {
-    readContext: function (context) {
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
-
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+function collectNearestChildContextValues(
+  startingChild,
+  context,
+  childContextValues
+) {
+  var child = startingChild;
 
-      try {
-        return rerenderReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnRerenderInDEV;
+  while (child !== null) {
+    collectNearestContextValues(child, context, childContextValues);
+    child = child.sibling;
+  }
+}
 
-      try {
-        return rerenderState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      updateHookTypesDev();
-      return rerenderDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      updateHookTypesDev();
-      return rerenderTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      updateHookTypesDev();
-      return updateId();
-    }
-  };
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
 
-  {
-    HooksDispatcherOnRerenderInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
+  if (currentFiber === null) {
+    return null;
   }
 
-  {
-    HooksDispatcherOnRerenderInDEV.use = use;
-  }
+  var child = currentFiber.child;
+  var scopedNodes = [];
 
-  {
-    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
+  if (child !== null) {
+    collectScopedNodesFromChildren(child, fn, scopedNodes);
   }
 
-  {
-    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
-      callback
-    ) {
-      currentHookNameInDev = "useEffectEvent";
-      updateHookTypesDev();
-      return updateEvent(callback);
-    };
+  return scopedNodes.length === 0 ? null : scopedNodes;
+}
+
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
+
+  if (currentFiber === null) {
+    return null;
   }
 
-  InvalidNestedHooksDispatcherOnMountInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  var child = currentFiber.child;
 
-      try {
-        return mountMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  if (child !== null) {
+    return collectFirstScopedNodeFromChildren(child, fn);
+  }
 
-      try {
-        return mountReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountRef(initialValue);
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnMountInDEV;
+  return null;
+}
 
-      try {
-        return mountState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      mountHookTypesDev();
-      return mountId();
+function containsNode$1(node) {
+  var fiber = getInstanceFromNode(node);
+
+  while (fiber !== null) {
+    if (fiber.tag === ScopeComponent && fiber.stateNode === this) {
+      return true;
     }
-  };
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        mountHookTypesDev();
-        return mountRefresh();
-      };
+    fiber = fiber.return;
   }
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
-  }
+  return false;
+}
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
-  }
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
 
-  {
-    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        mountHookTypesDev();
-        return mountEvent(callback);
-      };
+  if (currentFiber === null) {
+    return [];
   }
 
-  InvalidNestedHooksDispatcherOnUpdateInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  var child = currentFiber.child;
+  var childContextValues = [];
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  if (child !== null) {
+    collectNearestChildContextValues(child, context, childContextValues);
+  }
 
-      try {
-        return updateReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+  return childContextValues;
+}
 
-      try {
-        return updateState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
-      }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateId();
-    }
+function createScopeInstance() {
+  return {
+    DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+    DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+    containsNode: containsNode$1,
+    getChildContextValues: getChildContextValues
   };
+}
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
-  }
+function markUpdate(workInProgress) {
+  // Tag the fiber with an update effect. This turns a Placement into
+  // a PlacementAndUpdate.
+  workInProgress.flags |= Update;
+}
 
-  {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
-  }
+function markRef(workInProgress) {
+  workInProgress.flags |= Ref | RefStatic;
+}
 
+function appendAllChildren(
+  parent,
+  workInProgress,
+  needsVisibilityToggle,
+  isHidden
+) {
   {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
+    // We only have the top Fiber that was created but we need recurse down its
+    // children to find all the terminal nodes.
+    var node = workInProgress.child;
+
+    while (node !== null) {
+      if (node.tag === HostComponent || node.tag === HostText) {
+        appendInitialChild(parent, node.stateNode);
+      } else if (node.tag === HostPortal || node.tag === HostSingleton);
+      else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+
+      if (node === workInProgress) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      while (node.sibling === null) {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (node.return === null || node.return === workInProgress) {
+          return;
+        }
+
+        node = node.return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
   }
+} // An unfortunate fork of appendAllChildren because we have two different parent types.
 
+function updateHostComponent(current, workInProgress, type, newProps) {
   {
-    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        updateHookTypesDev();
-        return updateEvent(callback);
-      };
+    // If we have an alternate, that means this is an update and we need to
+    // schedule a side-effect to do the updates.
+    var oldProps = current.memoizedProps;
+
+    if (oldProps === newProps) {
+      // In mutation mode, this is sufficient for a bailout because
+      // we won't touch this node even if children changed.
+      return;
+    } // If we get updated because one of our children updated, we don't
+    // have newProps so we'll have to reuse them.
+    // TODO: Split the update API as separate for the props vs. children.
+    // Even better would be if children weren't special cased at all tho.
+
+    var instance = workInProgress.stateNode;
+    var currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host
+    // component is hitting the resume path. Figure out why. Possibly
+    // related to `hidden`.
+
+    var updatePayload = prepareUpdate(
+      instance,
+      type,
+      oldProps,
+      newProps,
+      currentHostContext
+    ); // TODO: Type this specific to this type of component.
+
+    workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
+    // is a new ref we mark this as an update. All the work is done in commitWork.
+
+    if (updatePayload) {
+      markUpdate(workInProgress);
+    }
   }
+}
 
-  InvalidNestedHooksDispatcherOnRerenderInDEV = {
-    readContext: function (context) {
-      warnInvalidContextAccess();
-      return readContext(context);
-    },
-    useCallback: function (callback, deps) {
-      currentHookNameInDev = "useCallback";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateCallback(callback, deps);
-    },
-    useContext: function (context) {
-      currentHookNameInDev = "useContext";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return readContext(context);
-    },
-    useEffect: function (create, deps) {
-      currentHookNameInDev = "useEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateEffect(create, deps);
-    },
-    useImperativeHandle: function (ref, create, deps) {
-      currentHookNameInDev = "useImperativeHandle";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateImperativeHandle(ref, create, deps);
-    },
-    useInsertionEffect: function (create, deps) {
-      currentHookNameInDev = "useInsertionEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateInsertionEffect(create, deps);
-    },
-    useLayoutEffect: function (create, deps) {
-      currentHookNameInDev = "useLayoutEffect";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateLayoutEffect(create, deps);
-    },
-    useMemo: function (create, deps) {
-      currentHookNameInDev = "useMemo";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
+function updateHostText(current, workInProgress, oldText, newText) {
+  {
+    // If the text differs, mark it as an update. All the work in done in commitWork.
+    if (oldText !== newText) {
+      markUpdate(workInProgress);
+    }
+  }
+}
 
-      try {
-        return updateMemo(create, deps);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (getIsHydrating()) {
+    // If we're hydrating, we should consume as many items as we can
+    // so we don't leave any behind.
+    return;
+  }
+
+  switch (renderState.tailMode) {
+    case "hidden": {
+      // Any insertions at the end of the tail list after this point
+      // should be invisible. If there are already mounted boundaries
+      // anything before them are not considered for collapsing.
+      // Therefore we need to go through the whole tail to find if
+      // there are any.
+      var tailNode = renderState.tail;
+      var lastTailNode = null;
+
+      while (tailNode !== null) {
+        if (tailNode.alternate !== null) {
+          lastTailNode = tailNode;
+        }
+
+        tailNode = tailNode.sibling;
+      } // Next we're simply going to delete all insertions after the
+      // last rendered item.
+
+      if (lastTailNode === null) {
+        // All remaining items in the tail are insertions.
+        renderState.tail = null;
+      } else {
+        // Detach the insertion after the last node that was already
+        // inserted.
+        lastTailNode.sibling = null;
       }
-    },
-    useReducer: function (reducer, initialArg, init) {
-      currentHookNameInDev = "useReducer";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      try {
-        return rerenderReducer(reducer, initialArg, init);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      break;
+    }
+
+    case "collapsed": {
+      // Any insertions at the end of the tail list after this point
+      // should be invisible. If there are already mounted boundaries
+      // anything before them are not considered for collapsing.
+      // Therefore we need to go through the whole tail to find if
+      // there are any.
+      var _tailNode = renderState.tail;
+      var _lastTailNode = null;
+
+      while (_tailNode !== null) {
+        if (_tailNode.alternate !== null) {
+          _lastTailNode = _tailNode;
+        }
+
+        _tailNode = _tailNode.sibling;
+      } // Next we're simply going to delete all insertions after the
+      // last rendered item.
+
+      if (_lastTailNode === null) {
+        // All remaining items in the tail are insertions.
+        if (!hasRenderedATailFallback && renderState.tail !== null) {
+          // We suspended during the head. We want to show at least one
+          // row at the tail. So we'll keep on and cut off the rest.
+          renderState.tail.sibling = null;
+        } else {
+          renderState.tail = null;
+        }
+      } else {
+        // Detach the insertion after the last node that was already
+        // inserted.
+        _lastTailNode.sibling = null;
       }
-    },
-    useRef: function (initialValue) {
-      currentHookNameInDev = "useRef";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateRef();
-    },
-    useState: function (initialState) {
-      currentHookNameInDev = "useState";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      var prevDispatcher = ReactCurrentDispatcher$1.current;
-      ReactCurrentDispatcher$1.current =
-        InvalidNestedHooksDispatcherOnUpdateInDEV;
 
-      try {
-        return rerenderState(initialState);
-      } finally {
-        ReactCurrentDispatcher$1.current = prevDispatcher;
+      break;
+    }
+  }
+}
+
+function bubbleProperties(completedWork) {
+  var didBailout =
+    completedWork.alternate !== null &&
+    completedWork.alternate.child === completedWork.child;
+  var newChildLanes = NoLanes;
+  var subtreeFlags = NoFlags$1;
+
+  if (!didBailout) {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      var actualDuration = completedWork.actualDuration;
+      var treeBaseDuration = completedWork.selfBaseDuration;
+      var child = completedWork.child;
+
+      while (child !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(child.lanes, child.childLanes)
+        );
+        subtreeFlags |= child.subtreeFlags;
+        subtreeFlags |= child.flags; // When a fiber is cloned, its actualDuration is reset to 0. This value will
+        // only be updated if work is done on the fiber (i.e. it doesn't bailout).
+        // When work is done, it should bubble to the parent's actualDuration. If
+        // the fiber has not been cloned though, (meaning no work was done), then
+        // this value will reflect the amount of time spent working on a previous
+        // render. In that case it should not bubble. We determine whether it was
+        // cloned by comparing the child pointer.
+        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        actualDuration += child.actualDuration; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        treeBaseDuration += child.treeBaseDuration;
+        child = child.sibling;
       }
-    },
-    useDebugValue: function (value, formatterFn) {
-      currentHookNameInDev = "useDebugValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateDebugValue();
-    },
-    useDeferredValue: function (value) {
-      currentHookNameInDev = "useDeferredValue";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return rerenderDeferredValue(value);
-    },
-    useTransition: function () {
-      currentHookNameInDev = "useTransition";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return rerenderTransition();
-    },
-    useMutableSource: function (source, getSnapshot, subscribe) {
-      currentHookNameInDev = "useMutableSource";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateMutableSource(source, getSnapshot, subscribe);
-    },
-    useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-      currentHookNameInDev = "useSyncExternalStore";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateSyncExternalStore(subscribe, getSnapshot);
-    },
-    useId: function () {
-      currentHookNameInDev = "useId";
-      warnInvalidHookAccess();
-      updateHookTypesDev();
-      return updateId();
+
+      completedWork.actualDuration = actualDuration;
+      completedWork.treeBaseDuration = treeBaseDuration;
+    } else {
+      var _child = completedWork.child;
+
+      while (_child !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child.lanes, _child.childLanes)
+        );
+        subtreeFlags |= _child.subtreeFlags;
+        subtreeFlags |= _child.flags; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        _child.return = completedWork;
+        _child = _child.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  } else {
+    // Bubble up the earliest expiration time.
+    if ((completedWork.mode & ProfileMode) !== NoMode) {
+      // In profiling mode, resetChildExpirationTime is also used to reset
+      // profiler durations.
+      var _treeBaseDuration = completedWork.selfBaseDuration;
+      var _child2 = completedWork.child;
+
+      while (_child2 !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child2.lanes, _child2.childLanes)
+        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
+        // so we should bubble those up even during a bailout. All the other
+        // flags have a lifetime only of a single render + commit, so we should
+        // ignore them.
+
+        subtreeFlags |= _child2.subtreeFlags & StaticMask;
+        subtreeFlags |= _child2.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+
+        _treeBaseDuration += _child2.treeBaseDuration;
+        _child2 = _child2.sibling;
+      }
+
+      completedWork.treeBaseDuration = _treeBaseDuration;
+    } else {
+      var _child3 = completedWork.child;
+
+      while (_child3 !== null) {
+        newChildLanes = mergeLanes(
+          newChildLanes,
+          mergeLanes(_child3.lanes, _child3.childLanes)
+        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
+        // so we should bubble those up even during a bailout. All the other
+        // flags have a lifetime only of a single render + commit, so we should
+        // ignore them.
+
+        subtreeFlags |= _child3.subtreeFlags & StaticMask;
+        subtreeFlags |= _child3.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
+        // smell because it assumes the commit phase is never concurrent with
+        // the render phase. Will address during refactor to alternate model.
+
+        _child3.return = completedWork;
+        _child3 = _child3.sibling;
+      }
+    }
+
+    completedWork.subtreeFlags |= subtreeFlags;
+  }
+
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
+}
+
+function completeDehydratedSuspenseBoundary(
+  current,
+  workInProgress,
+  nextState
+) {
+  if (
+    hasUnhydratedTailNodes() &&
+    (workInProgress.mode & ConcurrentMode) !== NoMode &&
+    (workInProgress.flags & DidCapture) === NoFlags$1
+  ) {
+    warnIfUnhydratedTailNodes(workInProgress);
+    resetHydrationState();
+    workInProgress.flags |= ForceClientRender | Incomplete | ShouldCapture;
+    return false;
+  }
+
+  var wasHydrated = popHydrationState(workInProgress);
+
+  if (nextState !== null && nextState.dehydrated !== null) {
+    // We might be inside a hydration state the first time we're picking up this
+    // Suspense boundary, and also after we've reentered it for further hydration.
+    if (current === null) {
+      if (!wasHydrated) {
+        throw new Error(
+          "A dehydrated suspense component was completed without a hydrated node. " +
+            "This is probably a bug in React."
+        );
+      }
+
+      prepareToHydrateHostSuspenseInstance(workInProgress);
+      bubbleProperties(workInProgress);
+
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          var isTimedOutSuspense = nextState !== null;
+
+          if (isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var primaryChildFragment = workInProgress.child;
+
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
+      return false;
+    } else {
+      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
+      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
+      resetHydrationState();
+
+      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
+        // This boundary did not suspend so it's now hydrated and unsuspended.
+        workInProgress.memoizedState = null;
+      } // If nothing suspended, we need to schedule an effect to mark this boundary
+      // as having hydrated so events know that they're free to be invoked.
+      // It's also a signal to replay events and the suspense callback.
+      // If something suspended, schedule an effect to attach retry listeners.
+      // So we might as well always mark this.
+
+      workInProgress.flags |= Update;
+      bubbleProperties(workInProgress);
+
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          var _isTimedOutSuspense = nextState !== null;
+
+          if (_isTimedOutSuspense) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var _primaryChildFragment = workInProgress.child;
+
+            if (_primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                _primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
+      return false;
+    }
+  } else {
+    // Successfully completed this tree. If this was a forced client render,
+    // there may have been recoverable errors during first hydration
+    // attempt. If so, add them to a queue so we can log them in the
+    // commit phase.
+    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+
+    return true;
+  }
+}
+
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+
+  popTreeContext(workInProgress);
+
+  switch (workInProgress.tag) {
+    case IndeterminateComponent:
+    case LazyComponent:
+    case SimpleMemoComponent:
+    case FunctionComponent:
+    case ForwardRef:
+    case Fragment:
+    case Mode:
+    case Profiler:
+    case ContextConsumer:
+    case MemoComponent:
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ClassComponent: {
+      bubbleProperties(workInProgress);
+      return null;
+    }
+
+    case HostRoot: {
+      var fiberRoot = workInProgress.stateNode;
+
+      if (enableTransitionTracing) {
+        var transitions = getWorkInProgressTransitions(); // We set the Passive flag here because if there are new transitions,
+        // we will need to schedule callbacks and process the transitions,
+        // which we do in the passive phase
+
+        if (transitions !== null) {
+          workInProgress.flags |= Passive$1;
+        }
+      }
+
+      {
+        var previousCache = null;
+
+        if (current !== null) {
+          previousCache = current.memoizedState.cache;
+        }
+
+        var cache = workInProgress.memoizedState.cache;
+
+        if (cache !== previousCache) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
+        }
+
+        popCacheProvider(workInProgress);
+      }
+
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
+
+      popRootTransition(workInProgress);
+      popHostContainer(workInProgress);
+      resetWorkInProgressVersions();
+
+      if (fiberRoot.pendingContext) {
+        fiberRoot.context = fiberRoot.pendingContext;
+        fiberRoot.pendingContext = null;
+      }
+
+      if (current === null || current.child === null) {
+        // If we hydrated, pop so that we can delete any remaining children
+        // that weren't hydrated.
+        var wasHydrated = popHydrationState(workInProgress);
+
+        if (wasHydrated) {
+          // If we hydrated, then we'll need to schedule an update for
+          // the commit side-effects on the root.
+          markUpdate(workInProgress);
+        } else {
+          if (current !== null) {
+            var prevState = current.memoizedState;
+
+            if (
+              // Check if this is a client root
+              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
+              (workInProgress.flags & ForceClientRender) !== NoFlags$1
+            ) {
+              // Schedule an effect to clear this container at the start of the
+              // next commit. This handles the case of React rendering into a
+              // container with previous children. It's also safe to do for
+              // updates too, because current.child would only be null if the
+              // previous render was null (so the container would already
+              // be empty).
+              workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
+              // recoverable errors during first hydration attempt. If so, add
+              // them to a queue so we can log them in the commit phase.
+
+              upgradeHydrationErrorsToRecoverable();
+            }
+          }
+        }
+      }
+      bubbleProperties(workInProgress);
+
+      if (enableTransitionTracing) {
+        if ((workInProgress.subtreeFlags & Visibility) !== NoFlags$1) {
+          // If any of our suspense children toggle visibility, this means that
+          // the pending boundaries array needs to be updated, which we only
+          // do in the passive phase.
+          workInProgress.flags |= Passive$1;
+        }
+      }
+
+      return null;
+    }
+
+    case HostHoistable: {
+      {
+        var currentRef = current ? current.ref : null;
+
+        if (currentRef !== workInProgress.ref) {
+          markRef(workInProgress);
+        }
+
+        if (
+          // We are mounting and must Update this Hoistable in this commit
+          current === null || // We are transitioning to, from, or between Hoistable Resources
+          // and require an update
+          current.memoizedState !== workInProgress.memoizedState
+        ) {
+          markUpdate(workInProgress);
+        } else if (workInProgress.memoizedState === null) {
+          // We may have props to update on the Hoistable instance. We use the
+          // updateHostComponent path becuase it produces the update queue
+          // we need for Hoistables
+          updateHostComponent(
+            current,
+            workInProgress,
+            workInProgress.type,
+            workInProgress.pendingProps
+          );
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+    }
+    // eslint-disable-next-line-no-fallthrough
+
+    case HostSingleton: {
+      {
+        popHostContext(workInProgress);
+        var rootContainerInstance = getRootHostContainer();
+        var type = workInProgress.type;
+
+        if (current !== null && workInProgress.stateNode != null) {
+          updateHostComponent(current, workInProgress, type, newProps);
+
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        } else {
+          if (!newProps) {
+            if (workInProgress.stateNode === null) {
+              throw new Error(
+                "We must have new props for new mounts. This error is likely " +
+                  "caused by a bug in React. Please file an issue."
+              );
+            } // This can happen when we abort work.
+
+            bubbleProperties(workInProgress);
+            return null;
+          }
+
+          var currentHostContext = getHostContext();
+
+          var _wasHydrated = popHydrationState(workInProgress);
+
+          if (_wasHydrated) {
+            // We ignore the boolean indicating there is an updateQueue because
+            // it is used only to set text children and HostSingletons do not
+            // use them.
+            prepareToHydrateHostInstance(workInProgress, currentHostContext);
+          } else {
+            workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              rootContainerInstance,
+              currentHostContext,
+              true
+            );
+            markUpdate(workInProgress);
+          }
+
+          if (workInProgress.ref !== null) {
+            // If there is a ref on a host node we need to schedule a callback
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
+      }
+    }
+    // eslint-disable-next-line-no-fallthrough
+
+    case HostComponent: {
+      popHostContext(workInProgress);
+      var _type = workInProgress.type;
+
+      if (current !== null && workInProgress.stateNode != null) {
+        updateHostComponent(current, workInProgress, _type, newProps);
+
+        if (current.ref !== workInProgress.ref) {
+          markRef(workInProgress);
+        }
+      } else {
+        if (!newProps) {
+          if (workInProgress.stateNode === null) {
+            throw new Error(
+              "We must have new props for new mounts. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          } // This can happen when we abort work.
+
+          bubbleProperties(workInProgress);
+          return null;
+        }
+
+        var _currentHostContext2 = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
+        // "stack" as the parent. Then append children as we go in beginWork
+        // or completeWork depending on whether we want to add them top->down or
+        // bottom->up. Top->down is faster in IE11.
+
+        var _wasHydrated2 = popHydrationState(workInProgress);
+
+        if (_wasHydrated2) {
+          // TODO: Move this and createInstance step into the beginPhase
+          // to consolidate.
+          if (
+            prepareToHydrateHostInstance(workInProgress, _currentHostContext2)
+          ) {
+            // If changes to the hydrated node need to be applied at the
+            // commit-phase we mark this as such.
+            markUpdate(workInProgress);
+          }
+        } else {
+          var _rootContainerInstance = getRootHostContainer();
+
+          var instance = createInstance(
+            _type,
+            newProps,
+            _rootContainerInstance,
+            _currentHostContext2,
+            workInProgress
+          );
+          appendAllChildren(instance, workInProgress);
+          workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
+          // (eg DOM renderer supports auto-focus for certain elements).
+          // Make sure such renderers get scheduled for later work.
+
+          if (finalizeInitialChildren(instance, _type, newProps)) {
+            markUpdate(workInProgress);
+          }
+        }
+
+        if (workInProgress.ref !== null) {
+          // If there is a ref on a host node we need to schedule a callback
+          markRef(workInProgress);
+        }
+      }
+
+      bubbleProperties(workInProgress);
+      return null;
+    }
+
+    case HostText: {
+      var newText = newProps;
+
+      if (current && workInProgress.stateNode != null) {
+        var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
+        // to schedule a side-effect to do the updates.
+
+        updateHostText(current, workInProgress, oldText, newText);
+      } else {
+        if (typeof newText !== "string") {
+          if (workInProgress.stateNode === null) {
+            throw new Error(
+              "We must have new props for new mounts. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          } // This can happen when we abort work.
+        }
+
+        var _rootContainerInstance2 = getRootHostContainer();
+
+        var _currentHostContext3 = getHostContext();
+
+        var _wasHydrated3 = popHydrationState(workInProgress);
+
+        if (_wasHydrated3) {
+          if (prepareToHydrateHostTextInstance(workInProgress)) {
+            markUpdate(workInProgress);
+          }
+        } else {
+          workInProgress.stateNode = createTextInstance(
+            newText,
+            _rootContainerInstance2,
+            _currentHostContext3,
+            workInProgress
+          );
+        }
+      }
+
+      bubbleProperties(workInProgress);
+      return null;
     }
-  };
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useCacheRefresh =
-      function useCacheRefresh() {
-        currentHookNameInDev = "useCacheRefresh";
-        updateHookTypesDev();
-        return updateRefresh();
-      };
-  }
+    case SuspenseComponent: {
+      popSuspenseHandler(workInProgress);
+      var nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
+      // to its own fiber type so that we can add other kinds of hydration
+      // boundaries that aren't associated with a Suspense tree. In anticipation
+      // of such a refactor, all the hydration logic is contained in
+      // this branch.
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.use = function (usable) {
-      warnInvalidHookAccess();
-      return use(usable);
-    };
-  }
+      if (
+        current === null ||
+        (current.memoizedState !== null &&
+          current.memoizedState.dehydrated !== null)
+      ) {
+        var fallthroughToNormalSuspensePath =
+          completeDehydratedSuspenseBoundary(
+            current,
+            workInProgress,
+            nextState
+          );
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
-      warnInvalidHookAccess();
-      return useMemoCache(size);
-    };
-  }
+        if (!fallthroughToNormalSuspensePath) {
+          if (workInProgress.flags & ShouldCapture) {
+            // Special case. There were remaining unhydrated nodes. We treat
+            // this as a mismatch. Revert to client rendering.
+            return workInProgress;
+          } else {
+            // Did not finish hydrating, either because this is the initial
+            // render or because something suspended.
+            return null;
+          }
+        } // Continue with the normal Suspense path.
+      }
 
-  {
-    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
-      function useEffectEvent(callback) {
-        currentHookNameInDev = "useEffectEvent";
-        warnInvalidHookAccess();
-        updateHookTypesDev();
-        return updateEvent(callback);
-      };
-  }
-}
+      if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
+        // Something suspended. Re-render with the fallback children.
+        workInProgress.lanes = renderLanes; // Do not reset the effect list.
 
-var now = Scheduler.unstable_now;
-var commitTime = 0;
-var layoutEffectStartTime = -1;
-var profilerStartTime = -1;
-var passiveEffectStartTime = -1;
-/**
- * Tracks whether the current update was a nested/cascading update (scheduled from a layout effect).
- *
- * The overall sequence is:
- *   1. render
- *   2. commit (and call `onRender`, `onCommit`)
- *   3. check for nested updates
- *   4. flush passive effects (and call `onPostCommit`)
- *
- * Nested updates are identified in step 3 above,
- * but step 4 still applies to the work that was just committed.
- * We use two flags to track nested updates then:
- * one tracks whether the upcoming update is a nested update,
- * and the other tracks whether the current update was a nested update.
- * The first value gets synced to the second at the start of the render phase.
- */
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        } // Don't bubble properties in this case.
 
-var currentUpdateIsNested = false;
-var nestedUpdateScheduled = false;
+        return workInProgress;
+      }
 
-function isCurrentUpdateNested() {
-  return currentUpdateIsNested;
-}
+      var nextDidTimeout = nextState !== null;
+      var prevDidTimeout = current !== null && current.memoizedState !== null;
 
-function markNestedUpdateScheduled() {
-  {
-    nestedUpdateScheduled = true;
-  }
-}
+      if (nextDidTimeout) {
+        var offscreenFiber = workInProgress.child;
+        var _previousCache = null;
 
-function resetNestedUpdateFlag() {
-  {
-    currentUpdateIsNested = false;
-    nestedUpdateScheduled = false;
-  }
-}
+        if (
+          offscreenFiber.alternate !== null &&
+          offscreenFiber.alternate.memoizedState !== null &&
+          offscreenFiber.alternate.memoizedState.cachePool !== null
+        ) {
+          _previousCache =
+            offscreenFiber.alternate.memoizedState.cachePool.pool;
+        }
 
-function syncNestedUpdateFlag() {
-  {
-    currentUpdateIsNested = nestedUpdateScheduled;
-    nestedUpdateScheduled = false;
-  }
-}
+        var _cache = null;
 
-function getCommitTime() {
-  return commitTime;
-}
+        if (
+          offscreenFiber.memoizedState !== null &&
+          offscreenFiber.memoizedState.cachePool !== null
+        ) {
+          _cache = offscreenFiber.memoizedState.cachePool.pool;
+        }
 
-function recordCommitTime() {
-  commitTime = now();
-}
+        if (_cache !== _previousCache) {
+          // Run passive effects to retain/release the cache.
+          offscreenFiber.flags |= Passive$1;
+        }
+      } // If the suspended state of the boundary changes, we need to schedule
+      // a passive effect, which is when we process the transitions
 
-function startProfilerTimer(fiber) {
-  profilerStartTime = now();
+      if (nextDidTimeout !== prevDidTimeout) {
+        if (enableTransitionTracing) {
+          var _offscreenFiber = workInProgress.child;
+          _offscreenFiber.flags |= Passive$1;
+        } // If the suspended state of the boundary changes, we need to schedule
+        // an effect to toggle the subtree's visibility. When we switch from
+        // fallback -> primary, the inner Offscreen fiber schedules this effect
+        // as part of its normal complete phase. But when we switch from
+        // primary -> fallback, the inner Offscreen fiber does not have a complete
+        // phase. So we need to schedule its effect here.
+        //
+        // We also use this flag to connect/disconnect the effects, but the same
+        // logic applies: when re-connecting, the Offscreen fiber's complete
+        // phase will handle scheduling the effect. It's only when the fallback
+        // is active that we have to do anything special.
 
-  if (fiber.actualStartTime < 0) {
-    fiber.actualStartTime = now();
-  }
-}
+        if (nextDidTimeout) {
+          var _offscreenFiber2 = workInProgress.child;
+          _offscreenFiber2.flags |= Visibility;
+        }
+      }
 
-function stopProfilerTimerIfRunning(fiber) {
-  profilerStartTime = -1;
-}
+      var wakeables = workInProgress.updateQueue;
 
-function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
-  if (profilerStartTime >= 0) {
-    var elapsedTime = now() - profilerStartTime;
-    fiber.actualDuration += elapsedTime;
+      if (wakeables !== null) {
+        // Schedule an effect to attach a retry listener to the promise.
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
+      }
 
-    if (overrideBaseTime) {
-      fiber.selfBaseDuration = elapsedTime;
-    }
+      if (
+        workInProgress.updateQueue !== null &&
+        workInProgress.memoizedProps.suspenseCallback != null
+      ) {
+        // Always notify the callback
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
+      }
 
-    profilerStartTime = -1;
-  }
-}
+      bubbleProperties(workInProgress);
 
-function recordLayoutEffectDuration(fiber) {
-  if (layoutEffectStartTime >= 0) {
-    var elapsedTime = now() - layoutEffectStartTime;
-    layoutEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
-    // Or the root (for the DevTools Profiler to read)
+      {
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          if (nextDidTimeout) {
+            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
+            var primaryChildFragment = workInProgress.child;
 
-    var parentFiber = fiber.return;
+            if (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
 
-    while (parentFiber !== null) {
-      switch (parentFiber.tag) {
-        case HostRoot:
-          var root = parentFiber.stateNode;
-          root.effectDuration += elapsedTime;
-          return;
+      return null;
+    }
 
-        case Profiler:
-          var parentStateNode = parentFiber.stateNode;
-          parentStateNode.effectDuration += elapsedTime;
-          return;
+    case HostPortal:
+      popHostContainer(workInProgress);
+
+      if (current === null) {
+        preparePortalMount(workInProgress.stateNode.containerInfo);
       }
 
-      parentFiber = parentFiber.return;
+      bubbleProperties(workInProgress);
+      return null;
+
+    case ContextProvider:
+      // Pop provider fiber
+      var context = workInProgress.type._context;
+      popProvider(context, workInProgress);
+      bubbleProperties(workInProgress);
+      return null;
+
+    case IncompleteClassComponent: {
+      bubbleProperties(workInProgress);
+      return null;
     }
-  }
-}
 
-function recordPassiveEffectDuration(fiber) {
-  if (passiveEffectStartTime >= 0) {
-    var elapsedTime = now() - passiveEffectStartTime;
-    passiveEffectStartTime = -1; // Store duration on the next nearest Profiler ancestor
-    // Or the root (for the DevTools Profiler to read)
+    case SuspenseListComponent: {
+      popSuspenseListContext(workInProgress);
+      var renderState = workInProgress.memoizedState;
 
-    var parentFiber = fiber.return;
+      if (renderState === null) {
+        // We're running in the default, "independent" mode.
+        // We don't do anything in this mode.
+        bubbleProperties(workInProgress);
+        return null;
+      }
 
-    while (parentFiber !== null) {
-      switch (parentFiber.tag) {
-        case HostRoot:
-          var root = parentFiber.stateNode;
+      var didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
+      var renderedTail = renderState.rendering;
 
-          if (root !== null) {
-            root.passiveEffectDuration += elapsedTime;
-          }
+      if (renderedTail === null) {
+        // We just rendered the head.
+        if (!didSuspendAlready) {
+          // This is the first pass. We need to figure out if anything is still
+          // suspended in the rendered set.
+          // If new content unsuspended, but there's still some content that
+          // didn't. Then we need to do a second pass that forces everything
+          // to keep showing their fallbacks.
+          // We might be suspended if something in this render pass suspended, or
+          // something in the previous committed pass suspended. Otherwise,
+          // there's no chance so we can skip the expensive call to
+          // findFirstSuspended.
+          var cannotBeSuspended =
+            renderHasNotSuspendedYet() &&
+            (current === null || (current.flags & DidCapture) === NoFlags$1);
 
-          return;
+          if (!cannotBeSuspended) {
+            var row = workInProgress.child;
 
-        case Profiler:
-          var parentStateNode = parentFiber.stateNode;
+            while (row !== null) {
+              var suspended = findFirstSuspended(row);
 
-          if (parentStateNode !== null) {
-            // Detached fibers have their state node cleared out.
-            // In this case, the return pointer is also cleared out,
-            // so we won't be able to report the time spent in this Profiler's subtree.
-            parentStateNode.passiveEffectDuration += elapsedTime;
-          }
+              if (suspended !== null) {
+                didSuspendAlready = true;
+                workInProgress.flags |= DidCapture;
+                cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
+                // part of the second pass. In that case nothing will subscribe to
+                // its thenables. Instead, we'll transfer its thenables to the
+                // SuspenseList so that it can retry if they resolve.
+                // There might be multiple of these in the list but since we're
+                // going to wait for all of them anyway, it doesn't really matter
+                // which ones gets to ping. In theory we could get clever and keep
+                // track of how many dependencies remain but it gets tricky because
+                // in the meantime, we can add/remove/change items and dependencies.
+                // We might bail out of the loop before finding any but that
+                // doesn't matter since that means that the other boundaries that
+                // we did find already has their listeners attached.
 
-          return;
-      }
+                var newThenables = suspended.updateQueue;
 
-      parentFiber = parentFiber.return;
-    }
-  }
-}
+                if (newThenables !== null) {
+                  workInProgress.updateQueue = newThenables;
+                  workInProgress.flags |= Update;
+                } // Rerender the whole list, but this time, we'll force fallbacks
+                // to stay in place.
+                // Reset the effect flags before doing the second pass since that's now invalid.
+                // Reset the child fibers to their original state.
 
-function startLayoutEffectTimer() {
-  layoutEffectStartTime = now();
-}
+                workInProgress.subtreeFlags = NoFlags$1;
+                resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
+                // immediately rerender the children.
 
-function startPassiveEffectTimer() {
-  passiveEffectStartTime = now();
-}
+                pushSuspenseListContext(
+                  workInProgress,
+                  setShallowSuspenseListContext(
+                    suspenseStackCursor.current,
+                    ForceSuspenseFallback
+                  )
+                ); // Don't bubble properties in this case.
 
-function transferActualDuration(fiber) {
-  // Transfer time spent rendering these children so we don't lose it
-  // after we rerender. This is used as a helper in special cases
-  // where we should count the work of multiple passes.
-  var child = fiber.child;
+                return workInProgress.child;
+              }
 
-  while (child) {
-    // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
-    fiber.actualDuration += child.actualDuration;
-    child = child.sibling;
-  }
-}
+              row = row.sibling;
+            }
+          }
 
-function resolveDefaultProps(Component, baseProps) {
-  if (Component && Component.defaultProps) {
-    // Resolve default props. Taken from ReactElement
-    var props = assign({}, baseProps);
-    var defaultProps = Component.defaultProps;
+          if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
+            // We have already passed our CPU deadline but we still have rows
+            // left in the tail. We'll just give up further attempts to render
+            // the main content and only render fallbacks.
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true;
+            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+            // to get it started back up to attempt the next item. While in terms
+            // of priority this work has the same priority as this current render,
+            // it's not part of the same transition once the transition has
+            // committed. If it's sync, we still want to yield so that it can be
+            // painted. Conceptually, this is really the same as pinging.
+            // We can use any RetryLane even if it's the one currently rendering
+            // since we're leaving it behind on this node.
 
-    for (var propName in defaultProps) {
-      if (props[propName] === undefined) {
-        props[propName] = defaultProps[propName];
-      }
-    }
+            workInProgress.lanes = SomeRetryLane;
+          }
+        } else {
+          cutOffTailIfNeeded(renderState, false);
+        } // Next we're going to render the tail.
+      } else {
+        // Append the rendered row to the child list.
+        if (!didSuspendAlready) {
+          var _suspended = findFirstSuspended(renderedTail);
 
-    return props;
-  }
+          if (_suspended !== null) {
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
+            // get lost if this row ends up dropped during a second pass.
 
-  return baseProps;
-}
+            var _newThenables = _suspended.updateQueue;
 
-var fakeInternalInstance = {};
-var didWarnAboutStateAssignmentForComponent;
-var didWarnAboutUninitializedState;
-var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate;
-var didWarnAboutLegacyLifecyclesAndDerivedState;
-var didWarnAboutUndefinedDerivedState;
-var didWarnAboutDirectlyAssigningPropsToState;
-var didWarnAboutInvalidateContextType;
-var didWarnOnInvalidCallback;
+            if (_newThenables !== null) {
+              workInProgress.updateQueue = _newThenables;
+              workInProgress.flags |= Update;
+            }
 
-{
-  didWarnAboutStateAssignmentForComponent = new Set();
-  didWarnAboutUninitializedState = new Set();
-  didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
-  didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
-  didWarnAboutDirectlyAssigningPropsToState = new Set();
-  didWarnAboutUndefinedDerivedState = new Set();
-  didWarnAboutInvalidateContextType = new Set();
-  didWarnOnInvalidCallback = new Set(); // This is so gross but it's at least non-critical and can be removed if
-  // it causes problems. This is meant to give a nicer error message for
-  // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,
-  // ...)) which otherwise throws a "_processChildContext is not a function"
-  // exception.
+            cutOffTailIfNeeded(renderState, true); // This might have been modified.
 
-  Object.defineProperty(fakeInternalInstance, "_processChildContext", {
-    enumerable: false,
-    value: function () {
-      throw new Error(
-        "_processChildContext is not available in React 16+. This likely " +
-          "means you have multiple copies of React and are attempting to nest " +
-          "a React 15 tree inside a React 16 tree using " +
-          "unstable_renderSubtreeIntoContainer, which isn't supported. Try " +
-          "to make sure you have only one copy of React (and ideally, switch " +
-          "to ReactDOM.createPortal)."
-      );
-    }
-  });
-  Object.freeze(fakeInternalInstance);
-}
+            if (
+              renderState.tail === null &&
+              renderState.tailMode === "hidden" &&
+              !renderedTail.alternate &&
+              !getIsHydrating() // We don't cut it if we're hydrating.
+            ) {
+              // We're done.
+              bubbleProperties(workInProgress);
+              return null;
+            }
+          } else if (
+            // The time it took to render last row is greater than the remaining
+            // time we have to render. So rendering one more row would likely
+            // exceed it.
+            now$1() * 2 - renderState.renderingStartTime >
+              getRenderTargetTime() &&
+            renderLanes !== OffscreenLane
+          ) {
+            // We have now passed our CPU deadline and we'll just give up further
+            // attempts to render the main content and only render fallbacks.
+            // The assumption is that this is usually faster.
+            workInProgress.flags |= DidCapture;
+            didSuspendAlready = true;
+            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
+            // to get it started back up to attempt the next item. While in terms
+            // of priority this work has the same priority as this current render,
+            // it's not part of the same transition once the transition has
+            // committed. If it's sync, we still want to yield so that it can be
+            // painted. Conceptually, this is really the same as pinging.
+            // We can use any RetryLane even if it's the one currently rendering
+            // since we're leaving it behind on this node.
+
+            workInProgress.lanes = SomeRetryLane;
+          }
+        }
+
+        if (renderState.isBackwards) {
+          // The effect list of the backwards tail will have been added
+          // to the end. This breaks the guarantee that life-cycles fire in
+          // sibling order but that isn't a strong guarantee promised by React.
+          // Especially since these might also just pop in during future commits.
+          // Append to the beginning of the list.
+          renderedTail.sibling = workInProgress.child;
+          workInProgress.child = renderedTail;
+        } else {
+          var previousSibling = renderState.last;
 
-function warnOnInvalidCallback(callback, callerName) {
-  {
-    if (callback === null || typeof callback === "function") {
-      return;
-    }
+          if (previousSibling !== null) {
+            previousSibling.sibling = renderedTail;
+          } else {
+            workInProgress.child = renderedTail;
+          }
 
-    var key = callerName + "_" + callback;
+          renderState.last = renderedTail;
+        }
+      }
 
-    if (!didWarnOnInvalidCallback.has(key)) {
-      didWarnOnInvalidCallback.add(key);
+      if (renderState.tail !== null) {
+        // We still have tail rows to render.
+        // Pop a row.
+        var next = renderState.tail;
+        renderState.rendering = next;
+        renderState.tail = next.sibling;
+        renderState.renderingStartTime = now$1();
+        next.sibling = null; // Restore the context.
+        // TODO: We can probably just avoid popping it instead and only
+        // setting it the first time we go from not suspended to suspended.
 
-      error(
-        "%s(...): Expected the last optional `callback` argument to be a " +
-          "function. Instead received: %s.",
-        callerName,
-        callback
-      );
-    }
-  }
-}
+        var suspenseContext = suspenseStackCursor.current;
 
-function warnOnUndefinedDerivedState(type, partialState) {
-  {
-    if (partialState === undefined) {
-      var componentName = getComponentNameFromType(type) || "Component";
+        if (didSuspendAlready) {
+          suspenseContext = setShallowSuspenseListContext(
+            suspenseContext,
+            ForceSuspenseFallback
+          );
+        } else {
+          suspenseContext =
+            setDefaultShallowSuspenseListContext(suspenseContext);
+        }
 
-      if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
-        didWarnAboutUndefinedDerivedState.add(componentName);
+        pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
+        // Don't bubble properties in this case.
 
-        error(
-          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
-            "You have returned undefined.",
-          componentName
-        );
+        return next;
       }
+
+      bubbleProperties(workInProgress);
+      return null;
     }
-  }
-}
 
-function applyDerivedStateFromProps(
-  workInProgress,
-  ctor,
-  getDerivedStateFromProps,
-  nextProps
-) {
-  var prevState = workInProgress.memoizedState;
-  var partialState = getDerivedStateFromProps(nextProps, prevState);
+    case ScopeComponent: {
+      {
+        if (current === null) {
+          var scopeInstance = createScopeInstance();
+          workInProgress.stateNode = scopeInstance;
+          prepareScopeUpdate(scopeInstance, workInProgress);
 
-  {
-    if (workInProgress.mode & StrictLegacyMode) {
-      setIsStrictModeForDevtools(true);
+          if (workInProgress.ref !== null) {
+            markRef(workInProgress);
+            markUpdate(workInProgress);
+          }
+        } else {
+          if (workInProgress.ref !== null) {
+            markUpdate(workInProgress);
+          }
 
-      try {
-        // Invoke the function an extra time to help detect side-effects.
-        partialState = getDerivedStateFromProps(nextProps, prevState);
-      } finally {
-        setIsStrictModeForDevtools(false);
+          if (current.ref !== workInProgress.ref) {
+            markRef(workInProgress);
+          }
+        }
+
+        bubbleProperties(workInProgress);
+        return null;
       }
     }
 
-    warnOnUndefinedDerivedState(ctor, partialState);
-  } // Merge the partial state and the previous state.
-
-  var memoizedState =
-    partialState === null || partialState === undefined
-      ? prevState
-      : assign({}, prevState, partialState);
-  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the
-  // base state.
-
-  if (workInProgress.lanes === NoLanes) {
-    // Queue is always non-null for classes
-    var updateQueue = workInProgress.updateQueue;
-    updateQueue.baseState = memoizedState;
-  }
-}
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      popSuspenseHandler(workInProgress);
+      popHiddenContext(workInProgress);
+      var _nextState = workInProgress.memoizedState;
+      var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
 
-var classComponentUpdater = {
-  isMounted: isMounted,
-  // $FlowFixMe[missing-local-annot]
-  enqueueSetState: function (inst, payload, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.payload = payload;
+      if (workInProgress.tag === LegacyHiddenComponent);
+      else {
+        if (current !== null) {
+          var _prevState = current.memoizedState;
+          var prevIsHidden = _prevState !== null;
 
-    if (callback !== undefined && callback !== null) {
-      {
-        warnOnInvalidCallback(callback, "setState");
+          if (prevIsHidden !== nextIsHidden) {
+            workInProgress.flags |= Visibility;
+          }
+        } else {
+          // On initial mount, we only need a Visibility effect if the tree
+          // is hidden.
+          if (nextIsHidden) {
+            workInProgress.flags |= Visibility;
+          }
+        }
       }
 
-      update.callback = callback;
-    }
-
-    var root = enqueueUpdate(fiber, update, lane);
-
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+      if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
+        bubbleProperties(workInProgress);
+      } else {
+        // Don't bubble properties for hidden children unless we're rendering
+        // at offscreen priority.
+        if (
+          includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
+          (workInProgress.flags & DidCapture) === NoLanes
+        ) {
+          bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
+          // If so, we need to hide those nodes in the commit phase, so
+          // schedule a visibility effect.
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logStateUpdateScheduled(name, lane, payload);
+          if (
+            workInProgress.tag !== LegacyHiddenComponent &&
+            workInProgress.subtreeFlags & (Placement | Update)
+          ) {
+            workInProgress.flags |= Visibility;
+          }
         }
       }
-    }
 
-    if (enableSchedulingProfiler) {
-      markStateUpdateScheduled(fiber, lane);
-    }
-  },
-  enqueueReplaceState: function (inst, payload, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.tag = ReplaceState;
-    update.payload = payload;
+      if (workInProgress.updateQueue !== null) {
+        // Schedule an effect to attach Suspense retry listeners
+        // TODO: Move to passive phase
+        workInProgress.flags |= Update;
+      }
 
-    if (callback !== undefined && callback !== null) {
       {
-        warnOnInvalidCallback(callback, "replaceState");
-      }
+        var _previousCache2 = null;
 
-      update.callback = callback;
-    }
+        if (
+          current !== null &&
+          current.memoizedState !== null &&
+          current.memoizedState.cachePool !== null
+        ) {
+          _previousCache2 = current.memoizedState.cachePool.pool;
+        }
 
-    var root = enqueueUpdate(fiber, update, lane);
+        var _cache2 = null;
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+        if (
+          workInProgress.memoizedState !== null &&
+          workInProgress.memoizedState.cachePool !== null
+        ) {
+          _cache2 = workInProgress.memoizedState.cachePool.pool;
+        }
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logStateUpdateScheduled(name, lane, payload);
+        if (_cache2 !== _previousCache2) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
         }
       }
-    }
 
-    if (enableSchedulingProfiler) {
-      markStateUpdateScheduled(fiber, lane);
+      popTransition(workInProgress, current);
+      return null;
     }
-  },
-  // $FlowFixMe[missing-local-annot]
-  enqueueForceUpdate: function (inst, callback) {
-    var fiber = get(inst);
-    var lane = requestUpdateLane(fiber);
-    var update = createUpdate(lane);
-    update.tag = ForceUpdate;
 
-    if (callback !== undefined && callback !== null) {
+    case CacheComponent: {
       {
-        warnOnInvalidCallback(callback, "forceUpdate");
-      }
-
-      update.callback = callback;
-    }
+        var _previousCache3 = null;
 
-    var root = enqueueUpdate(fiber, update, lane);
+        if (current !== null) {
+          _previousCache3 = current.memoizedState.cache;
+        }
 
-    if (root !== null) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-      entangleTransitions(root, fiber, lane);
-    }
+        var _cache3 = workInProgress.memoizedState.cache;
 
-    {
-      if (enableDebugTracing) {
-        if (fiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(fiber) || "Unknown";
-          logForceUpdateScheduled(name, lane);
+        if (_cache3 !== _previousCache3) {
+          // Run passive effects to retain/release the cache.
+          workInProgress.flags |= Passive$1;
         }
+
+        popCacheProvider(workInProgress);
+        bubbleProperties(workInProgress);
       }
-    }
 
-    if (enableSchedulingProfiler) {
-      markForceUpdateScheduled(fiber, lane);
+      return null;
     }
-  }
-};
-
-function checkShouldComponentUpdate(
-  workInProgress,
-  ctor,
-  oldProps,
-  newProps,
-  oldState,
-  newState,
-  nextContext
-) {
-  var instance = workInProgress.stateNode;
-
-  if (typeof instance.shouldComponentUpdate === "function") {
-    var shouldUpdate = instance.shouldComponentUpdate(
-      newProps,
-      newState,
-      nextContext
-    );
 
-    {
-      if (workInProgress.mode & StrictLegacyMode) {
-        setIsStrictModeForDevtools(true);
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var _instance3 = workInProgress.stateNode;
 
-        try {
-          // Invoke the function an extra time to help detect side-effects.
-          shouldUpdate = instance.shouldComponentUpdate(
-            newProps,
-            newState,
-            nextContext
-          );
-        } finally {
-          setIsStrictModeForDevtools(false);
+        if (_instance3 !== null) {
+          popMarkerInstance(workInProgress);
         }
-      }
 
-      if (shouldUpdate === undefined) {
-        error(
-          "%s.shouldComponentUpdate(): Returned undefined instead of a " +
-            "boolean value. Make sure to return true or false.",
-          getComponentNameFromType(ctor) || "Component"
-        );
+        bubbleProperties(workInProgress);
       }
-    }
-
-    return shouldUpdate;
-  }
 
-  if (ctor.prototype && ctor.prototype.isPureReactComponent) {
-    return (
-      !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
-    );
+      return null;
+    }
   }
 
-  return true;
+  throw new Error(
+    "Unknown unit of work tag (" +
+      workInProgress.tag +
+      "). This error is likely caused by a bug in " +
+      "React. Please file an issue."
+  );
 }
 
-function checkClassInstance(workInProgress, ctor, newProps) {
-  var instance = workInProgress.stateNode;
-
-  {
-    var name = getComponentNameFromType(ctor) || "Component";
-    var renderPresent = instance.render;
+function unwindWork(current, workInProgress, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(workInProgress);
 
-    if (!renderPresent) {
-      if (ctor.prototype && typeof ctor.prototype.render === "function") {
-        error(
-          "%s(...): No `render` method found on the returned component " +
-            "instance: did you accidentally return an object from the constructor?",
-          name
-        );
-      } else {
-        error(
-          "%s(...): No `render` method found on the returned component " +
-            "instance: you may have forgotten to define `render`.",
-          name
-        );
-      }
-    }
+  switch (workInProgress.tag) {
+    case ClassComponent: {
+      var flags = workInProgress.flags;
 
-    if (
-      instance.getInitialState &&
-      !instance.getInitialState.isReactClassApproved &&
-      !instance.state
-    ) {
-      error(
-        "getInitialState was defined on %s, a plain JavaScript class. " +
-          "This is only supported for classes created using React.createClass. " +
-          "Did you mean to define a state property instead?",
-        name
-      );
-    }
+      if (flags & ShouldCapture) {
+        workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
 
-    if (
-      instance.getDefaultProps &&
-      !instance.getDefaultProps.isReactClassApproved
-    ) {
-      error(
-        "getDefaultProps was defined on %s, a plain JavaScript class. " +
-          "This is only supported for classes created using React.createClass. " +
-          "Use a static property to define defaultProps instead.",
-        name
-      );
-    }
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
 
-    if (instance.propTypes) {
-      error(
-        "propTypes was defined as an instance property on %s. Use a static " +
-          "property to define propTypes instead.",
-        name
-      );
-    }
+        return workInProgress;
+      }
 
-    if (instance.contextType) {
-      error(
-        "contextType was defined as an instance property on %s. Use a static " +
-          "property to define contextType instead.",
-        name
-      );
+      return null;
     }
 
-    {
-      if (ctor.childContextTypes) {
-        error(
-          "%s uses the legacy childContextTypes API which is no longer supported. " +
-            "Use React.createContext() instead.",
-          name
-        );
+    case HostRoot: {
+      {
+        popCacheProvider(workInProgress);
       }
 
-      if (ctor.contextTypes) {
-        error(
-          "%s uses the legacy contextTypes API which is no longer supported. " +
-            "Use React.createContext() with static contextType instead.",
-          name
-        );
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
       }
-    }
 
-    if (typeof instance.componentShouldUpdate === "function") {
-      error(
-        "%s has a method called " +
-          "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
-          "The name is phrased as a question because the function is " +
-          "expected to return a value.",
-        name
-      );
-    }
+      popRootTransition(workInProgress);
+      popHostContainer(workInProgress);
+      resetWorkInProgressVersions();
+      var _flags = workInProgress.flags;
 
-    if (
-      ctor.prototype &&
-      ctor.prototype.isPureReactComponent &&
-      typeof instance.shouldComponentUpdate !== "undefined"
-    ) {
-      error(
-        "%s has a method called shouldComponentUpdate(). " +
-          "shouldComponentUpdate should not be used when extending React.PureComponent. " +
-          "Please extend React.Component if shouldComponentUpdate is used.",
-        getComponentNameFromType(ctor) || "A pure component"
-      );
-    }
+      if (
+        (_flags & ShouldCapture) !== NoFlags$1 &&
+        (_flags & DidCapture) === NoFlags$1
+      ) {
+        // There was an error during render that wasn't captured by a suspense
+        // boundary. Do a second pass on the root to unmount the children.
+        workInProgress.flags = (_flags & ~ShouldCapture) | DidCapture;
+        return workInProgress;
+      } // We unwound to the root without completing it. Exit.
 
-    if (typeof instance.componentDidUnmount === "function") {
-      error(
-        "%s has a method called " +
-          "componentDidUnmount(). But there is no such lifecycle method. " +
-          "Did you mean componentWillUnmount()?",
-        name
-      );
+      return null;
     }
 
-    if (typeof instance.componentDidReceiveProps === "function") {
-      error(
-        "%s has a method called " +
-          "componentDidReceiveProps(). But there is no such lifecycle method. " +
-          "If you meant to update the state in response to changing props, " +
-          "use componentWillReceiveProps(). If you meant to fetch data or " +
-          "run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
-        name
-      );
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      // TODO: popHydrationState
+      popHostContext(workInProgress);
+      return null;
     }
 
-    if (typeof instance.componentWillRecieveProps === "function") {
-      error(
-        "%s has a method called " +
-          "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
-        name
-      );
-    }
+    case SuspenseComponent: {
+      popSuspenseHandler(workInProgress);
+      var suspenseState = workInProgress.memoizedState;
 
-    if (typeof instance.UNSAFE_componentWillRecieveProps === "function") {
-      error(
-        "%s has a method called " +
-          "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
-        name
-      );
-    }
+      if (suspenseState !== null && suspenseState.dehydrated !== null) {
+        if (workInProgress.alternate === null) {
+          throw new Error(
+            "Threw in newly mounted dehydrated component. This is likely a bug in " +
+              "React. Please file an issue."
+          );
+        }
 
-    var hasMutatedProps = instance.props !== newProps;
+        resetHydrationState();
+      }
 
-    if (instance.props !== undefined && hasMutatedProps) {
-      error(
-        "%s(...): When calling super() in `%s`, make sure to pass " +
-          "up the same props that your component's constructor was passed.",
-        name,
-        name
-      );
-    }
+      var _flags2 = workInProgress.flags;
 
-    if (instance.defaultProps) {
-      error(
-        "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
-          " Instead, define defaultProps as a static property on %s.",
-        name,
-        name
-      );
-    }
+      if (_flags2 & ShouldCapture) {
+        workInProgress.flags = (_flags2 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
 
-    if (
-      typeof instance.getSnapshotBeforeUpdate === "function" &&
-      typeof instance.componentDidUpdate !== "function" &&
-      !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)
-    ) {
-      didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
 
-      error(
-        "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
-          "This component defines getSnapshotBeforeUpdate() only.",
-        getComponentNameFromType(ctor)
-      );
-    }
+        return workInProgress;
+      }
 
-    if (typeof instance.getDerivedStateFromProps === "function") {
-      error(
-        "%s: getDerivedStateFromProps() is defined as an instance method " +
-          "and will be ignored. Instead, declare it as a static method.",
-        name
-      );
+      return null;
     }
 
-    if (typeof instance.getDerivedStateFromError === "function") {
-      error(
-        "%s: getDerivedStateFromError() is defined as an instance method " +
-          "and will be ignored. Instead, declare it as a static method.",
-        name
-      );
-    }
+    case SuspenseListComponent: {
+      popSuspenseListContext(workInProgress); // SuspenseList doesn't actually catch anything. It should've been
+      // caught by a nested boundary. If not, it should bubble through.
 
-    if (typeof ctor.getSnapshotBeforeUpdate === "function") {
-      error(
-        "%s: getSnapshotBeforeUpdate() is defined as a static method " +
-          "and will be ignored. Instead, declare it as an instance method.",
-        name
-      );
+      return null;
     }
 
-    var state = instance.state;
+    case HostPortal:
+      popHostContainer(workInProgress);
+      return null;
 
-    if (state && (typeof state !== "object" || isArray(state))) {
-      error("%s.state: must be set to an object or null", name);
-    }
+    case ContextProvider:
+      var context = workInProgress.type._context;
+      popProvider(context, workInProgress);
+      return null;
 
-    if (
-      typeof instance.getChildContext === "function" &&
-      typeof ctor.childContextTypes !== "object"
-    ) {
-      error(
-        "%s.getChildContext(): childContextTypes must be defined in order to " +
-          "use getChildContext().",
-        name
-      );
-    }
-  }
-}
+    case OffscreenComponent:
+    case LegacyHiddenComponent: {
+      popSuspenseHandler(workInProgress);
+      popHiddenContext(workInProgress);
+      popTransition(workInProgress, current);
+      var _flags3 = workInProgress.flags;
 
-function adoptClassInstance(workInProgress, instance) {
-  instance.updater = classComponentUpdater;
-  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates
+      if (_flags3 & ShouldCapture) {
+        workInProgress.flags = (_flags3 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
 
-  set(instance, workInProgress);
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
 
-  {
-    instance._reactInternalInstance = fakeInternalInstance;
-  }
-}
+        return workInProgress;
+      }
 
-function constructClassInstance(workInProgress, ctor, props) {
-  var context = emptyContextObject;
-  var contextType = ctor.contextType;
+      return null;
+    }
 
-  {
-    if ("contextType" in ctor) {
-      var isValid = // Allow null for conditional declaration
-        contextType === null ||
-        (contextType !== undefined &&
-          contextType.$$typeof === REACT_CONTEXT_TYPE &&
-          contextType._context === undefined); // Not a <Context.Consumer>
+    case CacheComponent:
+      {
+        popCacheProvider(workInProgress);
+      }
 
-      if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
-        didWarnAboutInvalidateContextType.add(ctor);
-        var addendum = "";
+      return null;
 
-        if (contextType === undefined) {
-          addendum =
-            " However, it is set to undefined. " +
-            "This can be caused by a typo or by mixing up named and default imports. " +
-            "This can also happen due to a circular dependency, so " +
-            "try moving the createContext() call to a separate file.";
-        } else if (typeof contextType !== "object") {
-          addendum = " However, it is set to a " + typeof contextType + ".";
-        } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
-          addendum = " Did you accidentally pass the Context.Provider instead?";
-        } else if (contextType._context !== undefined) {
-          // <Context.Consumer>
-          addendum = " Did you accidentally pass the Context.Consumer instead?";
-        } else {
-          addendum =
-            " However, it is set to an object with keys {" +
-            Object.keys(contextType).join(", ") +
-            "}.";
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        if (workInProgress.stateNode !== null) {
+          popMarkerInstance(workInProgress);
         }
-
-        error(
-          "%s defines an invalid contextType. " +
-            "contextType should point to the Context object returned by React.createContext().%s",
-          getComponentNameFromType(ctor) || "Component",
-          addendum
-        );
       }
-    }
-  }
 
-  if (typeof contextType === "object" && contextType !== null) {
-    context = readContext(contextType);
+      return null;
+
+    default:
+      return null;
   }
+}
 
-  var instance = new ctor(props, context); // Instantiate twice to help detect side-effects.
+function unwindInterruptedWork(current, interruptedWork, renderLanes) {
+  // Note: This intentionally doesn't check if we're hydrating because comparing
+  // to the current tree provider fiber is just as fast and less error-prone.
+  // Ideally we would have a special version of the work loop only
+  // for hydration.
+  popTreeContext(interruptedWork);
 
-  {
-    if (workInProgress.mode & StrictLegacyMode) {
-      setIsStrictModeForDevtools(true);
+  switch (interruptedWork.tag) {
+    case ClassComponent: {
+      break;
+    }
 
-      try {
-        instance = new ctor(props, context); // eslint-disable-line no-new
-      } finally {
-        setIsStrictModeForDevtools(false);
+    case HostRoot: {
+      {
+        popCacheProvider(interruptedWork);
       }
-    }
-  }
 
-  var state = (workInProgress.memoizedState =
-    instance.state !== null && instance.state !== undefined
-      ? instance.state
-      : null);
-  adoptClassInstance(workInProgress, instance);
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(interruptedWork);
+      }
 
-  {
-    if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
-      var componentName = getComponentNameFromType(ctor) || "Component";
+      popRootTransition(interruptedWork);
+      popHostContainer(interruptedWork);
+      resetWorkInProgressVersions();
+      break;
+    }
 
-      if (!didWarnAboutUninitializedState.has(componentName)) {
-        didWarnAboutUninitializedState.add(componentName);
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      popHostContext(interruptedWork);
+      break;
+    }
 
-        error(
-          "`%s` uses `getDerivedStateFromProps` but its initial state is " +
-            "%s. This is not recommended. Instead, define the initial state by " +
-            "assigning an object to `this.state` in the constructor of `%s`. " +
-            "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
-          componentName,
-          instance.state === null ? "null" : "undefined",
-          componentName
-        );
-      }
-    } // If new component APIs are defined, "unsafe" lifecycles won't be called.
-    // Warn about these lifecycles if they are present.
-    // Don't warn about react-lifecycles-compat polyfilled methods though.
+    case HostPortal:
+      popHostContainer(interruptedWork);
+      break;
 
-    if (
-      typeof ctor.getDerivedStateFromProps === "function" ||
-      typeof instance.getSnapshotBeforeUpdate === "function"
-    ) {
-      var foundWillMountName = null;
-      var foundWillReceivePropsName = null;
-      var foundWillUpdateName = null;
+    case SuspenseComponent:
+      popSuspenseHandler(interruptedWork);
+      break;
 
-      if (
-        typeof instance.componentWillMount === "function" &&
-        instance.componentWillMount.__suppressDeprecationWarning !== true
-      ) {
-        foundWillMountName = "componentWillMount";
-      } else if (typeof instance.UNSAFE_componentWillMount === "function") {
-        foundWillMountName = "UNSAFE_componentWillMount";
-      }
+    case SuspenseListComponent:
+      popSuspenseListContext(interruptedWork);
+      break;
 
-      if (
-        typeof instance.componentWillReceiveProps === "function" &&
-        instance.componentWillReceiveProps.__suppressDeprecationWarning !== true
-      ) {
-        foundWillReceivePropsName = "componentWillReceiveProps";
-      } else if (
-        typeof instance.UNSAFE_componentWillReceiveProps === "function"
-      ) {
-        foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
-      }
+    case ContextProvider:
+      var context = interruptedWork.type._context;
+      popProvider(context, interruptedWork);
+      break;
 
-      if (
-        typeof instance.componentWillUpdate === "function" &&
-        instance.componentWillUpdate.__suppressDeprecationWarning !== true
-      ) {
-        foundWillUpdateName = "componentWillUpdate";
-      } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        foundWillUpdateName = "UNSAFE_componentWillUpdate";
-      }
+    case OffscreenComponent:
+    case LegacyHiddenComponent:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext(interruptedWork);
+      popTransition(interruptedWork, current);
+      break;
 
-      if (
-        foundWillMountName !== null ||
-        foundWillReceivePropsName !== null ||
-        foundWillUpdateName !== null
-      ) {
-        var _componentName = getComponentNameFromType(ctor) || "Component";
+    case CacheComponent:
+      {
+        popCacheProvider(interruptedWork);
+      }
 
-        var newApiName =
-          typeof ctor.getDerivedStateFromProps === "function"
-            ? "getDerivedStateFromProps()"
-            : "getSnapshotBeforeUpdate()";
+      break;
 
-        if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
-          didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        var instance = interruptedWork.stateNode;
 
-          error(
-            "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" +
-              "The above lifecycles should be removed. Learn more about this warning here:\n" +
-              "https://reactjs.org/link/unsafe-component-lifecycles",
-            _componentName,
-            newApiName,
-            foundWillMountName !== null ? "\n  " + foundWillMountName : "",
-            foundWillReceivePropsName !== null
-              ? "\n  " + foundWillReceivePropsName
-              : "",
-            foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : ""
-          );
+        if (instance !== null) {
+          popMarkerInstance(interruptedWork);
         }
       }
-    }
-  } // Cache unmasked context so we can avoid recreating masked context unless necessary.
 
-  return instance;
+      break;
+  }
 }
 
-function callComponentWillMount(workInProgress, instance) {
-  var oldState = instance.state;
+// Provided by www
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
 
-  if (typeof instance.componentWillMount === "function") {
-    instance.componentWillMount();
-  }
+if (typeof ReactFbErrorUtils.invokeGuardedCallback !== "function") {
+  throw new Error(
+    "Expected ReactFbErrorUtils.invokeGuardedCallback to be a function."
+  );
+}
 
-  if (typeof instance.UNSAFE_componentWillMount === "function") {
-    instance.UNSAFE_componentWillMount();
-  }
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  // This will call `this.onError(err)` if an error was caught.
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
+}
 
-  if (oldState !== instance.state) {
-    {
-      error(
-        "%s.componentWillMount(): Assigning directly to this.state is " +
-          "deprecated (except inside a component's " +
-          "constructor). Use setState instead.",
-        getComponentNameFromFiber(workInProgress) || "Component"
-      );
-    }
+var hasError = false;
+var caughtError = null; // Used by event system to capture/rethrow the first error.
 
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+var hasRethrowError = false;
+var rethrowError = null;
+var reporter = {
+  onError: function (error) {
+    hasError = true;
+    caughtError = error;
   }
+};
+/**
+ * Call a function while guarding against errors that happens within it.
+ * Returns an error if it throws, otherwise null.
+ *
+ * In production, this is implemented using a try-catch. The reason we don't
+ * use a try-catch directly is so that we can swap out a different
+ * implementation in DEV mode.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
+
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = false;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
 }
+/**
+ * Same as invokeGuardedCallback, but instead of returning an error, it stores
+ * it in a global so it can be rethrown by `rethrowCaughtError` later.
+ * TODO: See if caughtError and rethrowError can be unified.
+ *
+ * @param {String} name of the guard to use for logging or debugging
+ * @param {Function} func The function to invoke
+ * @param {*} context The context to use when calling the function
+ * @param {...*} args Arguments for function
+ */
 
-function callComponentWillReceiveProps(
-  workInProgress,
-  instance,
-  newProps,
-  nextContext
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
 ) {
-  var oldState = instance.state;
+  invokeGuardedCallback.apply(this, arguments);
 
-  if (typeof instance.componentWillReceiveProps === "function") {
-    instance.componentWillReceiveProps(newProps, nextContext);
+  if (hasError) {
+    var error = clearCaughtError();
+
+    if (!hasRethrowError) {
+      hasRethrowError = true;
+      rethrowError = error;
+    }
   }
+}
+/**
+ * During execution of guarded functions we will capture the first error which
+ * we will rethrow to be handled by the top level error handler.
+ */
 
-  if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
-    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+function rethrowCaughtError() {
+  if (hasRethrowError) {
+    var error = rethrowError;
+    hasRethrowError = false;
+    rethrowError = null;
+    throw error;
+  }
+}
+function hasCaughtError() {
+  return hasError;
+}
+function clearCaughtError() {
+  if (hasError) {
+    var error = caughtError;
+    hasError = false;
+    caughtError = null;
+    return error;
+  } else {
+    throw new Error(
+      "clearCaughtError was called but no error was captured. This error " +
+        "is likely caused by a bug in React. Please file an issue."
+    );
   }
+}
 
-  if (instance.state !== oldState) {
-    {
-      var componentName =
-        getComponentNameFromFiber(workInProgress) || "Component";
+var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
 
-      if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
-        didWarnAboutStateAssignmentForComponent.add(componentName);
+{
+  didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+} // Used during the commit phase to track the state of the Offscreen component stack.
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
 
-        error(
-          "%s.componentWillReceiveProps(): Assigning directly to " +
-            "this.state is deprecated (except inside a component's " +
-            "constructor). Use setState instead.",
-          componentName
-        );
-      }
+var offscreenSubtreeIsHidden = false;
+var offscreenSubtreeWasHidden = false;
+var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
+var nextEffect = null; // Used for Profiling builds to track updaters.
+
+var inProgressLanes = null;
+var inProgressRoot = null;
+
+function shouldProfile(current) {
+  return (
+    (current.mode & ProfileMode) !== NoMode &&
+    (getExecutionContext() & CommitContext) !== NoContext
+  );
+}
+
+function reportUncaughtErrorInDEV(error) {
+  // Wrapping each small part of the commit phase into a guarded
+  // callback is a bit too slow (https://github.com/facebook/react/pull/21666).
+  // But we rely on it to surface errors to DEV tools like overlays
+  // (https://github.com/facebook/react/issues/21712).
+  // As a compromise, rethrow only caught errors in a guard.
+  {
+    invokeGuardedCallback(null, function () {
+      throw error;
+    });
+    clearCaughtError();
+  }
+}
+
+function callComponentWillUnmountWithTimer(current, instance) {
+  instance.props = current.memoizedProps;
+  instance.state = current.memoizedState;
+
+  if (shouldProfile(current)) {
+    try {
+      startLayoutEffectTimer();
+      instance.componentWillUnmount();
+    } finally {
+      recordLayoutEffectDuration(current);
     }
+  } else {
+    instance.componentWillUnmount();
+  }
+} // Capture errors so they don't interrupt unmounting.
 
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+function safelyCallComponentWillUnmount(
+  current,
+  nearestMountedAncestor,
+  instance
+) {
+  try {
+    callComponentWillUnmountWithTimer(current, instance);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
   }
-} // Invokes the mount life-cycles on a previously never rendered instance.
+} // Capture errors so they don't interrupt mounting.
 
-function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  {
-    checkClassInstance(workInProgress, ctor, newProps);
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
   }
+}
 
-  var instance = workInProgress.stateNode;
-  instance.props = newProps;
-  instance.state = workInProgress.memoizedState;
-  instance.refs = {};
-  initializeUpdateQueue(workInProgress);
-  var contextType = ctor.contextType;
-
-  if (typeof contextType === "object" && contextType !== null) {
-    instance.context = readContext(contextType);
-  } else {
-    instance.context = emptyContextObject;
-  }
+function safelyDetachRef(current, nearestMountedAncestor) {
+  var ref = current.ref;
+  var refCleanup = current.refCleanup;
 
-  {
-    if (instance.state === newProps) {
-      var componentName = getComponentNameFromType(ctor) || "Component";
+  if (ref !== null) {
+    if (typeof refCleanup === "function") {
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            refCleanup();
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          refCleanup();
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
+        current.refCleanup = null;
+        var finishedWork = current.alternate;
 
-      if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
-        didWarnAboutDirectlyAssigningPropsToState.add(componentName);
+        if (finishedWork != null) {
+          finishedWork.refCleanup = null;
+        }
+      }
+    } else if (typeof ref === "function") {
+      var retVal;
 
-        error(
-          "%s: It is not recommended to assign props directly to state " +
-            "because updates to props won't be reflected in state. " +
-            "In most cases, it is better to use props directly.",
-          componentName
-        );
+      try {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            retVal = ref(null);
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
+          retVal = ref(null);
+        }
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
       }
-    }
 
-    if (workInProgress.mode & StrictLegacyMode) {
-      ReactStrictModeWarnings.recordLegacyContextWarning(
-        workInProgress,
-        instance
-      );
+      {
+        if (typeof retVal === "function") {
+          error(
+            "Unexpected return value from a callback ref in %s. " +
+              "A callback ref should not return a function.",
+            getComponentNameFromFiber(current)
+          );
+        }
+      }
+    } else {
+      // $FlowFixMe unable to narrow type to RefObject
+      ref.current = null;
     }
-
-    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
-      workInProgress,
-      instance
-    );
   }
+}
 
-  instance.state = workInProgress.memoizedState;
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
 
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    instance.state = workInProgress.memoizedState;
-  } // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+var focusedInstanceHandle = null;
+var shouldFireAfterActiveInstanceBlur = false;
+function commitBeforeMutationEffects(root, firstChild) {
+  focusedInstanceHandle = prepareForCommit();
+  nextEffect = firstChild;
+  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
 
-  if (
-    typeof ctor.getDerivedStateFromProps !== "function" &&
-    typeof instance.getSnapshotBeforeUpdate !== "function" &&
-    (typeof instance.UNSAFE_componentWillMount === "function" ||
-      typeof instance.componentWillMount === "function")
-  ) {
-    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's
-    // process them now.
+  var shouldFire = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = false;
+  focusedInstanceHandle = null;
+  return shouldFire;
+}
 
-    processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-    instance.state = workInProgress.memoizedState;
-  }
+function commitBeforeMutationEffects_begin() {
+  while (nextEffect !== null) {
+    var fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
+    // Let's skip the whole loop if it's off.
 
-  if (typeof instance.componentDidMount === "function") {
-    var fiberFlags = Update | LayoutStatic;
+    {
+      // TODO: Should wrap this in flags check, too, as optimization
+      var deletions = fiber.deletions;
 
-    if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-      fiberFlags |= MountLayoutDev;
+      if (deletions !== null) {
+        for (var i = 0; i < deletions.length; i++) {
+          var deletion = deletions[i];
+          commitBeforeMutationEffectsDeletion(deletion);
+        }
+      }
     }
 
-    workInProgress.flags |= fiberFlags;
+    var child = fiber.child;
+
+    if (
+      (fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 &&
+      child !== null
+    ) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitBeforeMutationEffects_complete();
+    }
   }
 }
 
-function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  var instance = workInProgress.stateNode;
-  var oldProps = workInProgress.memoizedProps;
-  instance.props = oldProps;
-  var oldContext = instance.context;
-  var contextType = ctor.contextType;
-  var nextContext = emptyContextObject;
+function commitBeforeMutationEffects_complete() {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    setCurrentFiber(fiber);
 
-  if (typeof contextType === "object" && contextType !== null) {
-    nextContext = readContext(contextType);
-  }
+    try {
+      commitBeforeMutationEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
 
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-  var hasNewLifecycles =
-    typeof getDerivedStateFromProps === "function" ||
-    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
-  // ever the previously attempted to render - not the "current". However,
-  // during componentDidUpdate we pass the "current" props.
-  // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+    resetCurrentFiber();
+    var sibling = fiber.sibling;
 
-  if (
-    !hasNewLifecycles &&
-    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
-      typeof instance.componentWillReceiveProps === "function")
-  ) {
-    if (oldProps !== newProps || oldContext !== nextContext) {
-      callComponentWillReceiveProps(
-        workInProgress,
-        instance,
-        newProps,
-        nextContext
-      );
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
     }
-  }
 
-  resetHasForceUpdateBeforeProcessing();
-  var oldState = workInProgress.memoizedState;
-  var newState = (instance.state = oldState);
-  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-  newState = workInProgress.memoizedState;
+    nextEffect = fiber.return;
+  }
+}
 
-  if (
-    oldProps === newProps &&
-    oldState === newState &&
-    !hasContextChanged() &&
-    !checkHasForceUpdateAfterProcessing()
-  ) {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidMount === "function") {
-      var fiberFlags = Update | LayoutStatic;
+function commitBeforeMutationEffectsOnFiber(finishedWork) {
+  var current = finishedWork.alternate;
+  var flags = finishedWork.flags;
 
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        fiberFlags |= MountLayoutDev;
+  {
+    if (!shouldFireAfterActiveInstanceBlur && focusedInstanceHandle !== null) {
+      // Check to see if the focused element was inside of a hidden (Suspense) subtree.
+      // TODO: Move this out of the hot path using a dedicated effect tag.
+      if (
+        finishedWork.tag === SuspenseComponent &&
+        isSuspenseBoundaryBeingHidden(current, finishedWork) && // $FlowFixMe[incompatible-call] found when upgrading Flow
+        doesFiberContain(finishedWork, focusedInstanceHandle)
+      ) {
+        shouldFireAfterActiveInstanceBlur = true;
+        beforeActiveInstanceBlur(finishedWork);
       }
-
-      workInProgress.flags |= fiberFlags;
     }
-
-    return false;
   }
 
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    newState = workInProgress.memoizedState;
+  if ((flags & Snapshot) !== NoFlags$1) {
+    setCurrentFiber(finishedWork);
   }
 
-  var shouldUpdate =
-    checkHasForceUpdateAfterProcessing() ||
-    checkShouldComponentUpdate(
-      workInProgress,
-      ctor,
-      oldProps,
-      newProps,
-      oldState,
-      newState,
-      nextContext
-    );
-
-  if (shouldUpdate) {
-    // In order to support react-lifecycles-compat polyfilled components,
-    // Unsafe lifecycles should not be invoked for components using the new APIs.
-    if (
-      !hasNewLifecycles &&
-      (typeof instance.UNSAFE_componentWillMount === "function" ||
-        typeof instance.componentWillMount === "function")
-    ) {
-      if (typeof instance.componentWillMount === "function") {
-        instance.componentWillMount();
+  switch (finishedWork.tag) {
+    case FunctionComponent: {
+      {
+        if ((flags & Update) !== NoFlags$1) {
+          commitUseEffectEventMount(finishedWork);
+        }
       }
 
-      if (typeof instance.UNSAFE_componentWillMount === "function") {
-        instance.UNSAFE_componentWillMount();
-      }
+      break;
     }
 
-    if (typeof instance.componentDidMount === "function") {
-      var _fiberFlags = Update | LayoutStatic;
-
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        _fiberFlags |= MountLayoutDev;
-      }
-
-      workInProgress.flags |= _fiberFlags;
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      break;
     }
-  } else {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidMount === "function") {
-      var _fiberFlags2 = Update | LayoutStatic;
-
-      if ((workInProgress.mode & StrictEffectsMode) !== NoMode) {
-        _fiberFlags2 |= MountLayoutDev;
-      }
-
-      workInProgress.flags |= _fiberFlags2;
-    } // If shouldComponentUpdate returned false, we should still update the
-    // memoized state to indicate that this work can be reused.
 
-    workInProgress.memoizedProps = newProps;
-    workInProgress.memoizedState = newState;
-  } // Update the existing instance's state, props, and context pointers even
-  // if shouldComponentUpdate returns false.
+    case ClassComponent: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        if (current !== null) {
+          var prevProps = current.memoizedProps;
+          var prevState = current.memoizedState;
+          var instance = finishedWork.stateNode; // We could update instance props and state here,
+          // but instead we rely on them being set during last render.
+          // TODO: revisit this when we implement resuming.
 
-  instance.props = newProps;
-  instance.state = newState;
-  instance.context = nextContext;
-  return shouldUpdate;
-} // Invokes the update life-cycles and returns false if it shouldn't rerender.
+          {
+            if (
+              finishedWork.type === finishedWork.elementType &&
+              !didWarnAboutReassigningProps
+            ) {
+              if (instance.props !== finishedWork.memoizedProps) {
+                error(
+                  "Expected %s props to match memoized props before " +
+                    "getSnapshotBeforeUpdate. " +
+                    "This might either be because of a bug in React, or because " +
+                    "a component reassigns its own `this.props`. " +
+                    "Please file an issue.",
+                  getComponentNameFromFiber(finishedWork) || "instance"
+                );
+              }
 
-function updateClassInstance(
-  current,
-  workInProgress,
-  ctor,
-  newProps,
-  renderLanes
-) {
-  var instance = workInProgress.stateNode;
-  cloneUpdateQueue(current, workInProgress);
-  var unresolvedOldProps = workInProgress.memoizedProps;
-  var oldProps =
-    workInProgress.type === workInProgress.elementType
-      ? unresolvedOldProps
-      : resolveDefaultProps(workInProgress.type, unresolvedOldProps);
-  instance.props = oldProps;
-  var unresolvedNewProps = workInProgress.pendingProps;
-  var oldContext = instance.context;
-  var contextType = ctor.contextType;
-  var nextContext = emptyContextObject;
+              if (instance.state !== finishedWork.memoizedState) {
+                error(
+                  "Expected %s state to match memoized state before " +
+                    "getSnapshotBeforeUpdate. " +
+                    "This might either be because of a bug in React, or because " +
+                    "a component reassigns its own `this.state`. " +
+                    "Please file an issue.",
+                  getComponentNameFromFiber(finishedWork) || "instance"
+                );
+              }
+            }
+          }
 
-  if (typeof contextType === "object" && contextType !== null) {
-    nextContext = readContext(contextType);
-  }
+          var snapshot = instance.getSnapshotBeforeUpdate(
+            finishedWork.elementType === finishedWork.type
+              ? prevProps
+              : resolveDefaultProps(finishedWork.type, prevProps),
+            prevState
+          );
 
-  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-  var hasNewLifecycles =
-    typeof getDerivedStateFromProps === "function" ||
-    typeof instance.getSnapshotBeforeUpdate === "function"; // Note: During these life-cycles, instance.props/instance.state are what
-  // ever the previously attempted to render - not the "current". However,
-  // during componentDidUpdate we pass the "current" props.
-  // In order to support react-lifecycles-compat polyfilled components,
-  // Unsafe lifecycles should not be invoked for components using the new APIs.
+          {
+            var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
 
-  if (
-    !hasNewLifecycles &&
-    (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
-      typeof instance.componentWillReceiveProps === "function")
-  ) {
-    if (
-      unresolvedOldProps !== unresolvedNewProps ||
-      oldContext !== nextContext
-    ) {
-      callComponentWillReceiveProps(
-        workInProgress,
-        instance,
-        newProps,
-        nextContext
-      );
-    }
-  }
+            if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
+              didWarnSet.add(finishedWork.type);
 
-  resetHasForceUpdateBeforeProcessing();
-  var oldState = workInProgress.memoizedState;
-  var newState = (instance.state = oldState);
-  processUpdateQueue(workInProgress, newProps, instance, renderLanes);
-  newState = workInProgress.memoizedState;
+              error(
+                "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
+                  "must be returned. You have returned undefined.",
+                getComponentNameFromFiber(finishedWork)
+              );
+            }
+          }
 
-  if (
-    unresolvedOldProps === unresolvedNewProps &&
-    oldState === newState &&
-    !hasContextChanged() &&
-    !checkHasForceUpdateAfterProcessing() &&
-    !(
-      enableLazyContextPropagation &&
-      current !== null &&
-      current.dependencies !== null &&
-      checkIfContextChanged(current.dependencies)
-    )
-  ) {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Update;
+          instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+        }
       }
-    }
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Snapshot;
-      }
+      break;
     }
 
-    return false;
-  }
-
-  if (typeof getDerivedStateFromProps === "function") {
-    applyDerivedStateFromProps(
-      workInProgress,
-      ctor,
-      getDerivedStateFromProps,
-      newProps
-    );
-    newState = workInProgress.memoizedState;
-  }
-
-  var shouldUpdate =
-    checkHasForceUpdateAfterProcessing() ||
-    checkShouldComponentUpdate(
-      workInProgress,
-      ctor,
-      oldProps,
-      newProps,
-      oldState,
-      newState,
-      nextContext
-    ) || // TODO: In some cases, we'll end up checking if context has changed twice,
-    // both before and after `shouldComponentUpdate` has been called. Not ideal,
-    // but I'm loath to refactor this function. This only happens for memoized
-    // components so it's not that common.
-    (enableLazyContextPropagation &&
-      current !== null &&
-      current.dependencies !== null &&
-      checkIfContextChanged(current.dependencies));
-
-  if (shouldUpdate) {
-    // In order to support react-lifecycles-compat polyfilled components,
-    // Unsafe lifecycles should not be invoked for components using the new APIs.
-    if (
-      !hasNewLifecycles &&
-      (typeof instance.UNSAFE_componentWillUpdate === "function" ||
-        typeof instance.componentWillUpdate === "function")
-    ) {
-      if (typeof instance.componentWillUpdate === "function") {
-        instance.componentWillUpdate(newProps, newState, nextContext);
+    case HostRoot: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        {
+          var root = finishedWork.stateNode;
+          clearContainer(root.containerInfo);
+        }
       }
 
-      if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
-      }
+      break;
     }
 
-    if (typeof instance.componentDidUpdate === "function") {
-      workInProgress.flags |= Update;
-    }
+    case HostComponent:
+    case HostHoistable:
+    case HostSingleton:
+    case HostText:
+    case HostPortal:
+    case IncompleteClassComponent:
+      // Nothing to do for these component types
+      break;
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      workInProgress.flags |= Snapshot;
-    }
-  } else {
-    // If an update was already in progress, we should schedule an Update
-    // effect even though we're bailing out, so that cWU/cDU are called.
-    if (typeof instance.componentDidUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Update;
+    default: {
+      if ((flags & Snapshot) !== NoFlags$1) {
+        throw new Error(
+          "This unit of work tag should not have side-effects. This error is " +
+            "likely caused by a bug in React. Please file an issue."
+        );
       }
     }
+  }
 
-    if (typeof instance.getSnapshotBeforeUpdate === "function") {
-      if (
-        unresolvedOldProps !== current.memoizedProps ||
-        oldState !== current.memoizedState
-      ) {
-        workInProgress.flags |= Snapshot;
-      }
-    } // If shouldComponentUpdate returned false, we should still update the
-    // memoized props/state to indicate that this work can be reused.
-
-    workInProgress.memoizedProps = newProps;
-    workInProgress.memoizedState = newState;
-  } // Update the existing instance's state, props, and context pointers even
-  // if shouldComponentUpdate returns false.
-
-  instance.props = newProps;
-  instance.state = newState;
-  instance.context = nextContext;
-  return shouldUpdate;
+  if ((flags & Snapshot) !== NoFlags$1) {
+    resetCurrentFiber();
+  }
 }
 
-function createCapturedValueAtFiber(value, source) {
-  // If the value is an error, call this function immediately after it is thrown
-  // so the stack is accurate.
-  return {
-    value: value,
-    source: source,
-    stack: getStackByFiberInDevAndProd(source),
-    digest: null
-  };
-}
-function createCapturedValue(value, digest, stack) {
-  return {
-    value: value,
-    source: null,
-    stack: stack != null ? stack : null,
-    digest: digest != null ? digest : null
-  };
+function commitBeforeMutationEffectsDeletion(deletion) {
+  {
+    // TODO (effects) It would be nice to avoid calling doesFiberContain()
+    // Maybe we can repurpose one of the subtreeFlags positions for this instead?
+    // Use it to store which part of the tree the focused instance is in?
+    // This assumes we can safely determine that instance during the "render" phase.
+    if (doesFiberContain(deletion, focusedInstanceHandle)) {
+      shouldFireAfterActiveInstanceBlur = true;
+      beforeActiveInstanceBlur(deletion);
+    }
+  }
 }
 
-var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
+function commitHookEffectListUnmount(
+  flags,
+  finishedWork,
+  nearestMountedAncestor
+) {
+  var updateQueue = finishedWork.updateQueue;
+  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
 
-if (typeof ReactFiberErrorDialogWWW.showErrorDialog !== "function") {
-  throw new Error(
-    "Expected ReactFiberErrorDialog.showErrorDialog to be a function."
-  );
-}
+  if (lastEffect !== null) {
+    var firstEffect = lastEffect.next;
+    var effect = firstEffect;
 
-function showErrorDialog(boundary, errorInfo) {
-  var capturedError = {
-    componentStack: errorInfo.stack !== null ? errorInfo.stack : "",
-    error: errorInfo.value,
-    errorBoundary:
-      boundary !== null && boundary.tag === ClassComponent
-        ? boundary.stateNode
-        : null
-  };
-  return ReactFiberErrorDialogWWW.showErrorDialog(capturedError);
+    do {
+      if ((effect.tag & flags) === flags) {
+        // Unmount
+        var destroy = effect.destroy;
+        effect.destroy = undefined;
+
+        if (destroy !== undefined) {
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStarted(finishedWork);
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStarted(finishedWork);
+            }
+          }
+
+          {
+            if ((flags & Insertion) !== NoFlags) {
+              setIsRunningInsertionEffect(true);
+            }
+          }
+
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+
+          {
+            if ((flags & Insertion) !== NoFlags) {
+              setIsRunningInsertionEffect(false);
+            }
+          }
+
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStopped();
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStopped();
+            }
+          }
+        }
+      }
+
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
 }
 
-function logCapturedError(boundary, errorInfo) {
-  try {
-    var logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.
-    // This enables renderers like ReactNative to better manage redbox behavior.
+function commitHookEffectListMount(flags, finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
 
-    if (logError === false) {
-      return;
-    }
+  if (lastEffect !== null) {
+    var firstEffect = lastEffect.next;
+    var effect = firstEffect;
 
-    var error = errorInfo.value;
+    do {
+      if ((effect.tag & flags) === flags) {
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStarted(finishedWork);
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStarted(finishedWork);
+          }
+        } // Mount
 
-    if (true) {
-      var source = errorInfo.source;
-      var stack = errorInfo.stack;
-      var componentStack = stack !== null ? stack : ""; // Browsers support silencing uncaught errors by calling
-      // `preventDefault()` in window `error` handler.
-      // We record this information as an expando on the error.
+        var create = effect.create;
 
-      if (error != null && error._suppressLogging) {
-        if (boundary.tag === ClassComponent) {
-          // The error is recoverable and was silenced.
-          // Ignore it and don't print the stack addendum.
-          // This is handy for testing error boundaries without noise.
-          return;
-        } // The error is fatal. Since the silencing might have
-        // been accidental, we'll surface it anyway.
-        // However, the browser would have silenced the original error
-        // so we'll print it first, and then print the stack addendum.
+        {
+          if ((flags & Insertion) !== NoFlags) {
+            setIsRunningInsertionEffect(true);
+          }
+        }
 
-        console["error"](error); // Don't transform to our wrapper
-        // For a more detailed description of this block, see:
-        // https://github.com/facebook/react/pull/13384
-      }
+        effect.destroy = create();
 
-      var componentName = source ? getComponentNameFromFiber(source) : null;
-      var componentNameMessage = componentName
-        ? "The above error occurred in the <" + componentName + "> component:"
-        : "The above error occurred in one of your React components:";
-      var errorBoundaryMessage;
+        {
+          if ((flags & Insertion) !== NoFlags) {
+            setIsRunningInsertionEffect(false);
+          }
+        }
 
-      if (boundary.tag === HostRoot) {
-        errorBoundaryMessage =
-          "Consider adding an error boundary to your tree to customize error handling behavior.\n" +
-          "Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.";
-      } else {
-        var errorBoundaryName =
-          getComponentNameFromFiber(boundary) || "Anonymous";
-        errorBoundaryMessage =
-          "React will try to recreate this component tree from scratch " +
-          ("using the error boundary you provided, " + errorBoundaryName + ".");
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStopped();
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStopped();
+          }
+        }
+
+        {
+          var destroy = effect.destroy;
+
+          if (destroy !== undefined && typeof destroy !== "function") {
+            var hookName = void 0;
+
+            if ((effect.tag & Layout) !== NoFlags$1) {
+              hookName = "useLayoutEffect";
+            } else if ((effect.tag & Insertion) !== NoFlags$1) {
+              hookName = "useInsertionEffect";
+            } else {
+              hookName = "useEffect";
+            }
+
+            var addendum = void 0;
+
+            if (destroy === null) {
+              addendum =
+                " You returned null. If your effect does not require clean " +
+                "up, return undefined (or nothing).";
+            } else if (typeof destroy.then === "function") {
+              addendum =
+                "\n\nIt looks like you wrote " +
+                hookName +
+                "(async () => ...) or returned a Promise. " +
+                "Instead, write the async function inside your effect " +
+                "and call it immediately:\n\n" +
+                hookName +
+                "(() => {\n" +
+                "  async function fetchData() {\n" +
+                "    // You can await here\n" +
+                "    const response = await MyAPI.getData(someId);\n" +
+                "    // ...\n" +
+                "  }\n" +
+                "  fetchData();\n" +
+                "}, [someId]); // Or [] if effect doesn't need props or state\n\n" +
+                "Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching";
+            } else {
+              addendum = " You returned: " + destroy;
+            }
+
+            error(
+              "%s must not return anything besides a function, " +
+                "which is used for clean-up.%s",
+              hookName,
+              addendum
+            );
+          }
+        }
       }
 
-      var combinedMessage =
-        componentNameMessage +
-        "\n" +
-        componentStack +
-        "\n\n" +
-        ("" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.
-      // We don't include the original error message and JS stack because the browser
-      // has already printed it. Even if the application swallows the error, it is still
-      // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.
+      effect = effect.next;
+    } while (effect !== firstEffect);
+  }
+}
 
-      console["error"](combinedMessage); // Don't transform to our wrapper
+function commitUseEffectEventMount(finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  var eventPayloads = updateQueue !== null ? updateQueue.events : null;
+
+  if (eventPayloads !== null) {
+    for (var ii = 0; ii < eventPayloads.length; ii++) {
+      var _eventPayloads$ii = eventPayloads[ii],
+        ref = _eventPayloads$ii.ref,
+        nextImpl = _eventPayloads$ii.nextImpl;
+      ref.impl = nextImpl;
     }
-  } catch (e) {
-    // This method must not throw, or React internal state will get messed up.
-    // If console.error is overridden, or logCapturedError() shows a dialog that throws,
-    // we want to report this error outside of the normal stack as a last resort.
-    // https://github.com/facebook/react/issues/13188
-    setTimeout(function () {
-      throw e;
-    });
   }
 }
 
-function createRootErrorUpdate(fiber, errorInfo, lane) {
-  var update = createUpdate(lane); // Unmount the root by rendering null.
+function commitPassiveEffectDurations(finishedRoot, finishedWork) {
+  if (getExecutionContext() & CommitContext) {
+    // Only Profilers with work in their subtree will have an Update effect scheduled.
+    if ((finishedWork.flags & Update) !== NoFlags$1) {
+      switch (finishedWork.tag) {
+        case Profiler: {
+          var passiveEffectDuration =
+            finishedWork.stateNode.passiveEffectDuration;
+          var _finishedWork$memoize = finishedWork.memoizedProps,
+            id = _finishedWork$memoize.id,
+            onPostCommit = _finishedWork$memoize.onPostCommit; // This value will still reflect the previous commit phase.
+          // It does not get reset until the start of the next commit phase.
 
-  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property
-  // being called "element".
+          var commitTime = getCommitTime();
+          var phase = finishedWork.alternate === null ? "mount" : "update";
 
-  update.payload = {
-    element: null
-  };
-  var error = errorInfo.value;
+          {
+            if (isCurrentUpdateNested()) {
+              phase = "nested-update";
+            }
+          }
 
-  update.callback = function () {
-    onUncaughtError(error);
-    logCapturedError(fiber, errorInfo);
-  };
+          if (typeof onPostCommit === "function") {
+            onPostCommit(id, phase, passiveEffectDuration, commitTime);
+          } // Bubble times to the next nearest ancestor Profiler.
+          // After we process that Profiler, we'll bubble further up.
 
-  return update;
-}
+          var parentFiber = finishedWork.return;
 
-function createClassErrorUpdate(fiber, errorInfo, lane) {
-  var update = createUpdate(lane);
-  update.tag = CaptureUpdate;
-  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+          outer: while (parentFiber !== null) {
+            switch (parentFiber.tag) {
+              case HostRoot:
+                var root = parentFiber.stateNode;
+                root.passiveEffectDuration += passiveEffectDuration;
+                break outer;
 
-  if (typeof getDerivedStateFromError === "function") {
-    var error$1 = errorInfo.value;
+              case Profiler:
+                var parentStateNode = parentFiber.stateNode;
+                parentStateNode.passiveEffectDuration += passiveEffectDuration;
+                break outer;
+            }
 
-    update.payload = function () {
-      return getDerivedStateFromError(error$1);
-    };
+            parentFiber = parentFiber.return;
+          }
 
-    update.callback = function () {
-      {
-        markFailedErrorBoundaryForHotReloading(fiber);
+          break;
+        }
       }
+    }
+  }
+}
 
-      logCapturedError(fiber, errorInfo);
-    };
+function commitHookLayoutEffects(finishedWork, hookFlags) {
+  // At this point layout effects have already been destroyed (during mutation phase).
+  // This is done to prevent sibling component effects from interfering with each other,
+  // e.g. a destroy function in one component should never override a ref set
+  // by a create function in another component during the same commit.
+  if (shouldProfile(finishedWork)) {
+    try {
+      startLayoutEffectTimer();
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+
+    recordLayoutEffectDuration(finishedWork);
+  } else {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
   }
+}
 
-  var inst = fiber.stateNode;
+function commitClassLayoutLifecycles(finishedWork, current) {
+  var instance = finishedWork.stateNode;
 
-  if (inst !== null && typeof inst.componentDidCatch === "function") {
-    // $FlowFixMe[missing-this-annot]
-    update.callback = function callback() {
-      {
-        markFailedErrorBoundaryForHotReloading(fiber);
+  if (current === null) {
+    // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "componentDidMount. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
+
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "componentDidMount. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
       }
+    }
 
-      logCapturedError(fiber, errorInfo);
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
 
-      if (typeof getDerivedStateFromError !== "function") {
-        // To preserve the preexisting retry behavior of error boundaries,
-        // we keep track of which ones already failed during this batch.
-        // This gets reset before we yield back to the browser.
-        // TODO: Warn in strict mode if getDerivedStateFromError is
-        // not defined.
-        markLegacyErrorBoundaryAsFailed(this);
+      recordLayoutEffectDuration(finishedWork);
+    } else {
+      try {
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
       }
+    }
+  } else {
+    var prevProps =
+      finishedWork.elementType === finishedWork.type
+        ? current.memoizedProps
+        : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+    var prevState = current.memoizedState; // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
 
-      var error$1 = errorInfo.value;
-      var stack = errorInfo.stack;
-      this.componentDidCatch(error$1, {
-        componentStack: stack !== null ? stack : ""
-      });
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "componentDidUpdate. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-      {
-        if (typeof getDerivedStateFromError !== "function") {
-          // If componentDidCatch is the only error boundary method defined,
-          // then it needs to call setState to recover from errors.
-          // If no state update is scheduled then the boundary will swallow the error.
-          if (!includesSomeLane(fiber.lanes, SyncLane)) {
-            error(
-              "%s: Error boundaries should implement getDerivedStateFromError(). " +
-                "In that method, return a state update to display an error message or fallback UI.",
-              getComponentNameFromFiber(fiber) || "Unknown"
-            );
-          }
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "componentDidUpdate. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
         }
       }
-    };
-  }
-
-  return update;
-}
-
-function resetSuspendedComponent(sourceFiber, rootRenderLanes) {
-  if (enableLazyContextPropagation) {
-    var currentSourceFiber = sourceFiber.alternate;
-
-    if (currentSourceFiber !== null) {
-      // Since we never visited the children of the suspended component, we
-      // need to propagate the context change now, to ensure that we visit
-      // them during the retry.
-      //
-      // We don't have to do this for errors because we retry errors without
-      // committing in between. So this is specific to Suspense.
-      propagateParentContextChangesToDeferredTree(
-        currentSourceFiber,
-        sourceFiber,
-        rootRenderLanes
-      );
     }
-  } // Reset the memoizedState to what it was before we attempted to render it.
-  // A legacy mode Suspense quirk, only relevant to hook components.
-
-  var tag = sourceFiber.tag;
 
-  if (
-    (sourceFiber.mode & ConcurrentMode) === NoMode &&
-    (tag === FunctionComponent ||
-      tag === ForwardRef ||
-      tag === SimpleMemoComponent)
-  ) {
-    var currentSource = sourceFiber.alternate;
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
 
-    if (currentSource) {
-      sourceFiber.updateQueue = currentSource.updateQueue;
-      sourceFiber.memoizedState = currentSource.memoizedState;
-      sourceFiber.lanes = currentSource.lanes;
+      recordLayoutEffectDuration(finishedWork);
     } else {
-      sourceFiber.updateQueue = null;
-      sourceFiber.memoizedState = null;
+      try {
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
     }
   }
 }
 
-function markSuspenseBoundaryShouldCapture(
-  suspenseBoundary,
-  returnFiber,
-  sourceFiber,
-  root,
-  rootRenderLanes
-) {
-  // This marks a Suspense boundary so that when we're unwinding the stack,
-  // it captures the suspended "exception" and does a second (fallback) pass.
-  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {
-    // Legacy Mode Suspense
-    //
-    // If the boundary is in legacy mode, we should *not*
-    // suspend the commit. Pretend as if the suspended component rendered
-    // null and keep rendering. When the Suspense boundary completes,
-    // we'll do a second pass to render the fallback.
-    if (suspenseBoundary === returnFiber) {
-      // Special case where we suspended while reconciling the children of
-      // a Suspense boundary's inner Offscreen wrapper fiber. This happens
-      // when a React.lazy component is a direct child of a
-      // Suspense boundary.
-      //
-      // Suspense boundaries are implemented as multiple fibers, but they
-      // are a single conceptual unit. The legacy mode behavior where we
-      // pretend the suspended fiber committed as `null` won't work,
-      // because in this case the "suspended" fiber is the inner
-      // Offscreen wrapper.
-      //
-      // Because the contents of the boundary haven't started rendering
-      // yet (i.e. nothing in the tree has partially rendered) we can
-      // switch to the regular, concurrent mode behavior: mark the
-      // boundary with ShouldCapture and enter the unwind phase.
-      suspenseBoundary.flags |= ShouldCapture;
-    } else {
-      suspenseBoundary.flags |= DidCapture;
-      sourceFiber.flags |= ForceUpdateForLegacySuspense; // 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.
+function commitClassCallbacks(finishedWork) {
+  // TODO: I think this is now always non-null by the time it reaches the
+  // commit phase. Consider removing the type check.
+  var updateQueue = finishedWork.updateQueue;
 
-      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);
+  if (updateQueue !== null) {
+    var instance = finishedWork.stateNode;
 
-      if (sourceFiber.tag === ClassComponent) {
-        var currentSourceFiber = sourceFiber.alternate;
+    {
+      if (
+        finishedWork.type === finishedWork.elementType &&
+        !didWarnAboutReassigningProps
+      ) {
+        if (instance.props !== finishedWork.memoizedProps) {
+          error(
+            "Expected %s props to match memoized props before " +
+              "processing the update queue. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.props`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
+        }
 
-        if (currentSourceFiber === null) {
-          // This is a new mount. Change the tag so it's not mistaken for a
-          // completed class component. For example, we should not call
-          // componentWillUnmount if it is deleted.
-          sourceFiber.tag = IncompleteClassComponent;
-        } else {
-          // When we try rendering again, we should not reuse the current fiber,
-          // since it's known to be in an inconsistent state. Use a force update to
-          // prevent a bail out.
-          var update = createUpdate(SyncLane);
-          update.tag = ForceUpdate;
-          enqueueUpdate(sourceFiber, update, SyncLane);
+        if (instance.state !== finishedWork.memoizedState) {
+          error(
+            "Expected %s state to match memoized state before " +
+              "processing the update queue. " +
+              "This might either be because of a bug in React, or because " +
+              "a component reassigns its own `this.state`. " +
+              "Please file an issue.",
+            getComponentNameFromFiber(finishedWork) || "instance"
+          );
         }
-      } // The source fiber did not complete. Mark it with Sync priority to
-      // indicate that it still has pending work.
+      }
+    } // We could update instance props and state here,
+    // but instead we rely on them being set during last render.
+    // TODO: revisit this when we implement resuming.
 
-      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
     }
-
-    return suspenseBoundary;
-  } // Confirmed that the boundary is in a concurrent mode tree. Continue
-  // with the normal suspend path.
-  //
-  // After this we'll use a set of heuristics to determine whether this
-  // render pass will run to completion or restart or "suspend" the commit.
-  // The actual logic for this is spread out in different places.
-  //
-  // This first principle is that if we're going to suspend when we complete
-  // a root, then we should also restart if we get an update or ping that
-  // might unsuspend it, and vice versa. The only reason to suspend is
-  // because you think you might want to restart before committing. However,
-  // it doesn't make sense to restart only while in the period we're suspended.
-  //
-  // Restarting too aggressively is also not good because it starves out any
-  // intermediate loading state. So we use heuristics to determine when.
-  // Suspense Heuristics
-  //
-  // If nothing threw a Promise or all the same fallbacks are already showing,
-  // then don't suspend/restart.
-  //
-  // If this is an initial render of a new tree of Suspense boundaries and
-  // those trigger a fallback, then don't suspend/restart. We want to ensure
-  // that we can show the initial loading state as quickly as possible.
-  //
-  // If we hit a "Delayed" case, such as when we'd switch from content back into
-  // a fallback, then we should always suspend/restart. Transitions apply
-  // to this case. If none is defined, JND is used instead.
-  //
-  // If we're already showing a fallback and it gets "retried", allowing us to show
-  // another level, but there's still an inner boundary that would show a fallback,
-  // then we suspend/restart for 500ms since the last time we showed a fallback
-  // anywhere in the tree. This effectively throttles progressive loading into a
-  // consistent train of commits. This also gives us an opportunity to restart to
-  // get to the completed state slightly earlier.
-  //
-  // If there's ambiguity due to batching it's resolved in preference of:
-  // 1) "delayed", 2) "initial render", 3) "retry".
-  //
-  // We want to ensure that a "busy" state doesn't get force committed. We want to
-  // ensure that new initial loading states can commit as soon as possible.
-
-  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in
-  // the begin phase to prevent an early bailout.
-
-  suspenseBoundary.lanes = rootRenderLanes;
-  return suspenseBoundary;
+  }
 }
 
-function throwException(
-  root,
-  returnFiber,
-  sourceFiber,
-  value,
-  rootRenderLanes
-) {
-  // The source fiber did not complete.
-  sourceFiber.flags |= Incomplete;
+function commitHostComponentMount(finishedWork) {
+  var type = finishedWork.type;
+  var props = finishedWork.memoizedProps;
+  var instance = finishedWork.stateNode;
 
-  {
-    if (isDevToolsPresent) {
-      // If we have pending work still, restore the original updaters
-      restorePendingUpdaters(root, rootRenderLanes);
-    }
+  try {
+    commitMount(instance, type, props, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
   }
+}
 
-  if (
-    value !== null &&
-    typeof value === "object" &&
-    typeof value.then === "function"
-  ) {
-    // This is a wakeable. The component suspended.
-    var wakeable = value;
-    resetSuspendedComponent(sourceFiber, rootRenderLanes);
-
-    {
-      if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
-        markDidThrowWhileHydratingDEV();
-      }
-    }
+function commitProfilerUpdate(finishedWork, current) {
+  if (getExecutionContext() & CommitContext) {
+    try {
+      var _finishedWork$memoize2 = finishedWork.memoizedProps,
+        onCommit = _finishedWork$memoize2.onCommit,
+        onRender = _finishedWork$memoize2.onRender;
+      var effectDuration = finishedWork.stateNode.effectDuration;
+      var commitTime = getCommitTime();
+      var phase = current === null ? "mount" : "update";
 
-    {
-      if (enableDebugTracing) {
-        if (sourceFiber.mode & DebugTracingMode) {
-          var name = getComponentNameFromFiber(sourceFiber) || "Unknown";
-          logComponentSuspended(name, wakeable);
+      if (enableProfilerNestedUpdatePhase) {
+        if (isCurrentUpdateNested()) {
+          phase = "nested-update";
         }
       }
-    } // Mark the nearest Suspense boundary to switch to rendering a fallback.
 
-    var suspenseBoundary = getSuspenseHandler();
+      if (typeof onRender === "function") {
+        onRender(
+          finishedWork.memoizedProps.id,
+          phase,
+          finishedWork.actualDuration,
+          finishedWork.treeBaseDuration,
+          finishedWork.actualStartTime,
+          commitTime
+        );
+      }
 
-    if (suspenseBoundary !== null) {
-      switch (suspenseBoundary.tag) {
-        case SuspenseComponent: {
-          // If this suspense boundary is not already showing a fallback, mark
-          // the in-progress render as suspended. We try to perform this logic
-          // as soon as soon as possible during the render phase, so the work
-          // loop can know things like whether it's OK to switch to other tasks,
-          // or whether it can wait for data to resolve before continuing.
-          // TODO: Most of these checks are already performed when entering a
-          // Suspense boundary. We should track the information on the stack so
-          // we don't have to recompute it on demand. This would also allow us
-          // to unify with `use` which needs to perform this logic even sooner,
-          // before `throwException` is called.
-          if (sourceFiber.mode & ConcurrentMode) {
-            if (getShellBoundary() === null) {
-              // Suspended in the "shell" of the app. This is an undesirable
-              // loading state. We should avoid committing this tree.
-              renderDidSuspendDelayIfPossible();
-            } else {
-              // If we suspended deeper than the shell, we don't need to delay
-              // the commmit. However, we still call renderDidSuspend if this is
-              // a new boundary, to tell the work loop that a new fallback has
-              // appeared during this render.
-              // TODO: Theoretically we should be able to delete this branch.
-              // It's currently used for two things: 1) to throttle the
-              // appearance of successive loading states, and 2) in
-              // SuspenseList, to determine whether the children include any
-              // pending fallbacks. For 1, we should apply throttling to all
-              // retries, not just ones that render an additional fallback. For
-              // 2, we should check subtreeFlags instead. Then we can delete
-              // this branch.
-              var current = suspenseBoundary.alternate;
+      if (enableProfilerCommitHooks) {
+        if (typeof onCommit === "function") {
+          onCommit(
+            finishedWork.memoizedProps.id,
+            phase,
+            effectDuration,
+            commitTime
+          );
+        } // Schedule a passive effect for this Profiler to call onPostCommit hooks.
+        // This effect should be scheduled even if there is no onPostCommit callback for this Profiler,
+        // because the effect is also where times bubble to parent Profilers.
 
-              if (current === null) {
-                renderDidSuspend();
-              }
-            }
-          }
+        enqueuePendingPassiveProfilerEffect(finishedWork); // Propagate layout effect durations to the next nearest Profiler ancestor.
+        // Do not reset these values until the next render so DevTools has a chance to read them first.
 
-          suspenseBoundary.flags &= ~ForceClientRender;
-          markSuspenseBoundaryShouldCapture(
-            suspenseBoundary,
-            returnFiber,
-            sourceFiber,
-            root,
-            rootRenderLanes
-          ); // Retry listener
-          //
-          // If the fallback does commit, we need to attach a different type of
-          // listener. This one schedules an update on the Suspense boundary to
-          // turn the fallback state off.
-          //
-          // Stash the wakeable on the boundary fiber so we can access it in the
-          // commit phase.
-          //
-          // When the wakeable resolves, we'll attempt to render the boundary
-          // again ("retry").
+        var parentFiber = finishedWork.return;
 
-          var wakeables = suspenseBoundary.updateQueue;
+        outer: while (parentFiber !== null) {
+          switch (parentFiber.tag) {
+            case HostRoot:
+              var root = parentFiber.stateNode;
+              root.effectDuration += effectDuration;
+              break outer;
 
-          if (wakeables === null) {
-            suspenseBoundary.updateQueue = new Set([wakeable]);
-          } else {
-            wakeables.add(wakeable);
+            case Profiler:
+              var parentStateNode = parentFiber.stateNode;
+              parentStateNode.effectDuration += effectDuration;
+              break outer;
           }
 
-          break;
+          parentFiber = parentFiber.return;
         }
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
 
-        case OffscreenComponent: {
-          if (suspenseBoundary.mode & ConcurrentMode) {
-            suspenseBoundary.flags |= ShouldCapture;
-            var offscreenQueue = suspenseBoundary.updateQueue;
-
-            if (offscreenQueue === null) {
-              var newOffscreenQueue = {
-                transitions: null,
-                markerInstances: null,
-                wakeables: new Set([wakeable])
-              };
-              suspenseBoundary.updateQueue = newOffscreenQueue;
-            } else {
-              var _wakeables = offscreenQueue.wakeables;
-
-              if (_wakeables === null) {
-                offscreenQueue.wakeables = new Set([wakeable]);
-              } else {
-                _wakeables.add(wakeable);
-              }
-            }
-
-            break;
-          }
-        }
-        // eslint-disable-next-line no-fallthrough
+function commitLayoutEffectOnFiber(
+  finishedRoot,
+  current,
+  finishedWork,
+  committedLanes
+) {
+  // When updating this function, also update reappearLayoutEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible.
+  var flags = finishedWork.flags;
 
-        default: {
-          throw new Error(
-            "Unexpected Suspense handler tag (" +
-              suspenseBoundary.tag +
-              "). This " +
-              "is a bug in React."
-          );
-        }
-      } // We only attach ping listeners in concurrent mode. Legacy Suspense always
-      // commits fallbacks synchronously, so there are no pings.
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-      if (suspenseBoundary.mode & ConcurrentMode) {
-        attachPingListener(root, wakeable, rootRenderLanes);
+      if (flags & Update) {
+        commitHookLayoutEffects(finishedWork, Layout | HasEffect);
       }
 
-      return;
-    } else {
-      // No boundary was found. Unless this is a sync update, this is OK.
-      // We can suspend and wait for more data to arrive.
-      if (root.tag === ConcurrentRoot) {
-        // In a concurrent root, suspending without a Suspense boundary is
-        // allowed. It will suspend indefinitely without committing.
-        //
-        // TODO: Should we have different behavior for discrete updates? What
-        // about flushSync? Maybe it should put the tree into an inert state,
-        // and potentially log a warning. Revisit this for a future release.
-        attachPingListener(root, wakeable, rootRenderLanes);
-        renderDidSuspendDelayIfPossible();
-        return;
-      } else {
-        // In a legacy root, suspending without a boundary is always an error.
-        var uncaughtSuspenseError = new Error(
-          "A component suspended while responding to synchronous input. This " +
-            "will cause the UI to be replaced with a loading indicator. To " +
-            "fix, updates that suspend should be wrapped " +
-            "with startTransition."
-        );
-        value = uncaughtSuspenseError;
-      }
+      break;
     }
-  } else {
-    // This is a regular error, not a Suspense wakeable.
-    if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
-      markDidThrowWhileHydratingDEV();
 
-      var _suspenseBoundary = getSuspenseHandler(); // If the error was thrown during hydration, we may be able to recover by
-      // discarding the dehydrated content and switching to a client render.
-      // Instead of surfacing the error, find the nearest Suspense boundary
-      // and render it again without hydration.
+    case ClassComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-      if (_suspenseBoundary !== null) {
-        if ((_suspenseBoundary.flags & ShouldCapture) === NoFlags$1) {
-          // Set a flag to indicate that we should try rendering the normal
-          // children again, not the fallback.
-          _suspenseBoundary.flags |= ForceClientRender;
-        }
+      if (flags & Update) {
+        commitClassLayoutLifecycles(finishedWork, current);
+      }
 
-        markSuspenseBoundaryShouldCapture(
-          _suspenseBoundary,
-          returnFiber,
-          sourceFiber,
-          root,
-          rootRenderLanes
-        ); // Even though the user may not be affected by this error, we should
-        // still log it so it can be fixed.
+      if (flags & Callback) {
+        commitClassCallbacks(finishedWork);
+      }
 
-        queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));
-        return;
+      if (flags & Ref) {
+        safelyAttachRef(finishedWork, finishedWork.return);
       }
+
+      break;
     }
-  }
 
-  value = createCapturedValueAtFiber(value, sourceFiber);
-  renderDidError(value); // 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.
+    case HostRoot: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-  var workInProgress = returnFiber;
+      if (flags & Callback) {
+        // TODO: I think this is now always non-null by the time it reaches the
+        // commit phase. Consider removing the type check.
+        var updateQueue = finishedWork.updateQueue;
 
-  do {
-    switch (workInProgress.tag) {
-      case HostRoot: {
-        var _errorInfo = value;
-        workInProgress.flags |= ShouldCapture;
-        var lane = pickArbitraryLane(rootRenderLanes);
-        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);
-        var update = createRootErrorUpdate(workInProgress, _errorInfo, lane);
-        enqueueCapturedUpdate(workInProgress, update);
-        return;
-      }
+        if (updateQueue !== null) {
+          var instance = null;
 
-      case ClassComponent:
-        // Capture and retry
-        var errorInfo = value;
-        var ctor = workInProgress.type;
-        var instance = workInProgress.stateNode;
+          if (finishedWork.child !== null) {
+            switch (finishedWork.child.tag) {
+              case HostSingleton:
+              case HostComponent:
+                instance = getPublicInstance(finishedWork.child.stateNode);
+                break;
 
-        if (
-          (workInProgress.flags & DidCapture) === NoFlags$1 &&
-          (typeof ctor.getDerivedStateFromError === "function" ||
-            (instance !== null &&
-              typeof instance.componentDidCatch === "function" &&
-              !isAlreadyFailedLegacyErrorBoundary(instance)))
-        ) {
-          workInProgress.flags |= ShouldCapture;
+              case ClassComponent:
+                instance = finishedWork.child.stateNode;
+                break;
+            }
+          }
 
-          var _lane = pickArbitraryLane(rootRenderLanes);
+          try {
+            commitCallbacks(updateQueue, instance);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
 
-          workInProgress.lanes = mergeLanes(workInProgress.lanes, _lane); // Schedule the error boundary to re-render using updated state
+      break;
+    }
 
-          var _update = createClassErrorUpdate(
-            workInProgress,
-            errorInfo,
-            _lane
-          );
+    case HostHoistable: {
+      {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
 
-          enqueueCapturedUpdate(workInProgress, _update);
-          return;
+        if (flags & Ref) {
+          safelyAttachRef(finishedWork, finishedWork.return);
         }
 
         break;
-    } // $FlowFixMe[incompatible-type] we bail out when we get a null
+      }
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-    workInProgress = workInProgress.return;
-  } while (workInProgress !== null);
-}
+    case HostSingleton:
+    case HostComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
+      // (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.
 
-var TransitionRoot = 0;
-var TransitionTracingMarker = 1;
-function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
-  if (enableTransitionTracing) {
-    if (pendingTransitions !== null) {
-      var transitionStart = pendingTransitions.transitionStart;
-      var onTransitionStart = callbacks.onTransitionStart;
+      if (current === null && flags & Update) {
+        commitHostComponentMount(finishedWork);
+      }
 
-      if (transitionStart !== null && onTransitionStart != null) {
-        transitionStart.forEach(function (transition) {
-          return onTransitionStart(transition.name, transition.startTime);
-        });
+      if (flags & Ref) {
+        safelyAttachRef(finishedWork, finishedWork.return);
       }
 
-      var markerProgress = pendingTransitions.markerProgress;
-      var onMarkerProgress = callbacks.onMarkerProgress;
+      break;
+    }
 
-      if (onMarkerProgress != null && markerProgress !== null) {
-        markerProgress.forEach(function (markerInstance, markerName) {
-          if (markerInstance.transitions !== null) {
-            // TODO: Clone the suspense object so users can't modify it
-            var pending =
-              markerInstance.pendingBoundaries !== null
-                ? Array.from(markerInstance.pendingBoundaries.values())
-                : [];
-            markerInstance.transitions.forEach(function (transition) {
-              onMarkerProgress(
-                transition.name,
-                markerName,
-                transition.startTime,
-                endTime,
-                pending
-              );
-            });
-          }
-        });
+    case Profiler: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
+      // fire when the tree becomes visible again.
+
+      if (flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
       }
 
-      var markerComplete = pendingTransitions.markerComplete;
-      var onMarkerComplete = callbacks.onMarkerComplete;
+      break;
+    }
 
-      if (markerComplete !== null && onMarkerComplete != null) {
-        markerComplete.forEach(function (transitions, markerName) {
-          transitions.forEach(function (transition) {
-            onMarkerComplete(
-              transition.name,
-              markerName,
-              transition.startTime,
-              endTime
-            );
-          });
-        });
+    case SuspenseComponent: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+
+      if (flags & Update) {
+        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
       }
 
-      var markerIncomplete = pendingTransitions.markerIncomplete;
-      var onMarkerIncomplete = callbacks.onMarkerIncomplete;
+      break;
+    }
 
-      if (onMarkerIncomplete != null && markerIncomplete !== null) {
-        markerIncomplete.forEach(function (_ref, markerName) {
-          var transitions = _ref.transitions,
-            aborts = _ref.aborts;
-          transitions.forEach(function (transition) {
-            var filteredAborts = [];
-            aborts.forEach(function (abort) {
-              switch (abort.reason) {
-                case "marker": {
-                  filteredAborts.push({
-                    type: "marker",
-                    name: abort.name,
-                    endTime: endTime
-                  });
-                  break;
-                }
+    case OffscreenComponent: {
+      var isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
 
-                case "suspense": {
-                  filteredAborts.push({
-                    type: "suspense",
-                    name: abort.name,
-                    endTime: endTime
-                  });
-                  break;
-                }
-              }
-            });
+      if (isModernRoot) {
+        var isHidden = finishedWork.memoizedState !== null;
+        var newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
 
-            if (filteredAborts.length > 0) {
-              onMarkerIncomplete(
-                transition.name,
-                markerName,
-                transition.startTime,
-                filteredAborts
-              );
-            }
-          });
-        });
-      }
+        if (newOffscreenSubtreeIsHidden);
+        else {
+          // The Offscreen tree is visible.
+          var wasHidden = current !== null && current.memoizedState !== null;
+          var newOffscreenSubtreeWasHidden =
+            wasHidden || offscreenSubtreeWasHidden;
+          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
 
-      var transitionProgress = pendingTransitions.transitionProgress;
-      var onTransitionProgress = callbacks.onTransitionProgress;
+          if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+            // This is the root of a reappearing boundary. As we continue
+            // traversing the layout effects, we must also re-mount layout
+            // effects that were unmounted when the Offscreen subtree was
+            // hidden. So this is a superset of the normal commitLayoutEffects.
+            var includeWorkInProgressEffects =
+              (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
+            recursivelyTraverseReappearLayoutEffects(
+              finishedRoot,
+              finishedWork,
+              includeWorkInProgressEffects
+            );
+          } else {
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          }
 
-      if (onTransitionProgress != null && transitionProgress !== null) {
-        transitionProgress.forEach(function (pending, transition) {
-          onTransitionProgress(
-            transition.name,
-            transition.startTime,
-            endTime,
-            Array.from(pending.values())
-          );
-        });
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        }
+      } else {
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
       }
 
-      var transitionComplete = pendingTransitions.transitionComplete;
-      var onTransitionComplete = callbacks.onTransitionComplete;
+      if (flags & Ref) {
+        var props = finishedWork.memoizedProps;
 
-      if (transitionComplete !== null && onTransitionComplete != null) {
-        transitionComplete.forEach(function (transition) {
-          return onTransitionComplete(
-            transition.name,
-            transition.startTime,
-            endTime
-          );
-        });
+        if (props.mode === "manual") {
+          safelyAttachRef(finishedWork, finishedWork.return);
+        } else {
+          safelyDetachRef(finishedWork, finishedWork.return);
+        }
       }
+
+      break;
+    }
+
+    default: {
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      break;
     }
   }
-} // For every tracing marker, store a pointer to it. We will later access it
-// to get the set of suspense boundaries that need to resolve before the
-// tracing marker can be logged as complete
-// This code lives separate from the ReactFiberTransition code because
-// we push and pop on the tracing marker, not the suspense boundary
+}
 
-var markerInstanceStack = createCursor(null);
-function pushRootMarkerInstance(workInProgress) {
+function abortRootTransitions(
+  root,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
   if (enableTransitionTracing) {
-    // On the root, every transition gets mapped to it's own map of
-    // suspense boundaries. The transition is marked as complete when
-    // the suspense boundaries map is empty. We do this because every
-    // transition completes at different times and depends on different
-    // suspense boundaries to complete. We store all the transitions
-    // along with its map of suspense boundaries in the root incomplete
-    // transitions map. Each entry in this map functions like a tracing
-    // marker does, so we can push it onto the marker instance stack
-    var transitions = getWorkInProgressTransitions();
-    var root = workInProgress.stateNode;
+    var rootTransitions = root.incompleteTransitions;
+    deletedTransitions.forEach(function (transition) {
+      if (rootTransitions.has(transition)) {
+        var transitionInstance = rootTransitions.get(transition);
 
-    if (transitions !== null) {
-      transitions.forEach(function (transition) {
-        if (!root.incompleteTransitions.has(transition)) {
-          var markerInstance = {
-            tag: TransitionRoot,
-            transitions: new Set([transition]),
-            pendingBoundaries: null,
-            aborts: null,
-            name: null
-          };
-          root.incompleteTransitions.set(transition, markerInstance);
+        if (transitionInstance.aborts === null) {
+          transitionInstance.aborts = [];
         }
-      });
-    }
 
-    var markerInstances = []; // For ever transition on the suspense boundary, we push the transition
-    // along with its map of pending suspense boundaries onto the marker
-    // instance stack.
+        transitionInstance.aborts.push(abort);
 
-    root.incompleteTransitions.forEach(function (markerInstance) {
-      markerInstances.push(markerInstance);
+        if (deletedOffscreenInstance !== null) {
+          if (
+            transitionInstance.pendingBoundaries !== null &&
+            transitionInstance.pendingBoundaries.has(deletedOffscreenInstance)
+          ) {
+            // $FlowFixMe[incompatible-use] found when upgrading Flow
+            transitionInstance.pendingBoundaries.delete(
+              deletedOffscreenInstance
+            );
+          }
+        }
+      }
     });
-    push(markerInstanceStack, markerInstances, workInProgress);
-  }
-}
-function popRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    pop(markerInstanceStack, workInProgress);
   }
 }
-function pushMarkerInstance(workInProgress, markerInstance) {
+
+function abortTracingMarkerTransitions(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
   if (enableTransitionTracing) {
-    if (markerInstanceStack.current === null) {
-      push(markerInstanceStack, [markerInstance], workInProgress);
-    } else {
-      push(
-        markerInstanceStack,
-        markerInstanceStack.current.concat(markerInstance),
-        workInProgress
-      );
+    var markerInstance = abortedFiber.stateNode;
+    var markerTransitions = markerInstance.transitions;
+    var pendingBoundaries = markerInstance.pendingBoundaries;
+
+    if (markerTransitions !== null) {
+      // TODO: Refactor this code. Is there a way to move this code to
+      // the deletions phase instead of calculating it here while making sure
+      // complete is called appropriately?
+      deletedTransitions.forEach(function (transition) {
+        // If one of the transitions on the tracing marker is a transition
+        // that was in an aborted subtree, we will abort that tracing marker
+        if (
+          abortedFiber !== null &&
+          markerTransitions.has(transition) &&
+          (markerInstance.aborts === null ||
+            !markerInstance.aborts.includes(abort))
+        ) {
+          if (markerInstance.transitions !== null) {
+            if (markerInstance.aborts === null) {
+              markerInstance.aborts = [abort];
+              addMarkerIncompleteCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                markerInstance.transitions,
+                markerInstance.aborts
+              );
+            } else {
+              markerInstance.aborts.push(abort);
+            } // We only want to call onTransitionProgress when the marker hasn't been
+            // deleted
+
+            if (
+              deletedOffscreenInstance !== null &&
+              !isInDeletedTree &&
+              pendingBoundaries !== null &&
+              pendingBoundaries.has(deletedOffscreenInstance)
+            ) {
+              pendingBoundaries.delete(deletedOffscreenInstance);
+              addMarkerProgressCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                deletedTransitions,
+                pendingBoundaries
+              );
+            }
+          }
+        }
+      });
     }
   }
 }
-function popMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    pop(markerInstanceStack, workInProgress);
-  }
-}
-function getMarkerInstances() {
+
+function abortParentMarkerTransitionsForDeletedFiber(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
   if (enableTransitionTracing) {
-    return markerInstanceStack.current;
-  }
+    // Find all pending markers that are waiting on child suspense boundaries in the
+    // aborted subtree and cancels them
+    var fiber = abortedFiber;
 
-  return null;
+    while (fiber !== null) {
+      switch (fiber.tag) {
+        case TracingMarkerComponent:
+          abortTracingMarkerTransitions(
+            fiber,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance,
+            isInDeletedTree
+          );
+          break;
+
+        case HostRoot:
+          var root = fiber.stateNode;
+          abortRootTransitions(
+            root,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance
+          );
+          break;
+      }
+
+      fiber = fiber.return;
+    }
+  }
 }
 
-var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
-// into a dehydrated boundary.
+function commitTransitionProgress(offscreenFiber) {
+  if (enableTransitionTracing) {
+    // This function adds suspense boundaries to the root
+    // or tracing marker's pendingBoundaries map.
+    // When a suspense boundary goes from a resolved to a fallback
+    // state we add the boundary to the map, and when it goes from
+    // a fallback to a resolved state, we remove the boundary from
+    // the map.
+    // We use stateNode on the Offscreen component as a stable object
+    // that doesnt change from render to render. This way we can
+    // distinguish between different Offscreen instances (vs. the same
+    // Offscreen instance with different fibers)
+    var offscreenInstance = offscreenFiber.stateNode;
+    var prevState = null;
+    var previousFiber = offscreenFiber.alternate;
 
-var SelectiveHydrationException = new Error(
-  "This is not a real error. It's an implementation detail of React's " +
-    "selective hydration feature. If this leaks into userspace, it's a bug in " +
-    "React. Please file an issue."
-);
-var didReceiveUpdate = false;
-var didWarnAboutBadClass;
-var didWarnAboutModulePatternComponent;
-var didWarnAboutContextTypeOnFunctionComponent;
-var didWarnAboutGetDerivedStateOnFunctionComponent;
-var didWarnAboutFunctionRefs;
-var didWarnAboutReassigningProps;
-var didWarnAboutRevealOrder;
-var didWarnAboutTailOptions;
-var didWarnAboutDefaultPropsOnFunctionComponent;
+    if (previousFiber !== null && previousFiber.memoizedState !== null) {
+      prevState = previousFiber.memoizedState;
+    }
 
-{
-  didWarnAboutBadClass = {};
-  didWarnAboutModulePatternComponent = {};
-  didWarnAboutContextTypeOnFunctionComponent = {};
-  didWarnAboutGetDerivedStateOnFunctionComponent = {};
-  didWarnAboutFunctionRefs = {};
-  didWarnAboutReassigningProps = false;
-  didWarnAboutRevealOrder = {};
-  didWarnAboutTailOptions = {};
-  didWarnAboutDefaultPropsOnFunctionComponent = {};
-}
+    var nextState = offscreenFiber.memoizedState;
+    var wasHidden = prevState !== null;
+    var isHidden = nextState !== null;
+    var pendingMarkers = offscreenInstance._pendingMarkers; // If there is a name on the suspense boundary, store that in
+    // the pending boundaries.
 
-function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
-  if (current === 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
-    // we can optimize this reconciliation pass by not tracking side-effects.
-    workInProgress.child = mountChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    // If the current child is the same as the work in progress, it means that
-    // we haven't yet started any work on these children. Therefore, we use
-    // the clone algorithm to create a copy of all the current children.
-    // If we had any progressed work already, that is invalid at this point so
-    // let's throw it out.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      current.child,
-      nextChildren,
-      renderLanes
-    );
-  }
-}
+    var name = null;
+    var parent = offscreenFiber.return;
 
-function forceUnmountCurrentAndReconcile(
-  current,
-  workInProgress,
-  nextChildren,
-  renderLanes
-) {
-  // This function is fork of reconcileChildren. It's used in cases where we
-  // want to reconcile without matching against the existing set. This has the
-  // effect of all current children being unmounted; even if the type and key
-  // are the same, the old child is unmounted and a new child is created.
-  //
-  // To do this, we're going to go through the reconcile algorithm twice. In
-  // the first pass, we schedule a deletion for all the current children by
-  // passing null.
-  workInProgress.child = reconcileChildFibers(
-    workInProgress,
-    current.child,
-    null,
-    renderLanes
-  ); // In the second pass, we mount the new children. The trick here is that we
-  // pass null in place of where we usually pass the current child set. This has
-  // the effect of remounting all children regardless of whether their
-  // identities match.
+    if (
+      parent !== null &&
+      parent.tag === SuspenseComponent &&
+      parent.memoizedProps.unstable_name
+    ) {
+      name = parent.memoizedProps.unstable_name;
+    }
 
-  workInProgress.child = reconcileChildFibers(
-    workInProgress,
-    null,
-    nextChildren,
-    renderLanes
-  );
-}
+    if (!wasHidden && isHidden) {
+      // The suspense boundaries was just hidden. Add the boundary
+      // to the pending boundary set if it's there
+      if (pendingMarkers !== null) {
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries;
+          var transitions = markerInstance.transitions;
+          var markerName = markerInstance.name;
 
-function updateForwardRef(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  // TODO: current can be non-null here even if the component
-  // hasn't yet mounted. This happens after the first render suspends.
-  // We'll need to figure out if this is fine or can cause issues.
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+          if (
+            pendingBoundaries !== null &&
+            !pendingBoundaries.has(offscreenInstance)
+          ) {
+            pendingBoundaries.set(offscreenInstance, {
+              name: name
+            });
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
+            if (transitions !== null) {
+              if (
+                markerInstance.tag === TransitionTracingMarker &&
+                markerName !== null
+              ) {
+                addMarkerProgressCallbackToPendingTransition(
+                  markerName,
+                  transitions,
+                  pendingBoundaries
+                );
+              } else if (markerInstance.tag === TransitionRoot) {
+                transitions.forEach(function (transition) {
+                  addTransitionProgressCallbackToPendingTransition(
+                    transition,
+                    pendingBoundaries
+                  );
+                });
+              }
+            }
+          }
+        });
       }
-    }
-  }
+    } else if (wasHidden && !isHidden) {
+      // The suspense boundary went from hidden to visible. Remove
+      // the boundary from the pending suspense boundaries set
+      // if it's there
+      if (pendingMarkers !== null) {
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries;
+          var transitions = markerInstance.transitions;
+          var markerName = markerInstance.name;
 
-  var render = Component.render;
-  var ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent
+          if (
+            pendingBoundaries !== null &&
+            pendingBoundaries.has(offscreenInstance)
+          ) {
+            pendingBoundaries.delete(offscreenInstance);
 
-  var nextChildren;
-  var hasId;
-  prepareToReadContext(workInProgress, renderLanes);
+            if (transitions !== null) {
+              if (
+                markerInstance.tag === TransitionTracingMarker &&
+                markerName !== null
+              ) {
+                addMarkerProgressCallbackToPendingTransition(
+                  markerName,
+                  transitions,
+                  pendingBoundaries
+                ); // If there are no more unresolved suspense boundaries, the interaction
+                // is considered finished
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
+                if (pendingBoundaries.size === 0) {
+                  if (markerInstance.aborts === null) {
+                    addMarkerCompleteCallbackToPendingTransition(
+                      markerName,
+                      transitions
+                    );
+                  }
+
+                  markerInstance.transitions = null;
+                  markerInstance.pendingBoundaries = null;
+                  markerInstance.aborts = null;
+                }
+              } else if (markerInstance.tag === TransitionRoot) {
+                transitions.forEach(function (transition) {
+                  addTransitionProgressCallbackToPendingTransition(
+                    transition,
+                    pendingBoundaries
+                  );
+                });
+              }
+            }
+          }
+        });
+      }
+    }
   }
+}
+
+function hideOrUnhideAllChildren(finishedWork, isHidden) {
+  // Only hide or unhide the top-most host nodes.
+  var hostSubtreeRoot = null;
 
   {
-    ReactCurrentOwner$1.current = workInProgress;
-    setIsRendering(true);
-    nextChildren = renderWithHooks(
-      current,
-      workInProgress,
-      render,
-      nextProps,
-      ref,
-      renderLanes
-    );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
+    // We only have the top Fiber that was inserted but we need to recurse down its
+    // children to find all the terminal nodes.
+    var node = finishedWork;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+    while (true) {
+      if (
+        node.tag === HostComponent ||
+        node.tag === HostHoistable ||
+        node.tag === HostSingleton
+      ) {
+        if (hostSubtreeRoot === null) {
+          hostSubtreeRoot = node;
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  }
+          try {
+            var instance = node.stateNode;
 
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
+            if (isHidden) {
+              hideInstance(instance);
+            } else {
+              unhideInstance(node.stateNode, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (node.tag === HostText) {
+        if (hostSubtreeRoot === null) {
+          try {
+            var _instance = node.stateNode;
 
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+            if (isHidden) {
+              hideTextInstance(_instance);
+            } else {
+              unhideTextInstance(_instance, node.memoizedProps);
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      } else if (
+        (node.tag === OffscreenComponent ||
+          node.tag === LegacyHiddenComponent) &&
+        node.memoizedState !== null &&
+        node !== finishedWork
+      );
+      else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
 
-function updateMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (current === null) {
-    var type = Component.type;
+      if (node === finishedWork) {
+        return;
+      }
 
-    if (
-      isSimpleFunctionComponent(type) &&
-      Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.
-      Component.defaultProps === undefined
-    ) {
-      var resolvedType = type;
+      while (node.sibling === null) {
+        if (node.return === null || node.return === finishedWork) {
+          return;
+        }
 
-      {
-        resolvedType = resolveFunctionForHotReloading(type);
-      } // If this is a plain function component without default props,
-      // and with only the default shallow comparison, we upgrade it
-      // to a SimpleMemoComponent to allow fast path updates.
+        if (hostSubtreeRoot === node) {
+          hostSubtreeRoot = null;
+        }
 
-      workInProgress.tag = SimpleMemoComponent;
-      workInProgress.type = resolvedType;
+        node = node.return;
+      }
 
-      {
-        validateFunctionComponentInDev(workInProgress, type);
+      if (hostSubtreeRoot === node) {
+        hostSubtreeRoot = null;
       }
 
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        resolvedType,
-        nextProps,
-        renderLanes
-      );
+      node.sibling.return = node.return;
+      node = node.sibling;
     }
+  }
+}
 
-    {
-      var innerPropTypes = type.propTypes;
+function commitAttachRef(finishedWork) {
+  var ref = finishedWork.ref;
 
-      if (innerPropTypes) {
-        // Inner memo component props aren't currently validated in createElement.
-        // We could move it there, but we'd still need this for lazy code path.
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(type)
-        );
-      }
+  if (ref !== null) {
+    var instance = finishedWork.stateNode;
+    var instanceToUse;
 
-      if (Component.defaultProps !== undefined) {
-        var componentName = getComponentNameFromType(type) || "Unknown";
+    switch (finishedWork.tag) {
+      case HostHoistable:
+      case HostSingleton:
+      case HostComponent:
+        instanceToUse = getPublicInstance(instance);
+        break;
 
-        if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
-          error(
-            "%s: Support for defaultProps will be removed from memo components " +
-              "in a future major release. Use JavaScript default parameters instead.",
-            componentName
-          );
+      default:
+        instanceToUse = instance;
+    } // Moved outside to ensure DCE works with this flag
 
-          didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+    if (finishedWork.tag === ScopeComponent) {
+      instanceToUse = instance;
+    }
+
+    if (typeof ref === "function") {
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          finishedWork.refCleanup = ref(instanceToUse);
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
         }
+      } else {
+        finishedWork.refCleanup = ref(instanceToUse);
       }
-    }
+    } else {
+      {
+        if (!ref.hasOwnProperty("current")) {
+          error(
+            "Unexpected ref object provided for %s. " +
+              "Use either a ref-setter function or React.createRef().",
+            getComponentNameFromFiber(finishedWork)
+          );
+        }
+      } // $FlowFixMe unable to narrow type to the non-function case
 
-    var child = createFiberFromTypeAndProps(
-      Component.type,
-      null,
-      nextProps,
-      workInProgress,
-      workInProgress.mode,
-      renderLanes
-    );
-    child.ref = workInProgress.ref;
-    child.return = workInProgress;
-    workInProgress.child = child;
-    return child;
+      ref.current = instanceToUse;
+    }
   }
+}
 
-  {
-    var _type = Component.type;
-    var _innerPropTypes = _type.propTypes;
+function detachFiberMutation(fiber) {
+  // Cut off the return pointer to disconnect it from the tree.
+  // This enables us to detect and warn against state updates on an unmounted component.
+  // It also prevents events from bubbling from within disconnected components.
+  //
+  // Ideally, we should also 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.
+  //
+  // Note that we can't clear child or sibling pointers yet.
+  // They're needed for passive effects and for findDOMNode.
+  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
+  //
+  // Don't reset the alternate yet, either. We need that so we can detach the
+  // alternate's fields in the passive phase. Clearing the return pointer is
+  // sufficient for findDOMNode semantics.
+  var alternate = fiber.alternate;
 
-    if (_innerPropTypes) {
-      // Inner memo component props aren't currently validated in createElement.
-      // We could move it there, but we'd still need this for lazy code path.
-      checkPropTypes(
-        _innerPropTypes,
-        nextProps, // Resolved props
-        "prop",
-        getComponentNameFromType(_type)
-      );
-    }
+  if (alternate !== null) {
+    alternate.return = null;
   }
 
-  var currentChild = current.child; // This is always exactly one child
+  fiber.return = null;
+}
 
-  var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
-    current,
-    renderLanes
-  );
+function detachFiberAfterEffects(fiber) {
+  var alternate = fiber.alternate;
 
-  if (!hasScheduledUpdateOrContext) {
-    // This will be the props with resolved defaultProps,
-    // unlike current.memoizedProps which will be the unresolved ones.
-    var prevProps = currentChild.memoizedProps; // Default to shallow comparison
+  if (alternate !== null) {
+    fiber.alternate = null;
+    detachFiberAfterEffects(alternate);
+  } // Clear cyclical Fiber fields. This level alone is designed to roughly
+  // approximate the planned Fiber refactor. In that world, `setState` will be
+  // bound to a special "instance" object instead of a Fiber. The Instance
+  // object will not have any of these fields. It will only be connected to
+  // the fiber tree via a single link at the root. So if this level alone is
+  // sufficient to fix memory issues, that bodes well for our plans.
 
-    var compare = Component.compare;
-    compare = compare !== null ? compare : shallowEqual;
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
+  // tree, which has its own pointers to children, parents, and siblings.
+  // The other host nodes also point back to fibers, so we should detach that
+  // one, too.
 
-    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  if (fiber.tag === HostComponent) {
+    var hostInstance = fiber.stateNode;
+
+    if (hostInstance !== null) {
+      detachDeletedInstance(hostInstance);
     }
-  } // React DevTools reads this flag.
+  }
 
-  workInProgress.flags |= PerformedWork;
-  var newChild = createWorkInProgress(currentChild, nextProps);
-  newChild.ref = workInProgress.ref;
-  newChild.return = workInProgress;
-  workInProgress.child = newChild;
-  return newChild;
-}
+  fiber.stateNode = null;
 
-function updateSimpleMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  // TODO: current can be non-null here even if the component
-  // hasn't yet mounted. This happens when the inner render suspends.
-  // We'll need to figure out if this is fine or can cause issues.
   {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var outerMemoType = workInProgress.elementType;
+    fiber._debugOwner = null;
+  } // Theoretically, nothing in here should be necessary, because we already
+  // disconnected the fiber from the tree. So even if something leaks this
+  // particular fiber, it won't leak anything else.
 
-      if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
-        // We warn when you define propTypes on lazy()
-        // so let's just skip over it to find memo() outer wrapper.
-        // Inner props for memo are validated later.
-        var lazyComponent = outerMemoType;
-        var payload = lazyComponent._payload;
-        var init = lazyComponent._init;
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
 
-        try {
-          outerMemoType = init(payload);
-        } catch (x) {
-          outerMemoType = null;
-        } // Inner propTypes will be validated in the function component path.
+  fiber.updateQueue = null;
+}
 
-        var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+function getHostParentFiber(fiber) {
+  var parent = fiber.return;
 
-        if (outerPropTypes) {
-          checkPropTypes(
-            outerPropTypes,
-            nextProps, // Resolved (SimpleMemoComponent has no defaultProps)
-            "prop",
-            getComponentNameFromType(outerMemoType)
-          );
-        }
-      }
+  while (parent !== null) {
+    if (isHostParent(parent)) {
+      return parent;
     }
-  }
-
-  if (current !== null) {
-    var prevProps = current.memoizedProps;
-
-    if (
-      shallowEqual(prevProps, nextProps) &&
-      current.ref === workInProgress.ref && // Prevent bailout if the implementation changed due to hot reload.
-      workInProgress.type === current.type
-    ) {
-      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we
-      // would during a normal fiber bailout.
-      //
-      // We don't have strong guarantees that the props object is referentially
-      // equal during updates where we can't bail out anyway — like if the props
-      // are shallowly equal, but there's a local state or context update in the
-      // same batch.
-      //
-      // However, as a principle, we should aim to make the behavior consistent
-      // across different ways of memoizing a component. For example, React.memo
-      // has a different internal Fiber layout if you pass a normal function
-      // component (SimpleMemoComponent) versus if you pass a different type
-      // like forwardRef (MemoComponent). But this is an implementation detail.
-      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't
-      // affect whether the props object is reused during a bailout.
-
-      workInProgress.pendingProps = nextProps = prevProps;
 
-      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
-        // The pending lanes were cleared at the beginning of beginWork. We're
-        // about to bail out, but there might be other lanes that weren't
-        // included in the current render. Usually, the priority level of the
-        // remaining updates is accumulated during the evaluation of the
-        // component (i.e. when processing the update queue). But since since
-        // we're bailing out early *without* evaluating the component, we need
-        // to account for it here, too. Reset to the value of the current fiber.
-        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,
-        // because a MemoComponent fiber does not have hooks or an update queue;
-        // rather, it wraps around an inner component, which may or may not
-        // contains hooks.
-        // TODO: Move the reset at in beginWork out of the common path so that
-        // this is no longer necessary.
-        workInProgress.lanes = current.lanes;
-        return bailoutOnAlreadyFinishedWork(
-          current,
-          workInProgress,
-          renderLanes
-        );
-      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
-        // This is a special case that only exists for legacy mode.
-        // See https://github.com/facebook/react/pull/19216.
-        didReceiveUpdate = true;
-      }
-    }
+    parent = parent.return;
   }
 
-  return updateFunctionComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    renderLanes
+  throw new Error(
+    "Expected to find a host parent. This error is likely caused by a bug " +
+      "in React. Please file an issue."
   );
 }
 
-function updateOffscreenComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  var nextIsDetached =
-    (workInProgress.stateNode._pendingVisibility & OffscreenDetached) !== 0;
-  var prevState = current !== null ? current.memoizedState : null;
-  markRef$1(current, workInProgress);
+function isHostParent(fiber) {
+  return (
+    fiber.tag === HostComponent ||
+    fiber.tag === HostRoot ||
+    fiber.tag === HostHoistable ||
+    fiber.tag === HostSingleton ||
+    fiber.tag === HostPortal
+  );
+}
 
-  if (
-    nextProps.mode === "hidden" ||
-    nextProps.mode === "unstable-defer-without-hiding" ||
-    nextIsDetached
-  ) {
-    // Rendering a hidden tree.
-    var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+function getHostSibling(fiber) {
+  // We're going to search forward into the tree until we find a sibling host
+  // node. Unfortunately, if multiple insertions are done in a row we have to
+  // search past them. This leads to exponential search for the next sibling.
+  // TODO: Find a more efficient way to do this.
+  var node = fiber;
 
-    if (didSuspend) {
-      // Something suspended inside a hidden tree
-      // Include the base lanes from the last render
-      var nextBaseLanes =
-        prevState !== null
-          ? mergeLanes(prevState.baseLanes, renderLanes)
-          : renderLanes;
+  siblings: while (true) {
+    // If we didn't find anything, let's try the next sibling.
+    while (node.sibling === null) {
+      if (node.return === null || isHostParent(node.return)) {
+        // If we pop out of the root or hit the parent the fiber we are the
+        // last sibling.
+        return null;
+      } // $FlowFixMe[incompatible-type] found when upgrading Flow
 
-      if (current !== null) {
-        // Reset to the current children
-        var currentChild = (workInProgress.child = current.child); // The current render suspended, but there may be other lanes with
-        // pending work. We can't read `childLanes` from the current Offscreen
-        // fiber because we reset it when it was deferred; however, we can read
-        // the pending lanes from the child fibers.
+      node = node.return;
+    }
 
-        var currentChildLanes = NoLanes;
+    node.sibling.return = node.return;
+    node = node.sibling;
 
-        while (currentChild !== null) {
-          currentChildLanes = mergeLanes(
-            mergeLanes(currentChildLanes, currentChild.lanes),
-            currentChild.childLanes
-          );
-          currentChild = currentChild.sibling;
-        }
+    while (
+      node.tag !== HostComponent &&
+      node.tag !== HostText &&
+      node.tag !== HostSingleton &&
+      node.tag !== DehydratedFragment
+    ) {
+      // If it is not host node and, we might have a host node inside it.
+      // Try to search down until we find one.
+      if (node.flags & Placement) {
+        // If we don't have a child, try the siblings instead.
+        continue siblings;
+      } // If we don't have a child, try the siblings instead.
+      // We also skip portals because they are not part of this host tree.
 
-        var lanesWeJustAttempted = nextBaseLanes;
-        var remainingChildLanes = removeLanes(
-          currentChildLanes,
-          lanesWeJustAttempted
-        );
-        workInProgress.childLanes = remainingChildLanes;
+      if (node.child === null || node.tag === HostPortal) {
+        continue siblings;
       } else {
-        workInProgress.childLanes = NoLanes;
-        workInProgress.child = null;
+        node.child.return = node;
+        node = node.child;
       }
+    } // Check if this host node is stable or about to be placed.
 
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        nextBaseLanes,
-        renderLanes
-      );
+    if (!(node.flags & Placement)) {
+      // Found it!
+      return node.stateNode;
     }
+  }
+}
 
-    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-      // In legacy sync mode, don't defer the subtree. Render it now.
-      // TODO: Consider how Offscreen should work with transitions in the future
-      var nextState = {
-        baseLanes: NoLanes,
-        cachePool: null
-      };
-      workInProgress.memoizedState = nextState;
+function commitPlacement(finishedWork) {
+  {
+    if (finishedWork.tag === HostSingleton) {
+      // Singletons are already in the Host and don't need to be placed
+      // Since they operate somewhat like Portals though their children will
+      // have Placement and will get placed inside them
+      return;
+    }
+  } // Recursively insert all host nodes into the parent.
+
+  var parentFiber = getHostParentFiber(finishedWork);
 
+  switch (parentFiber.tag) {
+    case HostSingleton: {
       {
-        // push the cache pool even though we're going to bail out
-        // because otherwise there'd be a context mismatch
-        if (current !== null) {
-          pushTransition(workInProgress, null, null);
-        }
+        var parent = parentFiber.stateNode;
+        var before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+        // children to find all the terminal nodes.
+
+        insertOrAppendPlacementNode(finishedWork, before, parent);
+        break;
       }
+    }
+    // eslint-disable-next-line no-fallthrough
 
-      reuseHiddenContextOnStack(workInProgress);
-      pushOffscreenSuspenseHandler(workInProgress);
-    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {
-      // We're hidden, and we're not rendering at Offscreen. We will bail out
-      // and resume this tree later.
-      // Schedule this fiber to re-render at Offscreen priority
-      workInProgress.lanes = workInProgress.childLanes =
-        laneToLanes(OffscreenLane); // Include the base lanes from the last render
+    case HostComponent: {
+      var _parent = parentFiber.stateNode;
 
-      var _nextBaseLanes =
-        prevState !== null
-          ? mergeLanes(prevState.baseLanes, renderLanes)
-          : renderLanes;
+      if (parentFiber.flags & ContentReset) {
+        // Reset the text content of the parent before doing any insertions
+        resetTextContent(_parent); // Clear ContentReset from the effect tag
 
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        _nextBaseLanes,
-        renderLanes
+        parentFiber.flags &= ~ContentReset;
+      }
+
+      var _before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
+      // children to find all the terminal nodes.
+
+      insertOrAppendPlacementNode(finishedWork, _before, _parent);
+      break;
+    }
+
+    case HostRoot:
+    case HostPortal: {
+      var _parent2 = parentFiber.stateNode.containerInfo;
+
+      var _before2 = getHostSibling(finishedWork);
+
+      insertOrAppendPlacementNodeIntoContainer(
+        finishedWork,
+        _before2,
+        _parent2
       );
-    } else {
-      // This is the second render. The surrounding visible content has already
-      // committed. Now we resume rendering the hidden tree.
-      // Rendering at offscreen, so we can clear the base lanes.
-      var _nextState = {
-        baseLanes: NoLanes,
-        cachePool: null
-      };
-      workInProgress.memoizedState = _nextState;
+      break;
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-      if (current !== null) {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        var prevCachePool = prevState !== null ? prevState.cachePool : null; // TODO: Consider if and how Offscreen pre-rendering should
-        // be attributed to the transition that spawned it
+    default:
+      throw new Error(
+        "Invalid host parent fiber. This error is likely caused by a bug " +
+          "in React. Please file an issue."
+      );
+  }
+}
 
-        pushTransition(workInProgress, prevCachePool, null);
-      } // Push the lanes that were skipped when we bailed out.
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  var tag = node.tag;
+  var isHost = tag === HostComponent || tag === HostText;
 
-      if (prevState !== null) {
-        pushHiddenContext(workInProgress, prevState);
-      } else {
-        reuseHiddenContextOnStack(workInProgress);
-      }
+  if (isHost) {
+    var stateNode = node.stateNode;
 
-      pushOffscreenSuspenseHandler(workInProgress);
+    if (before) {
+      insertInContainerBefore(parent, stateNode, before);
+    } else {
+      appendChildToContainer(parent, stateNode);
     }
-  } else {
-    // Rendering a visible tree.
-    if (prevState !== null) {
-      // We're going from hidden -> visible.
-      var _prevCachePool = null;
+  } else if (tag === HostPortal || tag === HostSingleton);
+  else {
+    var child = node.child;
 
-      {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        _prevCachePool = prevState.cachePool;
+    if (child !== null) {
+      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
+      var sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
+        sibling = sibling.sibling;
       }
+    }
+  }
+}
 
-      var transitions = null;
+function insertOrAppendPlacementNode(node, before, parent) {
+  var tag = node.tag;
+  var isHost = tag === HostComponent || tag === HostText;
 
-      if (enableTransitionTracing) {
-        // We have now gone from hidden to visible, so any transitions should
-        // be added to the stack to get added to any Offscreen/suspense children
-        var instance = workInProgress.stateNode;
+  if (isHost) {
+    var stateNode = node.stateNode;
 
-        if (instance !== null && instance._transitions != null) {
-          transitions = Array.from(instance._transitions);
-        }
+    if (before) {
+      insertBefore(parent, stateNode, before);
+    } else {
+      appendChild(parent, stateNode);
+    }
+  } else if (tag === HostPortal || tag === HostSingleton);
+  else {
+    var child = node.child;
+
+    if (child !== null) {
+      insertOrAppendPlacementNode(child, before, parent);
+      var sibling = child.sibling;
+
+      while (sibling !== null) {
+        insertOrAppendPlacementNode(sibling, before, parent);
+        sibling = sibling.sibling;
       }
+    }
+  }
+} // These are tracked on the stack as we recursively traverse a
+// deleted subtree.
+// TODO: Update these during the whole mutation phase, not just during
+// a deletion.
 
-      pushTransition(workInProgress, _prevCachePool, transitions); // Push the lanes that were skipped when we bailed out.
+var hostParent = null;
+var hostParentIsContainer = false;
 
-      pushHiddenContext(workInProgress, prevState);
-      reuseSuspenseHandlerOnStack(workInProgress); // Since we're not hidden anymore, reset the state
+function commitDeletionEffects(root, returnFiber, deletedFiber) {
+  {
+    // We only have the top Fiber that was deleted but we need to recurse down its
+    // children to find all the terminal nodes.
+    // Recursively delete all host nodes from the parent, detach refs, clean
+    // up mounted layout effects, and call componentWillUnmount.
+    // We only need to remove the topmost host child in each branch. But then we
+    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
+    // could split this into two separate traversals functions, where the second
+    // one doesn't include any removeChild logic. This is maybe the same
+    // function as "disappearLayoutEffects" (or whatever that turns into after
+    // the layout phase is refactored to use recursion).
+    // Before starting, find the nearest host parent on the stack so we know
+    // which instance/container to remove the children from.
+    // TODO: Instead of searching up the fiber return path on every deletion, we
+    // can track the nearest host component on the JS stack as we traverse the
+    // tree during the commit phase. This would make insertions faster, too.
+    var parent = returnFiber;
 
-      workInProgress.memoizedState = null;
-    } else {
-      // We weren't previously hidden, and we still aren't, so there's nothing
-      // special to do. Need to push to the stack regardless, though, to avoid
-      // a push/pop misalignment.
-      {
-        // If the render that spawned this one accessed the cache pool, resume
-        // using the same cache. Unless the parent changed, since that means
-        // there was a refresh.
-        if (current !== null) {
-          pushTransition(workInProgress, null, null);
+    findParent: while (parent !== null) {
+      switch (parent.tag) {
+        case HostSingleton:
+        case HostComponent: {
+          hostParent = parent.stateNode;
+          hostParentIsContainer = false;
+          break findParent;
         }
-      } // We're about to bail out, but we need to push this to the stack anyway
-      // to avoid a push/pop misalignment.
 
-      reuseHiddenContextOnStack(workInProgress);
-      reuseSuspenseHandlerOnStack(workInProgress);
+        case HostRoot: {
+          hostParent = parent.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          break findParent;
+        }
+
+        case HostPortal: {
+          hostParent = parent.stateNode.containerInfo;
+          hostParentIsContainer = true;
+          break findParent;
+        }
+      }
+
+      parent = parent.return;
+    }
+
+    if (hostParent === null) {
+      throw new Error(
+        "Expected to find a host parent. This error is likely caused by " +
+          "a bug in React. Please file an issue."
+      );
     }
+
+    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+    hostParent = null;
+    hostParentIsContainer = false;
   }
 
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
+  detachFiberMutation(deletedFiber);
 }
 
-function deferHiddenOffscreenComponent(
-  current,
-  workInProgress,
-  nextBaseLanes,
-  renderLanes
+function recursivelyTraverseDeletionEffects(
+  finishedRoot,
+  nearestMountedAncestor,
+  parent
 ) {
-  var nextState = {
-    baseLanes: nextBaseLanes,
-    // Save the cache pool so we can resume later.
-    cachePool: getOffscreenDeferredCache()
-  };
-  workInProgress.memoizedState = nextState;
-
-  {
-    // push the cache pool even though we're going to bail out
-    // because otherwise there'd be a context mismatch
-    if (current !== null) {
-      pushTransition(workInProgress, null, null);
-    }
-  } // We're about to bail out, but we need to push this to the stack anyway
-  // to avoid a push/pop misalignment.
-
-  reuseHiddenContextOnStack(workInProgress);
-  pushOffscreenSuspenseHandler(workInProgress);
+  // TODO: Use a static flag to skip trees that don't have unmount effects
+  var child = parent.child;
 
-  if (enableLazyContextPropagation && current !== null) {
-    // Since this tree will resume rendering in a separate render, we need
-    // to propagate parent contexts now so we don't lose track of which
-    // ones changed.
-    propagateParentContextChangesToDeferredTree(
-      current,
-      workInProgress,
-      renderLanes
-    );
+  while (child !== null) {
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
+    child = child.sibling;
   }
+}
 
-  return null;
-} // Note: These happen to have identical begin phases, for now. We shouldn't hold
-// ourselves to this constraint, though. If the behavior diverges, we should
-// fork the function.
+function commitDeletionEffectsOnFiber(
+  finishedRoot,
+  nearestMountedAncestor,
+  deletedFiber
+) {
+  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
+  // into their subtree. There are simpler cases in the inner switch
+  // that don't modify the stack.
 
-var updateLegacyHiddenComponent = updateOffscreenComponent;
+  switch (deletedFiber.tag) {
+    case HostHoistable: {
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        }
 
-function updateCacheComponent(current, workInProgress, renderLanes) {
-  prepareToReadContext(workInProgress, renderLanes);
-  var parentCache = readContext(CacheContext);
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
 
-  if (current === null) {
-    // Initial mount. Request a fresh cache from the pool.
-    var freshCache = requestCacheFromPool(renderLanes);
-    var initialState = {
-      parent: parentCache,
-      cache: freshCache
-    };
-    workInProgress.memoizedState = initialState;
-    initializeUpdateQueue(workInProgress);
-    pushCacheProvider(workInProgress, freshCache);
-  } else {
-    // Check for updates
-    if (includesSomeLane(current.lanes, renderLanes)) {
-      cloneUpdateQueue(current, workInProgress);
-      processUpdateQueue(workInProgress, null, null, renderLanes);
-    }
+        if (deletedFiber.memoizedState) {
+          releaseResource(deletedFiber.memoizedState);
+        } else if (deletedFiber.stateNode) {
+          unmountHoistable(deletedFiber.stateNode);
+        }
 
-    var prevState = current.memoizedState;
-    var nextState = workInProgress.memoizedState; // Compare the new parent cache to the previous to see detect there was
-    // a refresh.
+        return;
+      }
+    }
+    // eslint-disable-next-line no-fallthrough
 
-    if (prevState.parent !== parentCache) {
-      // Refresh in parent. Update the parent.
-      var derivedState = {
-        parent: parentCache,
-        cache: parentCache
-      }; // Copied from getDerivedStateFromProps implementation. Once the update
-      // queue is empty, persist the derived state onto the base state.
+    case HostSingleton: {
+      {
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        }
 
-      workInProgress.memoizedState = derivedState;
+        var prevHostParent = hostParent;
+        var prevHostParentIsContainer = hostParentIsContainer;
+        hostParent = deletedFiber.stateNode;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        ); // Normally this is called in passive unmount effect phase however with
+        // HostSingleton we warn if you acquire one that is already associated to
+        // a different fiber. To increase our chances of avoiding this, specifically
+        // if you keyed a HostSingleton so there will be a delete followed by a Placement
+        // we treat detach eagerly here
 
-      if (workInProgress.lanes === NoLanes) {
-        var updateQueue = workInProgress.updateQueue;
-        workInProgress.memoizedState = updateQueue.baseState = derivedState;
+        releaseSingletonInstance(deletedFiber.stateNode);
+        hostParent = prevHostParent;
+        hostParentIsContainer = prevHostParentIsContainer;
+        return;
       }
+    }
+    // eslint-disable-next-line no-fallthrough
 
-      pushCacheProvider(workInProgress, parentCache); // No need to propagate a context change because the refreshed parent
-      // already did.
-    } else {
-      // The parent didn't refresh. Now check if this cache did.
-      var nextCache = nextState.cache;
-      pushCacheProvider(workInProgress, nextCache);
+    case HostComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      } // Intentional fallthrough to next branch
+    }
+    // eslint-disable-next-line-no-fallthrough
+
+    case HostText: {
+      // We only need to remove the nearest host child. Set the host parent
+      // to `null` on the stack to indicate that nested children don't
+      // need to be removed.
+      {
+        var _prevHostParent = hostParent;
+        var _prevHostParentIsContainer = hostParentIsContainer;
+        hostParent = null;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        hostParent = _prevHostParent;
+        hostParentIsContainer = _prevHostParentIsContainer;
 
-      if (nextCache !== prevState.cache) {
-        // This cache refreshed. Propagate a context change.
-        propagateContextChange(workInProgress, CacheContext, renderLanes);
+        if (hostParent !== null) {
+          // Now that all the child effects have unmounted, we can remove the
+          // node from the tree.
+          if (hostParentIsContainer) {
+            removeChildFromContainer(hostParent, deletedFiber.stateNode);
+          } else {
+            removeChild(hostParent, deletedFiber.stateNode);
+          }
+        }
       }
+
+      return;
     }
-  }
 
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-} // This should only be called if the name changes
+    case DehydratedFragment: {
+      {
+        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
 
-function updateTracingMarkerComponent(current, workInProgress, renderLanes) {
-  if (!enableTransitionTracing) {
-    return null;
-  } // TODO: (luna) Only update the tracing marker if it's newly rendered or it's name changed.
-  // A tracing marker is only associated with the transitions that rendered
-  // or updated it, so we can create a new set of transitions each time
+        if (hydrationCallbacks !== null) {
+          var onDeleted = hydrationCallbacks.onDeleted;
 
-  if (current === null) {
-    var currentTransitions = getPendingTransitions();
+          if (onDeleted) {
+            onDeleted(deletedFiber.stateNode);
+          }
+        }
+      } // Dehydrated fragments don't have any children
+      // Delete the dehydrated suspense boundary and all of its content.
 
-    if (currentTransitions !== null) {
-      var markerInstance = {
-        tag: TransitionTracingMarker,
-        transitions: new Set(currentTransitions),
-        pendingBoundaries: null,
-        name: workInProgress.pendingProps.name,
-        aborts: null
-      };
-      workInProgress.stateNode = markerInstance; // We call the marker complete callback when all child suspense boundaries resolve.
-      // We do this in the commit phase on Offscreen. If the marker has no child suspense
-      // boundaries, we need to schedule a passive effect to make sure we call the marker
-      // complete callback.
+      {
+        if (hostParent !== null) {
+          if (hostParentIsContainer) {
+            clearSuspenseBoundaryFromContainer(
+              hostParent,
+              deletedFiber.stateNode
+            );
+          } else {
+            clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
+          }
+        }
+      }
 
-      workInProgress.flags |= Passive$1;
+      return;
     }
-  } else {
-    {
-      if (current.memoizedProps.name !== workInProgress.pendingProps.name) {
-        error(
-          "Changing the name of a tracing marker after mount is not supported. " +
-            "To remount the tracing marker, pass it a new key."
+
+    case HostPortal: {
+      {
+        // When we go into a portal, it becomes the parent to remove from.
+        var _prevHostParent2 = hostParent;
+        var _prevHostParentIsContainer2 = hostParentIsContainer;
+        hostParent = deletedFiber.stateNode.containerInfo;
+        hostParentIsContainer = true;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
         );
+        hostParent = _prevHostParent2;
+        hostParentIsContainer = _prevHostParentIsContainer2;
       }
-    }
-  }
 
-  var instance = workInProgress.stateNode;
+      return;
+    }
 
-  if (instance !== null) {
-    pushMarkerInstance(workInProgress, instance);
-  }
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        var updateQueue = deletedFiber.updateQueue;
 
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+        if (updateQueue !== null) {
+          var lastEffect = updateQueue.lastEffect;
 
-function updateFragment(current, workInProgress, renderLanes) {
-  var nextChildren = workInProgress.pendingProps;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+          if (lastEffect !== null) {
+            var firstEffect = lastEffect.next;
+            var effect = firstEffect;
 
-function updateMode(current, workInProgress, renderLanes) {
-  var nextChildren = workInProgress.pendingProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+            do {
+              var _effect = effect,
+                destroy = _effect.destroy,
+                tag = _effect.tag;
 
-function updateProfiler(current, workInProgress, renderLanes) {
-  {
-    workInProgress.flags |= Update;
+              if (destroy !== undefined) {
+                if ((tag & Insertion) !== NoFlags) {
+                  safelyCallDestroy(
+                    deletedFiber,
+                    nearestMountedAncestor,
+                    destroy
+                  );
+                } else if ((tag & Layout) !== NoFlags) {
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStarted(deletedFiber);
+                  }
 
-    {
-      // Reset effect durations for the next eventual effect phase.
-      // These are reset during render to allow the DevTools commit hook a chance to read them,
-      var stateNode = workInProgress.stateNode;
-      stateNode.effectDuration = 0;
-      stateNode.passiveEffectDuration = 0;
-    }
-  }
+                  if (shouldProfile(deletedFiber)) {
+                    startLayoutEffectTimer();
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                    recordLayoutEffectDuration(deletedFiber);
+                  } else {
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                  }
 
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStopped();
+                  }
+                }
+              }
 
-function markRef$1(current, workInProgress) {
-  var ref = workInProgress.ref;
+              effect = effect.next;
+            } while (effect !== firstEffect);
+          }
+        }
+      }
 
-  if (
-    (current === null && ref !== null) ||
-    (current !== null && current.ref !== ref)
-  ) {
-    // Schedule a Ref effect
-    workInProgress.flags |= Ref;
-    workInProgress.flags |= RefStatic;
-  }
-}
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
 
-function updateFunctionComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  {
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+    case ClassComponent: {
+      if (!offscreenSubtreeWasHidden) {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        var instance = deletedFiber.stateNode;
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
+        if (typeof instance.componentWillUnmount === "function") {
+          safelyCallComponentWillUnmount(
+            deletedFiber,
+            nearestMountedAncestor,
+            instance
+          );
+        }
       }
+
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
     }
-  }
 
-  var context;
+    case ScopeComponent: {
+      {
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      }
 
-  var nextChildren;
-  var hasId;
-  prepareToReadContext(workInProgress, renderLanes);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+    case OffscreenComponent: {
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
 
-  {
-    ReactCurrentOwner$1.current = workInProgress;
-    setIsRendering(true);
-    nextChildren = renderWithHooks(
-      current,
-      workInProgress,
-      Component,
-      nextProps,
-      context,
-      renderLanes
-    );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
+      if (deletedFiber.mode & ConcurrentMode) {
+        // If this offscreen component is hidden, we already unmounted it. Before
+        // deleting the children, track that it's already unmounted so that we
+        // don't attempt to unmount the effects again.
+        // TODO: If the tree is hidden, in most cases we should be able to skip
+        // over the nested children entirely. An exception is we haven't yet found
+        // the topmost host node to delete, which we already track on the stack.
+        // But the other case is portals, which need to be detached no matter how
+        // deeply they are nested. We should use a subtree flag to track whether a
+        // subtree includes a nested portal.
+        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+        offscreenSubtreeWasHidden =
+          prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+      } else {
+        recursivelyTraverseDeletionEffects(
+          finishedRoot,
+          nearestMountedAncestor,
+          deletedFiber
+        );
+      }
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+      break;
+    }
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    default: {
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      return;
+    }
   }
-
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
 }
 
-function replayFunctionComponent(
-  current,
-  workInProgress,
-  nextProps,
-  Component,
-  renderLanes
-) {
-  // This function is used to replay a component that previously suspended,
-  // after its data resolves. It's a simplified version of
-  // updateFunctionComponent that reuses the hooks from the previous attempt.
-  var context;
-
-  prepareToReadContext(workInProgress, renderLanes);
-
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+function commitSuspenseCallback(finishedWork) {
+  // TODO: Move this to passive phase
+  var newState = finishedWork.memoizedState;
 
-  var nextChildren = replaySuspendedComponentWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    context
-  );
-  var hasId = checkDidRenderIdHook();
+  if (newState !== null) {
+    var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  }
+    if (typeof suspenseCallback === "function") {
+      var wakeables = finishedWork.updateQueue;
 
-  if (current !== null && !didReceiveUpdate) {
-    bailoutHooks(current, workInProgress, renderLanes);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      if (wakeables !== null) {
+        suspenseCallback(new Set(wakeables));
+      }
+    } else {
+      if (suspenseCallback !== undefined) {
+        error("Unexpected type for suspenseCallback.");
+      }
+    }
   }
-
-  if (getIsHydrating() && hasId) {
-    pushMaterializedTreeId(workInProgress);
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
 }
 
-function updateClassComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  {
-    // This is used by DevTools to force a boundary to error.
-    switch (shouldError(workInProgress)) {
-      case false: {
-        var _instance = workInProgress.stateNode;
-        var ctor = workInProgress.type; // TODO This way of resetting the error boundary state is a hack.
-        // Is there a better way to do this?
-
-        var tempInstance = new ctor(
-          workInProgress.memoizedProps,
-          _instance.context
-        );
-        var state = tempInstance.state;
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+  var newState = finishedWork.memoizedState;
 
-        _instance.updater.enqueueSetState(_instance, state, null);
+  if (newState === null) {
+    var current = finishedWork.alternate;
 
-        break;
-      }
+    if (current !== null) {
+      var prevState = current.memoizedState;
 
-      case true: {
-        workInProgress.flags |= DidCapture;
-        workInProgress.flags |= ShouldCapture; // eslint-disable-next-line react-internal/prod-error-codes
+      if (prevState !== null) {
+        var suspenseInstance = prevState.dehydrated;
 
-        var error$1 = new Error("Simulated error coming from DevTools");
-        var lane = pickArbitraryLane(renderLanes);
-        workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state
+        if (suspenseInstance !== null) {
+          try {
+            commitHydratedSuspenseInstance(suspenseInstance);
 
-        var update = createClassErrorUpdate(
-          workInProgress,
-          createCapturedValueAtFiber(error$1, workInProgress),
-          lane
-        );
-        enqueueCapturedUpdate(workInProgress, update);
-        break;
-      }
-    }
+            if (enableSuspenseCallback) {
+              var hydrationCallbacks = finishedRoot.hydrationCallbacks;
 
-    if (workInProgress.type !== workInProgress.elementType) {
-      // Lazy component props can't be validated in createElement
-      // because they're only guaranteed to be resolved here.
-      var innerPropTypes = Component.propTypes;
+              if (hydrationCallbacks !== null) {
+                var onHydrated = hydrationCallbacks.onHydrated;
 
-      if (innerPropTypes) {
-        checkPropTypes(
-          innerPropTypes,
-          nextProps, // Resolved props
-          "prop",
-          getComponentNameFromType(Component)
-        );
+                if (onHydrated) {
+                  onHydrated(suspenseInstance);
+                }
+              }
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
       }
     }
-  } // 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;
-
-  if (isContextProvider()) {
-    hasContext = true;
-  } else {
-    hasContext = false;
-  }
-
-  prepareToReadContext(workInProgress, renderLanes);
-  var instance = workInProgress.stateNode;
-  var shouldUpdate;
-
-  if (instance === null) {
-    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.
-
-    constructClassInstance(workInProgress, Component, nextProps);
-    mountClassInstance(workInProgress, Component, nextProps, renderLanes);
-    shouldUpdate = true;
-  } else if (current === null) {
-    // In a resume, we'll already have an instance we can reuse.
-    shouldUpdate = resumeMountClassInstance(
-      workInProgress,
-      Component,
-      nextProps,
-      renderLanes
-    );
-  } else {
-    shouldUpdate = updateClassInstance(
-      current,
-      workInProgress,
-      Component,
-      nextProps,
-      renderLanes
-    );
   }
+}
 
-  var nextUnitOfWork = finishClassComponent(
-    current,
-    workInProgress,
-    Component,
-    shouldUpdate,
-    hasContext,
-    renderLanes
-  );
+function getRetryCache(finishedWork) {
+  // TODO: Unify the interface for the retry cache so we don't have to switch
+  // on the tag like this.
+  switch (finishedWork.tag) {
+    case SuspenseComponent:
+    case SuspenseListComponent: {
+      var retryCache = finishedWork.stateNode;
 
-  {
-    var inst = workInProgress.stateNode;
+      if (retryCache === null) {
+        retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+      }
 
-    if (shouldUpdate && inst.props !== nextProps) {
-      if (!didWarnAboutReassigningProps) {
-        error(
-          "It looks like %s is reassigning its own `this.props` while rendering. " +
-            "This is not supported and can lead to confusing bugs.",
-          getComponentNameFromFiber(workInProgress) || "a component"
-        );
+      return retryCache;
+    }
+
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
+      var _retryCache = instance._retryCache;
+
+      if (_retryCache === null) {
+        _retryCache = instance._retryCache = new PossiblyWeakSet();
       }
 
-      didWarnAboutReassigningProps = true;
+      return _retryCache;
     }
-  }
 
-  return nextUnitOfWork;
+    default: {
+      throw new Error(
+        "Unexpected Suspense handler tag (" +
+          finishedWork.tag +
+          "). This is a " +
+          "bug in React."
+      );
+    }
+  }
 }
 
-function finishClassComponent(
-  current,
-  workInProgress,
-  Component,
-  shouldUpdate,
-  hasContext,
-  renderLanes
-) {
-  // Refs should update even if shouldComponentUpdate returns false
-  markRef$1(current, workInProgress);
-  var didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags$1;
+function detachOffscreenInstance(instance) {
+  var fiber = instance._current;
 
-  if (!shouldUpdate && !didCaptureError) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  if (fiber === null) {
+    throw new Error(
+      "Calling Offscreen.detach before instance handle has been set."
+    );
   }
 
-  var instance = workInProgress.stateNode; // Rerender
+  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
+    // The instance is already detached, this is a noop.
+    return;
+  } // TODO: There is an opportunity to optimise this by not entering commit phase
+  // and unmounting effects directly.
 
-  ReactCurrentOwner$1.current = workInProgress;
-  var nextChildren;
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-  if (
-    didCaptureError &&
-    typeof Component.getDerivedStateFromError !== "function"
-  ) {
-    // If we captured an error, but getDerivedStateFromError is not defined,
-    // unmount all the children. componentDidCatch will schedule an update to
-    // re-render a fallback. This is temporary until we migrate everyone to
-    // the new API.
-    // TODO: Warn in a future release.
-    nextChildren = null;
+  if (root !== null) {
+    instance._pendingVisibility |= OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
+}
+function attachOffscreenInstance(instance) {
+  var fiber = instance._current;
 
-    {
-      stopProfilerTimerIfRunning();
-    }
-  } else {
-    if (enableSchedulingProfiler) {
-      markComponentRenderStarted(workInProgress);
-    }
+  if (fiber === null) {
+    throw new Error(
+      "Calling Offscreen.detach before instance handle has been set."
+    );
+  }
 
-    {
-      setIsRendering(true);
-      nextChildren = instance.render();
+  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
+    // The instance is already attached, this is a noop.
+    return;
+  }
 
-      if (workInProgress.mode & StrictLegacyMode) {
-        setIsStrictModeForDevtools(true);
+  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-        try {
-          instance.render();
-        } finally {
-          setIsStrictModeForDevtools(false);
+  if (root !== null) {
+    instance._pendingVisibility &= ~OffscreenDetached;
+    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+  }
+}
+
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  // If this boundary just timed out, then it will have a set of wakeables.
+  // For each wakeable, attach a listener so that when it resolves, React
+  // attempts to re-render the boundary in the primary (pre-timeout) state.
+  var retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(function (wakeable) {
+    // Memoize using the boundary fiber to prevent redundant listeners.
+    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+
+    if (!retryCache.has(wakeable)) {
+      retryCache.add(wakeable);
+
+      {
+        if (isDevToolsPresent) {
+          if (inProgressLanes !== null && inProgressRoot !== null) {
+            // If we have pending work still, associate the original updaters with it.
+            restorePendingUpdaters(inProgressRoot, inProgressLanes);
+          } else {
+            throw Error(
+              "Expected finished root and lanes to be set. This is a bug in React."
+            );
+          }
         }
       }
 
-      setIsRendering(false);
-    }
-
-    if (enableSchedulingProfiler) {
-      markComponentRenderStopped();
+      wakeable.then(retry, retry);
     }
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
+  });
+} // This function detects when a Suspense boundary goes from visible to hidden.
+// It returns false if the boundary is already hidden.
+// TODO: Use an effect tag.
 
-  if (current !== null && didCaptureError) {
-    // If we're recovering from an error, reconcile without reusing any of
-    // the existing children. Conceptually, the normal children and the children
-    // that are shown on error are two different sets, so we shouldn't reuse
-    // normal children even if their identities match.
-    forceUnmountCurrentAndReconcile(
-      current,
-      workInProgress,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  } // Memoize state using the values we just used to render.
-  // TODO: Restructure so we never read values from the instance.
+function isSuspenseBoundaryBeingHidden(current, finishedWork) {
+  if (current !== null) {
+    var oldState = current.memoizedState;
 
-  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.
+    if (oldState === null || oldState.dehydrated !== null) {
+      var newState = finishedWork.memoizedState;
+      return newState !== null && newState.dehydrated === null;
+    }
+  }
 
-  return workInProgress.child;
+  return false;
 }
-
-function pushHostRootContext(workInProgress) {
-  var root = workInProgress.stateNode;
-
-  pushHostContainer(workInProgress, root.containerInfo);
+function commitMutationEffects(root, finishedWork, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  setCurrentFiber(finishedWork);
+  commitMutationEffectsOnFiber(finishedWork, root);
+  setCurrentFiber(finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
 }
 
-function updateHostRoot(current, workInProgress, renderLanes) {
-  pushHostRootContext(workInProgress);
-
-  if (current === null) {
-    throw new Error("Should have a current fiber. This is a bug in React.");
-  }
+function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects hae fired.
+  var deletions = parentFiber.deletions;
 
-  var nextProps = workInProgress.pendingProps;
-  var prevState = workInProgress.memoizedState;
-  var prevChildren = prevState.element;
-  cloneUpdateQueue(current, workInProgress);
-  processUpdateQueue(workInProgress, nextProps, null, renderLanes);
-  var nextState = workInProgress.memoizedState;
-  var root = workInProgress.stateNode;
-  pushRootTransition(workInProgress);
+  if (deletions !== null) {
+    for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i];
 
-  if (enableTransitionTracing) {
-    pushRootMarkerInstance(workInProgress);
+      try {
+        commitDeletionEffects(root, parentFiber, childToDelete);
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
+    }
   }
 
-  {
-    var nextCache = nextState.cache;
-    pushCacheProvider(workInProgress, nextCache);
+  var prevDebugFiber = getCurrentFiber();
 
-    if (nextCache !== prevState.cache) {
-      // The root cache refreshed.
-      propagateContextChange(workInProgress, CacheContext, renderLanes);
+  if (parentFiber.subtreeFlags & MutationMask) {
+    var child = parentFiber.child;
+
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitMutationEffectsOnFiber(child, root);
+      child = child.sibling;
     }
-  } // Caution: React DevTools currently depends on this property
-  // being called "element".
+  }
 
-  var nextChildren = nextState.element;
+  setCurrentFiber(prevDebugFiber);
+}
 
-  if (prevState.isDehydrated) {
-    // This is a hydration root whose shell has not yet hydrated. We should
-    // attempt to hydrate.
-    // Flip isDehydrated to false to indicate that when this render
-    // finishes, the root will no longer be dehydrated.
-    var overrideState = {
-      element: nextChildren,
-      isDehydrated: false,
-      cache: nextState.cache
-    };
-    var updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't
-    // have reducer functions so it doesn't need rebasing.
+var currentHoistableRoot = null;
 
-    updateQueue.baseState = overrideState;
-    workInProgress.memoizedState = overrideState;
+function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
+  var current = finishedWork.alternate;
+  var flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
+  // because the fiber tag is more specific. An exception is any flag related
+  // to reconciliation, because those can be set on all fiber types.
 
-    if (workInProgress.flags & ForceClientRender) {
-      // Something errored during a previous attempt to hydrate the shell, so we
-      // forced a client render.
-      var recoverableError = createCapturedValueAtFiber(
-        new Error(
-          "There was an error while hydrating. Because the error happened outside " +
-            "of a Suspense boundary, the entire root will switch to " +
-            "client rendering."
-        ),
-        workInProgress
-      );
-      return mountHostRootWithoutHydrating(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes,
-        recoverableError
-      );
-    } else if (nextChildren !== prevChildren) {
-      var _recoverableError = createCapturedValueAtFiber(
-        new Error(
-          "This root received an early update, before anything was able " +
-            "hydrate. Switched the entire root to client rendering."
-        ),
-        workInProgress
-      );
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-      return mountHostRootWithoutHydrating(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes,
-        _recoverableError
-      );
-    } else {
-      // The outermost shell has not hydrated yet. Start hydrating.
-      enterHydrationState(workInProgress);
+      if (flags & Update) {
+        try {
+          commitHookEffectListUnmount(
+            Insertion | HasEffect,
+            finishedWork,
+            finishedWork.return
+          );
+          commitHookEffectListMount(Insertion | HasEffect, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        } // Layout effects are destroyed during the mutation phase so that all
+        // destroy functions for all fibers are called before any create functions.
+        // This prevents sibling component effects from interfering with each other,
+        // e.g. a destroy function in one component should never override a ref set
+        // by a create function in another component during the same commit.
 
-      {
-        var mutableSourceEagerHydrationData =
-          root.mutableSourceEagerHydrationData;
+        if (shouldProfile(finishedWork)) {
+          try {
+            startLayoutEffectTimer();
+            commitHookEffectListUnmount(
+              Layout | HasEffect,
+              finishedWork,
+              finishedWork.return
+            );
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
 
-        if (mutableSourceEagerHydrationData != null) {
-          for (var i = 0; i < mutableSourceEagerHydrationData.length; i += 2) {
-            var mutableSource = mutableSourceEagerHydrationData[i];
-            var version = mutableSourceEagerHydrationData[i + 1];
-            setWorkInProgressVersion(mutableSource, version);
+          recordLayoutEffectDuration(finishedWork);
+        } else {
+          try {
+            commitHookEffectListUnmount(
+              Layout | HasEffect,
+              finishedWork,
+              finishedWork.return
+            );
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
           }
         }
       }
 
-      var child = mountChildFibers(
-        workInProgress,
-        null,
-        nextChildren,
-        renderLanes
-      );
-      workInProgress.child = child;
-      var node = child;
-
-      while (node) {
-        // Mark each child as hydrating. This is a fast path to know whether this
-        // tree is part of a hydrating tree. This is used to determine if a child
-        // node has fully mounted yet, and for scheduling event replaying.
-        // Conceptually this is similar to Placement in that a new subtree is
-        // inserted into the React tree here. It just happens to not need DOM
-        // mutations because it already exists.
-        node.flags = (node.flags & ~Placement) | Hydrating;
-        node = node.sibling;
-      }
+      return;
     }
-  } else {
-    // Root is not dehydrated. Either this is a client-only root, or it
-    // already hydrated.
-    resetHydrationState();
 
-    if (nextChildren === prevChildren) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-    }
+    case ClassComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  }
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
+      }
 
-  return workInProgress.child;
-}
+      if (flags & Callback && offscreenSubtreeIsHidden) {
+        var updateQueue = finishedWork.updateQueue;
 
-function mountHostRootWithoutHydrating(
-  current,
-  workInProgress,
-  nextChildren,
-  renderLanes,
-  recoverableError
-) {
-  // Revert to client rendering.
-  resetHydrationState();
-  queueHydrationError(recoverableError);
-  workInProgress.flags |= ForceClientRender;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+        if (updateQueue !== null) {
+          deferHiddenCallbacks(updateQueue);
+        }
+      }
 
-function updateHostComponent$1(current, workInProgress, renderLanes) {
-  pushHostContext(workInProgress);
+      return;
+    }
 
-  if (current === null) {
-    tryToClaimNextHydratableInstance(workInProgress);
-  }
+    case HostHoistable: {
+      {
+        // We cast because we always set the root at the React root and so it cannot be
+        // null while we are processing mutation effects
+        var hoistableRoot = currentHoistableRoot;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
 
-  var type = workInProgress.type;
-  var nextProps = workInProgress.pendingProps;
-  var prevProps = current !== null ? current.memoizedProps : null;
-  var nextChildren = nextProps.children;
-  var isDirectTextChild = shouldSetTextContent(type, nextProps);
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(current, current.return);
+          }
+        }
 
-  if (isDirectTextChild) {
-    // We special case a direct text child of a host node. This is a common
-    // case. We won't handle it as a reified child. We will instead handle
-    // this in the host environment that also has access to this prop. That
-    // avoids allocating another HostText fiber and traversing it.
-    nextChildren = null;
-  } 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.flags |= ContentReset;
-  }
+        if (flags & Update) {
+          var currentResource = current !== null ? current.memoizedState : null;
+          var newResource = finishedWork.memoizedState;
 
-  markRef$1(current, workInProgress);
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+          if (current === null) {
+            // We are mounting a new HostHoistable Fiber. We fork the mount
+            // behavior based on whether this instance is a Hoistable Instance
+            // or a Hoistable Resource
+            if (newResource === null) {
+              if (finishedWork.stateNode === null) {
+                finishedWork.stateNode = hydrateHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.memoizedProps,
+                  finishedWork
+                );
+              } else {
+                mountHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.stateNode
+                );
+              }
+            } else {
+              finishedWork.stateNode = acquireResource(
+                hoistableRoot,
+                newResource,
+                finishedWork.memoizedProps
+              );
+            }
+          } else if (currentResource !== newResource) {
+            // We are moving to or from Hoistable Resource, or between different Hoistable Resources
+            if (currentResource === null) {
+              if (current.stateNode !== null) {
+                unmountHoistable(current.stateNode);
+              }
+            } else {
+              releaseResource(currentResource);
+            }
 
-function updateHostHoistable(current, workInProgress, renderLanes) {
-  markRef$1(current, workInProgress);
-  var currentProps = current === null ? null : current.memoizedProps;
-  var resource = (workInProgress.memoizedState = getResource(
-    workInProgress.type,
-    currentProps,
-    workInProgress.pendingProps
-  ));
+            if (newResource === null) {
+              mountHoistable(
+                hoistableRoot,
+                finishedWork.type,
+                finishedWork.stateNode
+              );
+            } else {
+              acquireResource(
+                hoistableRoot,
+                newResource,
+                finishedWork.memoizedProps
+              );
+            }
+          } else if (newResource === null && finishedWork.stateNode !== null) {
+            // We may have an update on a Hoistable element
+            var updatePayload = finishedWork.updateQueue;
+            finishedWork.updateQueue = null;
 
-  if (current === null) {
-    if (!getIsHydrating() && resource === null) {
-      // This is not a Resource Hoistable and we aren't hydrating so we construct the instance.
-      workInProgress.stateNode = createHoistableInstance(
-        workInProgress.type,
-        workInProgress.pendingProps,
-        getRootHostContainer(),
-        workInProgress
-      );
+            if (updatePayload !== null) {
+              try {
+                commitUpdate(
+                  finishedWork.stateNode,
+                  updatePayload,
+                  finishedWork.type,
+                  current.memoizedProps,
+                  finishedWork.memoizedProps,
+                  finishedWork
+                );
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          }
+        }
+
+        return;
+      }
     }
-  } // Resources never have reconciler managed children. It is possible for
-  // the host implementation of getResource to consider children in the
-  // resource construction but they will otherwise be discarded. In practice
-  // this precludes all but the simplest children and Host specific warnings
-  // should be implemented to warn when children are passsed when otherwise not
-  // expected
+    // eslint-disable-next-line-no-fallthrough
 
-  return null;
-}
+    case HostSingleton: {
+      {
+        if (flags & Update) {
+          var previousWork = finishedWork.alternate;
 
-function updateHostSingleton(current, workInProgress, renderLanes) {
-  pushHostContext(workInProgress);
+          if (previousWork === null) {
+            var singleton = finishedWork.stateNode;
+            var props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
 
-  if (current === null) {
-    claimHydratableSingleton(workInProgress);
-  }
+            clearSingleton(singleton);
+            acquireSingletonInstance(
+              finishedWork.type,
+              props,
+              singleton,
+              finishedWork
+            );
+          }
+        }
+      }
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-  var nextChildren = workInProgress.pendingProps.children;
+    case HostComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-  if (current === null && !getIsHydrating()) {
-    // Similar to Portals we append Singleton children in the commit phase. So we
-    // Track insertions even on mount.
-    // TODO: Consider unifying this with how the root works.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  }
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
+      }
 
-  markRef$1(current, workInProgress);
-  return workInProgress.child;
-}
+      {
+        // TODO: ContentReset gets cleared by the children during the commit
+        // phase. This is a refactor hazard because it means we must read
+        // flags the flags after `commitReconciliationEffects` has already run;
+        // the order matters. We should refactor so that ContentReset does not
+        // rely on mutating the flag during commit. Like by setting a flag
+        // during the render phase instead.
+        if (finishedWork.flags & ContentReset) {
+          var instance = finishedWork.stateNode;
 
-function updateHostText$1(current, workInProgress) {
-  if (current === null) {
-    tryToClaimNextHydratableTextInstance(workInProgress);
-  } // Nothing to do here. This is terminal. We'll do the completion step
-  // immediately after.
+          try {
+            resetTextContent(instance);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
 
-  return null;
-}
+        if (flags & Update) {
+          var _instance2 = finishedWork.stateNode;
 
-function mountLazyComponent(
-  _current,
-  workInProgress,
-  elementType,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
-  var props = workInProgress.pendingProps;
-  var lazyComponent = elementType;
-  var payload = lazyComponent._payload;
-  var init = lazyComponent._init;
-  var Component = init(payload); // Store the unwrapped component in the type.
+          if (_instance2 != null) {
+            // Commit the work prepared earlier.
+            var newProps = finishedWork.memoizedProps; // 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.
 
-  workInProgress.type = Component;
-  var resolvedTag = (workInProgress.tag = resolveLazyComponentTag(Component));
-  var resolvedProps = resolveDefaultProps(Component, props);
-  var child;
+            var oldProps = current !== null ? current.memoizedProps : newProps;
+            var type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
 
-  switch (resolvedTag) {
-    case FunctionComponent: {
-      {
-        validateFunctionComponentInDev(workInProgress, Component);
-        workInProgress.type = Component =
-          resolveFunctionForHotReloading(Component);
+            var _updatePayload = finishedWork.updateQueue;
+            finishedWork.updateQueue = null;
+
+            if (_updatePayload !== null) {
+              try {
+                commitUpdate(
+                  _instance2,
+                  _updatePayload,
+                  type,
+                  oldProps,
+                  newProps,
+                  finishedWork
+                );
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          }
+        }
       }
 
-      child = updateFunctionComponent(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
+      return;
     }
 
-    case ClassComponent: {
-      {
-        workInProgress.type = Component =
-          resolveClassForHotReloading(Component);
-      }
+    case HostText: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-      child = updateClassComponent(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
-    }
+      if (flags & Update) {
+        {
+          if (finishedWork.stateNode === null) {
+            throw new Error(
+              "This should have a text node initialized. This error is likely " +
+                "caused by a bug in React. Please file an issue."
+            );
+          }
 
-    case ForwardRef: {
-      {
-        workInProgress.type = Component =
-          resolveForwardRefForHotReloading(Component);
+          var textInstance = finishedWork.stateNode;
+          var newText = finishedWork.memoizedProps; // 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;
+
+          try {
+            commitTextUpdate(textInstance, oldText, newText);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
       }
 
-      child = updateForwardRef(
-        null,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
-      return child;
+      return;
     }
 
-    case MemoComponent: {
+    case HostRoot: {
       {
-        if (workInProgress.type !== workInProgress.elementType) {
-          var outerPropTypes = Component.propTypes;
+        prepareToCommitHoistables();
+        var previousHoistableRoot = currentHoistableRoot;
+        currentHoistableRoot = getHoistableRoot(root.containerInfo);
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        currentHoistableRoot = previousHoistableRoot;
+        commitReconciliationEffects(finishedWork);
+      }
 
-          if (outerPropTypes) {
-            checkPropTypes(
-              outerPropTypes,
-              resolvedProps, // Resolved for outer only
-              "prop",
-              getComponentNameFromType(Component)
-            );
+      if (flags & Update) {
+        {
+          if (current !== null) {
+            var prevRootState = current.memoizedState;
+
+            if (prevRootState.isDehydrated) {
+              try {
+                commitHydratedContainer(root.containerInfo);
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
           }
         }
       }
 
-      child = updateMemoComponent(
-        null,
-        workInProgress,
-        Component,
-        resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too
-        renderLanes
-      );
-      return child;
+      return;
     }
-  }
 
-  var hint = "";
+    case HostPortal: {
+      {
+        var _previousHoistableRoot = currentHoistableRoot;
+        currentHoistableRoot = getHoistableRoot(
+          finishedWork.stateNode.containerInfo
+        );
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        currentHoistableRoot = _previousHoistableRoot;
+      }
 
-  {
-    if (
-      Component !== null &&
-      typeof Component === "object" &&
-      Component.$$typeof === REACT_LAZY_TYPE
-    ) {
-      hint = " Did you wrap a component in React.lazy() more than once?";
+      return;
     }
-  } // This message intentionally doesn't mention ForwardRef or MemoComponent
-  // because the fact that it's a separate type of work is an
-  // implementation detail.
-
-  throw new Error(
-    "Element type is invalid. Received a promise that resolves to: " +
-      Component +
-      ". " +
-      ("Lazy element type must resolve to a class or function." + hint)
-  );
-}
-
-function mountIncompleteClassComponent(
-  _current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.
-
-  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`
-  // 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;
-
-  if (isContextProvider()) {
-    hasContext = true;
-  } else {
-    hasContext = false;
-  }
 
-  prepareToReadContext(workInProgress, renderLanes);
-  constructClassInstance(workInProgress, Component, nextProps);
-  mountClassInstance(workInProgress, Component, nextProps, renderLanes);
-  return finishClassComponent(
-    null,
-    workInProgress,
-    Component,
-    true,
-    hasContext,
-    renderLanes
-  );
-}
+    case SuspenseComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      var offscreenFiber = finishedWork.child;
 
-function mountIndeterminateComponent(
-  _current,
-  workInProgress,
-  Component,
-  renderLanes
-) {
-  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);
-  var props = workInProgress.pendingProps;
-  var context;
+      if (offscreenFiber.flags & Visibility) {
+        var newState = offscreenFiber.memoizedState;
+        var isHidden = newState !== null;
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var value;
-  var hasId;
+        if (isHidden) {
+          var wasHidden =
+            offscreenFiber.alternate !== null &&
+            offscreenFiber.alternate.memoizedState !== null;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+          if (!wasHidden) {
+            // TODO: Move to passive phase
+            markCommitTimeOfFallback();
+          }
+        }
+      }
 
-  {
-    if (
-      Component.prototype &&
-      typeof Component.prototype.render === "function"
-    ) {
-      var componentName = getComponentNameFromType(Component) || "Unknown";
+      if (flags & Update) {
+        try {
+          commitSuspenseCallback(finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
 
-      if (!didWarnAboutBadClass[componentName]) {
-        error(
-          "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
-            "This is likely to cause errors. Change %s to extend React.Component instead.",
-          componentName,
-          componentName
-        );
+        var wakeables = finishedWork.updateQueue;
 
-        didWarnAboutBadClass[componentName] = true;
+        if (wakeables !== null) {
+          finishedWork.updateQueue = null;
+          attachSuspenseRetryListeners(finishedWork, wakeables);
+        }
       }
-    }
 
-    if (workInProgress.mode & StrictLegacyMode) {
-      ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+      return;
     }
 
-    setIsRendering(true);
-    ReactCurrentOwner$1.current = workInProgress;
-    value = renderWithHooks(
-      null,
-      workInProgress,
-      Component,
-      props,
-      context,
-      renderLanes
-    );
-    hasId = checkDidRenderIdHook();
-    setIsRendering(false);
-  }
-
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  } // React DevTools reads this flag.
-
-  workInProgress.flags |= PerformedWork;
-
-  {
-    // Support for module components is deprecated and is removed behind a flag.
-    // Whether or not it would crash later, we want to show a good message in DEV first.
-    if (
-      typeof value === "object" &&
-      value !== null &&
-      typeof value.render === "function" &&
-      value.$$typeof === undefined
-    ) {
-      var _componentName = getComponentNameFromType(Component) || "Unknown";
+    case OffscreenComponent: {
+      if (flags & Ref) {
+        if (current !== null) {
+          safelyDetachRef(current, current.return);
+        }
+      }
 
-      if (!didWarnAboutModulePatternComponent[_componentName]) {
-        error(
-          "The <%s /> component appears to be a function component that returns a class instance. " +
-            "Change %s to a class that extends React.Component instead. " +
-            "If you can't use a class try assigning the prototype on the function as a workaround. " +
-            "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " +
-            "cannot be called with `new` by React.",
-          _componentName,
-          _componentName,
-          _componentName
-        );
+      var _newState = finishedWork.memoizedState;
 
-        didWarnAboutModulePatternComponent[_componentName] = true;
-      }
-    }
-  }
+      var _isHidden = _newState !== null;
 
-  {
-    // Proceed under the assumption that this is a function component
-    workInProgress.tag = FunctionComponent;
+      var _wasHidden = current !== null && current.memoizedState !== null;
 
-    {
-      if (Component.contextTypes) {
-        error(
-          "%s uses the legacy contextTypes API which is no longer supported. " +
-            "Use React.createContext() with React.useContext() instead.",
-          getComponentNameFromType(Component) || "Unknown"
-        );
+      if (finishedWork.mode & ConcurrentMode) {
+        // Before committing the children, track on the stack whether this
+        // offscreen subtree was already hidden, so that we don't unmount the
+        // effects again.
+        var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || _isHidden;
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || _wasHidden;
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+      } else {
+        recursivelyTraverseMutationEffects(root, finishedWork);
       }
-    }
-
-    if (getIsHydrating() && hasId) {
-      pushMaterializedTreeId(workInProgress);
-    }
 
-    reconcileChildren(null, workInProgress, value, renderLanes);
+      commitReconciliationEffects(finishedWork);
+      var offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
 
-    {
-      validateFunctionComponentInDev(workInProgress, Component);
-    }
+      offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
+      // to support batching of `attach` and `detach` calls.
 
-    return workInProgress.child;
-  }
-}
+      offscreenInstance._visibility &= ~OffscreenDetached;
+      offscreenInstance._visibility |=
+        offscreenInstance._pendingVisibility & OffscreenDetached;
 
-function validateFunctionComponentInDev(workInProgress, Component) {
-  {
-    if (Component) {
-      if (Component.childContextTypes) {
-        error(
-          "%s(...): childContextTypes cannot be defined on a function component.",
-          Component.displayName || Component.name || "Component"
-        );
-      }
-    }
+      if (flags & Visibility) {
+        // Track the current state on the Offscreen instance so we can
+        // read it during an event
+        if (_isHidden) {
+          offscreenInstance._visibility &= ~OffscreenVisible;
+        } else {
+          offscreenInstance._visibility |= OffscreenVisible;
+        }
 
-    if (workInProgress.ref !== null) {
-      var info = "";
-      var ownerName = getCurrentFiberOwnerNameInDevOrNull();
+        if (_isHidden) {
+          var isUpdate = current !== null;
+          var wasHiddenByAncestorOffscreen =
+            offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
+          //   - This is an update, not first mount.
+          //   - This Offscreen was not hidden before.
+          //   - Ancestor Offscreen was not hidden in previous commit.
 
-      if (ownerName) {
-        info += "\n\nCheck the render method of `" + ownerName + "`.";
-      }
+          if (isUpdate && !_wasHidden && !wasHiddenByAncestorOffscreen) {
+            if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
+              // Disappear the layout effects of all the children
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+            }
+          }
+        } // Offscreen with manual mode manages visibility manually.
 
-      var warningKey = ownerName || "";
-      var debugSource = workInProgress._debugSource;
+        if (!isOffscreenManual(finishedWork)) {
+          // TODO: This needs to run whenever there's an insertion or update
+          // inside a hidden Offscreen tree.
+          hideOrUnhideAllChildren(finishedWork, _isHidden);
+        }
+      } // TODO: Move to passive phase
 
-      if (debugSource) {
-        warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
-      }
+      if (flags & Update) {
+        var offscreenQueue = finishedWork.updateQueue;
 
-      if (!didWarnAboutFunctionRefs[warningKey]) {
-        didWarnAboutFunctionRefs[warningKey] = true;
+        if (offscreenQueue !== null) {
+          var _wakeables = offscreenQueue.wakeables;
 
-        error(
-          "Function components cannot be given refs. " +
-            "Attempts to access this ref will fail. " +
-            "Did you mean to use React.forwardRef()?%s",
-          info
-        );
+          if (_wakeables !== null) {
+            offscreenQueue.wakeables = null;
+            attachSuspenseRetryListeners(finishedWork, _wakeables);
+          }
+        }
       }
+
+      return;
     }
 
-    if (Component.defaultProps !== undefined) {
-      var componentName = getComponentNameFromType(Component) || "Unknown";
+    case SuspenseListComponent: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
 
-      if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
-        error(
-          "%s: Support for defaultProps will be removed from function components " +
-            "in a future major release. Use JavaScript default parameters instead.",
-          componentName
-        );
+      if (flags & Update) {
+        var _wakeables2 = finishedWork.updateQueue;
 
-        didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
+        if (_wakeables2 !== null) {
+          finishedWork.updateQueue = null;
+          attachSuspenseRetryListeners(finishedWork, _wakeables2);
+        }
       }
+
+      return;
     }
 
-    if (typeof Component.getDerivedStateFromProps === "function") {
-      var _componentName3 = getComponentNameFromType(Component) || "Unknown";
+    case ScopeComponent: {
+      {
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork); // TODO: This is a temporary solution that allowed us to transition away
+        // from React Flare on www.
 
-      if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3]) {
-        error(
-          "%s: Function components do not support getDerivedStateFromProps.",
-          _componentName3
-        );
+        if (flags & Ref) {
+          if (current !== null) {
+            safelyDetachRef(finishedWork, finishedWork.return);
+          }
 
-        didWarnAboutGetDerivedStateOnFunctionComponent[_componentName3] = true;
-      }
-    }
+          safelyAttachRef(finishedWork, finishedWork.return);
+        }
 
-    if (
-      typeof Component.contextType === "object" &&
-      Component.contextType !== null
-    ) {
-      var _componentName4 = getComponentNameFromType(Component) || "Unknown";
+        if (flags & Update) {
+          var scopeInstance = finishedWork.stateNode;
+          prepareScopeUpdate(scopeInstance, finishedWork);
+        }
+      }
 
-      if (!didWarnAboutContextTypeOnFunctionComponent[_componentName4]) {
-        error(
-          "%s: Function components do not support contextType.",
-          _componentName4
-        );
+      return;
+    }
 
-        didWarnAboutContextTypeOnFunctionComponent[_componentName4] = true;
-      }
+    default: {
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      return;
     }
   }
 }
 
-var SUSPENDED_MARKER = {
-  dehydrated: null,
-  treeContext: null,
-  retryLane: NoLane
-};
+function commitReconciliationEffects(finishedWork) {
+  // Placement effects (insertions, reorders) can be scheduled on any fiber
+  // type. They needs to happen after the children effects have fired, but
+  // before the effects on this fiber have fired.
+  var flags = finishedWork.flags;
 
-function mountSuspenseOffscreenState(renderLanes) {
-  return {
-    baseLanes: renderLanes,
-    cachePool: getSuspendedCache()
-  };
+  if (flags & Placement) {
+    try {
+      commitPlacement(finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    } // Clear the "placement" from effect tag so that we know that this is
+    // inserted, before any life-cycles like componentDidMount gets called.
+    // TODO: findDOMNode doesn't rely on this any more but isMounted does
+    // and isMounted is deprecated anyway so we should be able to kill this.
+
+    finishedWork.flags &= ~Placement;
+  }
+
+  if (flags & Hydrating) {
+    finishedWork.flags &= ~Hydrating;
+  }
 }
 
-function updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {
-  var cachePool = null;
+function commitLayoutEffects(finishedWork, root, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
+  var current = finishedWork.alternate;
+  commitLayoutEffectOnFiber(root, current, finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
+}
 
-  {
-    var prevCachePool = prevOffscreenState.cachePool;
+function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
+  var prevDebugFiber = getCurrentFiber();
 
-    if (prevCachePool !== null) {
-      var parentCache = CacheContext._currentValue;
+  if (parentFiber.subtreeFlags & LayoutMask) {
+    var child = parentFiber.child;
 
-      if (prevCachePool.parent !== parentCache) {
-        // Detected a refresh in the parent. This overrides any previously
-        // suspended cache.
-        cachePool = {
-          parent: parentCache,
-          pool: parentCache
-        };
-      } else {
-        // We can reuse the cache from last time. The only thing that would have
-        // overridden it is a parent refresh, which we checked for above.
-        cachePool = prevCachePool;
-      }
-    } else {
-      // If there's no previous cache pool, grab the current one.
-      cachePool = getSuspendedCache();
+    while (child !== null) {
+      setCurrentFiber(child);
+      var current = child.alternate;
+      commitLayoutEffectOnFiber(root, current, child);
+      child = child.sibling;
     }
   }
 
-  return {
-    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),
-    cachePool: cachePool
-  };
-} // TODO: Probably should inline this back
+  setCurrentFiber(prevDebugFiber);
+}
 
-function shouldRemainOnFallback(current, workInProgress, renderLanes) {
-  // If we're already showing a fallback, there are cases where we need to
-  // remain on that fallback regardless of whether the content has resolved.
-  // For example, SuspenseList coordinates when nested content appears.
-  if (current !== null) {
-    var suspenseState = current.memoizedState;
+function disappearLayoutEffects(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case MemoComponent:
+    case SimpleMemoComponent: {
+      // TODO (Offscreen) Check: flags & LayoutStatic
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          commitHookEffectListUnmount(
+            Layout,
+            finishedWork,
+            finishedWork.return
+          );
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
+        commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
+      }
 
-    if (suspenseState === null) {
-      // Currently showing content. Don't hide it, even if ForceSuspenseFallback
-      // is true. More precise name might be "ForceRemainSuspenseFallback".
-      // Note: This is a factoring smell. Can't remain on a fallback if there's
-      // no fallback to remain on.
-      return false;
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
     }
-  } // Not currently showing content. Consult the Suspense context.
-
-  var suspenseContext = suspenseStackCursor.current;
-  return hasSuspenseListContext(suspenseContext, ForceSuspenseFallback);
-}
 
-function getRemainingWorkInPrimaryTree(current, renderLanes) {
-  // TODO: Should not remove render lanes that were pinged during this render
-  return removeLanes(current.childLanes, renderLanes);
-}
+    case ClassComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      var instance = finishedWork.stateNode;
 
-function updateSuspenseComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.
+      if (typeof instance.componentWillUnmount === "function") {
+        safelyCallComponentWillUnmount(
+          finishedWork,
+          finishedWork.return,
+          instance
+        );
+      }
 
-  {
-    if (shouldSuspend(workInProgress)) {
-      workInProgress.flags |= DidCapture;
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
     }
-  }
 
-  var showFallback = false;
-  var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
 
-  if (didSuspend || shouldRemainOnFallback(current)) {
-    // Something in this boundary's subtree already suspended. Switch to
-    // rendering the fallback children.
-    showFallback = true;
-    workInProgress.flags &= ~DidCapture;
-  } // OK, the next part is confusing. We're about to reconcile the Suspense
-  // boundary's children. This involves some custom reconciliation logic. Two
-  // main reasons this is so complicated.
-  //
-  // First, Legacy Mode has different semantics for backwards compatibility. The
-  // primary tree will commit in an inconsistent state, so when we do the
-  // second pass to render the fallback, we do some exceedingly, uh, clever
-  // hacks to make that not totally break. Like transferring effects and
-  // deletions from hidden tree. In Concurrent Mode, it's much simpler,
-  // because we bailout on the primary tree completely and leave it in its old
-  // state, no effects. Same as what we do for Offscreen (except that
-  // Offscreen doesn't have the first render pass).
-  //
-  // Second is hydration. During hydration, the Suspense fiber has a slightly
-  // different layout, where the child points to a dehydrated fragment, which
-  // contains the DOM rendered by the server.
-  //
-  // Third, even if you set all that aside, Suspense is like error boundaries in
-  // that we first we try to render one tree, and if that fails, we render again
-  // and switch to a different tree. Like a try/catch block. So we have to track
-  // which branch we're currently rendering. Ideally we would model this using
-  // a stack.
+    case OffscreenComponent: {
+      // TODO (Offscreen) Check: flags & RefStatic
+      safelyDetachRef(finishedWork, finishedWork.return);
+      var isHidden = finishedWork.memoizedState !== null;
 
-  if (current === null) {
-    // Initial mount
-    // Special path for hydration
-    // If we're currently hydrating, try to hydrate this boundary.
-    if (getIsHydrating()) {
-      // We must push the suspense handler context *before* attempting to
-      // hydrate, to avoid a mismatch in case it errors.
-      if (showFallback) {
-        pushPrimaryTreeSuspenseHandler(workInProgress);
-      } else {
-        pushFallbackTreeSuspenseHandler(workInProgress);
+      if (isHidden);
+      else {
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
       }
 
-      tryToClaimNextHydratableSuspenseInstance(workInProgress); // This could've been a dehydrated suspense component.
+      break;
+    }
 
-      var suspenseState = workInProgress.memoizedState;
+    default: {
+      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      break;
+    }
+  }
+}
 
-      if (suspenseState !== null) {
-        var dehydrated = suspenseState.dehydrated;
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+  var child = parentFiber.child;
 
-        if (dehydrated !== null) {
-          return mountDehydratedSuspenseComponent(workInProgress, dehydrated);
-        }
-      } // If hydration didn't succeed, fall through to the normal Suspense path.
-      // To avoid a stack mismatch we need to pop the Suspense handler that we
-      // pushed above. This will become less awkward when move the hydration
-      // logic to its own fiber.
+  while (child !== null) {
+    disappearLayoutEffects(child);
+    child = child.sibling;
+  }
+}
 
-      popSuspenseHandler(workInProgress);
-    }
+function reappearLayoutEffects(
+  finishedRoot,
+  current,
+  finishedWork, // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  includeWorkInProgressEffects
+) {
+  // Turn on layout effects in a tree that previously disappeared.
+  var flags = finishedWork.flags;
 
-    var nextPrimaryChildren = nextProps.children;
-    var nextFallbackChildren = nextProps.fallback;
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Check flags & LayoutStatic
 
-    if (showFallback) {
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var fallbackFragment = mountSuspenseFallbackChildren(
-        workInProgress,
-        nextPrimaryChildren,
-        nextFallbackChildren,
-        renderLanes
-      );
-      var primaryChildFragment = workInProgress.child;
-      primaryChildFragment.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER;
+      commitHookLayoutEffects(finishedWork, Layout);
+      break;
+    }
 
-      if (enableTransitionTracing) {
-        var currentTransitions = getPendingTransitions();
+    case ClassComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Check for LayoutStatic flag
 
-        if (currentTransitions !== null) {
-          var parentMarkerInstances = getMarkerInstances();
-          var offscreenQueue = primaryChildFragment.updateQueue;
+      var instance = finishedWork.stateNode;
 
-          if (offscreenQueue === null) {
-            var newOffscreenQueue = {
-              transitions: currentTransitions,
-              markerInstances: parentMarkerInstances,
-              wakeables: null
-            };
-            primaryChildFragment.updateQueue = newOffscreenQueue;
-          } else {
-            offscreenQueue.transitions = currentTransitions;
-            offscreenQueue.markerInstances = parentMarkerInstances;
-          }
+      if (typeof instance.componentDidMount === "function") {
+        try {
+          instance.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
         }
-      }
-
-      return fallbackFragment;
-    } else if (typeof nextProps.unstable_expectedLoadTime === "number") {
-      // This is a CPU-bound tree. Skip this tree and show a placeholder to
-      // unblock the surrounding content. Then immediately retry after the
-      // initial commit.
-      pushFallbackTreeSuspenseHandler(workInProgress);
-
-      var _fallbackFragment = mountSuspenseFallbackChildren(
-        workInProgress,
-        nextPrimaryChildren,
-        nextFallbackChildren,
-        renderLanes
-      );
+      } // Commit any callbacks that would have fired while the component
+      // was hidden.
 
-      var _primaryChildFragment = workInProgress.child;
-      _primaryChildFragment.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER; // TODO: Transition Tracing is not yet implemented for CPU Suspense.
-      // Since nothing actually suspended, there will nothing to ping this to
-      // get it started back up to attempt the next item. While in terms of
-      // priority this work has the same priority as this current render, it's
-      // not part of the same transition once the transition has committed. If
-      // it's sync, we still want to yield so that it can be painted.
-      // Conceptually, this is really the same as pinging. We can use any
-      // RetryLane even if it's the one currently rendering since we're leaving
-      // it behind on this node.
+      var updateQueue = finishedWork.updateQueue;
 
-      workInProgress.lanes = SomeRetryLane;
-      return _fallbackFragment;
-    } else {
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
-    }
-  } else {
-    // This is an update.
-    // Special path for hydration
-    var prevState = current.memoizedState;
+      if (updateQueue !== null) {
+        commitHiddenCallbacks(updateQueue, instance);
+      } // If this is newly finished work, check for setState callbacks
 
-    if (prevState !== null) {
-      var _dehydrated = prevState.dehydrated;
+      if (includeWorkInProgressEffects && flags & Callback) {
+        commitClassCallbacks(finishedWork);
+      } // TODO: Check flags & RefStatic
 
-      if (_dehydrated !== null) {
-        return updateDehydratedSuspenseComponent(
-          current,
-          workInProgress,
-          didSuspend,
-          nextProps,
-          _dehydrated,
-          prevState,
-          renderLanes
-        );
-      }
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
     }
+    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
 
-    if (showFallback) {
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var _nextFallbackChildren = nextProps.fallback;
-      var _nextPrimaryChildren = nextProps.children;
-      var fallbackChildFragment = updateSuspenseFallbackChildren(
-        current,
-        workInProgress,
-        _nextPrimaryChildren,
-        _nextFallbackChildren,
-        renderLanes
-      );
-      var _primaryChildFragment2 = workInProgress.child;
-      var prevOffscreenState = current.child.memoizedState;
-      _primaryChildFragment2.memoizedState =
-        prevOffscreenState === null
-          ? mountSuspenseOffscreenState(renderLanes)
-          : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
-
-      if (enableTransitionTracing) {
-        var _currentTransitions = getPendingTransitions();
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // Renderers may schedule work to be done after host components are mounted
+      // (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 (_currentTransitions !== null) {
-          var _parentMarkerInstances = getMarkerInstances();
+      if (includeWorkInProgressEffects && current === null && flags & Update) {
+        commitHostComponentMount(finishedWork);
+      } // TODO: Check flags & Ref
 
-          var _offscreenQueue = _primaryChildFragment2.updateQueue;
-          var currentOffscreenQueue = current.updateQueue;
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    }
 
-          if (_offscreenQueue === null) {
-            var _newOffscreenQueue = {
-              transitions: _currentTransitions,
-              markerInstances: _parentMarkerInstances,
-              wakeables: null
-            };
-            _primaryChildFragment2.updateQueue = _newOffscreenQueue;
-          } else if (_offscreenQueue === currentOffscreenQueue) {
-            // If the work-in-progress queue is the same object as current, we
-            // can't modify it without cloning it first.
-            var _newOffscreenQueue2 = {
-              transitions: _currentTransitions,
-              markerInstances: _parentMarkerInstances,
-              wakeables:
-                currentOffscreenQueue !== null
-                  ? currentOffscreenQueue.wakeables
-                  : null
-            };
-            _primaryChildFragment2.updateQueue = _newOffscreenQueue2;
-          } else {
-            _offscreenQueue.transitions = _currentTransitions;
-            _offscreenQueue.markerInstances = _parentMarkerInstances;
-          }
-        }
+    case Profiler: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Figure out how Profiler updates should work with Offscreen
+
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
       }
 
-      _primaryChildFragment2.childLanes = getRemainingWorkInPrimaryTree(
-        current,
-        renderLanes
-      );
-      workInProgress.memoizedState = SUSPENDED_MARKER;
-      return fallbackChildFragment;
-    } else {
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      var _nextPrimaryChildren2 = nextProps.children;
+      break;
+    }
 
-      var _primaryChildFragment3 = updateSuspensePrimaryChildren(
-        current,
-        workInProgress,
-        _nextPrimaryChildren2,
-        renderLanes
-      );
+    case SuspenseComponent: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      ); // TODO: Figure out how Suspense hydration callbacks should work
+      // with Offscreen.
 
-      workInProgress.memoizedState = null;
-      return _primaryChildFragment3;
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+      }
+
+      break;
     }
-  }
-}
 
-function mountSuspensePrimaryChildren(
-  workInProgress,
-  primaryChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode;
-  var primaryChildProps = {
-    mode: "visible",
-    children: primaryChildren
-  };
-  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
-    primaryChildProps,
-    mode
-  );
-  primaryChildFragment.return = workInProgress;
-  workInProgress.child = primaryChildFragment;
-  return primaryChildFragment;
-}
+    case OffscreenComponent: {
+      var offscreenState = finishedWork.memoizedState;
+      var isHidden = offscreenState !== null;
 
-function mountSuspenseFallbackChildren(
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode;
-  var progressedPrimaryFragment = workInProgress.child;
-  var primaryChildProps = {
-    mode: "hidden",
-    children: primaryChildren
-  };
-  var primaryChildFragment;
-  var fallbackChildFragment;
+      if (isHidden);
+      else {
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+      } // TODO: Check flags & Ref
 
-  if (
-    (mode & ConcurrentMode) === NoMode &&
-    progressedPrimaryFragment !== null
-  ) {
-    // In legacy mode, we commit the primary tree as if it successfully
-    // completed, even though it's in an inconsistent state.
-    primaryChildFragment = progressedPrimaryFragment;
-    primaryChildFragment.childLanes = NoLanes;
-    primaryChildFragment.pendingProps = primaryChildProps;
+      safelyAttachRef(finishedWork, finishedWork.return);
+      break;
+    }
 
-    if (workInProgress.mode & ProfileMode) {
-      // Reset the durations from the first pass so they aren't included in the
-      // final amounts. This seems counterintuitive, since we're intentionally
-      // not measuring part of the render phase, but this makes it match what we
-      // do in Concurrent Mode.
-      primaryChildFragment.actualDuration = 0;
-      primaryChildFragment.actualStartTime = -1;
-      primaryChildFragment.selfBaseDuration = 0;
-      primaryChildFragment.treeBaseDuration = 0;
+    default: {
+      recursivelyTraverseReappearLayoutEffects(
+        finishedRoot,
+        finishedWork,
+        includeWorkInProgressEffects
+      );
+      break;
     }
+  }
+}
 
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    );
-  } else {
-    primaryChildFragment = mountWorkInProgressOffscreenFiber(
-      primaryChildProps,
-      mode
-    );
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
+function recursivelyTraverseReappearLayoutEffects(
+  finishedRoot,
+  parentFiber,
+  includeWorkInProgressEffects
+) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  var childShouldIncludeWorkInProgressEffects =
+    includeWorkInProgressEffects &&
+    (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+
+  var prevDebugFiber = getCurrentFiber();
+  var child = parentFiber.child;
+
+  while (child !== null) {
+    var current = child.alternate;
+    reappearLayoutEffects(
+      finishedRoot,
+      current,
+      child,
+      childShouldIncludeWorkInProgressEffects
     );
+    child = child.sibling;
   }
 
-  primaryChildFragment.return = workInProgress;
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
-  return fallbackChildFragment;
+  setCurrentFiber(prevDebugFiber);
 }
 
-function mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {
-  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use
-  // this wrapper function to constrain it.
-  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);
-}
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
 
-function updateWorkInProgressOffscreenFiber(current, offscreenProps) {
-  // The props argument to `createWorkInProgress` is `any` typed, so we use this
-  // wrapper function to constrain it.
-  return createWorkInProgress(current, offscreenProps);
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
 }
 
-function updateSuspensePrimaryChildren(
-  current,
-  workInProgress,
-  primaryChildren,
-  renderLanes
-) {
-  var currentPrimaryChildFragment = current.child;
-  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
-  var primaryChildFragment = updateWorkInProgressOffscreenFiber(
-    currentPrimaryChildFragment,
-    {
-      mode: "visible",
-      children: primaryChildren
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  {
+    var previousCache = null;
+
+    if (
+      current !== null &&
+      current.memoizedState !== null &&
+      current.memoizedState.cachePool !== null
+    ) {
+      previousCache = current.memoizedState.cachePool.pool;
     }
-  );
 
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    primaryChildFragment.lanes = renderLanes;
-  }
+    var nextCache = null;
 
-  primaryChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = null;
+    if (
+      finishedWork.memoizedState !== null &&
+      finishedWork.memoizedState.cachePool !== null
+    ) {
+      nextCache = finishedWork.memoizedState.cachePool.pool;
+    } // Retain/release the cache used for pending (suspended) nodes.
+    // Note that this is only reached in the non-suspended/visible case:
+    // when the content is suspended/hidden, the retain/release occurs
+    // via the parent Suspense component (see case above).
 
-  if (currentFallbackChildFragment !== null) {
-    // Delete the fallback child fragment
-    var deletions = workInProgress.deletions;
+    if (nextCache !== previousCache) {
+      if (nextCache != null) {
+        retainCache(nextCache);
+      }
 
-    if (deletions === null) {
-      workInProgress.deletions = [currentFallbackChildFragment];
-      workInProgress.flags |= ChildDeletion;
-    } else {
-      deletions.push(currentFallbackChildFragment);
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
     }
   }
 
-  workInProgress.child = primaryChildFragment;
-  return primaryChildFragment;
-}
+  if (enableTransitionTracing) {
+    // TODO: Pre-rendering should not be counted as part of a transition. We
+    // may add separate logs for pre-rendering, but it's not part of the
+    // primary metrics.
+    var offscreenState = finishedWork.memoizedState;
+    var queue = finishedWork.updateQueue;
+    var isHidden = offscreenState !== null;
 
-function updateSuspenseFallbackChildren(
-  current,
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var mode = workInProgress.mode;
-  var currentPrimaryChildFragment = current.child;
-  var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
-  var primaryChildProps = {
-    mode: "hidden",
-    children: primaryChildren
-  };
-  var primaryChildFragment;
+    if (queue !== null) {
+      if (isHidden) {
+        var transitions = queue.transitions;
 
-  if (
-    // In legacy mode, we commit the primary tree as if it successfully
-    // completed, even though it's in an inconsistent state.
-    (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was
-    // already cloned. In legacy mode, the only case where this isn't true is
-    // when DevTools forces us to display a fallback; we skip the first render
-    // pass entirely and go straight to rendering the fallback. (In Concurrent
-    // Mode, SuspenseList can also trigger this scenario, but this is a legacy-
-    // only codepath.)
-    workInProgress.child !== currentPrimaryChildFragment
-  ) {
-    var progressedPrimaryFragment = workInProgress.child;
-    primaryChildFragment = progressedPrimaryFragment;
-    primaryChildFragment.childLanes = NoLanes;
-    primaryChildFragment.pendingProps = primaryChildProps;
+        if (transitions !== null) {
+          transitions.forEach(function (transition) {
+            // Add all the transitions saved in the update queue during
+            // the render phase (ie the transitions associated with this boundary)
+            // into the transitions set.
+            if (instance._transitions === null) {
+              instance._transitions = new Set();
+            }
 
-    if (workInProgress.mode & ProfileMode) {
-      // Reset the durations from the first pass so they aren't included in the
-      // final amounts. This seems counterintuitive, since we're intentionally
-      // not measuring part of the render phase, but this makes it match what we
-      // do in Concurrent Mode.
-      primaryChildFragment.actualDuration = 0;
-      primaryChildFragment.actualStartTime = -1;
-      primaryChildFragment.selfBaseDuration =
-        currentPrimaryChildFragment.selfBaseDuration;
-      primaryChildFragment.treeBaseDuration =
-        currentPrimaryChildFragment.treeBaseDuration;
-    } // The fallback fiber was added as a deletion during the first pass.
-    // However, since we're going to remain on the fallback, we no longer want
-    // to delete it.
+            instance._transitions.add(transition);
+          });
+        }
 
-    workInProgress.deletions = null;
-  } else {
-    primaryChildFragment = updateWorkInProgressOffscreenFiber(
-      currentPrimaryChildFragment,
-      primaryChildProps
-    ); // Since we're reusing a current tree, we need to reuse the flags, too.
-    // (We don't do this in legacy mode, because in legacy mode we don't re-use
-    // the current tree; see previous branch.)
+        var markerInstances = queue.markerInstances;
 
-    primaryChildFragment.subtreeFlags =
-      currentPrimaryChildFragment.subtreeFlags & StaticMask;
-  }
+        if (markerInstances !== null) {
+          markerInstances.forEach(function (markerInstance) {
+            var markerTransitions = markerInstance.transitions; // There should only be a few tracing marker transitions because
+            // they should be only associated with the transition that
+            // caused them
 
-  var fallbackChildFragment;
+            if (markerTransitions !== null) {
+              markerTransitions.forEach(function (transition) {
+                if (instance._transitions === null) {
+                  instance._transitions = new Set();
+                } else if (instance._transitions.has(transition)) {
+                  if (markerInstance.pendingBoundaries === null) {
+                    markerInstance.pendingBoundaries = new Map();
+                  }
 
-  if (currentFallbackChildFragment !== null) {
-    fallbackChildFragment = createWorkInProgress(
-      currentFallbackChildFragment,
-      fallbackChildren
-    );
-  } else {
-    fallbackChildFragment = createFiberFromFragment(
-      fallbackChildren,
-      mode,
-      renderLanes,
-      null
-    ); // Needs a placement effect because the parent (the Suspense boundary) already
-    // mounted but this is a new fiber.
+                  if (instance._pendingMarkers === null) {
+                    instance._pendingMarkers = new Set();
+                  }
 
-    fallbackChildFragment.flags |= Placement;
-  }
+                  instance._pendingMarkers.add(markerInstance);
+                }
+              });
+            }
+          });
+        }
+      }
 
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
-  return fallbackChildFragment;
-}
+      finishedWork.updateQueue = null;
+    }
 
-function retrySuspenseComponentWithoutHydrating(
-  current,
-  workInProgress,
-  renderLanes,
-  recoverableError
-) {
-  // Falling back to client rendering. Because this has performance
-  // implications, it's considered a recoverable error, even though the user
-  // likely won't observe anything wrong with the UI.
-  //
-  // The error is passed in as an argument to enforce that every caller provide
-  // a custom message, or explicitly opt out (currently the only path that opts
-  // out is legacy mode; every concurrent path provides an error).
-  if (recoverableError !== null) {
-    queueHydrationError(recoverableError);
-  } // This will add the old fiber to the deletion list
+    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
 
-  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.
+    if (!isHidden) {
+      instance._transitions = null;
+      instance._pendingMarkers = null;
+    }
+  }
+}
 
-  var nextProps = workInProgress.pendingProps;
-  var primaryChildren = nextProps.children;
-  var primaryChildFragment = mountSuspensePrimaryChildren(
-    workInProgress,
-    primaryChildren
-  ); // Needs a placement effect because the parent (the Suspense boundary) already
-  // mounted but this is a new fiber.
+function commitCachePassiveMountEffect(current, finishedWork) {
+  {
+    var previousCache = null;
 
-  primaryChildFragment.flags |= Placement;
-  workInProgress.memoizedState = null;
-  return primaryChildFragment;
-}
+    if (finishedWork.alternate !== null) {
+      previousCache = finishedWork.alternate.memoizedState.cache;
+    }
 
-function mountSuspenseFallbackAfterRetryWithoutHydrating(
-  current,
-  workInProgress,
-  primaryChildren,
-  fallbackChildren,
-  renderLanes
-) {
-  var fiberMode = workInProgress.mode;
-  var primaryChildProps = {
-    mode: "visible",
-    children: primaryChildren
-  };
-  var primaryChildFragment = mountWorkInProgressOffscreenFiber(
-    primaryChildProps,
-    fiberMode
-  );
-  var fallbackChildFragment = createFiberFromFragment(
-    fallbackChildren,
-    fiberMode,
-    renderLanes,
-    null
-  ); // Needs a placement effect because the parent (the Suspense
-  // boundary) already mounted but this is a new fiber.
+    var nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
+    // could be "borrowing" a cache instance owned by some parent,
+    // in which case we could avoid retaining/releasing. But it
+    // is non-trivial to determine when that is the case, so we
+    // always retain/release.
 
-  fallbackChildFragment.flags |= Placement;
-  primaryChildFragment.return = workInProgress;
-  fallbackChildFragment.return = workInProgress;
-  primaryChildFragment.sibling = fallbackChildFragment;
-  workInProgress.child = primaryChildFragment;
+    if (nextCache !== previousCache) {
+      retainCache(nextCache);
 
-  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {
-    // We will have dropped the effect list which contains the
-    // deletion. We need to reconcile to delete the current child.
-    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+      if (previousCache != null) {
+        releaseCache(previousCache);
+      }
+    }
   }
-
-  return fallbackChildFragment;
 }
 
-function mountDehydratedSuspenseComponent(
-  workInProgress,
-  suspenseInstance,
-  renderLanes
-) {
-  // During the first pass, we'll bail out and not drill into the children.
-  // Instead, we'll leave the content in place and try to hydrate it later.
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    {
-      error(
-        "Cannot hydrate Suspense in legacy mode. Switch from " +
-          "ReactDOM.hydrate(element, container) to " +
-          "ReactDOMClient.hydrateRoot(container, <App />)" +
-          ".render(element) or remove the Suspense components from " +
-          "the server rendered components."
-      );
-    }
+function commitTracingMarkerPassiveMountEffect(finishedWork) {
+  // Get the transitions that were initiatized during the render
+  // and add a start transition callback for each of them
+  // We will only call this on initial mount of the tracing marker
+  // only if there are no suspense children
+  var instance = finishedWork.stateNode;
 
-    workInProgress.lanes = laneToLanes(SyncLane);
-  } else if (isSuspenseInstanceFallback(suspenseInstance)) {
-    // This is a client-only boundary. Since we won't get any content from the server
-    // for this, we need to schedule that at a higher priority based on when it would
-    // have timed out. In theory we could render it in this pass but it would have the
-    // wrong priority associated with it and will prevent hydration of parent path.
-    // Instead, we'll leave work left on it to render it in a separate commit.
-    // TODO This time should be the time at which the server rendered response that is
-    // a parent to this boundary was displayed. However, since we currently don't have
-    // a protocol to transfer that time, we'll just estimate it by using the current
-    // time. This will mean that Suspense timeouts are slightly shifted to later than
-    // they should be.
-    // Schedule a normal pri update to render this content.
-    workInProgress.lanes = laneToLanes(DefaultHydrationLane);
-  } else {
-    // We'll continue hydrating the rest at offscreen priority since we'll already
-    // be showing the right content coming from the server, it is no rush.
-    workInProgress.lanes = laneToLanes(OffscreenLane);
+  if (instance.transitions !== null && instance.pendingBoundaries === null) {
+    addMarkerCompleteCallbackToPendingTransition(
+      finishedWork.memoizedProps.name,
+      instance.transitions
+    );
+    instance.transitions = null;
+    instance.pendingBoundaries = null;
+    instance.aborts = null;
+    instance.name = null;
   }
+}
 
-  return null;
+function commitPassiveMountEffects(
+  root,
+  finishedWork,
+  committedLanes,
+  committedTransitions
+) {
+  setCurrentFiber(finishedWork);
+  commitPassiveMountOnFiber(
+    root,
+    finishedWork,
+    committedLanes,
+    committedTransitions
+  );
+  resetCurrentFiber();
 }
 
-function updateDehydratedSuspenseComponent(
-  current,
-  workInProgress,
-  didSuspend,
-  nextProps,
-  suspenseInstance,
-  suspenseState,
-  renderLanes
+function recursivelyTraversePassiveMountEffects(
+  root,
+  parentFiber,
+  committedLanes,
+  committedTransitions
 ) {
-  if (!didSuspend) {
-    // This is the first render pass. Attempt to hydrate.
-    pushPrimaryTreeSuspenseHandler(workInProgress); // We should never be hydrating at this point because it is the first pass,
-    // but after we've already committed once.
+  var prevDebugFiber = getCurrentFiber();
 
-    warnIfHydrating();
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-    if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        null
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitPassiveMountOnFiber(
+        root,
+        child,
+        committedLanes,
+        committedTransitions
       );
+      child = child.sibling;
     }
+  }
 
-    if (isSuspenseInstanceFallback(suspenseInstance)) {
-      // This boundary is in a permanent fallback state. In this case, we'll never
-      // get an update and we'll never be able to hydrate the final content. Let's just try the
-      // client side render instead.
-      var digest, message, stack;
-
-      {
-        var _getSuspenseInstanceF =
-          getSuspenseInstanceFallbackErrorDetails(suspenseInstance);
+  setCurrentFiber(prevDebugFiber);
+}
 
-        digest = _getSuspenseInstanceF.digest;
-        message = _getSuspenseInstanceF.message;
-        stack = _getSuspenseInstanceF.stack;
-      }
+function commitPassiveMountOnFiber(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions
+) {
+  // When updating this function, also update reconnectPassiveEffects, which does
+  // most of the same things when an offscreen tree goes from hidden -> visible,
+  // or when toggling effects inside a hidden tree.
+  var flags = finishedWork.flags;
 
-      var error;
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-      if (message) {
-        // eslint-disable-next-line react-internal/prod-error-codes
-        error = new Error(message);
-      } else {
-        error = new Error(
-          "The server could not finish this Suspense boundary, likely " +
-            "due to an error during server rendering. Switched to " +
-            "client rendering."
-        );
+      if (flags & Passive$1) {
+        commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
       }
 
-      error.digest = digest;
-      var capturedValue = createCapturedValue(error, digest, stack);
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        capturedValue
-      );
+      break;
     }
 
-    if (
-      enableLazyContextPropagation && // TODO: Factoring is a little weird, since we check this right below, too.
-      // But don't want to re-arrange the if-else chain until/unless this
-      // feature lands.
-      !didReceiveUpdate
-    ) {
-      // We need to check if any children have context before we decide to bail
-      // out, so propagate the changes now.
-      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
-    } // We use lanes to indicate that a child might depend on context, so if
-    // any context has changed, we need to treat is as if the input might have changed.
-
-    var hasContextChanged = includesSomeLane(renderLanes, current.childLanes);
+    case HostRoot: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-    if (didReceiveUpdate || hasContextChanged) {
-      // This boundary has changed since the first render. This means that we are now unable to
-      // hydrate it. We might still be able to hydrate it using a higher priority lane.
-      var root = getWorkInProgressRoot();
+      if (flags & Passive$1) {
+        {
+          var previousCache = null;
 
-      if (root !== null) {
-        var attemptHydrationAtLane = getBumpedLaneForHydration(
-          root,
-          renderLanes
-        );
+          if (finishedWork.alternate !== null) {
+            previousCache = finishedWork.alternate.memoizedState.cache;
+          }
 
-        if (
-          attemptHydrationAtLane !== NoLane &&
-          attemptHydrationAtLane !== suspenseState.retryLane
-        ) {
-          // Intentionally mutating since this render will get interrupted. This
-          // is one of the very rare times where we mutate the current tree
-          // during the render phase.
-          suspenseState.retryLane = attemptHydrationAtLane; // TODO: Ideally this would inherit the event time of the current render
+          var nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
+          // Note that on initial mount, previousCache and nextCache will be the same
+          // and this retain won't occur. To counter this, we instead retain the HostRoot's
+          // initial cache when creating the root itself (see createFiberRoot() in
+          // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
+          // here, such that previous/next caches are retained correctly.
 
-          var eventTime = NoTimestamp;
-          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);
-          scheduleUpdateOnFiber(
-            root,
-            current,
-            attemptHydrationAtLane,
-            eventTime
-          ); // Throw a special object that signals to the work loop that it should
-          // interrupt the current render.
-          //
-          // Because we're inside a React-only execution stack, we don't
-          // strictly need to throw here — we could instead modify some internal
-          // work loop state. But using an exception means we don't need to
-          // check for this case on every iteration of the work loop. So doing
-          // it this way moves the check out of the fast path.
+          if (nextCache !== previousCache) {
+            retainCache(nextCache);
 
-          throw SelectiveHydrationException;
+            if (previousCache != null) {
+              releaseCache(previousCache);
+            }
+          }
         }
-      } // If we did not selectively hydrate, we'll continue rendering without
-      // hydrating. Mark this tree as suspended to prevent it from committing
-      // outside a transition.
-      //
-      // This path should only happen if the hydration lane already suspended.
-      // Currently, it also happens during sync updates because there is no
-      // hydration lane for sync updates.
-      // TODO: We should ideally have a sync hydration lane that we can apply to do
-      // a pass where we hydrate this subtree in place using the previous Context and then
-      // reapply the update afterwards.
 
-      renderDidSuspendDelayIfPossible();
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        null
-      );
-    } else if (isSuspenseInstancePending(suspenseInstance)) {
-      // This component is still pending more data from the server, so we can't hydrate its
-      // content. We treat it as if this component suspended itself. It might seem as if
-      // we could just try to render it client-side instead. However, this will perform a
-      // lot of unnecessary work and is unlikely to complete since it often will suspend
-      // on missing data anyway. Additionally, the server might be able to render more
-      // than we can on the client yet. In that case we'd end up with more fallback states
-      // on the client than if we just leave it alone. If the server times out or errors
-      // these should update this boundary to the permanent Fallback state instead.
-      // Mark it as having captured (i.e. suspended).
-      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.
+        if (enableTransitionTracing) {
+          // Get the transitions that were initiatized during the render
+          // and add a start transition callback for each of them
+          var root = finishedWork.stateNode;
+          var incompleteTransitions = root.incompleteTransitions; // Initial render
 
-      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.
+          if (committedTransitions !== null) {
+            committedTransitions.forEach(function (transition) {
+              addTransitionStartCallbackToPendingTransition(transition);
+            });
+            clearTransitionsForLanes(finishedRoot, committedLanes);
+          }
 
-      var retry = retryDehydratedSuspenseBoundary.bind(null, current);
-      registerSuspenseInstanceRetry(suspenseInstance, retry);
-      return null;
-    } else {
-      // This is the first attempt.
-      reenterHydrationStateFromDehydratedSuspenseInstance(
-        workInProgress,
-        suspenseInstance,
-        suspenseState.treeContext
-      );
-      var primaryChildren = nextProps.children;
-      var primaryChildFragment = mountSuspensePrimaryChildren(
-        workInProgress,
-        primaryChildren
-      ); // Mark the children as hydrating. This is a fast path to know whether this
-      // tree is part of a hydrating tree. This is used to determine if a child
-      // node has fully mounted yet, and for scheduling event replaying.
-      // Conceptually this is similar to Placement in that a new subtree is
-      // inserted into the React tree here. It just happens to not need DOM
-      // mutations because it already exists.
+          incompleteTransitions.forEach(function (markerInstance, transition) {
+            var pendingBoundaries = markerInstance.pendingBoundaries;
 
-      primaryChildFragment.flags |= Hydrating;
-      return primaryChildFragment;
-    }
-  } else {
-    // This is the second render pass. We already attempted to hydrated, but
-    // something either suspended or errored.
-    if (workInProgress.flags & ForceClientRender) {
-      // Something errored during hydration. Try again without hydrating.
-      pushPrimaryTreeSuspenseHandler(workInProgress);
-      workInProgress.flags &= ~ForceClientRender;
+            if (pendingBoundaries === null || pendingBoundaries.size === 0) {
+              if (markerInstance.aborts === null) {
+                addTransitionCompleteCallbackToPendingTransition(transition);
+              }
 
-      var _capturedValue = createCapturedValue(
-        new Error(
-          "There was an error while hydrating this Suspense boundary. " +
-            "Switched to client rendering."
-        )
-      );
+              incompleteTransitions.delete(transition);
+            }
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
+        }
+      }
 
-      return retrySuspenseComponentWithoutHydrating(
-        current,
-        workInProgress,
-        renderLanes,
-        _capturedValue
-      );
-    } else if (workInProgress.memoizedState !== null) {
-      // Something suspended and we should still be in dehydrated mode.
-      // Leave the existing child in place.
-      // Push to avoid a mismatch
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there
-      // but the normal suspense pass doesn't.
+      break;
+    }
 
-      workInProgress.flags |= DidCapture;
-      return null;
-    } else {
-      // Suspended but we should no longer be in dehydrated mode.
-      // Therefore we now have to render the fallback.
-      pushFallbackTreeSuspenseHandler(workInProgress);
-      var nextPrimaryChildren = nextProps.children;
-      var nextFallbackChildren = nextProps.fallback;
-      var fallbackChildFragment =
-        mountSuspenseFallbackAfterRetryWithoutHydrating(
-          current,
-          workInProgress,
-          nextPrimaryChildren,
-          nextFallbackChildren,
-          renderLanes
+    case LegacyHiddenComponent: {
+      {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
         );
-      var _primaryChildFragment4 = workInProgress.child;
-      _primaryChildFragment4.memoizedState =
-        mountSuspenseOffscreenState(renderLanes);
-      workInProgress.memoizedState = SUSPENDED_MARKER;
-      return fallbackChildFragment;
+
+        if (flags & Passive$1) {
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+        }
+      }
+
+      break;
     }
-  }
-}
 
-function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
-  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
-  var alternate = fiber.alternate;
+    case OffscreenComponent: {
+      // TODO: Pass `current` as argument to this function
+      var _instance3 = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
 
-  if (alternate !== null) {
-    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-  }
+      if (isHidden) {
+        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          );
+        } else {
+          if (finishedWork.mode & ConcurrentMode) {
+            // The effects are currently disconnected. Since the tree is hidden,
+            // don't connect them. This also applies to the initial render.
+            {
+              // "Atomic" effects are ones that need to fire on every commit,
+              // even during pre-rendering. An example is updating the reference
+              // count on cache instances.
+              recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              );
+            }
+          } else {
+            // Legacy Mode: Fire the effects even if the tree is hidden.
+            _instance3._visibility |= OffscreenPassiveEffectsConnected;
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+          }
+        }
+      } else {
+        // Tree is visible
+        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraversePassiveMountEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          );
+        } else {
+          // The effects are currently disconnected. Reconnect them, while also
+          // firing effects inside newly mounted trees. This also applies to
+          // the initial render.
+          _instance3._visibility |= OffscreenPassiveEffectsConnected;
+          var includeWorkInProgressEffects =
+            (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+        }
+      }
 
-  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
-}
+      if (flags & Passive$1) {
+        var _current = finishedWork.alternate;
+        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
+      }
 
-function propagateSuspenseContextChange(
-  workInProgress,
-  firstChild,
-  renderLanes
-) {
-  // Mark any Suspense boundaries with fallbacks as having work to do.
-  // If they were previously forced into fallbacks, they may now be able
-  // to unblock.
-  var node = firstChild;
+      break;
+    }
 
-  while (node !== null) {
-    if (node.tag === SuspenseComponent) {
-      var state = node.memoizedState;
+    case CacheComponent: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
 
-      if (state !== null) {
-        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current2 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current2, finishedWork);
       }
-    } else if (node.tag === SuspenseListComponent) {
-      // If the tail is hidden there might not be an Suspense boundaries
-      // to schedule work on. In this case we have to schedule it on the
-      // list itself.
-      // We don't have to traverse to the children of the list since
-      // the list will propagate the change when it rerenders.
-      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);
-    } else if (node.child !== null) {
-      node.child.return = node;
-      node = node.child;
-      continue;
+
+      break;
     }
 
-    if (node === workInProgress) {
-      return;
-    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
 
-    while (node.sibling === null) {
-      // $FlowFixMe[incompatible-use] found when upgrading Flow
-      if (node.return === null || node.return === workInProgress) {
-        return;
-      }
+        if (flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
+        }
 
-      node = node.return;
-    } // $FlowFixMe[incompatible-use] found when upgrading Flow
+        break;
+      } // Intentional fallthrough to next branch
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-    node.sibling.return = node.return;
-    node = node.sibling;
+    default: {
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+      break;
+    }
   }
 }
 
-function findLastContentRow(firstChild) {
-  // This is going to find the last row among these children that is already
-  // showing content on the screen, as opposed to being in fallback state or
-  // new. If a row has multiple Suspense boundaries, any of them being in the
-  // fallback state, counts as the whole row being in a fallback state.
-  // Note that the "rows" will be workInProgress, but any nested children
-  // will still be current since we haven't rendered them yet. The mounted
-  // order may not be the same as the new order. We use the new order.
-  var row = firstChild;
-  var lastContentRow = null;
+function recursivelyTraverseReconnectPassiveEffects(
+  finishedRoot,
+  parentFiber,
+  committedLanes,
+  committedTransitions,
+  includeWorkInProgressEffects
+) {
+  // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  var childShouldIncludeWorkInProgressEffects =
+    includeWorkInProgressEffects &&
+    (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
 
-  while (row !== null) {
-    var currentRow = row.alternate; // New rows can't be content rows.
+  var prevDebugFiber = getCurrentFiber();
+  var child = parentFiber.child;
+
+  while (child !== null) {
+    reconnectPassiveEffects(
+      finishedRoot,
+      child,
+      committedLanes,
+      committedTransitions,
+      childShouldIncludeWorkInProgressEffects
+    );
+    child = child.sibling;
+  }
+
+  setCurrentFiber(prevDebugFiber);
+}
+
+function reconnectPassiveEffects(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions, // This function visits both newly finished work and nodes that were re-used
+  // from a previously committed tree. We cannot check non-static flags if the
+  // node was reused.
+  includeWorkInProgressEffects
+) {
+  var flags = finishedWork.flags;
+
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      ); // TODO: Check for PassiveStatic flag
 
-    if (currentRow !== null && findFirstSuspended(currentRow) === null) {
-      lastContentRow = row;
+      commitHookPassiveMountEffects(finishedWork, Passive);
+      break;
     }
+    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
+    // because this function only visits nodes that are inside an
+    // Offscreen fiber.
+    // case HostRoot: {
+    //  ...
+    // }
 
-    row = row.sibling;
-  }
-
-  return lastContentRow;
-}
+    case LegacyHiddenComponent: {
+      {
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
 
-function validateRevealOrder(revealOrder) {
-  {
-    if (
-      revealOrder !== undefined &&
-      revealOrder !== "forwards" &&
-      revealOrder !== "backwards" &&
-      revealOrder !== "together" &&
-      !didWarnAboutRevealOrder[revealOrder]
-    ) {
-      didWarnAboutRevealOrder[revealOrder] = true;
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          // TODO: Pass `current` as argument to this function
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+        }
+      }
 
-      if (typeof revealOrder === "string") {
-        switch (revealOrder.toLowerCase()) {
-          case "together":
-          case "forwards":
-          case "backwards": {
-            error(
-              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
-                'Use lowercase "%s" instead.',
-              revealOrder,
-              revealOrder.toLowerCase()
-            );
+      break;
+    }
 
-            break;
-          }
+    case OffscreenComponent: {
+      var _instance4 = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
 
-          case "forward":
-          case "backward": {
-            error(
-              '"%s" is not a valid value for revealOrder on <SuspenseList />. ' +
-                'React uses the -s suffix in the spelling. Use "%ss" instead.',
-              revealOrder,
-              revealOrder.toLowerCase()
+      if (isHidden) {
+        if (_instance4._visibility & OffscreenPassiveEffectsConnected) {
+          // The effects are currently connected. Update them.
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+        } else {
+          if (finishedWork.mode & ConcurrentMode) {
+            // The effects are currently disconnected. Since the tree is hidden,
+            // don't connect them. This also applies to the initial render.
+            {
+              // "Atomic" effects are ones that need to fire on every commit,
+              // even during pre-rendering. An example is updating the reference
+              // count on cache instances.
+              recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              );
+            }
+          } else {
+            // Legacy Mode: Fire the effects even if the tree is hidden.
+            _instance4._visibility |= OffscreenPassiveEffectsConnected;
+            recursivelyTraverseReconnectPassiveEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions,
+              includeWorkInProgressEffects
             );
-
-            break;
           }
-
-          default:
-            error(
-              '"%s" is not a supported revealOrder on <SuspenseList />. ' +
-                'Did you mean "together", "forwards" or "backwards"?',
-              revealOrder
-            );
-
-            break;
         }
       } else {
-        error(
-          "%s is not a supported value for revealOrder on <SuspenseList />. " +
-            'Did you mean "together", "forwards" or "backwards"?',
-          revealOrder
+        // Tree is visible
+        // Since we're already inside a reconnecting tree, it doesn't matter
+        // whether the effects are currently connected. In either case, we'll
+        // continue traversing the tree and firing all the effects.
+        //
+        // We do need to set the "connected" flag on the instance, though.
+        _instance4._visibility |= OffscreenPassiveEffectsConnected;
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
         );
       }
-    }
-  }
-}
 
-function validateTailOptions(tailMode, revealOrder) {
-  {
-    if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
-      if (tailMode !== "collapsed" && tailMode !== "hidden") {
-        didWarnAboutTailOptions[tailMode] = true;
+      if (includeWorkInProgressEffects && flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current3 = finishedWork.alternate;
+        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
+      }
 
-        error(
-          '"%s" is not a supported value for tail on <SuspenseList />. ' +
-            'Did you mean "collapsed" or "hidden"?',
-          tailMode
-        );
-      } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
-        didWarnAboutTailOptions[tailMode] = true;
+      break;
+    }
 
-        error(
-          '<SuspenseList tail="%s" /> is only valid if revealOrder is ' +
-            '"forwards" or "backwards". ' +
-            'Did you mean to specify revealOrder="forwards"?',
-          tailMode
-        );
+    case CacheComponent: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      );
+
+      if (includeWorkInProgressEffects && flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current4 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current4, finishedWork);
       }
+
+      break;
     }
-  }
-}
 
-function validateSuspenseListNestedChild(childSlot, index) {
-  {
-    var isAnArray = isArray(childSlot);
-    var isIterable =
-      !isAnArray && typeof getIteratorFn(childSlot) === "function";
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
 
-    if (isAnArray || isIterable) {
-      var type = isAnArray ? "array" : "iterable";
+        if (includeWorkInProgressEffects && flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
+        }
 
-      error(
-        "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " +
-          "an additional SuspenseList to configure its revealOrder: " +
-          "<SuspenseList revealOrder=...> ... " +
-          "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " +
-          "</SuspenseList>",
-        type,
-        index,
-        type
-      );
+        break;
+      } // Intentional fallthrough to next branch
+    }
+    // eslint-disable-next-line-no-fallthrough
 
-      return false;
+    default: {
+      recursivelyTraverseReconnectPassiveEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions,
+        includeWorkInProgressEffects
+      );
+      break;
     }
   }
-
-  return true;
 }
 
-function validateSuspenseListChildren(children, revealOrder) {
-  {
-    if (
-      (revealOrder === "forwards" || revealOrder === "backwards") &&
-      children !== undefined &&
-      children !== null &&
-      children !== false
-    ) {
-      if (isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-          if (!validateSuspenseListNestedChild(children[i], i)) {
-            return;
-          }
-        }
-      } else {
-        var iteratorFn = getIteratorFn(children);
-
-        if (typeof iteratorFn === "function") {
-          var childrenIterator = iteratorFn.call(children);
-
-          if (childrenIterator) {
-            var step = childrenIterator.next();
-            var _i = 0;
+function recursivelyTraverseAtomicPassiveEffects(
+  finishedRoot,
+  parentFiber,
+  committedLanes,
+  committedTransitions
+) {
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  var prevDebugFiber = getCurrentFiber(); // TODO: Add special flag for atomic effects
 
-            for (; !step.done; step = childrenIterator.next()) {
-              if (!validateSuspenseListNestedChild(step.value, _i)) {
-                return;
-              }
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-              _i++;
-            }
-          }
-        } else {
-          error(
-            'A single row was passed to a <SuspenseList revealOrder="%s" />. ' +
-              "This is not useful since it needs multiple rows. " +
-              "Did you mean to pass multiple children or an array?",
-            revealOrder
-          );
-        }
-      }
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitAtomicPassiveEffects(finishedRoot, child);
+      child = child.sibling;
     }
   }
+
+  setCurrentFiber(prevDebugFiber);
 }
 
-function initSuspenseListRenderState(
-  workInProgress,
-  isBackwards,
-  tail,
-  lastContentRow,
-  tailMode
+function commitAtomicPassiveEffects(
+  finishedRoot,
+  finishedWork,
+  committedLanes,
+  committedTransitions
 ) {
-  var renderState = workInProgress.memoizedState;
+  // "Atomic" effects are ones that need to fire on every commit, even during
+  // pre-rendering. We call this function when traversing a hidden tree whose
+  // regular effects are currently disconnected.
+  var flags = finishedWork.flags;
 
-  if (renderState === null) {
-    workInProgress.memoizedState = {
-      isBackwards: isBackwards,
-      rendering: null,
-      renderingStartTime: 0,
-      last: lastContentRow,
-      tail: tail,
-      tailMode: tailMode
-    };
-  } else {
-    // We can reuse the existing object from previous renders.
-    renderState.isBackwards = isBackwards;
-    renderState.rendering = null;
-    renderState.renderingStartTime = 0;
-    renderState.last = lastContentRow;
-    renderState.tail = tail;
-    renderState.tailMode = tailMode;
-  }
-} // This can end up rendering this component multiple passes.
-// The first pass splits the children fibers into two sets. A head and tail.
-// We first render the head. If anything is in fallback state, we do another
-// pass through beginWork to rerender all children (including the tail) with
-// the force suspend context. If the first render didn't have anything in
-// in fallback state. Then we render each row in the tail one-by-one.
-// That happens in the completeWork phase without going back to beginWork.
+  switch (finishedWork.tag) {
+    case OffscreenComponent: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
 
-function updateSuspenseListComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var revealOrder = nextProps.revealOrder;
-  var tailMode = nextProps.tail;
-  var newChildren = nextProps.children;
-  validateRevealOrder(revealOrder);
-  validateTailOptions(tailMode, revealOrder);
-  validateSuspenseListChildren(newChildren, revealOrder);
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  var suspenseContext = suspenseStackCursor.current;
-  var shouldForceFallback = hasSuspenseListContext(
-    suspenseContext,
-    ForceSuspenseFallback
-  );
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var current = finishedWork.alternate;
+        var instance = finishedWork.stateNode;
+        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+      }
 
-  if (shouldForceFallback) {
-    suspenseContext = setShallowSuspenseListContext(
-      suspenseContext,
-      ForceSuspenseFallback
-    );
-    workInProgress.flags |= DidCapture;
-  } else {
-    var didSuspendBefore =
-      current !== null && (current.flags & DidCapture) !== NoFlags$1;
+      break;
+    }
 
-    if (didSuspendBefore) {
-      // If we previously forced a fallback, we need to schedule work
-      // on any nested boundaries to let them know to try to render
-      // again. This is the same as context updating.
-      propagateSuspenseContextChange(
-        workInProgress,
-        workInProgress.child,
-        renderLanes
-      );
+    case CacheComponent: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+
+      if (flags & Passive$1) {
+        // TODO: Pass `current` as argument to this function
+        var _current5 = finishedWork.alternate;
+        commitCachePassiveMountEffect(_current5, finishedWork);
+      }
+
+      break;
     }
+    // eslint-disable-next-line-no-fallthrough
 
-    suspenseContext = setDefaultShallowSuspenseListContext(suspenseContext);
+    default: {
+      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+      break;
+    }
   }
+}
 
-  pushSuspenseListContext(workInProgress, suspenseContext);
-
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    // In legacy mode, SuspenseList doesn't work so we just
-    // use make it a noop by treating it as the default revealOrder.
-    workInProgress.memoizedState = null;
-  } else {
-    switch (revealOrder) {
-      case "forwards": {
-        var lastContentRow = findLastContentRow(workInProgress.child);
-        var tail;
+function commitPassiveUnmountEffects(finishedWork) {
+  setCurrentFiber(finishedWork);
+  commitPassiveUnmountOnFiber(finishedWork);
+  resetCurrentFiber();
+}
 
-        if (lastContentRow === null) {
-          // The whole list is part of the tail.
-          // TODO: We could fast path by just rendering the tail now.
-          tail = workInProgress.child;
-          workInProgress.child = null;
-        } else {
-          // Disconnect the tail rows after the content row.
-          // We're going to render them separately later.
-          tail = lastContentRow.sibling;
-          lastContentRow.sibling = null;
-        }
+function detachAlternateSiblings(parentFiber) {
+  // A fiber was deleted from this parent fiber, but it's still part of the
+  // previous (alternate) parent fiber's list of children. Because children
+  // are a linked list, an earlier sibling that's still alive will be
+  // connected to the deleted fiber via its `alternate`:
+  //
+  //   live fiber --alternate--> previous live fiber --sibling--> deleted
+  //   fiber
+  //
+  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
+  // but we can disconnect the `sibling` and `child` pointers.
+  var previousFiber = parentFiber.alternate;
 
-        initSuspenseListRenderState(
-          workInProgress,
-          false, // isBackwards
-          tail,
-          lastContentRow,
-          tailMode
-        );
-        break;
-      }
+  if (previousFiber !== null) {
+    var detachedChild = previousFiber.child;
 
-      case "backwards": {
-        // We're going to find the first row that has existing content.
-        // At the same time we're going to reverse the list of everything
-        // we pass in the meantime. That's going to be our tail in reverse
-        // order.
-        var _tail = null;
-        var row = workInProgress.child;
-        workInProgress.child = null;
+    if (detachedChild !== null) {
+      previousFiber.child = null;
 
-        while (row !== null) {
-          var currentRow = row.alternate; // New rows can't be content rows.
+      do {
+        // $FlowFixMe[incompatible-use] found when upgrading Flow
+        var detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
 
-          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
-            // This is the beginning of the main content.
-            workInProgress.child = row;
-            break;
-          }
+        detachedChild.sibling = null;
+        detachedChild = detachedSibling;
+      } while (detachedChild !== null);
+    }
+  }
+}
 
-          var nextRow = row.sibling;
-          row.sibling = _tail;
-          _tail = row;
-          row = nextRow;
-        } // TODO: If workInProgress.child is null, we can continue on the tail immediately.
+function commitHookPassiveUnmountEffects(
+  finishedWork,
+  nearestMountedAncestor,
+  hookFlags
+) {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+    recordPassiveEffectDuration(finishedWork);
+  } else {
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+  }
+}
 
-        initSuspenseListRenderState(
-          workInProgress,
-          true, // isBackwards
-          _tail,
-          null, // last
-          tailMode
-        );
-        break;
-      }
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  var deletions = parentFiber.deletions;
 
-      case "together": {
-        initSuspenseListRenderState(
-          workInProgress,
-          false, // isBackwards
-          null, // tail
-          null, // last
-          undefined
-        );
-        break;
-      }
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
 
-      default: {
-        // The default reveal order is the same as not having
-        // a boundary.
-        workInProgress.memoizedState = null;
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
       }
     }
+
+    detachAlternateSiblings(parentFiber);
   }
 
-  return workInProgress.child;
-}
+  var prevDebugFiber = getCurrentFiber(); // TODO: Split PassiveMask into separate masks for mount and unmount?
 
-function updatePortalComponent(current, workInProgress, renderLanes) {
-  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-  var nextChildren = workInProgress.pendingProps;
+  if (parentFiber.subtreeFlags & PassiveMask) {
+    var child = parentFiber.child;
 
-  if (current === 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
-    // the root always starts with a "current" with a null child.
-    // TODO: Consider unifying this with how the root works.
-    workInProgress.child = reconcileChildFibers(
-      workInProgress,
-      null,
-      nextChildren,
-      renderLanes
-    );
-  } else {
-    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+    while (child !== null) {
+      setCurrentFiber(child);
+      commitPassiveUnmountOnFiber(child);
+      child = child.sibling;
+    }
   }
 
-  return workInProgress.child;
+  setCurrentFiber(prevDebugFiber);
 }
 
-var hasWarnedAboutUsingNoValuePropOnContextProvider = false;
-
-function updateContextProvider(current, workInProgress, renderLanes) {
-  var providerType = workInProgress.type;
-  var context = providerType._context;
-  var newProps = workInProgress.pendingProps;
-  var oldProps = workInProgress.memoizedProps;
-  var newValue = newProps.value;
-
-  {
-    if (!("value" in newProps)) {
-      if (!hasWarnedAboutUsingNoValuePropOnContextProvider) {
-        hasWarnedAboutUsingNoValuePropOnContextProvider = true;
+function commitPassiveUnmountOnFiber(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
 
-        error(
-          "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
+      if (finishedWork.flags & Passive$1) {
+        commitHookPassiveUnmountEffects(
+          finishedWork,
+          finishedWork.return,
+          Passive | HasEffect
         );
       }
+
+      break;
     }
 
-    var providerPropTypes = workInProgress.type.propTypes;
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
+      var nextState = finishedWork.memoizedState;
+      var isHidden = nextState !== null;
 
-    if (providerPropTypes) {
-      checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider");
+      if (
+        isHidden &&
+        instance._visibility & OffscreenPassiveEffectsConnected && // For backwards compatibility, don't unmount when a tree suspends. In
+        // the future we may change this to unmount after a delay.
+        (finishedWork.return === null ||
+          finishedWork.return.tag !== SuspenseComponent)
+      ) {
+        // The effects are currently connected. Disconnect them.
+        // TODO: Add option or heuristic to delay before disconnecting the
+        // effects. Then if the tree reappears before the delay has elapsed, we
+        // can skip toggling the effects entirely.
+        instance._visibility &= ~OffscreenPassiveEffectsConnected;
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      } else {
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+      }
+
+      break;
+    }
+
+    default: {
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
+      break;
     }
   }
+}
 
-  pushProvider(workInProgress, context, newValue);
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  // Deletions effects can be scheduled on any fiber type. They need to happen
+  // before the children effects have fired.
+  var deletions = parentFiber.deletions;
 
-  if (enableLazyContextPropagation);
-  else {
-    if (oldProps !== null) {
-      var oldValue = oldProps.value;
+  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
+    if (deletions !== null) {
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
 
-      if (objectIs(oldValue, newValue)) {
-        // No change. Bailout early if children are the same.
-        if (oldProps.children === newProps.children && !hasContextChanged()) {
-          return bailoutOnAlreadyFinishedWork(
-            current,
-            workInProgress,
-            renderLanes
-          );
-        }
-      } else {
-        // The context value changed. Search for matching consumers and schedule
-        // them to update.
-        propagateContextChange(workInProgress, context, renderLanes);
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
       }
     }
+
+    detachAlternateSiblings(parentFiber);
   }
 
-  var newChildren = newProps.children;
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  return workInProgress.child;
+  var prevDebugFiber = getCurrentFiber(); // TODO: Check PassiveStatic flag
+
+  var child = parentFiber.child;
+
+  while (child !== null) {
+    setCurrentFiber(child);
+    disconnectPassiveEffect(child);
+    child = child.sibling;
+  }
+
+  setCurrentFiber(prevDebugFiber);
 }
 
-var hasWarnedAboutUsingContextAsConsumer = false;
+function disconnectPassiveEffect(finishedWork) {
+  switch (finishedWork.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      // TODO: Check PassiveStatic flag
+      commitHookPassiveUnmountEffects(
+        finishedWork,
+        finishedWork.return,
+        Passive
+      ); // When disconnecting passive effects, we fire the effects in the same
+      // order as during a deletiong: parent before child
 
-function updateContextConsumer(current, workInProgress, renderLanes) {
-  var context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In
-  // DEV mode, we create a separate object for Context.Consumer that acts
-  // like a proxy to Context. This proxy object adds unnecessary code in PROD
-  // so we use the old behaviour (Context.Consumer references Context) to
-  // reduce size and overhead. The separate object references context via
-  // a property called "_context", which also gives us the ability to check
-  // in DEV mode if this property exists or not and warn if it does not.
+      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      break;
+    }
 
-  {
-    if (context._context === undefined) {
-      // This may be because it's a Context (rather than a Consumer).
-      // Or it may be because it's older React where they're the same thing.
-      // We only want to warn if we're sure it's a new React.
-      if (context !== context.Consumer) {
-        if (!hasWarnedAboutUsingContextAsConsumer) {
-          hasWarnedAboutUsingContextAsConsumer = true;
+    case OffscreenComponent: {
+      var instance = finishedWork.stateNode;
 
-          error(
-            "Rendering <Context> directly is not supported and will be removed in " +
-              "a future major release. Did you mean to render <Context.Consumer> instead?"
-          );
-        }
+      if (instance._visibility & OffscreenPassiveEffectsConnected) {
+        instance._visibility &= ~OffscreenPassiveEffectsConnected;
+        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
       }
-    } else {
-      context = context._context;
+
+      break;
+    }
+
+    default: {
+      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      break;
     }
   }
+}
 
-  var newProps = workInProgress.pendingProps;
-  var render = newProps.children;
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+  deletedSubtreeRoot,
+  nearestMountedAncestor
+) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect; // Deletion effects fire in parent -> child order
+    // TODO: Check if fiber has a PassiveStatic flag
 
-  {
-    if (typeof render !== "function") {
-      error(
-        "A context consumer was rendered with multiple children, or a child " +
-          "that isn't a function. A context consumer expects a single child " +
-          "that is a function. If you did pass a function, make sure there " +
-          "is no trailing or leading whitespace around it."
+    setCurrentFiber(fiber);
+    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
+    resetCurrentFiber();
+    var child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+
+    if (child !== null) {
+      child.return = fiber;
+      nextEffect = child;
+    } else {
+      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
+        deletedSubtreeRoot
       );
     }
   }
+}
 
-  prepareToReadContext(workInProgress, renderLanes);
-  var newValue = readContext(context);
-
-  if (enableSchedulingProfiler) {
-    markComponentRenderStarted(workInProgress);
-  }
+function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
+  deletedSubtreeRoot
+) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    var sibling = fiber.sibling;
+    var returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
+    // This is more aggressive than ideal, and the long term goal is to only
+    // have to detach the deleted tree at the root.
 
-  var newChildren;
+    detachFiberAfterEffects(fiber);
 
-  {
-    ReactCurrentOwner$1.current = workInProgress;
-    setIsRendering(true);
-    newChildren = render(newValue);
-    setIsRendering(false);
-  }
+    if (fiber === deletedSubtreeRoot) {
+      nextEffect = null;
+      return;
+    }
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
-  } // React DevTools reads this flag.
+    if (sibling !== null) {
+      sibling.return = returnFiber;
+      nextEffect = sibling;
+      return;
+    }
 
-  workInProgress.flags |= PerformedWork;
-  reconcileChildren(current, workInProgress, newChildren, renderLanes);
-  return workInProgress.child;
+    nextEffect = returnFiber;
+  }
 }
 
-function updateScopeComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps;
-  var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
-  return workInProgress.child;
-}
+function commitPassiveUnmountInsideDeletedTreeOnFiber(
+  current,
+  nearestMountedAncestor
+) {
+  switch (current.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent: {
+      commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+      break;
+    }
+    // TODO: run passive unmount effects when unmounting a root.
+    // Because passive unmount effects are not currently run,
+    // the cache instance owned by the root will never be freed.
+    // When effects are run, the cache should be freed here:
+    // case HostRoot: {
+    //   if (enableCache) {
+    //     const cache = current.memoizedState.cache;
+    //     releaseCache(cache);
+    //   }
+    //   break;
+    // }
 
-function markWorkInProgressReceivedUpdate() {
-  didReceiveUpdate = true;
-}
-function checkIfWorkInProgressReceivedUpdate() {
-  return didReceiveUpdate;
-}
+    case LegacyHiddenComponent:
+    case OffscreenComponent: {
+      {
+        if (
+          current.memoizedState !== null &&
+          current.memoizedState.cachePool !== null
+        ) {
+          var cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
+          // Note that this is only reached in the non-suspended/visible case:
+          // when the content is suspended/hidden, the retain/release occurs
+          // via the parent Suspense component (see case above).
 
-function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
-  if ((workInProgress.mode & ConcurrentMode) === NoMode) {
-    if (current !== null) {
-      // A lazy component only mounts if it suspended inside a non-
-      // concurrent tree, in an inconsistent state. We want to treat it like
-      // a new mount, even though an empty version of it already committed.
-      // Disconnect the alternate pointers.
-      current.alternate = null;
-      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect
+          if (cache != null) {
+            retainCache(cache);
+          }
+        }
+      }
 
-      workInProgress.flags |= Placement;
+      break;
     }
-  }
-}
 
-function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
-  if (current !== null) {
-    // Reuse previous dependencies
-    workInProgress.dependencies = current.dependencies;
-  }
+    case SuspenseComponent: {
+      if (enableTransitionTracing) {
+        // We need to mark this fiber's parents as deleted
+        var offscreenFiber = current.child;
+        var instance = offscreenFiber.stateNode;
+        var transitions = instance._transitions;
 
-  {
-    // Don't update "base" render times for bailouts.
-    stopProfilerTimerIfRunning();
-  }
+        if (transitions !== null) {
+          var abortReason = {
+            reason: "suspense",
+            name: current.memoizedProps.unstable_name || null
+          };
 
-  markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.
+          if (
+            current.memoizedState === null ||
+            current.memoizedState.dehydrated === null
+          ) {
+            abortParentMarkerTransitionsForDeletedFiber(
+              offscreenFiber,
+              abortReason,
+              transitions,
+              instance,
+              true
+            );
 
-  if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
-    // 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.
-    if (enableLazyContextPropagation && current !== null) {
-      // Before bailing out, check if there are any context changes in
-      // the children.
-      lazilyPropagateParentContextChanges(current, workInProgress, renderLanes);
+            if (nearestMountedAncestor !== null) {
+              abortParentMarkerTransitionsForDeletedFiber(
+                nearestMountedAncestor,
+                abortReason,
+                transitions,
+                instance,
+                false
+              );
+            }
+          }
+        }
+      }
 
-      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
-        return null;
+      break;
+    }
+
+    case CacheComponent: {
+      {
+        var _cache = current.memoizedState.cache;
+        releaseCache(_cache);
       }
-    } else {
-      return null;
+
+      break;
     }
-  } // This fiber doesn't have work, but its subtree does. Clone the child
-  // fibers and continue.
 
-  cloneChildFibers(current, workInProgress);
-  return workInProgress.child;
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        // We need to mark this fiber's parents as deleted
+        var _instance5 = current.stateNode;
+        var _transitions = _instance5.transitions;
+
+        if (_transitions !== null) {
+          var _abortReason = {
+            reason: "marker",
+            name: current.memoizedProps.name
+          };
+          abortParentMarkerTransitionsForDeletedFiber(
+            current,
+            _abortReason,
+            _transitions,
+            null,
+            true
+          );
+
+          if (nearestMountedAncestor !== null) {
+            abortParentMarkerTransitionsForDeletedFiber(
+              nearestMountedAncestor,
+              _abortReason,
+              _transitions,
+              null,
+              false
+            );
+          }
+        }
+      }
+
+      break;
+    }
+  }
 }
 
-function remountFiber(current, oldWorkInProgress, newWorkInProgress) {
+function invokeLayoutEffectMountInDEV(fiber) {
   {
-    var returnFiber = oldWorkInProgress.return;
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListMount(Layout | HasEffect, fiber);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-    if (returnFiber === null) {
-      // eslint-disable-next-line react-internal/prod-error-codes
-      throw new Error("Cannot swap the root fiber.");
-    } // Disconnect from the old current.
-    // It will get deleted.
+        break;
+      }
 
-    current.alternate = null;
-    oldWorkInProgress.alternate = null; // Connect to the new tree.
+      case ClassComponent: {
+        var instance = fiber.stateNode;
 
-    newWorkInProgress.index = oldWorkInProgress.index;
-    newWorkInProgress.sibling = oldWorkInProgress.sibling;
-    newWorkInProgress.return = oldWorkInProgress.return;
-    newWorkInProgress.ref = oldWorkInProgress.ref; // Replace the child/sibling pointers above it.
+        try {
+          instance.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-    if (oldWorkInProgress === returnFiber.child) {
-      returnFiber.child = newWorkInProgress;
-    } else {
-      var prevSibling = returnFiber.child;
+        break;
+      }
+    }
+  }
+}
 
-      if (prevSibling === null) {
-        // eslint-disable-next-line react-internal/prod-error-codes
-        throw new Error("Expected parent to have a child.");
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+function invokePassiveEffectMountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListMount(Passive | HasEffect, fiber);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
 
-      while (prevSibling.sibling !== oldWorkInProgress) {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        prevSibling = prevSibling.sibling;
+        break;
+      }
+    }
+  }
+}
 
-        if (prevSibling === null) {
-          // eslint-disable-next-line react-internal/prod-error-codes
-          throw new Error("Expected to find the previous sibling.");
+function invokeLayoutEffectUnmountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
         }
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-      prevSibling.sibling = newWorkInProgress;
-    } // Delete the old fiber and place the new one.
-    // Since the old fiber is disconnected, we have to schedule it manually.
 
-    var deletions = returnFiber.deletions;
+        break;
+      }
 
-    if (deletions === null) {
-      returnFiber.deletions = [current];
-      returnFiber.flags |= ChildDeletion;
-    } else {
-      deletions.push(current);
-    }
+      case ClassComponent: {
+        var instance = fiber.stateNode;
 
-    newWorkInProgress.flags |= Placement; // Restart work from the new fiber.
+        if (typeof instance.componentWillUnmount === "function") {
+          safelyCallComponentWillUnmount(fiber, fiber.return, instance);
+        }
 
-    return newWorkInProgress;
+        break;
+      }
+    }
   }
 }
 
-function checkScheduledUpdateOrContext(current, renderLanes) {
-  // Before performing an early bailout, we must check if there are pending
-  // updates or context.
-  var updateLanes = current.lanes;
+function invokePassiveEffectUnmountInDEV(fiber) {
+  {
+    // We don't need to re-check StrictEffectsMode here.
+    // This function is only called if that check has already passed.
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case SimpleMemoComponent: {
+        try {
+          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
+        } catch (error) {
+          captureCommitPhaseError(fiber, fiber.return, error);
+        }
+      }
+    }
+  }
+}
 
-  if (includesSomeLane(updateLanes, renderLanes)) {
-    return true;
-  } // No pending update, but because context is propagated lazily, we need
-  // to check for a context change before we bail out.
+function getCacheSignal() {
+  var cache = readContext(CacheContext);
+  return cache.controller.signal;
+}
 
-  if (enableLazyContextPropagation) {
-    var dependencies = current.dependencies;
+function getCacheForType(resourceType) {
+  var cache = readContext(CacheContext);
+  var cacheForType = cache.data.get(resourceType);
 
-    if (dependencies !== null && checkIfContextChanged(dependencies)) {
-      return true;
-    }
+  if (cacheForType === undefined) {
+    cacheForType = resourceType();
+    cache.data.set(resourceType, cacheForType);
   }
 
-  return false;
+  return cacheForType;
 }
 
-function attemptEarlyBailoutIfNoScheduledUpdate(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  // 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);
-      pushRootTransition(workInProgress);
+var DefaultCacheDispatcher = {
+  getCacheSignal: getCacheSignal,
+  getCacheForType: getCacheForType
+};
 
-      if (enableTransitionTracing) {
-        pushRootMarkerInstance(workInProgress);
-      }
+var COMPONENT_TYPE = 0;
+var HAS_PSEUDO_CLASS_TYPE = 1;
+var ROLE_TYPE = 2;
+var TEST_NAME_TYPE = 3;
+var TEXT_TYPE = 4;
 
-      {
-        var cache = current.memoizedState.cache;
-        pushCacheProvider(workInProgress, cache);
-      }
+if (typeof Symbol === "function" && Symbol.for) {
+  var symbolFor = Symbol.for;
+  COMPONENT_TYPE = symbolFor("selector.component");
+  HAS_PSEUDO_CLASS_TYPE = symbolFor("selector.has_pseudo_class");
+  ROLE_TYPE = symbolFor("selector.role");
+  TEST_NAME_TYPE = symbolFor("selector.test_id");
+  TEXT_TYPE = symbolFor("selector.text");
+}
 
-      resetHydrationState();
-      break;
+function createComponentSelector(component) {
+  return {
+    $$typeof: COMPONENT_TYPE,
+    value: component
+  };
+}
+function createHasPseudoClassSelector(selectors) {
+  return {
+    $$typeof: HAS_PSEUDO_CLASS_TYPE,
+    value: selectors
+  };
+}
+function createRoleSelector(role) {
+  return {
+    $$typeof: ROLE_TYPE,
+    value: role
+  };
+}
+function createTextSelector(text) {
+  return {
+    $$typeof: TEXT_TYPE,
+    value: text
+  };
+}
+function createTestNameSelector(id) {
+  return {
+    $$typeof: TEST_NAME_TYPE,
+    value: id
+  };
+}
 
-    case HostSingleton:
-    case HostComponent:
-      pushHostContext(workInProgress);
-      break;
+function findFiberRootForHostRoot(hostRoot) {
+  var maybeFiber = getInstanceFromNode(hostRoot);
 
-    case ClassComponent: {
-      break;
+  if (maybeFiber != null) {
+    if (typeof maybeFiber.memoizedProps["data-testname"] !== "string") {
+      throw new Error(
+        "Invalid host root specified. Should be either a React container or a node with a testname attribute."
+      );
     }
 
-    case HostPortal:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      break;
+    return maybeFiber;
+  } else {
+    var fiberRoot = findFiberRoot(hostRoot);
 
-    case ContextProvider: {
-      var newValue = workInProgress.memoizedProps.value;
-      var context = workInProgress.type._context;
-      pushProvider(workInProgress, context, newValue);
-      break;
-    }
+    if (fiberRoot === null) {
+      throw new Error(
+        "Could not find React container within specified host subtree."
+      );
+    } // The Flow type for FiberRoot is a little funky.
+    // createFiberRoot() cheats this by treating the root as :any and adding stateNode lazily.
 
-    case Profiler:
-      {
-        // Profiler should only call onRender when one of its descendants actually rendered.
-        var hasChildWork = includesSomeLane(
-          renderLanes,
-          workInProgress.childLanes
-        );
+    return fiberRoot.stateNode.current;
+  }
+}
 
-        if (hasChildWork) {
-          workInProgress.flags |= Update;
-        }
+function matchSelector(fiber, selector) {
+  var tag = fiber.tag;
 
-        {
-          // Reset effect durations for the next eventual effect phase.
-          // These are reset during render to allow the DevTools commit hook a chance to read them,
-          var stateNode = workInProgress.stateNode;
-          stateNode.effectDuration = 0;
-          stateNode.passiveEffectDuration = 0;
-        }
+  switch (selector.$$typeof) {
+    case COMPONENT_TYPE:
+      if (fiber.type === selector.value) {
+        return true;
       }
 
       break;
 
-    case SuspenseComponent: {
-      var state = workInProgress.memoizedState;
-
-      if (state !== null) {
-        if (state.dehydrated !== null) {
-          // We're not going to render the children, so this is just to maintain
-          // push/pop symmetry
-          pushPrimaryTreeSuspenseHandler(workInProgress); // We know that this component will suspend again because if it has
-          // been unsuspended it has committed as a resolved Suspense component.
-          // If it needs to be retried, it should have work scheduled on it.
-
-          workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we
-          // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.
+    case HAS_PSEUDO_CLASS_TYPE:
+      return hasMatchingPaths(fiber, selector.value);
 
-          return null;
-        } // If this boundary is currently timed out, we need to decide
-        // whether to retry the primary children, or to skip over it and
-        // go straight to the fallback. Check the priority of the primary
-        // child fragment.
+    case ROLE_TYPE:
+      if (
+        tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton
+      ) {
+        var node = fiber.stateNode;
 
-        var primaryChildFragment = workInProgress.child;
-        var primaryChildLanes = primaryChildFragment.childLanes;
+        if (matchAccessibilityRole(node, selector.value)) {
+          return true;
+        }
+      }
 
-        if (includesSomeLane(renderLanes, primaryChildLanes)) {
-          // The primary children have pending work. Use the normal path
-          // to attempt to render the primary children again.
-          return updateSuspenseComponent(current, workInProgress, renderLanes);
-        } else {
-          // The primary child fragment does not have pending work marked
-          // on it
-          pushPrimaryTreeSuspenseHandler(workInProgress); // The primary children do not have pending work with sufficient
-          // priority. Bailout.
+      break;
 
-          var child = bailoutOnAlreadyFinishedWork(
-            current,
-            workInProgress,
-            renderLanes
-          );
+    case TEXT_TYPE:
+      if (
+        tag === HostComponent ||
+        tag === HostText ||
+        tag === HostHoistable ||
+        tag === HostSingleton
+      ) {
+        var textContent = getTextContent(fiber);
 
-          if (child !== null) {
-            // The fallback children have pending work. Skip over the
-            // primary children and work on the fallback.
-            return child.sibling;
-          } else {
-            // Note: We can return `null` here because we already checked
-            // whether there were nested context consumers, via the call to
-            // `bailoutOnAlreadyFinishedWork` above.
-            return null;
-          }
+        if (textContent !== null && textContent.indexOf(selector.value) >= 0) {
+          return true;
         }
-      } else {
-        pushPrimaryTreeSuspenseHandler(workInProgress);
       }
 
       break;
-    }
-
-    case SuspenseListComponent: {
-      var didSuspendBefore = (current.flags & DidCapture) !== NoFlags$1;
 
-      var _hasChildWork = includesSomeLane(
-        renderLanes,
-        workInProgress.childLanes
-      );
+    case TEST_NAME_TYPE:
+      if (
+        tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton
+      ) {
+        var dataTestID = fiber.memoizedProps["data-testname"];
 
-      if (enableLazyContextPropagation && !_hasChildWork) {
-        // Context changes may not have been propagated yet. We need to do
-        // that now, before we can decide whether to bail out.
-        // TODO: We use `childLanes` as a heuristic for whether there is
-        // remaining work in a few places, including
-        // `bailoutOnAlreadyFinishedWork` and
-        // `updateDehydratedSuspenseComponent`. We should maybe extract this
-        // into a dedicated function.
-        lazilyPropagateParentContextChanges(
-          current,
-          workInProgress,
-          renderLanes
-        );
-        _hasChildWork = includesSomeLane(
-          renderLanes,
-          workInProgress.childLanes
-        );
+        if (
+          typeof dataTestID === "string" &&
+          dataTestID.toLowerCase() === selector.value.toLowerCase()
+        ) {
+          return true;
+        }
       }
 
-      if (didSuspendBefore) {
-        if (_hasChildWork) {
-          // If something was in fallback state last time, and we have all the
-          // same children then we're still in progressive loading state.
-          // Something might get unblocked by state updates or retries in the
-          // tree which will affect the tail. So we need to use the normal
-          // path to compute the correct tail.
-          return updateSuspenseListComponent(
-            current,
-            workInProgress,
-            renderLanes
-          );
-        } // If none of the children had any work, that means that none of
-        // them got retried so they'll still be blocked in the same way
-        // as before. We can fast bail out.
-
-        workInProgress.flags |= DidCapture;
-      } // If nothing suspended before and we're rendering the same children,
-      // then the tail doesn't matter. Anything new that suspends will work
-      // in the "together" mode, so we can continue from the state we had.
-
-      var renderState = workInProgress.memoizedState;
+      break;
 
-      if (renderState !== null) {
-        // Reset to the "together" mode in case we've started a different
-        // update in the past but didn't complete it.
-        renderState.rendering = null;
-        renderState.tail = null;
-        renderState.lastEffect = null;
-      }
+    default:
+      throw new Error("Invalid selector type specified.");
+  }
 
-      pushSuspenseListContext(workInProgress, suspenseStackCursor.current);
+  return false;
+}
 
-      if (_hasChildWork) {
-        break;
-      } else {
-        // If none of the children had any work, that means that none of
-        // them got retried so they'll still be blocked in the same way
-        // as before. We can fast bail out.
-        return null;
-      }
-    }
+function selectorToString(selector) {
+  switch (selector.$$typeof) {
+    case COMPONENT_TYPE:
+      var displayName = getComponentNameFromType(selector.value) || "Unknown";
+      return "<" + displayName + ">";
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      // Need to check if the tree still needs to be deferred. This is
-      // almost identical to the logic used in the normal update path,
-      // so we'll just enter that. The only difference is we'll bail out
-      // at the next level instead of this one, because the child props
-      // have not changed. Which is fine.
-      // TODO: Probably should refactor `beginWork` to split the bailout
-      // path from the normal path. I'm tempted to do a labeled break here
-      // but I won't :)
-      workInProgress.lanes = NoLanes;
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    }
+    case HAS_PSEUDO_CLASS_TYPE:
+      return ":has(" + (selectorToString(selector) || "") + ")";
 
-    case CacheComponent: {
-      {
-        var _cache = current.memoizedState.cache;
-        pushCacheProvider(workInProgress, _cache);
-      }
+    case ROLE_TYPE:
+      return '[role="' + selector.value + '"]';
 
-      break;
-    }
+    case TEXT_TYPE:
+      return '"' + selector.value + '"';
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        var instance = workInProgress.stateNode;
+    case TEST_NAME_TYPE:
+      return '[data-testname="' + selector.value + '"]';
 
-        if (instance !== null) {
-          pushMarkerInstance(workInProgress, instance);
-        }
-      }
-    }
+    default:
+      throw new Error("Invalid selector type specified.");
   }
-
-  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
 }
 
-function beginWork$1(current, workInProgress, renderLanes) {
-  {
-    if (workInProgress._debugNeedsRemount && current !== null) {
-      // This will restart the begin phase with a new fiber.
-      return remountFiber(
-        current,
-        workInProgress,
-        createFiberFromTypeAndProps(
-          workInProgress.type,
-          workInProgress.key,
-          workInProgress.pendingProps,
-          workInProgress._debugOwner || null,
-          workInProgress.mode,
-          workInProgress.lanes
-        )
-      );
-    }
-  }
+function findPaths(root, selectors) {
+  var matchingFibers = [];
+  var stack = [root, 0];
+  var index = 0;
 
-  if (current !== null) {
-    var oldProps = current.memoizedProps;
-    var newProps = workInProgress.pendingProps;
+  while (index < stack.length) {
+    var fiber = stack[index++];
+    var tag = fiber.tag;
+    var selectorIndex = stack[index++];
+    var selector = selectors[selectorIndex];
 
     if (
-      oldProps !== newProps ||
-      hasContextChanged() || // Force a re-render if the implementation changed due to hot reload:
-      workInProgress.type !== current.type
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      isHiddenSubtree(fiber)
     ) {
-      // If props or context changed, mark the fiber as having performed work.
-      // This may be unset if the props are determined to be equal later (memo).
-      didReceiveUpdate = true;
+      continue;
     } else {
-      // Neither props nor legacy context changes. Check if there's a pending
-      // update or context change.
-      var hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(
-        current,
-        renderLanes
-      );
-
-      if (
-        !hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there
-        // may not be work scheduled on `current`, so we check for this flag.
-        (workInProgress.flags & DidCapture) === NoFlags$1
-      ) {
-        // No pending updates or context. Bail out now.
-        didReceiveUpdate = false;
-        return attemptEarlyBailoutIfNoScheduledUpdate(
-          current,
-          workInProgress,
-          renderLanes
-        );
-      }
-
-      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags$1) {
-        // This is a special case that only exists for legacy mode.
-        // See https://github.com/facebook/react/pull/19216.
-        didReceiveUpdate = true;
-      } else {
-        // An update was scheduled on this fiber, but there are no new props
-        // nor legacy context. Set this to false. If an update queue or context
-        // consumer produces a changed value, it will set this to true. Otherwise,
-        // the component will assume the children have not changed and bail out.
-        didReceiveUpdate = false;
+      while (selector != null && matchSelector(fiber, selector)) {
+        selectorIndex++;
+        selector = selectors[selectorIndex];
       }
     }
-  } else {
-    didReceiveUpdate = false;
-
-    if (getIsHydrating() && isForkedChild(workInProgress)) {
-      // Check if this child belongs to a list of muliple children in
-      // its parent.
-      //
-      // In a true multi-threaded implementation, we would render children on
-      // parallel threads. This would represent the beginning of a new render
-      // thread for this subtree.
-      //
-      // We only use this for id generation during hydration, which is why the
-      // logic is located in this special branch.
-      var slotIndex = workInProgress.index;
-      var numberOfForks = getForksAtLevel();
-      pushTreeId(workInProgress, numberOfForks, slotIndex);
-    }
-  } // Before entering the begin phase, clear pending update priority.
-  // TODO: This assumes that we're about to evaluate the component and process
-  // the update queue. However, there's an exception: SimpleMemoComponent
-  // sometimes bails out later in the begin phase. This indicates that we should
-  // move this assignment out of the common path and into each branch.
-
-  workInProgress.lanes = NoLanes;
-
-  switch (workInProgress.tag) {
-    case IndeterminateComponent: {
-      return mountIndeterminateComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        renderLanes
-      );
-    }
-
-    case LazyComponent: {
-      var elementType = workInProgress.elementType;
-      return mountLazyComponent(
-        current,
-        workInProgress,
-        elementType,
-        renderLanes
-      );
-    }
 
-    case FunctionComponent: {
-      var Component = workInProgress.type;
-      var unresolvedProps = workInProgress.pendingProps;
-      var resolvedProps =
-        workInProgress.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      return updateFunctionComponent(
-        current,
-        workInProgress,
-        Component,
-        resolvedProps,
-        renderLanes
-      );
+    if (selectorIndex === selectors.length) {
+      matchingFibers.push(fiber);
+    } else {
+      var child = fiber.child;
+
+      while (child !== null) {
+        stack.push(child, selectorIndex);
+        child = child.sibling;
+      }
     }
+  }
 
-    case ClassComponent: {
-      var _Component = workInProgress.type;
-      var _unresolvedProps = workInProgress.pendingProps;
+  return matchingFibers;
+} // Same as findPaths but with eager bailout on first match
 
-      var _resolvedProps =
-        workInProgress.elementType === _Component
-          ? _unresolvedProps
-          : resolveDefaultProps(_Component, _unresolvedProps);
+function hasMatchingPaths(root, selectors) {
+  var stack = [root, 0];
+  var index = 0;
 
-      return updateClassComponent(
-        current,
-        workInProgress,
-        _Component,
-        _resolvedProps,
-        renderLanes
-      );
+  while (index < stack.length) {
+    var fiber = stack[index++];
+    var tag = fiber.tag;
+    var selectorIndex = stack[index++];
+    var selector = selectors[selectorIndex];
+
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      isHiddenSubtree(fiber)
+    ) {
+      continue;
+    } else {
+      while (selector != null && matchSelector(fiber, selector)) {
+        selectorIndex++;
+        selector = selectors[selectorIndex];
+      }
     }
 
-    case HostRoot:
-      return updateHostRoot(current, workInProgress, renderLanes);
+    if (selectorIndex === selectors.length) {
+      return true;
+    } else {
+      var child = fiber.child;
 
-    case HostHoistable: {
-      return updateHostHoistable(current, workInProgress);
+      while (child !== null) {
+        stack.push(child, selectorIndex);
+        child = child.sibling;
+      }
     }
+  }
 
-    // eslint-disable-next-line no-fallthrough
+  return false;
+}
 
-    case HostSingleton: {
-      return updateHostSingleton(current, workInProgress, renderLanes);
+function findAllNodes(hostRoot, selectors) {
+  var root = findFiberRootForHostRoot(hostRoot);
+  var matchingFibers = findPaths(root, selectors);
+  var instanceRoots = [];
+  var stack = Array.from(matchingFibers);
+  var index = 0;
+
+  while (index < stack.length) {
+    var node = stack[index++];
+    var tag = node.tag;
+
+    if (
+      tag === HostComponent ||
+      tag === HostHoistable ||
+      tag === HostSingleton
+    ) {
+      if (isHiddenSubtree(node)) {
+        continue;
+      }
+
+      instanceRoots.push(node.stateNode);
+    } else {
+      var child = node.child;
+
+      while (child !== null) {
+        stack.push(child);
+        child = child.sibling;
+      }
     }
+  }
 
-    // eslint-disable-next-line no-fallthrough
+  return instanceRoots;
+}
+function getFindAllNodesFailureDescription(hostRoot, selectors) {
+  var root = findFiberRootForHostRoot(hostRoot);
+  var maxSelectorIndex = 0;
+  var matchedNames = []; // The logic of this loop should be kept in sync with findPaths()
 
-    case HostComponent:
-      return updateHostComponent$1(current, workInProgress, renderLanes);
+  var stack = [root, 0];
+  var index = 0;
 
-    case HostText:
-      return updateHostText$1(current, workInProgress);
+  while (index < stack.length) {
+    var fiber = stack[index++];
+    var tag = fiber.tag;
+    var selectorIndex = stack[index++];
+    var selector = selectors[selectorIndex];
 
-    case SuspenseComponent:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      isHiddenSubtree(fiber)
+    ) {
+      continue;
+    } else if (matchSelector(fiber, selector)) {
+      matchedNames.push(selectorToString(selector));
+      selectorIndex++;
 
-    case HostPortal:
-      return updatePortalComponent(current, workInProgress, renderLanes);
+      if (selectorIndex > maxSelectorIndex) {
+        maxSelectorIndex = selectorIndex;
+      }
+    }
 
-    case ForwardRef: {
-      var type = workInProgress.type;
-      var _unresolvedProps2 = workInProgress.pendingProps;
+    if (selectorIndex < selectors.length) {
+      var child = fiber.child;
 
-      var _resolvedProps2 =
-        workInProgress.elementType === type
-          ? _unresolvedProps2
-          : resolveDefaultProps(type, _unresolvedProps2);
+      while (child !== null) {
+        stack.push(child, selectorIndex);
+        child = child.sibling;
+      }
+    }
+  }
 
-      return updateForwardRef(
-        current,
-        workInProgress,
-        type,
-        _resolvedProps2,
-        renderLanes
-      );
+  if (maxSelectorIndex < selectors.length) {
+    var unmatchedNames = [];
+
+    for (var i = maxSelectorIndex; i < selectors.length; i++) {
+      unmatchedNames.push(selectorToString(selectors[i]));
     }
 
-    case Fragment:
-      return updateFragment(current, workInProgress, renderLanes);
+    return (
+      "findAllNodes was able to match part of the selector:\n" +
+      ("  " + matchedNames.join(" > ") + "\n\n") +
+      "No matching component was found for:\n" +
+      ("  " + unmatchedNames.join(" > "))
+    );
+  }
 
-    case Mode:
-      return updateMode(current, workInProgress, renderLanes);
+  return null;
+}
+function findBoundingRects(hostRoot, selectors) {
+  var instanceRoots = findAllNodes(hostRoot, selectors);
+  var boundingRects = [];
 
-    case Profiler:
-      return updateProfiler(current, workInProgress, renderLanes);
+  for (var i = 0; i < instanceRoots.length; i++) {
+    boundingRects.push(getBoundingRect(instanceRoots[i]));
+  }
 
-    case ContextProvider:
-      return updateContextProvider(current, workInProgress, renderLanes);
+  for (var _i = boundingRects.length - 1; _i > 0; _i--) {
+    var targetRect = boundingRects[_i];
+    var targetLeft = targetRect.x;
+    var targetRight = targetLeft + targetRect.width;
+    var targetTop = targetRect.y;
+    var targetBottom = targetTop + targetRect.height;
 
-    case ContextConsumer:
-      return updateContextConsumer(current, workInProgress, renderLanes);
+    for (var j = _i - 1; j >= 0; j--) {
+      if (_i !== j) {
+        var otherRect = boundingRects[j];
+        var otherLeft = otherRect.x;
+        var otherRight = otherLeft + otherRect.width;
+        var otherTop = otherRect.y;
+        var otherBottom = otherTop + otherRect.height; // Merging all rects to the minimums set would be complicated,
+        // but we can handle the most common cases:
+        // 1. completely overlapping rects
+        // 2. adjacent rects that are the same width or height (e.g. items in a list)
+        //
+        // Even given the above constraints,
+        // we still won't end up with the fewest possible rects without doing multiple passes,
+        // but it's good enough for this purpose.
 
-    case MemoComponent: {
-      var _type2 = workInProgress.type;
-      var _unresolvedProps3 = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.
+        if (
+          targetLeft >= otherLeft &&
+          targetTop >= otherTop &&
+          targetRight <= otherRight &&
+          targetBottom <= otherBottom
+        ) {
+          // Complete overlapping rects; remove the inner one.
+          boundingRects.splice(_i, 1);
+          break;
+        } else if (
+          targetLeft === otherLeft &&
+          targetRect.width === otherRect.width &&
+          !(otherBottom < targetTop) &&
+          !(otherTop > targetBottom)
+        ) {
+          // Adjacent vertical rects; merge them.
+          if (otherTop > targetTop) {
+            otherRect.height += otherTop - targetTop;
+            otherRect.y = targetTop;
+          }
 
-      var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
+          if (otherBottom < targetBottom) {
+            otherRect.height = targetBottom - otherTop;
+          }
 
-      {
-        if (workInProgress.type !== workInProgress.elementType) {
-          var outerPropTypes = _type2.propTypes;
+          boundingRects.splice(_i, 1);
+          break;
+        } else if (
+          targetTop === otherTop &&
+          targetRect.height === otherRect.height &&
+          !(otherRight < targetLeft) &&
+          !(otherLeft > targetRight)
+        ) {
+          // Adjacent horizontal rects; merge them.
+          if (otherLeft > targetLeft) {
+            otherRect.width += otherLeft - targetLeft;
+            otherRect.x = targetLeft;
+          }
 
-          if (outerPropTypes) {
-            checkPropTypes(
-              outerPropTypes,
-              _resolvedProps3, // Resolved for outer only
-              "prop",
-              getComponentNameFromType(_type2)
-            );
+          if (otherRight < targetRight) {
+            otherRect.width = targetRight - otherLeft;
           }
+
+          boundingRects.splice(_i, 1);
+          break;
         }
       }
-
-      _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
-      return updateMemoComponent(
-        current,
-        workInProgress,
-        _type2,
-        _resolvedProps3,
-        renderLanes
-      );
-    }
-
-    case SimpleMemoComponent: {
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
-      );
     }
+  }
 
-    case IncompleteClassComponent: {
-      var _Component2 = workInProgress.type;
-      var _unresolvedProps4 = workInProgress.pendingProps;
+  return boundingRects;
+}
+function focusWithin(hostRoot, selectors) {
+  var root = findFiberRootForHostRoot(hostRoot);
+  var matchingFibers = findPaths(root, selectors);
+  var stack = Array.from(matchingFibers);
+  var index = 0;
 
-      var _resolvedProps4 =
-        workInProgress.elementType === _Component2
-          ? _unresolvedProps4
-          : resolveDefaultProps(_Component2, _unresolvedProps4);
+  while (index < stack.length) {
+    var fiber = stack[index++];
+    var tag = fiber.tag;
 
-      return mountIncompleteClassComponent(
-        current,
-        workInProgress,
-        _Component2,
-        _resolvedProps4,
-        renderLanes
-      );
+    if (isHiddenSubtree(fiber)) {
+      continue;
     }
 
-    case SuspenseListComponent: {
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    }
+    if (
+      tag === HostComponent ||
+      tag === HostHoistable ||
+      tag === HostSingleton
+    ) {
+      var node = fiber.stateNode;
 
-    case ScopeComponent: {
-      {
-        return updateScopeComponent(current, workInProgress, renderLanes);
+      if (setFocusIfFocusable(node)) {
+        return true;
       }
     }
 
-    case OffscreenComponent: {
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    var child = fiber.child;
+
+    while (child !== null) {
+      stack.push(child);
+      child = child.sibling;
     }
+  }
 
-    case LegacyHiddenComponent: {
-      {
-        return updateLegacyHiddenComponent(
-          current,
-          workInProgress,
-          renderLanes
-        );
+  return false;
+}
+var commitHooks = [];
+function onCommitRoot() {
+  {
+    commitHooks.forEach(function (commitHook) {
+      return commitHook();
+    });
+  }
+}
+function observeVisibleRects(hostRoot, selectors, callback, options) {
+  var instanceRoots = findAllNodes(hostRoot, selectors);
+
+  var _setupIntersectionObs = setupIntersectionObserver(
+      instanceRoots,
+      callback,
+      options
+    ),
+    disconnect = _setupIntersectionObs.disconnect,
+    observe = _setupIntersectionObs.observe,
+    unobserve = _setupIntersectionObs.unobserve; // When React mutates the host environment, we may need to change what we're listening to.
+
+  var commitHook = function () {
+    var nextInstanceRoots = findAllNodes(hostRoot, selectors);
+    instanceRoots.forEach(function (target) {
+      if (nextInstanceRoots.indexOf(target) < 0) {
+        unobserve(target);
+      }
+    });
+    nextInstanceRoots.forEach(function (target) {
+      if (instanceRoots.indexOf(target) < 0) {
+        observe(target);
       }
+    });
+  };
+
+  commitHooks.push(commitHook);
+  return {
+    disconnect: function () {
+      // Stop listening for React mutations:
+      var index = commitHooks.indexOf(commitHook);
+
+      if (index >= 0) {
+        commitHooks.splice(index, 1);
+      } // Disconnect the host observer:
+
+      disconnect();
     }
+  };
+}
 
-    case CacheComponent: {
-      {
-        return updateCacheComponent(current, workInProgress, renderLanes);
-      }
+var ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;
+function isLegacyActEnvironment(fiber) {
+  {
+    // Legacy mode. We preserve the behavior of React 17's act. It assumes an
+    // act environment whenever `jest` is defined, but you can still turn off
+    // spurious warnings by setting IS_REACT_ACT_ENVIRONMENT explicitly
+    // to false.
+    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
+        ? IS_REACT_ACT_ENVIRONMENT
+        : undefined; // $FlowFixMe - Flow doesn't know about jest
+
+    var jestIsDefined = typeof jest !== "undefined";
+    return jestIsDefined && isReactActEnvironmentGlobal !== false;
+  }
+}
+function isConcurrentActEnvironment() {
+  {
+    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
+        ? IS_REACT_ACT_ENVIRONMENT
+        : undefined;
+
+    if (
+      !isReactActEnvironmentGlobal &&
+      ReactCurrentActQueue$1.current !== null
+    ) {
+      // TODO: Include link to relevant documentation page.
+      error(
+        "The current testing environment is not configured to support " +
+          "act(...)"
+      );
     }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        return updateTracingMarkerComponent(
-          current,
-          workInProgress,
-          renderLanes
-        );
+    return isReactActEnvironmentGlobal;
+  }
+}
+
+var postPaintCallbackScheduled = false;
+var callbacks = [];
+function schedulePostPaintCallback(callback) {
+  callbacks.push(callback);
+
+  if (!postPaintCallbackScheduled) {
+    postPaintCallbackScheduled = true;
+    requestPostPaintCallback(function (endTime) {
+      for (var i = 0; i < callbacks.length; i++) {
+        callbacks[i](endTime);
       }
 
-      break;
-    }
-  }
+      postPaintCallbackScheduled = false;
+      callbacks = [];
+    });
+  }
+}
+
+var ceil = Math.ceil;
+var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+  ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
+var NoContext =
+  /*             */
+  0;
+var BatchedContext =
+  /*               */
+  1;
+var RenderContext =
+  /*         */
+  2;
+var CommitContext =
+  /*         */
+  4;
+var RootInProgress = 0;
+var RootFatalErrored = 1;
+var RootErrored = 2;
+var RootSuspended = 3;
+var RootSuspendedWithDelay = 4;
+var RootCompleted = 5;
+var RootDidNotComplete = 6; // Describes where we are in the React execution stack
+
+var executionContext = NoContext; // The root we're working on
+
+var workInProgressRoot = null; // The fiber we're working on
+
+var workInProgress = null; // The lanes we're rendering
+
+var workInProgressRootRenderLanes = NoLanes;
+var NotSuspended = 0;
+var SuspendedOnError = 1;
+var SuspendedOnData = 2;
+var SuspendedOnImmediate = 3;
+var SuspendedOnDeprecatedThrowPromise = 4;
+var SuspendedAndReadyToContinue = 5;
+var SuspendedOnHydration = 6; // When this is true, the work-in-progress fiber just suspended (or errored) and
+// we've yet to unwind the stack. In some cases, we may yield to the main thread
+// after this happens. If the fiber is pinged before we resume, we can retry
+// immediately instead of unwinding the stack.
+
+var workInProgressSuspendedReason = NotSuspended;
+var workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
+// different that whether something suspended, because we don't add multiple
+// listeners to a promise we've already seen (per root and lane).
+
+var workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
+// the lanes that we started working on at the root. When we enter a subtree
+// that is currently hidden, we add the lanes that would have committed if
+// the hidden tree hadn't been deferred. This is modified by the
+// HiddenContext module.
+//
+// Most things in the work loop should deal with workInProgressRootRenderLanes.
+// Most things in begin/complete phases should deal with renderLanes.
+
+var renderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
 
-  throw new Error(
-    "Unknown unit of work tag (" +
-      workInProgress.tag +
-      "). This error is likely caused by a bug in " +
-      "React. Please file an issue."
-  );
-}
+var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
 
-var valueCursor = createCursor(null);
-var rendererCursorDEV;
+var workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
+// includes unprocessed updates, not work in bailed out children.
 
-{
-  rendererCursorDEV = createCursor(null);
-}
+var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
 
-var rendererSigil;
+var workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
 
-{
-  // Use this to detect multiple renderers using the same context
-  rendererSigil = {};
-}
+var workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.
 
-var currentlyRenderingFiber = null;
-var lastContextDependency = null;
-var lastFullyObservedContext = null;
-var isDisallowedContextReadInDEV = false;
-function resetContextDependencies() {
-  // This is called right before React yields execution, to ensure `readContext`
-  // cannot be called outside the render phase.
-  currentlyRenderingFiber = null;
-  lastContextDependency = null;
-  lastFullyObservedContext = null;
+var workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
+// We will log them once the tree commits.
 
-  {
-    isDisallowedContextReadInDEV = false;
-  }
-}
-function enterDisallowedContextReadInDEV() {
-  {
-    isDisallowedContextReadInDEV = true;
-  }
-}
-function exitDisallowedContextReadInDEV() {
-  {
-    isDisallowedContextReadInDEV = false;
-  }
-}
-function pushProvider(providerFiber, context, nextValue) {
-  {
-    push(valueCursor, context._currentValue, providerFiber);
-    context._currentValue = nextValue;
+var workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train
+// model where we don't commit new loading states in too quick succession.
 
-    {
-      push(rendererCursorDEV, context._currentRenderer, providerFiber);
+var globalMostRecentFallbackTime = 0;
+var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
+// more and prefer CPU suspense heuristics instead.
 
-      if (
-        context._currentRenderer !== undefined &&
-        context._currentRenderer !== null &&
-        context._currentRenderer !== rendererSigil
-      ) {
-        error(
-          "Detected multiple renderers concurrently rendering the " +
-            "same context provider. This is currently unsupported."
-        );
-      }
+var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
+// suspense heuristics and opt out of rendering more content.
 
-      context._currentRenderer = rendererSigil;
-    }
-  }
+var RENDER_TIMEOUT_MS = 500;
+var workInProgressTransitions = null;
+function getWorkInProgressTransitions() {
+  return workInProgressTransitions;
 }
-function popProvider(context, providerFiber) {
-  var currentValue = valueCursor.current;
-
-  {
-    if (currentValue === REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED) {
-      context._currentValue = context._defaultValue;
-    } else {
-      context._currentValue = currentValue;
+var currentPendingTransitionCallbacks = null;
+var currentEndTime = null;
+function addTransitionStartCallbackToPendingTransition(transition) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: [],
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
     }
 
-    {
-      var currentRenderer = rendererCursorDEV.current;
-      pop(rendererCursorDEV, providerFiber);
-      context._currentRenderer = currentRenderer;
+    if (currentPendingTransitionCallbacks.transitionStart === null) {
+      currentPendingTransitionCallbacks.transitionStart = [];
     }
-  }
 
-  pop(valueCursor, providerFiber);
+    currentPendingTransitionCallbacks.transitionStart.push(transition);
+  }
 }
-function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
-  // Update the child lanes of all the ancestors, including the alternates.
-  var node = parent;
-
-  while (node !== null) {
-    var alternate = node.alternate;
-
-    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {
-      node.childLanes = mergeLanes(node.childLanes, renderLanes);
-
-      if (alternate !== null) {
-        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
-      }
-    } else if (
-      alternate !== null &&
-      !isSubsetOfLanes(alternate.childLanes, renderLanes)
-    ) {
-      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);
-    } else;
+function addMarkerProgressCallbackToPendingTransition(
+  markerName,
+  transitions,
+  pendingBoundaries
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: new Map(),
+        markerIncomplete: null,
+        markerComplete: null
+      };
+    }
 
-    if (node === propagationRoot) {
-      break;
+    if (currentPendingTransitionCallbacks.markerProgress === null) {
+      currentPendingTransitionCallbacks.markerProgress = new Map();
     }
 
-    node = node.return;
+    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
+      pendingBoundaries: pendingBoundaries,
+      transitions: transitions
+    });
   }
+}
+function addMarkerIncompleteCallbackToPendingTransition(
+  markerName,
+  transitions,
+  aborts
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: new Map(),
+        markerComplete: null
+      };
+    }
 
-  {
-    if (node !== propagationRoot) {
-      error(
-        "Expected to find the propagation root when scheduling context work. " +
-          "This error is likely caused by a bug in React. Please file an issue."
-      );
+    if (currentPendingTransitionCallbacks.markerIncomplete === null) {
+      currentPendingTransitionCallbacks.markerIncomplete = new Map();
     }
+
+    currentPendingTransitionCallbacks.markerIncomplete.set(markerName, {
+      transitions: transitions,
+      aborts: aborts
+    });
   }
 }
-function propagateContextChange(workInProgress, context, renderLanes) {
-  if (enableLazyContextPropagation) {
-    // TODO: This path is only used by Cache components. Update
-    // lazilyPropagateParentContextChanges to look for Cache components so they
-    // can take advantage of lazy propagation.
-    var forcePropagateEntireTree = true;
-    propagateContextChanges(
-      workInProgress,
-      [context],
-      renderLanes,
-      forcePropagateEntireTree
+function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: new Map()
+      };
+    }
+
+    if (currentPendingTransitionCallbacks.markerComplete === null) {
+      currentPendingTransitionCallbacks.markerComplete = new Map();
+    }
+
+    currentPendingTransitionCallbacks.markerComplete.set(
+      markerName,
+      transitions
     );
-  } else {
-    propagateContextChange_eager(workInProgress, context, renderLanes);
   }
 }
+function addTransitionProgressCallbackToPendingTransition(
+  transition,
+  boundaries
+) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: new Map(),
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
+    }
 
-function propagateContextChange_eager(workInProgress, context, renderLanes) {
-  // Only used by eager implementation
-  if (enableLazyContextPropagation) {
-    return;
-  }
-
-  var fiber = workInProgress.child;
+    if (currentPendingTransitionCallbacks.transitionProgress === null) {
+      currentPendingTransitionCallbacks.transitionProgress = new Map();
+    }
 
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
+    currentPendingTransitionCallbacks.transitionProgress.set(
+      transition,
+      boundaries
+    );
   }
+}
+function addTransitionCompleteCallbackToPendingTransition(transition) {
+  if (enableTransitionTracing) {
+    if (currentPendingTransitionCallbacks === null) {
+      currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: [],
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      };
+    }
 
-  while (fiber !== null) {
-    var nextFiber = void 0; // Visit this fiber.
-
-    var list = fiber.dependencies;
-
-    if (list !== null) {
-      nextFiber = fiber.child;
-      var dependency = list.firstContext;
+    if (currentPendingTransitionCallbacks.transitionComplete === null) {
+      currentPendingTransitionCallbacks.transitionComplete = [];
+    }
 
-      while (dependency !== null) {
-        // Check if the context matches.
-        if (dependency.context === context) {
-          // Match! Schedule an update on this fiber.
-          if (fiber.tag === ClassComponent) {
-            // Schedule a force update on the work-in-progress.
-            var lane = pickArbitraryLane(renderLanes);
-            var update = createUpdate(lane);
-            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the
-            // update to the current fiber, too, which means it will persist even if
-            // this render is thrown away. Since it's a race condition, not sure it's
-            // worth fixing.
-            // Inlined `enqueueUpdate` to remove interleaved update check
+    currentPendingTransitionCallbacks.transitionComplete.push(transition);
+  }
+}
 
-            var updateQueue = fiber.updateQueue;
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+}
 
-            if (updateQueue === null);
-            else {
-              var sharedQueue = updateQueue.shared;
-              var pending = sharedQueue.pending;
+function getRenderTargetTime() {
+  return workInProgressRootRenderTargetTime;
+}
+var hasUncaughtError = false;
+var firstUncaughtError = null;
+var legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
+// to track which root is currently committing layout effects.
 
-              if (pending === null) {
-                // This is the first update. Create a circular list.
-                update.next = update;
-              } else {
-                update.next = pending.next;
-                pending.next = update;
-              }
+var rootCommittingMutationOrLayoutEffects = null;
+var rootDoesHavePassiveEffects = false;
+var rootWithPendingPassiveEffects = null;
+var pendingPassiveEffectsLanes = NoLanes;
+var pendingPassiveProfilerEffects = [];
+var pendingPassiveEffectsRemainingLanes = NoLanes;
+var pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
 
-              sharedQueue.pending = update;
-            }
-          }
+var NESTED_UPDATE_LIMIT = 50;
+var nestedUpdateCount = 0;
+var rootWithNestedUpdates = null;
+var isFlushingPassiveEffects = false;
+var didScheduleUpdateDuringPassiveEffects = false;
+var NESTED_PASSIVE_UPDATE_LIMIT = 50;
+var nestedPassiveUpdateCount = 0;
+var rootWithPassiveNestedUpdates = null; // If two updates are scheduled within the same event, we should treat their
+// event times as simultaneous, even if the actual clock time has advanced
+// between the first and second call.
 
-          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);
-          var alternate = fiber.alternate;
+var currentEventTime = NoTimestamp;
+var currentEventTransitionLane = NoLanes;
+var isRunningInsertionEffect = false;
+function getWorkInProgressRoot() {
+  return workInProgressRoot;
+}
+function getWorkInProgressRootRenderLanes() {
+  return workInProgressRootRenderLanes;
+}
+function requestEventTime() {
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    // We're inside React, so it's fine to read the actual time.
+    return now$1();
+  } // We're not inside React, so we may be in the middle of a browser event.
 
-          if (alternate !== null) {
-            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-          }
+  if (currentEventTime !== NoTimestamp) {
+    // Use the same start time for all updates until we enter React again.
+    return currentEventTime;
+  } // This is the first update since React yielded. Compute a new start time.
 
-          scheduleContextWorkOnParentPath(
-            fiber.return,
-            renderLanes,
-            workInProgress
-          ); // Mark the updated lanes on the list, too.
+  currentEventTime = now$1();
+  return currentEventTime;
+}
+function requestUpdateLane(fiber) {
+  // Special cases
+  var mode = fiber.mode;
 
-          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the
-          // dependency list.
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
+  } else if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    (executionContext & RenderContext) !== NoContext &&
+    workInProgressRootRenderLanes !== NoLanes
+  ) {
+    // This is a render phase update. These are not officially supported. The
+    // old behavior is to give this the same "thread" (lanes) as
+    // whatever is currently rendering. So if you call `setState` on a component
+    // that happens later in the same render, it will flush. Ideally, we want to
+    // remove the special case and treat them as if they came from an
+    // interleaved event. Regardless, this pattern is not officially supported.
+    // This behavior is only a fallback. The flag only exists until we can roll
+    // out the setState warning, since existing code might accidentally rely on
+    // the current behavior.
+    return pickArbitraryLane(workInProgressRootRenderLanes);
+  }
 
-          break;
-        }
+  var isTransition = requestCurrentTransition() !== NoTransition;
 
-        dependency = dependency.next;
-      }
-    } else if (fiber.tag === ContextProvider) {
-      // Don't scan deeper if this is a matching provider
-      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-    } else if (fiber.tag === DehydratedFragment) {
-      // If a dehydrated suspense boundary is in this subtree, we don't know
-      // if it will have any context consumers in it. The best we can do is
-      // mark it as having updates.
-      var parentSuspense = fiber.return;
+  if (isTransition) {
+    if (ReactCurrentBatchConfig$1.transition !== null) {
+      var transition = ReactCurrentBatchConfig$1.transition;
 
-      if (parentSuspense === null) {
-        throw new Error(
-          "We just came from a parent so we must have had a parent. This is a bug in React."
-        );
+      if (!transition._updatedFibers) {
+        transition._updatedFibers = new Set();
       }
 
-      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
-      var _alternate = parentSuspense.alternate;
-
-      if (_alternate !== null) {
-        _alternate.lanes = mergeLanes(_alternate.lanes, renderLanes);
-      } // This is intentionally passing this fiber as the parent
-      // because we want to schedule this fiber as having work
-      // on its children. We'll use the childLanes on
-      // this fiber to indicate that a context has changed.
+      transition._updatedFibers.add(fiber);
+    } // The algorithm for assigning an update to a lane should be stable for all
+    // updates at the same priority within the same event. To do this, the
+    // inputs to the algorithm must be the same.
+    //
+    // The trick we use is to cache the first of each of these inputs within an
+    // event. Then reset the cached values once we can be sure the event is
+    // over. Our heuristic for that is whenever we enter a concurrent work loop.
 
-      scheduleContextWorkOnParentPath(
-        parentSuspense,
-        renderLanes,
-        workInProgress
-      );
-      nextFiber = fiber.sibling;
-    } else {
-      // Traverse down.
-      nextFiber = fiber.child;
+    if (currentEventTransitionLane === NoLane) {
+      // All transitions within the same event are assigned the same lane.
+      currentEventTransitionLane = claimNextTransitionLane();
     }
 
-    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;
+    return currentEventTransitionLane;
+  } // Updates originating inside certain React methods, like flushSync, have
+  // their priority set by tracking it with a context variable.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
 
-        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.
+  var updateLane = getCurrentUpdatePriority();
 
-        nextFiber = nextFiber.return;
-      }
-    }
+  if (updateLane !== NoLane) {
+    return updateLane;
+  } // This update originated outside React. Ask the host environment for an
+  // appropriate priority, based on the type of event.
+  //
+  // The opaque type returned by the host config is internally a lane, so we can
+  // use that directly.
+  // TODO: Move this type conversion to the event priority module.
 
-    fiber = nextFiber;
-  }
+  var eventLane = getCurrentEventPriority();
+  return eventLane;
 }
 
-function propagateContextChanges(
-  workInProgress,
-  contexts,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  // Only used by lazy implementation
-  if (!enableLazyContextPropagation) {
-    return;
+function requestRetryLane(fiber) {
+  // This is a fork of `requestUpdateLane` designed specifically for Suspense
+  // "retries" — a special update that attempts to flip a Suspense boundary
+  // from its placeholder state to its primary/resolved state.
+  // Special cases
+  var mode = fiber.mode;
+
+  if ((mode & ConcurrentMode) === NoMode) {
+    return SyncLane;
   }
 
-  var fiber = workInProgress.child;
+  return claimNextRetryLane();
+}
 
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
+function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+  {
+    if (isRunningInsertionEffect) {
+      error("useInsertionEffect must not schedule updates.");
+    }
   }
 
-  while (fiber !== null) {
-    var nextFiber = void 0; // Visit this fiber.
-
-    var list = fiber.dependencies;
+  {
+    if (isFlushingPassiveEffects) {
+      didScheduleUpdateDuringPassiveEffects = true;
+    }
+  } // Check if the work loop is currently suspended and waiting for data to
+  // finish loading.
 
-    if (list !== null) {
-      nextFiber = fiber.child;
-      var dep = list.firstContext;
+  if (
+    workInProgressSuspendedReason === SuspendedOnData &&
+    root === workInProgressRoot
+  ) {
+    // The incoming update might unblock the current render. Interrupt the
+    // current attempt and restart from the top.
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, workInProgressRootRenderLanes);
+  } // Mark that the root has a pending update.
 
-      findChangedDep: while (dep !== null) {
-        // Assigning these to constants to help Flow
-        var dependency = dep;
-        var consumer = fiber;
+  markRootUpdated(root, lane, eventTime);
 
-        for (var i = 0; i < contexts.length; i++) {
-          var context = contexts[i]; // Check if the context matches.
-          // TODO: Compare selected values to bail out early.
+  if (
+    (executionContext & RenderContext) !== NoLanes &&
+    root === workInProgressRoot
+  ) {
+    // This update was dispatched during the render phase. This is a mistake
+    // if the update originates from user space (with the exception of local
+    // hook updates, which are handled differently and don't reach this
+    // function), but there are some internal React features that use this as
+    // an implementation detail, like selective hydration.
+    warnAboutRenderPhaseUpdatesInDEV(fiber); // Track lanes that were updated during the render phase
+  } else {
+    // This is a normal update, scheduled from outside the render phase. For
+    // example, during an input event.
+    {
+      if (isDevToolsPresent) {
+        addFiberToLanesMap(root, fiber, lane);
+      }
+    }
 
-          if (dependency.context === context) {
-            // Match! Schedule an update on this fiber.
-            // In the lazy implementation, don't mark a dirty flag on the
-            // dependency itself. Not all changes are propagated, so we can't
-            // rely on the propagation function alone to determine whether
-            // something has changed; the consumer will check. In the future, we
-            // could add back a dirty flag as an optimization to avoid double
-            // checking, but until we have selectors it's not really worth
-            // the trouble.
-            consumer.lanes = mergeLanes(consumer.lanes, renderLanes);
-            var alternate = consumer.alternate;
+    warnIfUpdatesNotWrappedWithActDEV(fiber);
 
-            if (alternate !== null) {
-              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
-            }
+    if (enableProfilerNestedUpdateScheduledHook) {
+      if (
+        (executionContext & CommitContext) !== NoContext &&
+        root === rootCommittingMutationOrLayoutEffects
+      ) {
+        if (fiber.mode & ProfileMode) {
+          var current = fiber;
 
-            scheduleContextWorkOnParentPath(
-              consumer.return,
-              renderLanes,
-              workInProgress
-            );
+          while (current !== null) {
+            if (current.tag === Profiler) {
+              var _current$memoizedProp = current.memoizedProps,
+                id = _current$memoizedProp.id,
+                onNestedUpdateScheduled =
+                  _current$memoizedProp.onNestedUpdateScheduled;
 
-            if (!forcePropagateEntireTree) {
-              // During lazy propagation, when we find a match, we can defer
-              // propagating changes to the children, because we're going to
-              // visit them during render. We should continue propagating the
-              // siblings, though
-              nextFiber = null;
-            } // Since we already found a match, we can stop traversing the
-            // dependency list.
+              if (typeof onNestedUpdateScheduled === "function") {
+                onNestedUpdateScheduled(id);
+              }
+            }
 
-            break findChangedDep;
+            current = current.return;
           }
         }
-
-        dep = dependency.next;
-      }
-    } else if (fiber.tag === DehydratedFragment) {
-      // If a dehydrated suspense boundary is in this subtree, we don't know
-      // if it will have any context consumers in it. The best we can do is
-      // mark it as having updates.
-      var parentSuspense = fiber.return;
-
-      if (parentSuspense === null) {
-        throw new Error(
-          "We just came from a parent so we must have had a parent. This is a bug in React."
-        );
       }
-
-      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);
-      var _alternate2 = parentSuspense.alternate;
-
-      if (_alternate2 !== null) {
-        _alternate2.lanes = mergeLanes(_alternate2.lanes, renderLanes);
-      } // This is intentionally passing this fiber as the parent
-      // because we want to schedule this fiber as having work
-      // on its children. We'll use the childLanes on
-      // this fiber to indicate that a context has changed.
-
-      scheduleContextWorkOnParentPath(
-        parentSuspense,
-        renderLanes,
-        workInProgress
-      );
-      nextFiber = null;
-    } 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;
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig$1.transition;
 
-      while (nextFiber !== null) {
-        if (nextFiber === workInProgress) {
-          // We're back to the root of this subtree. Exit.
-          nextFiber = null;
-          break;
+      if (transition !== null && transition.name != null) {
+        if (transition.startTime === -1) {
+          transition.startTime = now$1();
         }
 
-        var sibling = nextFiber.sibling;
+        addTransitionToLanesMap(root, transition, lane);
+      }
+    }
 
-        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.
+    if (root === workInProgressRoot) {
+      // Received an update to a tree that's in the middle of rendering. Mark
+      // that there was an interleaved update work on this root. Unless the
+      // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
+      // phase update. In that case, we don't treat render phase updates as if
+      // they were interleaved, for backwards compat reasons.
+      if (
+        deferRenderPhaseUpdateToNextBatch ||
+        (executionContext & RenderContext) === NoContext
+      ) {
+        workInProgressRootInterleavedUpdatedLanes = mergeLanes(
+          workInProgressRootInterleavedUpdatedLanes,
+          lane
+        );
+      }
 
-        nextFiber = nextFiber.return;
+      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
+        // The root already suspended with a delay, which means this render
+        // definitely won't finish. Since we have a new update, let's mark it as
+        // suspended now, right before marking the incoming update. This has the
+        // effect of interrupting the current render and switching to the update.
+        // TODO: Make sure this doesn't override pings that happen while we've
+        // already started rendering.
+        markRootSuspended(root, workInProgressRootRenderLanes);
       }
     }
 
-    fiber = nextFiber;
+    ensureRootIsScheduled(root, eventTime);
+
+    if (
+      lane === SyncLane &&
+      executionContext === NoContext &&
+      (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+      !ReactCurrentActQueue.isBatchingLegacy
+    ) {
+      // Flush the synchronous work now, unless we're already working or inside
+      // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
+      // scheduleCallbackForFiber to preserve the ability to schedule a callback
+      // without immediately flushing it. We only do this for user-initiated
+      // updates, to preserve historical behavior of legacy mode.
+      resetRenderTimer();
+      flushSyncCallbacksOnlyInLegacyMode();
+    }
   }
 }
-
-function lazilyPropagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  var forcePropagateEntireTree = false;
-  propagateParentContextChanges(
-    current,
-    workInProgress,
-    renderLanes,
-    forcePropagateEntireTree
+function scheduleInitialHydrationOnRoot(root, lane, eventTime) {
+  // This is a special fork of scheduleUpdateOnFiber that is only used to
+  // schedule the initial hydration of a root that has just been created. Most
+  // of the stuff in scheduleUpdateOnFiber can be skipped.
+  //
+  // The main reason for this separate path, though, is to distinguish the
+  // initial children from subsequent updates. In fully client-rendered roots
+  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
+  // updates, but hydration roots are special because the initial render must
+  // match what was rendered on the server.
+  var current = root.current;
+  current.lanes = lane;
+  markRootUpdated(root, lane, eventTime);
+  ensureRootIsScheduled(root, eventTime);
+}
+function isUnsafeClassRenderPhaseUpdate(fiber) {
+  // Check if this is a render phase update. Only called by class components,
+  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+  return (
+    // TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We
+    // decided not to enable it.
+    (!deferRenderPhaseUpdateToNextBatch ||
+      (fiber.mode & ConcurrentMode) === NoMode) &&
+    (executionContext & RenderContext) !== NoContext
   );
-} // Used for propagating a deferred tree (Suspense, Offscreen). We must propagate
-// to the entire subtree, because we won't revisit it until after the current
-// render has completed, at which point we'll have lost track of which providers
-// have changed.
+} // Use this function to schedule a task for a root. There's only one task per
+// root; if a task was already scheduled, we'll check to make sure the priority
+// of the existing task is the same as the priority of the next level that the
+// root has work on. This function is called on every update, and right before
+// exiting a task.
 
-function propagateParentContextChangesToDeferredTree(
-  current,
-  workInProgress,
-  renderLanes
-) {
-  var forcePropagateEntireTree = true;
-  propagateParentContextChanges(
-    current,
-    workInProgress,
-    renderLanes,
-    forcePropagateEntireTree
+function ensureRootIsScheduled(root, currentTime) {
+  var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
+  // expired so we know to work on those next.
+
+  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+
+  var nextLanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
   );
-}
 
-function propagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (!enableLazyContextPropagation) {
+  if (nextLanes === NoLanes) {
+    // Special case: There's nothing to work on.
+    if (existingCallbackNode !== null) {
+      cancelCallback(existingCallbackNode);
+    }
+
+    root.callbackNode = null;
+    root.callbackPriority = NoLane;
     return;
-  } // Collect all the parent providers that changed. Since this is usually small
-  // number, we use an Array instead of Set.
+  } // If this root is currently suspended and waiting for data to resolve, don't
+  // schedule a task to render it. We'll either wait for a ping, or wait to
+  // receive an update.
 
-  var contexts = null;
-  var parent = workInProgress;
-  var isInsidePropagationBailout = false;
+  if (
+    workInProgressSuspendedReason === SuspendedOnData &&
+    workInProgressRoot === root
+  ) {
+    root.callbackPriority = NoLane;
+    root.callbackNode = null;
+    return;
+  } // We use the highest priority lane to represent the priority of the callback.
 
-  while (parent !== null) {
-    if (!isInsidePropagationBailout) {
-      if ((parent.flags & NeedsPropagation) !== NoFlags$1) {
-        isInsidePropagationBailout = true;
-      } else if ((parent.flags & DidPropagateContext) !== NoFlags$1) {
-        break;
-      }
-    }
+  var newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.
 
-    if (parent.tag === ContextProvider) {
-      var currentParent = parent.alternate;
+  var existingCallbackPriority = root.callbackPriority;
 
-      if (currentParent === null) {
-        throw new Error("Should have a current fiber. This is a bug in React.");
+  if (
+    existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
+    // Scheduler task, rather than an `act` task, cancel it and re-scheduled
+    // on the `act` queue.
+    !(
+      ReactCurrentActQueue.current !== null &&
+      existingCallbackNode !== fakeActCallbackNode
+    )
+  ) {
+    {
+      // If we're going to re-use an existing task, it needs to exist.
+      // Assume that discrete update microtasks are non-cancellable and null.
+      // TODO: Temporary until we confirm this warning is not fired.
+      if (
+        existingCallbackNode == null &&
+        !includesSyncLane(existingCallbackPriority)
+      ) {
+        error(
+          "Expected scheduled callback to exist. This error is likely caused by a bug in React. Please file an issue."
+        );
       }
+    } // The priority hasn't changed. We can reuse the existing task. Exit.
 
-      var oldProps = currentParent.memoizedProps;
+    return;
+  }
 
-      if (oldProps !== null) {
-        var providerType = parent.type;
-        var context = providerType._context;
-        var newProps = parent.pendingProps;
-        var newValue = newProps.value;
-        var oldValue = oldProps.value;
+  if (existingCallbackNode != null) {
+    // Cancel the existing callback. We'll schedule a new one below.
+    cancelCallback(existingCallbackNode);
+  } // Schedule a new callback.
 
-        if (!objectIs(newValue, oldValue)) {
-          if (contexts !== null) {
-            contexts.push(context);
-          } else {
-            contexts = [context];
-          }
-        }
+  var newCallbackNode;
+
+  if (includesSyncLane(newCallbackPriority)) {
+    // Special case: Sync React callbacks are scheduled on a special
+    // internal queue
+    if (root.tag === LegacyRoot) {
+      if (ReactCurrentActQueue.isBatchingLegacy !== null) {
+        ReactCurrentActQueue.didScheduleLegacyUpdate = true;
       }
+
+      scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));
+    } else {
+      scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
     }
 
-    parent = parent.return;
-  }
+    {
+      // Flush the queue in a microtask.
+      if (ReactCurrentActQueue.current !== null) {
+        // Inside `act`, use our internal `act` queue so that these get flushed
+        // at the end of the current scope even when using the sync version
+        // of `act`.
+        ReactCurrentActQueue.current.push(flushSyncCallbacks);
+      } else {
+        scheduleMicrotask(function () {
+          // In Safari, appending an iframe forces microtasks to run.
+          // https://github.com/facebook/react/issues/22459
+          // We don't support running callbacks in the middle of render
+          // or commit so we need to check against that.
+          if (
+            (executionContext & (RenderContext | CommitContext)) ===
+            NoContext
+          ) {
+            // Note that this would still prematurely flush the callbacks
+            // if this happens outside render or commit phase (e.g. in an event).
+            flushSyncCallbacks();
+          }
+        });
+      }
+    }
 
-  if (contexts !== null) {
-    // If there were any changed providers, search through the children and
-    // propagate their changes.
-    propagateContextChanges(
-      workInProgress,
-      contexts,
-      renderLanes,
-      forcePropagateEntireTree
-    );
-  } // This is an optimization so that we only propagate once per subtree. If a
-  // deeply nested child bails out, and it calls this propagation function, it
-  // uses this flag to know that the remaining ancestor providers have already
-  // been propagated.
-  //
-  // NOTE: This optimization is only necessary because we sometimes enter the
-  // begin phase of nodes that don't have any work scheduled on them —
-  // specifically, the siblings of a node that _does_ have scheduled work. The
-  // siblings will bail out and call this function again, even though we already
-  // propagated content changes to it and its subtree. So we use this flag to
-  // mark that the parent providers already propagated.
-  //
-  // Unfortunately, though, we need to ignore this flag when we're inside a
-  // tree whose context propagation was deferred — that's what the
-  // `NeedsPropagation` flag is for.
-  //
-  // If we could instead bail out before entering the siblings' begin phase,
-  // then we could remove both `DidPropagateContext` and `NeedsPropagation`.
-  // Consider this as part of the next refactor to the fiber tree structure.
+    newCallbackNode = null;
+  } else {
+    var schedulerPriorityLevel;
 
-  workInProgress.flags |= DidPropagateContext;
-}
+    switch (lanesToEventPriority(nextLanes)) {
+      case DiscreteEventPriority:
+        schedulerPriorityLevel = ImmediatePriority;
+        break;
 
-function checkIfContextChanged(currentDependencies) {
-  if (!enableLazyContextPropagation) {
-    return false;
-  } // Iterate over the current dependencies to see if something changed. This
-  // only gets called if props and state has already bailed out, so it's a
-  // relatively uncommon path, except at the root of a changed subtree.
-  // Alternatively, we could move these comparisons into `readContext`, but
-  // that's a much hotter path, so I think this is an appropriate trade off.
+      case ContinuousEventPriority:
+        schedulerPriorityLevel = UserBlockingPriority;
+        break;
 
-  var dependency = currentDependencies.firstContext;
+      case DefaultEventPriority:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
 
-  while (dependency !== null) {
-    var context = dependency.context;
-    var newValue = context._currentValue;
-    var oldValue = dependency.memoizedValue;
+      case IdleEventPriority:
+        schedulerPriorityLevel = IdlePriority;
+        break;
 
-    if (!objectIs(newValue, oldValue)) {
-      return true;
+      default:
+        schedulerPriorityLevel = NormalPriority$1;
+        break;
     }
 
-    dependency = dependency.next;
+    newCallbackNode = scheduleCallback(
+      schedulerPriorityLevel,
+      performConcurrentWorkOnRoot.bind(null, root)
+    );
   }
 
-  return false;
-}
-function prepareToReadContext(workInProgress, renderLanes) {
-  currentlyRenderingFiber = workInProgress;
-  lastContextDependency = null;
-  lastFullyObservedContext = null;
-  var dependencies = workInProgress.dependencies;
+  root.callbackPriority = newCallbackPriority;
+  root.callbackNode = newCallbackNode;
+} // This is the entry point for every concurrent task, i.e. anything that
+// goes through Scheduler.
 
-  if (dependencies !== null) {
-    if (enableLazyContextPropagation) {
-      // Reset the work-in-progress list
-      dependencies.firstContext = null;
-    } else {
-      var firstContext = dependencies.firstContext;
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  {
+    resetNestedUpdateFlag();
+  } // Since we know we're in a React event, we can clear the current
+  // event time. The next update will compute a new event time.
 
-      if (firstContext !== null) {
-        if (includesSomeLane(dependencies.lanes, renderLanes)) {
-          // Context list has a pending update. Mark that this fiber performed work.
-          markWorkInProgressReceivedUpdate();
-        } // Reset the work-in-progress list
+  currentEventTime = NoTimestamp;
+  currentEventTransitionLane = NoLanes;
 
-        dependencies.firstContext = null;
-      }
-    }
-  }
-}
-function readContext(context) {
-  {
-    // This warning would fire if you read context inside a Hook like useMemo.
-    // Unlike the class check below, it's not enforced in production for perf.
-    if (isDisallowedContextReadInDEV) {
-      error(
-        "Context can only be read while React is rendering. " +
-          "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-          "In function components, you can read it directly in the function body, but not " +
-          "inside Hooks like useReducer() or useMemo()."
-      );
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
+  } // Flush any pending passive effects before deciding which lanes to work on,
+  // in case they schedule additional work.
+
+  var originalCallbackNode = root.callbackNode;
+  var didFlushPassiveEffects = flushPassiveEffects();
+
+  if (didFlushPassiveEffects) {
+    // Something in the passive effect phase may have canceled the current task.
+    // Check if the task node for this root was changed.
+    if (root.callbackNode !== originalCallbackNode) {
+      // The current task was canceled. Exit. We don't need to call
+      // `ensureRootIsScheduled` because the check above implies either that
+      // there's a new task, or that there's no remaining work on this root.
+      return null;
     }
-  }
+  } // Determine the next lanes to work on, using the fields stored
+  // on the root.
 
-  return readContextForConsumer(currentlyRenderingFiber, context);
-}
-function readContextDuringReconcilation(consumer, context, renderLanes) {
-  if (currentlyRenderingFiber === null) {
-    prepareToReadContext(consumer, renderLanes);
-  }
+  var lanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
+  );
 
-  return readContextForConsumer(consumer, context);
-}
+  if (lanes === NoLanes) {
+    // Defensive coding. This is never expected to happen.
+    return null;
+  } // We disable time-slicing in some cases: if the work has been CPU-bound
+  // for too long ("expired" work, to prevent starvation), or we're in
+  // sync-updates-by-default mode.
+  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
+  // bug we're still investigating. Once the bug in Scheduler is fixed,
+  // we can remove this, since we track expiration ourselves.
 
-function readContextForConsumer(consumer, context) {
-  var value = context._currentValue;
+  var shouldTimeSlice =
+    !includesBlockingLane(root, lanes) &&
+    !includesExpiredLane(root, lanes) &&
+    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
+  var exitStatus = shouldTimeSlice
+    ? renderRootConcurrent(root, lanes)
+    : renderRootSync(root, lanes);
 
-  if (lastFullyObservedContext === context);
-  else {
-    var contextItem = {
-      context: context,
-      memoizedValue: value,
-      next: null
-    };
+  if (exitStatus !== RootInProgress) {
+    if (exitStatus === RootErrored) {
+      // If something threw an error, try rendering one more time. We'll
+      // render synchronously to block concurrent data mutations, and we'll
+      // includes all pending updates are included. If it still fails after
+      // the second attempt, we'll give up and commit the resulting tree.
+      var originallyAttemptedLanes = lanes;
+      var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+        root,
+        originallyAttemptedLanes
+      );
 
-    if (lastContextDependency === null) {
-      if (consumer === null) {
-        throw new Error(
-          "Context can only be read while React is rendering. " +
-            "In classes, you can read it in the render method or getDerivedStateFromProps. " +
-            "In function components, you can read it directly in the function body, but not " +
-            "inside Hooks like useReducer() or useMemo()."
+      if (errorRetryLanes !== NoLanes) {
+        lanes = errorRetryLanes;
+        exitStatus = recoverFromConcurrentError(
+          root,
+          originallyAttemptedLanes,
+          errorRetryLanes
         );
-      } // This is the first dependency for this component. Create a new list.
-
-      lastContextDependency = contextItem;
-      consumer.dependencies = {
-        lanes: NoLanes,
-        firstContext: contextItem
-      };
-
-      if (enableLazyContextPropagation) {
-        consumer.flags |= NeedsPropagation;
       }
-    } else {
-      // Append a new context item.
-      lastContextDependency = lastContextDependency.next = contextItem;
     }
-  }
 
-  return value;
-}
+    if (exitStatus === RootFatalErrored) {
+      var fatalError = workInProgressRootFatalError;
+      prepareFreshStack(root, NoLanes);
+      markRootSuspended(root, lanes);
+      ensureRootIsScheduled(root, now$1());
+      throw fatalError;
+    }
 
-// replace it with a lightweight shim that only has the features we use.
+    if (exitStatus === RootDidNotComplete) {
+      // The render unwound without completing the tree. This happens in special
+      // cases where need to exit the current render without producing a
+      // consistent tree or committing.
+      markRootSuspended(root, lanes);
+    } else {
+      // The render completed.
+      // Check if this render may have yielded to a concurrent event, and if so,
+      // confirm that any newly rendered stores are consistent.
+      // TODO: It's possible that even a concurrent render may never have yielded
+      // to the main thread, if it was fast enough, or if it expired. We could
+      // skip the consistency check in that case, too.
+      var renderWasConcurrent = !includesBlockingLane(root, lanes);
+      var finishedWork = root.current.alternate;
 
-var AbortControllerLocal =
-  typeof AbortController !== "undefined"
-    ? AbortController // $FlowFixMe[missing-this-annot]
-    : function AbortControllerShim() {
-        var listeners = [];
-        var signal = (this.signal = {
-          aborted: false,
-          addEventListener: function (type, listener) {
-            listeners.push(listener);
-          }
-        });
+      if (
+        renderWasConcurrent &&
+        !isRenderConsistentWithExternalStores(finishedWork)
+      ) {
+        // A store was mutated in an interleaved event. Render again,
+        // synchronously, to block further mutations.
+        exitStatus = renderRootSync(root, lanes); // We need to check again if something threw
 
-        this.abort = function () {
-          signal.aborted = true;
-          listeners.forEach(function (listener) {
-            return listener();
-          });
-        };
-      }; // Intentionally not named imports because Rollup would
-// use dynamic dispatch for CommonJS interop named imports.
+        if (exitStatus === RootErrored) {
+          var _originallyAttemptedLanes = lanes;
 
-var scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
-  NormalPriority = Scheduler.unstable_NormalPriority;
-var CacheContext = {
-  $$typeof: REACT_CONTEXT_TYPE,
-  // We don't use Consumer/Provider for Cache components. So we'll cheat.
-  Consumer: null,
-  Provider: null,
-  // We'll initialize these at the root.
-  _currentValue: null,
-  _currentValue2: null,
-  _threadCount: 0,
-  _defaultValue: null,
-  _globalName: null
-};
+          var _errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+            root,
+            _originallyAttemptedLanes
+          );
 
-{
-  CacheContext._currentRenderer = null;
-  CacheContext._currentRenderer2 = null;
-} // Creates a new empty Cache instance with a ref-count of 0. The caller is responsible
-// for retaining the cache once it is in use (retainCache), and releasing the cache
-// once it is no longer needed (releaseCache).
+          if (_errorRetryLanes !== NoLanes) {
+            lanes = _errorRetryLanes;
+            exitStatus = recoverFromConcurrentError(
+              root,
+              _originallyAttemptedLanes,
+              _errorRetryLanes
+            ); // We assume the tree is now consistent because we didn't yield to any
+            // concurrent events.
+          }
+        }
 
-function createCache() {
-  var cache = {
-    controller: new AbortControllerLocal(),
-    data: new Map(),
-    refCount: 0
-  };
-  return cache;
-}
-function retainCache(cache) {
-  {
-    if (cache.controller.signal.aborted) {
-      warn(
-        "A cache instance was retained after it was already freed. " +
-          "This likely indicates a bug in React."
-      );
+        if (exitStatus === RootFatalErrored) {
+          var _fatalError = workInProgressRootFatalError;
+          prepareFreshStack(root, NoLanes);
+          markRootSuspended(root, lanes);
+          ensureRootIsScheduled(root, now$1());
+          throw _fatalError;
+        } // FIXME: Need to check for RootDidNotComplete again. The factoring here
+        // isn't ideal.
+      } // We now have a consistent tree. The next step is either to commit it,
+      // or, if something suspended, wait to commit it after a timeout.
+
+      root.finishedWork = finishedWork;
+      root.finishedLanes = lanes;
+      finishConcurrentRender(root, exitStatus, lanes);
     }
   }
 
-  cache.refCount++;
-} // Cleanup a cache instance, potentially freeing it if there are no more references
-
-function releaseCache(cache) {
-  cache.refCount--;
+  ensureRootIsScheduled(root, now$1());
 
-  {
-    if (cache.refCount < 0) {
-      warn(
-        "A cache instance was released after it was already freed. " +
-          "This likely indicates a bug in React."
-      );
-    }
+  if (root.callbackNode === originalCallbackNode) {
+    // The task node scheduled for this root is the same one that's
+    // currently executed. Need to return a continuation.
+    return performConcurrentWorkOnRoot.bind(null, root);
   }
 
-  if (cache.refCount === 0) {
-    scheduleCallback$1(NormalPriority, function () {
-      cache.controller.abort();
-    });
-  }
-}
-function pushCacheProvider(workInProgress, cache) {
-  pushProvider(workInProgress, CacheContext, cache);
-}
-function popCacheProvider(workInProgress, cache) {
-  popProvider(CacheContext, workInProgress);
+  return null;
 }
 
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig;
-var NoTransition = null;
-function requestCurrentTransition() {
-  return ReactCurrentBatchConfig$1.transition;
-} // When retrying a Suspense/Offscreen boundary, we restore the cache that was
-// used during the previous render by placing it here, on the stack.
-
-var resumedCache = createCursor(null); // During the render/synchronous commit phase, we don't actually process the
-// transitions. Therefore, we want to lazily combine transitions. Instead of
-// comparing the arrays of transitions when we combine them and storing them
-// and filtering out the duplicates, we will instead store the unprocessed transitions
-// in an array and actually filter them in the passive phase.
-
-var transitionStack = createCursor(null);
-
-function peekCacheFromPool() {
-  // If we're rendering inside a Suspense boundary that is currently hidden,
-  // we should use the same cache that we used during the previous render, if
-  // one exists.
+function recoverFromConcurrentError(
+  root,
+  originallyAttemptedLanes,
+  errorRetryLanes
+) {
+  // If an error occurred during hydration, discard server response and fall
+  // back to client side render.
+  // Before rendering again, save the errors from the previous attempt.
+  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
+  var wasRootDehydrated = isRootDehydrated(root);
 
-  var cacheResumedFromPreviousRender = resumedCache.current;
+  if (wasRootDehydrated) {
+    // The shell failed to hydrate. Set a flag to force a client rendering
+    // during the next attempt. To do this, we call prepareFreshStack now
+    // to create the root work-in-progress fiber. This is a bit weird in terms
+    // of factoring, because it relies on renderRootSync not calling
+    // prepareFreshStack again in the call below, which happens because the
+    // root and lanes haven't changed.
+    //
+    // TODO: I think what we should do is set ForceClientRender inside
+    // throwException, like we do for nested Suspense boundaries. The reason
+    // it's here instead is so we can switch to the synchronous work loop, too.
+    // Something to consider for a future refactor.
+    var rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
+    rootWorkInProgress.flags |= ForceClientRender;
 
-  if (cacheResumedFromPreviousRender !== null) {
-    return cacheResumedFromPreviousRender;
-  } // Otherwise, check the root's cache pool.
+    {
+      errorHydratingContainer(root.containerInfo);
+    }
+  }
 
-  var root = getWorkInProgressRoot();
-  var cacheFromRootCachePool = root.pooledCache;
-  return cacheFromRootCachePool;
-}
+  var exitStatus = renderRootSync(root, errorRetryLanes);
 
-function requestCacheFromPool(renderLanes) {
-  // Similar to previous function, except if there's not already a cache in the
-  // pool, we allocate a new one.
-  var cacheFromPool = peekCacheFromPool();
+  if (exitStatus !== RootErrored) {
+    // Successfully finished rendering on retry
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+      // During the synchronous render, we attached additional ping listeners.
+      // This is highly suggestive of an uncached promise (though it's not the
+      // only reason this would happen). If it was an uncached promise, then
+      // it may have masked a downstream error from ocurring without actually
+      // fixing it. Example:
+      //
+      //    use(Promise.resolve('uncached'))
+      //    throw new Error('Oops!')
+      //
+      // When this happens, there's a conflict between blocking potential
+      // concurrent data races and unwrapping uncached promise values. We
+      // have to choose one or the other. Because the data race recovery is
+      // a last ditch effort, we'll disable it.
+      root.errorRecoveryDisabledLanes = mergeLanes(
+        root.errorRecoveryDisabledLanes,
+        originallyAttemptedLanes
+      ); // Mark the current render as suspended and force it to restart. Once
+      // these lanes finish successfully, we'll re-enable the error recovery
+      // mechanism for subsequent updates.
 
-  if (cacheFromPool !== null) {
-    return cacheFromPool;
-  } // Create a fresh cache and add it to the root cache pool. A cache can have
-  // multiple owners:
-  // - A cache pool that lives on the FiberRoot. This is where all fresh caches
-  //   are originally created (TODO: except during refreshes, until we implement
-  //   this correctly). The root takes ownership immediately when the cache is
-  //   created. Conceptually, root.pooledCache is an Option<Arc<Cache>> (owned),
-  //   and the return value of this function is a &Arc<Cache> (borrowed).
-  // - One of several fiber types: host root, cache boundary, suspense
-  //   component. These retain and release in the commit phase.
+      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+      return RootSuspendedWithDelay;
+    } // The errors from the failed first attempt have been recovered. Add
+    // them to the collection of recoverable errors. We'll log them in the
+    // commit phase.
 
-  var root = getWorkInProgressRoot();
-  var freshCache = createCache();
-  root.pooledCache = freshCache;
-  retainCache(freshCache);
+    var errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
+    // from the first attempt, to preserve the causal sequence.
 
-  if (freshCache !== null) {
-    root.pooledCacheLanes |= renderLanes;
+    if (errorsFromSecondAttempt !== null) {
+      queueRecoverableErrors(errorsFromSecondAttempt);
+    }
   }
 
-  return freshCache;
-}
-function pushRootTransition(workInProgress, root, renderLanes) {
-  if (enableTransitionTracing) {
-    var rootTransitions = getWorkInProgressTransitions();
-    push(transitionStack, rootTransitions, workInProgress);
-  }
+  return exitStatus;
 }
-function popRootTransition(workInProgress, root, renderLanes) {
-  if (enableTransitionTracing) {
-    pop(transitionStack, workInProgress);
+
+function queueRecoverableErrors(errors) {
+  if (workInProgressRootRecoverableErrors === null) {
+    workInProgressRootRecoverableErrors = errors;
+  } else {
+    // $FlowFixMe[method-unbinding]
+    workInProgressRootRecoverableErrors.push.apply(
+      workInProgressRootRecoverableErrors,
+      errors
+    );
   }
 }
-function pushTransition(
-  offscreenWorkInProgress,
-  prevCachePool,
-  newTransitions
-) {
-  {
-    if (prevCachePool === null) {
-      push(resumedCache, resumedCache.current, offscreenWorkInProgress);
-    } else {
-      push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
+
+function finishConcurrentRender(root, exitStatus, lanes) {
+  switch (exitStatus) {
+    case RootInProgress:
+    case RootFatalErrored: {
+      throw new Error("Root did not complete. This is a bug in React.");
     }
-  }
+    // Flow knows about invariant, so it complains if I add a break
+    // statement, but eslint doesn't know about invariant, so it complains
+    // if I do. eslint-disable-next-line no-fallthrough
 
-  if (enableTransitionTracing) {
-    if (transitionStack.current === null) {
-      push(transitionStack, newTransitions, offscreenWorkInProgress);
-    } else if (newTransitions === null) {
-      push(transitionStack, transitionStack.current, offscreenWorkInProgress);
-    } else {
-      push(
-        transitionStack,
-        transitionStack.current.concat(newTransitions),
-        offscreenWorkInProgress
+    case RootErrored: {
+      // We should have already attempted to retry this tree. If we reached
+      // this point, it errored again. Commit it.
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
       );
-    }
-  }
-}
-function popTransition(workInProgress, current) {
-  if (current !== null) {
-    if (enableTransitionTracing) {
-      pop(transitionStack, workInProgress);
+      break;
     }
 
-    {
-      pop(resumedCache, workInProgress);
+    case RootSuspended: {
+      markRootSuspended(root, lanes); // We have an acceptable loading state. We need to figure out if we
+      // should immediately commit it or wait a bit.
+
+      if (
+        includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
+        !shouldForceFlushFallbacksInDEV()
+      ) {
+        // This render only included retries, no updates. Throttle committing
+        // retries so that we don't show too many loading states too quickly.
+        var msUntilTimeout =
+          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
+
+        if (msUntilTimeout > 10) {
+          var nextLanes = getNextLanes(root, NoLanes);
+
+          if (nextLanes !== NoLanes) {
+            // There's additional work on this root.
+            break;
+          } // The render is suspended, it hasn't timed out, and there's no
+          // lower priority work to do. Instead of committing the fallback
+          // immediately, wait for more data to arrive.
+
+          root.timeoutHandle = scheduleTimeout(
+            commitRoot.bind(
+              null,
+              root,
+              workInProgressRootRecoverableErrors,
+              workInProgressTransitions
+            ),
+            msUntilTimeout
+          );
+          break;
+        }
+      } // The work expired. Commit immediately.
+
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
     }
-  }
-}
-function getPendingTransitions() {
-  if (!enableTransitionTracing) {
-    return null;
-  }
 
-  return transitionStack.current;
-}
-function getSuspendedCache() {
-  // cache that would have been used to render fresh data during this render,
-  // if there was any, so that we can resume rendering with the same cache when
-  // we receive more data.
+    case RootSuspendedWithDelay: {
+      markRootSuspended(root, lanes);
 
-  var cacheFromPool = peekCacheFromPool();
+      if (includesOnlyTransitions(lanes)) {
+        // This is a transition, so we should exit without committing a
+        // placeholder and without scheduling a timeout. Delay indefinitely
+        // until we receive more data.
+        break;
+      }
 
-  if (cacheFromPool === null) {
-    return null;
-  }
+      if (!shouldForceFlushFallbacksInDEV()) {
+        // This is not a transition, but we did trigger an avoided state.
+        // Schedule a placeholder to display after a short delay, using the Just
+        // Noticeable Difference.
+        // TODO: Is the JND optimization worth the added complexity? If this is
+        // the only reason we track the event time, then probably not.
+        // Consider removing.
+        var mostRecentEventTime = getMostRecentEventTime(root, lanes);
+        var eventTimeMs = mostRecentEventTime;
+        var timeElapsedMs = now$1() - eventTimeMs;
 
-  return {
-    // We must also save the parent, so that when we resume we can detect
-    // a refresh.
-    parent: CacheContext._currentValue,
-    pool: cacheFromPool
-  };
-}
-function getOffscreenDeferredCache() {
-  var cacheFromPool = peekCacheFromPool();
+        var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
+
+        if (_msUntilTimeout > 10) {
+          // Instead of committing the fallback immediately, wait for more data
+          // to arrive.
+          root.timeoutHandle = scheduleTimeout(
+            commitRoot.bind(
+              null,
+              root,
+              workInProgressRootRecoverableErrors,
+              workInProgressTransitions
+            ),
+            _msUntilTimeout
+          );
+          break;
+        }
+      } // Commit the placeholder.
+
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
+    }
+
+    case RootCompleted: {
+      // The work completed. Ready to commit.
+      commitRoot(
+        root,
+        workInProgressRootRecoverableErrors,
+        workInProgressTransitions
+      );
+      break;
+    }
 
-  if (cacheFromPool === null) {
-    return null;
+    default: {
+      throw new Error("Unknown root exit status.");
+    }
   }
-
-  return {
-    // We must also store the parent, so that when we resume we can detect
-    // a refresh.
-    parent: CacheContext._currentValue,
-    pool: cacheFromPool
-  };
 }
 
-function getSuspenseFallbackChild(fiber) {
-  return fiber.child.sibling.child;
-}
+function isRenderConsistentWithExternalStores(finishedWork) {
+  // Search the rendered tree for external store reads, and check whether the
+  // stores were mutated in a concurrent event. Intentionally using an iterative
+  // loop instead of recursion so we can exit early.
+  var node = finishedWork;
 
-var emptyObject = {};
+  while (true) {
+    if (node.flags & StoreConsistency) {
+      var updateQueue = node.updateQueue;
 
-function collectScopedNodes(node, fn, scopedNodes) {
-  {
-    if (node.tag === HostComponent) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        stateNode = node.stateNode;
-      var instance = getPublicInstance(stateNode);
+      if (updateQueue !== null) {
+        var checks = updateQueue.stores;
 
-      if (
-        instance !== null &&
-        fn(type, memoizedProps || emptyObject, instance) === true
-      ) {
-        scopedNodes.push(instance);
+        if (checks !== null) {
+          for (var i = 0; i < checks.length; i++) {
+            var check = checks[i];
+            var getSnapshot = check.getSnapshot;
+            var renderedValue = check.value;
+
+            try {
+              if (!objectIs(getSnapshot(), renderedValue)) {
+                // Found an inconsistent store.
+                return false;
+              }
+            } catch (error) {
+              // If `getSnapshot` throws, return `false`. This will schedule
+              // a re-render, and the error will be rethrown during render.
+              return false;
+            }
+          }
+        }
       }
     }
 
     var child = node.child;
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
+    if (node.subtreeFlags & StoreConsistency && child !== null) {
+      child.return = node;
+      node = child;
+      continue;
     }
 
-    if (child !== null) {
-      collectScopedNodesFromChildren(child, fn, scopedNodes);
+    if (node === finishedWork) {
+      return true;
     }
-  }
-}
-
-function collectFirstScopedNode(node, fn) {
-  {
-    if (node.tag === HostComponent) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        stateNode = node.stateNode;
-      var instance = getPublicInstance(stateNode);
 
-      if (instance !== null && fn(type, memoizedProps, instance) === true) {
-        return instance;
+    while (node.sibling === null) {
+      if (node.return === null || node.return === finishedWork) {
+        return true;
       }
+
+      node = node.return;
     }
 
-    var child = node.child;
+    node.sibling.return = node.return;
+    node = node.sibling;
+  } // Flow doesn't know this is unreachable, but eslint does
+  // eslint-disable-next-line no-unreachable
 
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
-    }
+  return true;
+}
 
-    if (child !== null) {
-      return collectFirstScopedNodeFromChildren(child, fn);
-    }
+function markRootSuspended(root, suspendedLanes) {
+  // When suspending, we should always exclude lanes that were pinged or (more
+  // rarely, since we try to avoid it) updated during the render phase.
+  // TODO: Lol maybe there's a better way to factor this besides this
+  // obnoxiously named function :)
+  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
+  suspendedLanes = removeLanes(
+    suspendedLanes,
+    workInProgressRootInterleavedUpdatedLanes
+  );
+  markRootSuspended$1(root, suspendedLanes);
+} // This is the entry point for synchronous tasks that don't go
+// through Scheduler
+
+function performSyncWorkOnRoot(root) {
+  {
+    syncNestedUpdateFlag();
   }
 
-  return null;
-}
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
+  }
 
-function collectScopedNodesFromChildren(startingChild, fn, scopedNodes) {
-  var child = startingChild;
+  flushPassiveEffects();
+  var lanes = getNextLanes(root, NoLanes);
 
-  while (child !== null) {
-    collectScopedNodes(child, fn, scopedNodes);
-    child = child.sibling;
+  if (!includesSyncLane(lanes)) {
+    // There's no remaining sync work left.
+    ensureRootIsScheduled(root, now$1());
+    return null;
   }
-}
 
-function collectFirstScopedNodeFromChildren(startingChild, fn) {
-  var child = startingChild;
+  var exitStatus = renderRootSync(root, lanes);
 
-  while (child !== null) {
-    var scopedNode = collectFirstScopedNode(child, fn);
+  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
+    // If something threw an error, try rendering one more time. We'll render
+    // synchronously to block concurrent data mutations, and we'll includes
+    // all pending updates are included. If it still fails after the second
+    // attempt, we'll give up and commit the resulting tree.
+    var originallyAttemptedLanes = lanes;
+    var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+      root,
+      originallyAttemptedLanes
+    );
 
-    if (scopedNode !== null) {
-      return scopedNode;
+    if (errorRetryLanes !== NoLanes) {
+      lanes = errorRetryLanes;
+      exitStatus = recoverFromConcurrentError(
+        root,
+        originallyAttemptedLanes,
+        errorRetryLanes
+      );
     }
+  }
 
-    child = child.sibling;
+  if (exitStatus === RootFatalErrored) {
+    var fatalError = workInProgressRootFatalError;
+    prepareFreshStack(root, NoLanes);
+    markRootSuspended(root, lanes);
+    ensureRootIsScheduled(root, now$1());
+    throw fatalError;
   }
 
+  if (exitStatus === RootDidNotComplete) {
+    // The render unwound without completing the tree. This happens in special
+    // cases where need to exit the current render without producing a
+    // consistent tree or committing.
+    markRootSuspended(root, lanes);
+    ensureRootIsScheduled(root, now$1());
+    return null;
+  } // We now have a consistent tree. Because this is a sync render, we
+  // will commit it even if something suspended.
+
+  var finishedWork = root.current.alternate;
+  root.finishedWork = finishedWork;
+  root.finishedLanes = lanes;
+  commitRoot(
+    root,
+    workInProgressRootRecoverableErrors,
+    workInProgressTransitions
+  ); // Before exiting, make sure there's a callback scheduled for the next
+  // pending level.
+
+  ensureRootIsScheduled(root, now$1());
   return null;
 }
 
-function collectNearestContextValues(node, context, childContextValues) {
-  if (node.tag === ContextProvider && node.type._context === context) {
-    var contextValue = node.memoizedProps.value;
-    childContextValues.push(contextValue);
-  } else {
-    var child = node.child;
-
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
-    }
+function flushRoot(root, lanes) {
+  if (lanes !== NoLanes) {
+    markRootEntangled(root, mergeLanes(lanes, SyncLane));
+    ensureRootIsScheduled(root, now$1());
 
-    if (child !== null) {
-      collectNearestChildContextValues(child, context, childContextValues);
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      resetRenderTimer();
+      flushSyncCallbacks();
     }
   }
 }
-
-function collectNearestChildContextValues(
-  startingChild,
-  context,
-  childContextValues
-) {
-  var child = startingChild;
-
-  while (child !== null) {
-    collectNearestContextValues(child, context, childContextValues);
-    child = child.sibling;
-  }
+function getExecutionContext() {
+  return executionContext;
 }
+function batchedUpdates$1(fn, a) {
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
 
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
+  try {
+    return fn(a);
+  } finally {
+    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
+    // most batchedUpdates-like method.
 
-  if (currentFiber === null) {
-    return null;
+    if (
+      executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
+      !ReactCurrentActQueue.isBatchingLegacy
+    ) {
+      resetRenderTimer();
+      flushSyncCallbacksOnlyInLegacyMode();
+    }
   }
+}
+// Warning, this opts-out of checking the function body.
+// eslint-disable-next-line no-unused-vars
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
 
-  var child = currentFiber.child;
-  var scopedNodes = [];
-
-  if (child !== null) {
-    collectScopedNodesFromChildren(child, fn, scopedNodes);
+function flushSync$1(fn) {
+  // In legacy mode, we flush pending passive effects at the beginning of the
+  // next event, not at the end of the previous one.
+  if (
+    rootWithPendingPassiveEffects !== null &&
+    rootWithPendingPassiveEffects.tag === LegacyRoot &&
+    (executionContext & (RenderContext | CommitContext)) === NoContext
+  ) {
+    flushPassiveEffects();
   }
 
-  return scopedNodes.length === 0 ? null : scopedNodes;
-}
-
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+  var previousPriority = getCurrentUpdatePriority();
 
-  if (currentFiber === null) {
-    return null;
-  }
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
 
-  var child = currentFiber.child;
+    if (fn) {
+      return fn();
+    } else {
+      return undefined;
+    }
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
+    // Note that this will happen even if batchedUpdates is higher up
+    // the stack.
 
-  if (child !== null) {
-    return collectFirstScopedNodeFromChildren(child, fn);
+    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
+      flushSyncCallbacks();
+    }
   }
-
-  return null;
 }
+function isAlreadyRendering() {
+  // Used by the renderer to print a warning if certain APIs are called from
+  // the wrong context.
+  return (executionContext & (RenderContext | CommitContext)) !== NoContext;
+}
+function isInvalidExecutionContextForEventFunction() {
+  // Used to throw if certain APIs are called from the wrong context.
+  return (executionContext & RenderContext) !== NoContext;
+}
+function flushControlled(fn) {
+  var prevExecutionContext = executionContext;
+  executionContext |= BatchedContext;
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
+  var previousPriority = getCurrentUpdatePriority();
 
-function containsNode(node) {
-  var fiber = getInstanceFromNode(node);
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    fn();
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    executionContext = prevExecutionContext;
 
-  while (fiber !== null) {
-    if (fiber.tag === ScopeComponent && fiber.stateNode === this) {
-      return true;
+    if (executionContext === NoContext) {
+      // Flush the immediate callbacks that were scheduled during this batch
+      resetRenderTimer();
+      flushSyncCallbacks();
     }
-
-    fiber = fiber.return;
   }
+} // This is called by the HiddenContext module when we enter or leave a
+// hidden subtree. The stack logic is managed there because that's the only
+// place that ever modifies it. Which module it lives in doesn't matter for
+// performance because this function will get inlined regardless
 
-  return false;
+function setRenderLanes(subtreeRenderLanes) {
+  renderLanes = subtreeRenderLanes;
+}
+function getRenderLanes() {
+  return renderLanes;
 }
 
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
+function resetWorkInProgressStack() {
+  if (workInProgress === null) return;
+  var interruptedWork;
 
-  if (currentFiber === null) {
-    return [];
+  if (workInProgressSuspendedReason === NotSuspended) {
+    // Normal case. Work-in-progress hasn't started yet. Unwind all
+    // its parents.
+    interruptedWork = workInProgress.return;
+  } else {
+    // Work-in-progress is in suspended state. Reset the work loop and unwind
+    // both the suspended fiber and all its parents.
+    resetSuspendedWorkLoopOnUnwind();
+    interruptedWork = workInProgress;
   }
 
-  var child = currentFiber.child;
-  var childContextValues = [];
-
-  if (child !== null) {
-    collectNearestChildContextValues(child, context, childContextValues);
+  while (interruptedWork !== null) {
+    var current = interruptedWork.alternate;
+    unwindInterruptedWork(current, interruptedWork);
+    interruptedWork = interruptedWork.return;
   }
 
-  return childContextValues;
-}
-
-function createScopeInstance() {
-  return {
-    DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-    DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-    containsNode: containsNode,
-    getChildContextValues: getChildContextValues
-  };
-}
-
-function markUpdate(workInProgress) {
-  // Tag the fiber with an update effect. This turns a Placement into
-  // a PlacementAndUpdate.
-  workInProgress.flags |= Update;
-}
-
-function markRef(workInProgress) {
-  workInProgress.flags |= Ref | RefStatic;
+  workInProgress = null;
 }
 
-function appendAllChildren(
-  parent,
-  workInProgress,
-  needsVisibilityToggle,
-  isHidden
-) {
-  {
-    // We only have the top Fiber that was created but we need recurse down its
-    // children to find all the terminal nodes.
-    var node = workInProgress.child;
-
-    while (node !== null) {
-      if (node.tag === HostComponent || node.tag === HostText) {
-        appendInitialChild(parent, node.stateNode);
-      } else if (node.tag === HostPortal || node.tag === HostSingleton);
-      else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
-
-      if (node === workInProgress) {
-        return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
-
-      while (node.sibling === null) {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        if (node.return === null || node.return === workInProgress) {
-          return;
-        }
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
+  var timeoutHandle = root.timeoutHandle;
 
-        node = node.return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+  if (timeoutHandle !== noTimeout) {
+    // The root previous suspended and scheduled a timeout to commit a fallback
+    // state. Now that we have additional work, cancel the timeout.
+    root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
 
-      node.sibling.return = node.return;
-      node = node.sibling;
-    }
+    cancelTimeout(timeoutHandle);
   }
-} // An unfortunate fork of appendAllChildren because we have two different parent types.
 
-function updateHostComponent(current, workInProgress, type, newProps) {
-  {
-    // If we have an alternate, that means this is an update and we need to
-    // schedule a side-effect to do the updates.
-    var oldProps = current.memoizedProps;
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  var rootWorkInProgress = createWorkInProgress(root.current, null);
+  workInProgress = rootWorkInProgress;
+  workInProgressRootRenderLanes = renderLanes = lanes;
+  workInProgressSuspendedReason = NotSuspended;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = false;
+  workInProgressRootExitStatus = RootInProgress;
+  workInProgressRootFatalError = null;
+  workInProgressRootSkippedLanes = NoLanes;
+  workInProgressRootInterleavedUpdatedLanes = NoLanes;
+  workInProgressRootPingedLanes = NoLanes;
+  workInProgressRootConcurrentErrors = null;
+  workInProgressRootRecoverableErrors = null;
+  finishQueueingConcurrentUpdates();
 
-    if (oldProps === newProps) {
-      // In mutation mode, this is sufficient for a bailout because
-      // we won't touch this node even if children changed.
-      return;
-    } // If we get updated because one of our children updated, we don't
-    // have newProps so we'll have to reuse them.
-    // TODO: Split the update API as separate for the props vs. children.
-    // Even better would be if children weren't special cased at all tho.
+  {
+    ReactStrictModeWarnings.discardPendingWarnings();
+  }
 
-    var instance = workInProgress.stateNode;
-    var currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host
-    // component is hitting the resume path. Figure out why. Possibly
-    // related to `hidden`.
+  return rootWorkInProgress;
+}
 
-    var updatePayload = prepareUpdate(
-      instance,
-      type,
-      oldProps,
-      newProps,
-      currentHostContext
-    ); // TODO: Type this specific to this type of component.
+function resetSuspendedWorkLoopOnUnwind() {
+  // Reset module-level state that was set during the render phase.
+  resetContextDependencies();
+  resetHooksOnUnwind();
+  resetChildReconcilerOnUnwind();
+}
 
-    workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there
-    // is a new ref we mark this as an update. All the work is done in commitWork.
+function handleThrow(root, thrownValue) {
+  // A component threw an exception. Usually this is because it suspended, but
+  // it also includes regular program errors.
+  //
+  // We're either going to unwind the stack to show a Suspense or error
+  // boundary, or we're going to replay the component again. Like after a
+  // promise resolves.
+  //
+  // Until we decide whether we're going to unwind or replay, we should preserve
+  // the current state of the work loop without resetting anything.
+  //
+  // If we do decide to unwind the stack, module-level variables will be reset
+  // in resetSuspendedWorkLoopOnUnwind.
+  // These should be reset immediately because they're only supposed to be set
+  // when React is executing user code.
+  resetHooksAfterThrow();
+  resetCurrentFiber();
+  ReactCurrentOwner.current = null;
 
-    if (updatePayload) {
-      markUpdate(workInProgress);
-    }
+  if (thrownValue === SuspenseException) {
+    // This is a special type of exception used for Suspense. For historical
+    // reasons, the rest of the Suspense implementation expects the thrown value
+    // to be a thenable, because before `use` existed that was the (unstable)
+    // API for suspending. This implementation detail can change later, once we
+    // deprecate the old API in favor of `use`.
+    thrownValue = getSuspendedThenable();
+    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
+      ? SuspendedOnData
+      : SuspendedOnImmediate;
+  } else if (thrownValue === SelectiveHydrationException) {
+    // An update flowed into a dehydrated boundary. Before we can apply the
+    // update, we need to finish hydrating. Interrupt the work-in-progress
+    // render so we can restart at the hydration lane.
+    //
+    // The ideal implementation would be able to switch contexts without
+    // unwinding the current stack.
+    //
+    // We could name this something more general but as of now it's the only
+    // case where we think this should happen.
+    workInProgressSuspendedReason = SuspendedOnHydration;
+  } else {
+    // This is a regular error.
+    var isWakeable =
+      thrownValue !== null &&
+      typeof thrownValue === "object" &&
+      typeof thrownValue.then === "function";
+    workInProgressSuspendedReason = isWakeable // A wakeable object was thrown by a legacy Suspense implementation.
+      ? // This has slightly different behavior than suspending with `use`.
+        SuspendedOnDeprecatedThrowPromise // This is a regular error. If something earlier in the component already
+      : // suspended, we must clear the thenable state to unblock the work loop.
+        SuspendedOnError;
   }
-}
 
-function updateHostText(current, workInProgress, oldText, newText) {
-  {
-    // If the text differs, mark it as an update. All the work in done in commitWork.
-    if (oldText !== newText) {
-      markUpdate(workInProgress);
-    }
-  }
-}
+  workInProgressThrownValue = thrownValue;
+  var erroredWork = workInProgress;
 
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (getIsHydrating()) {
-    // If we're hydrating, we should consume as many items as we can
-    // so we don't leave any behind.
+  if (erroredWork === null) {
+    // This is a fatal error
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue;
     return;
   }
 
-  switch (renderState.tailMode) {
-    case "hidden": {
-      // Any insertions at the end of the tail list after this point
-      // should be invisible. If there are already mounted boundaries
-      // anything before them are not considered for collapsing.
-      // Therefore we need to go through the whole tail to find if
-      // there are any.
-      var tailNode = renderState.tail;
-      var lastTailNode = null;
-
-      while (tailNode !== null) {
-        if (tailNode.alternate !== null) {
-          lastTailNode = tailNode;
-        }
+  if (erroredWork.mode & ProfileMode) {
+    // Record the time spent rendering before an error was thrown. This
+    // avoids inaccurate Profiler durations in the case of a
+    // suspended render.
+    stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
+  }
 
-        tailNode = tailNode.sibling;
-      } // Next we're simply going to delete all insertions after the
-      // last rendered item.
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
 
-      if (lastTailNode === null) {
-        // All remaining items in the tail are insertions.
-        renderState.tail = null;
-      } else {
-        // Detach the insertion after the last node that was already
-        // inserted.
-        lastTailNode.sibling = null;
+    switch (workInProgressSuspendedReason) {
+      case SuspendedOnError: {
+        markComponentErrored(
+          erroredWork,
+          thrownValue,
+          workInProgressRootRenderLanes
+        );
+        break;
       }
 
-      break;
+      case SuspendedOnData:
+      case SuspendedOnImmediate:
+      case SuspendedOnDeprecatedThrowPromise:
+      case SuspendedAndReadyToContinue: {
+        var wakeable = thrownValue;
+        markComponentSuspended(
+          erroredWork,
+          wakeable,
+          workInProgressRootRenderLanes
+        );
+        break;
+      }
     }
+  }
+}
 
-    case "collapsed": {
-      // Any insertions at the end of the tail list after this point
-      // should be invisible. If there are already mounted boundaries
-      // anything before them are not considered for collapsing.
-      // Therefore we need to go through the whole tail to find if
-      // there are any.
-      var _tailNode = renderState.tail;
-      var _lastTailNode = null;
-
-      while (_tailNode !== null) {
-        if (_tailNode.alternate !== null) {
-          _lastTailNode = _tailNode;
-        }
+function shouldAttemptToSuspendUntilDataResolves() {
+  // Check if there are other pending updates that might possibly unblock this
+  // component from suspending. This mirrors the check in
+  // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
+  // TODO: Consider unwinding immediately, using the
+  // SuspendedOnHydration mechanism.
+  if (
+    includesNonIdleWork(workInProgressRootSkippedLanes) ||
+    includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)
+  ) {
+    // Suspend normally. renderDidSuspendDelayIfPossible will handle
+    // interrupting the work loop.
+    return false;
+  } // TODO: We should be able to remove the equivalent check in
+  // finishConcurrentRender, and rely just on this one.
 
-        _tailNode = _tailNode.sibling;
-      } // Next we're simply going to delete all insertions after the
-      // last rendered item.
+  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
+    // If we're rendering inside the "shell" of the app, it's better to suspend
+    // rendering and wait for the data to resolve. Otherwise, we should switch
+    // to a fallback and continue rendering.
+    return getShellBoundary() === null;
+  }
 
-      if (_lastTailNode === null) {
-        // All remaining items in the tail are insertions.
-        if (!hasRenderedATailFallback && renderState.tail !== null) {
-          // We suspended during the head. We want to show at least one
-          // row at the tail. So we'll keep on and cut off the rest.
-          renderState.tail.sibling = null;
-        } else {
-          renderState.tail = null;
-        }
-      } else {
-        // Detach the insertion after the last node that was already
-        // inserted.
-        _lastTailNode.sibling = null;
-      }
+  var handler = getSuspenseHandler();
 
-      break;
+  if (handler === null);
+  else {
+    if (includesOnlyRetries(workInProgressRootRenderLanes)) {
+      // During a retry, we can suspend rendering if the nearest Suspense boundary
+      // is the boundary of the "shell", because we're guaranteed not to block
+      // any new content from appearing.
+      return handler === getShellBoundary();
     }
-  }
-}
+  } // For all other Lanes besides Transitions and Retries, we should not wait
+  // for the data to load.
+  // TODO: We should wait during Offscreen prerendering, too.
 
-function bubbleProperties(completedWork) {
-  var didBailout =
-    completedWork.alternate !== null &&
-    completedWork.alternate.child === completedWork.child;
-  var newChildLanes = NoLanes;
-  var subtreeFlags = NoFlags$1;
+  return false;
+}
 
-  if (!didBailout) {
-    // Bubble up the earliest expiration time.
-    if ((completedWork.mode & ProfileMode) !== NoMode) {
-      // In profiling mode, resetChildExpirationTime is also used to reset
-      // profiler durations.
-      var actualDuration = completedWork.actualDuration;
-      var treeBaseDuration = completedWork.selfBaseDuration;
-      var child = completedWork.child;
+function pushDispatcher(container) {
+  prepareRendererToRender(container);
+  var prevDispatcher = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
 
-      while (child !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(child.lanes, child.childLanes)
-        );
-        subtreeFlags |= child.subtreeFlags;
-        subtreeFlags |= child.flags; // When a fiber is cloned, its actualDuration is reset to 0. This value will
-        // only be updated if work is done on the fiber (i.e. it doesn't bailout).
-        // When work is done, it should bubble to the parent's actualDuration. If
-        // the fiber has not been cloned though, (meaning no work was done), then
-        // this value will reflect the amount of time spent working on a previous
-        // render. In that case it should not bubble. We determine whether it was
-        // cloned by comparing the child pointer.
-        // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+  if (prevDispatcher === null) {
+    // The React isomorphic package does not include a default dispatcher.
+    // Instead the first renderer will lazily attach one, in order to give
+    // nicer error messages.
+    return ContextOnlyDispatcher;
+  } else {
+    return prevDispatcher;
+  }
+}
 
-        actualDuration += child.actualDuration; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+function popDispatcher(prevDispatcher) {
+  resetRendererAfterRender();
+  ReactCurrentDispatcher.current = prevDispatcher;
+}
 
-        treeBaseDuration += child.treeBaseDuration;
-        child = child.sibling;
-      }
+function pushCacheDispatcher() {
+  {
+    var prevCacheDispatcher = ReactCurrentCache.current;
+    ReactCurrentCache.current = DefaultCacheDispatcher;
+    return prevCacheDispatcher;
+  }
+}
 
-      completedWork.actualDuration = actualDuration;
-      completedWork.treeBaseDuration = treeBaseDuration;
-    } else {
-      var _child = completedWork.child;
+function popCacheDispatcher(prevCacheDispatcher) {
+  {
+    ReactCurrentCache.current = prevCacheDispatcher;
+  }
+}
 
-      while (_child !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child.lanes, _child.childLanes)
-        );
-        subtreeFlags |= _child.subtreeFlags;
-        subtreeFlags |= _child.flags; // Update the return pointer so the tree is consistent. This is a code
-        // smell because it assumes the commit phase is never concurrent with
-        // the render phase. Will address during refactor to alternate model.
+function markCommitTimeOfFallback() {
+  globalMostRecentFallbackTime = now$1();
+}
+function markSkippedUpdateLanes(lane) {
+  workInProgressRootSkippedLanes = mergeLanes(
+    lane,
+    workInProgressRootSkippedLanes
+  );
+}
+function renderDidSuspend() {
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootSuspended;
+  }
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
+  // this render.
 
-        _child.return = completedWork;
-        _child = _child.sibling;
-      }
-    }
+  if (
+    workInProgressRoot !== null &&
+    (includesNonIdleWork(workInProgressRootSkippedLanes) ||
+      includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))
+  ) {
+    // Mark the current render as suspended so that we switch to working on
+    // the updates that were skipped. Usually we only suspend at the end of
+    // the render phase.
+    // TODO: We should probably always mark the root as suspended immediately
+    // (inside this function), since by suspending at the end of the render
+    // phase introduces a potential mistake where we suspend lanes that were
+    // pinged or updated while we were rendering.
+    // TODO: Consider unwinding immediately, using the
+    // SuspendedOnHydration mechanism.
+    // $FlowFixMe[incompatible-call] need null check workInProgressRoot
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+  }
+}
+function renderDidError(error) {
+  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
+    workInProgressRootExitStatus = RootErrored;
+  }
 
-    completedWork.subtreeFlags |= subtreeFlags;
+  if (workInProgressRootConcurrentErrors === null) {
+    workInProgressRootConcurrentErrors = [error];
   } else {
-    // Bubble up the earliest expiration time.
-    if ((completedWork.mode & ProfileMode) !== NoMode) {
-      // In profiling mode, resetChildExpirationTime is also used to reset
-      // profiler durations.
-      var _treeBaseDuration = completedWork.selfBaseDuration;
-      var _child2 = completedWork.child;
-
-      while (_child2 !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child2.lanes, _child2.childLanes)
-        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
-        // so we should bubble those up even during a bailout. All the other
-        // flags have a lifetime only of a single render + commit, so we should
-        // ignore them.
-
-        subtreeFlags |= _child2.subtreeFlags & StaticMask;
-        subtreeFlags |= _child2.flags & StaticMask; // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+    workInProgressRootConcurrentErrors.push(error);
+  }
+} // Called during render to determine if anything has suspended.
+// Returns false if we're not sure.
 
-        _treeBaseDuration += _child2.treeBaseDuration;
-        _child2 = _child2.sibling;
-      }
+function renderHasNotSuspendedYet() {
+  // If something errored or completed, we can't really be sure,
+  // so those are false.
+  return workInProgressRootExitStatus === RootInProgress;
+} // TODO: Over time, this function and renderRootConcurrent have become more
+// and more similar. Not sure it makes sense to maintain forked paths. Consider
+// unifying them again.
 
-      completedWork.treeBaseDuration = _treeBaseDuration;
-    } else {
-      var _child3 = completedWork.child;
+function renderRootSync(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  var prevDispatcher = pushDispatcher(root.containerInfo);
+  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
 
-      while (_child3 !== null) {
-        newChildLanes = mergeLanes(
-          newChildLanes,
-          mergeLanes(_child3.lanes, _child3.childLanes)
-        ); // "Static" flags share the lifetime of the fiber/hook they belong to,
-        // so we should bubble those up even during a bailout. All the other
-        // flags have a lifetime only of a single render + commit, so we should
-        // ignore them.
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        var memoizedUpdaters = root.memoizedUpdaters;
 
-        subtreeFlags |= _child3.subtreeFlags & StaticMask;
-        subtreeFlags |= _child3.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code
-        // smell because it assumes the commit phase is never concurrent with
-        // the render phase. Will address during refactor to alternate model.
+        if (memoizedUpdaters.size > 0) {
+          restorePendingUpdaters(root, workInProgressRootRenderLanes);
+          memoizedUpdaters.clear();
+        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
+        // If we bailout on this work, we'll move them back (like above).
+        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
+        // That way we can keep the current update and future updates separate.
 
-        _child3.return = completedWork;
-        _child3 = _child3.sibling;
+        movePendingFibersToMemoized(root, lanes);
       }
     }
 
-    completedWork.subtreeFlags |= subtreeFlags;
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    prepareFreshStack(root, lanes);
   }
 
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
-}
-
-function completeDehydratedSuspenseBoundary(
-  current,
-  workInProgress,
-  nextState
-) {
-  if (
-    hasUnhydratedTailNodes() &&
-    (workInProgress.mode & ConcurrentMode) !== NoMode &&
-    (workInProgress.flags & DidCapture) === NoFlags$1
-  ) {
-    warnIfUnhydratedTailNodes(workInProgress);
-    resetHydrationState();
-    workInProgress.flags |= ForceClientRender | Incomplete | ShouldCapture;
-    return false;
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
+    }
   }
 
-  var wasHydrated = popHydrationState(workInProgress);
-
-  if (nextState !== null && nextState.dehydrated !== null) {
-    // We might be inside a hydration state the first time we're picking up this
-    // Suspense boundary, and also after we've reentered it for further hydration.
-    if (current === null) {
-      if (!wasHydrated) {
-        throw new Error(
-          "A dehydrated suspense component was completed without a hydrated node. " +
-            "This is probably a bug in React."
-        );
-      }
-
-      prepareToHydrateHostSuspenseInstance(workInProgress);
-      bubbleProperties(workInProgress);
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          var isTimedOutSuspense = nextState !== null;
+  outer: do {
+    try {
+      if (
+        workInProgressSuspendedReason !== NotSuspended &&
+        workInProgress !== null
+      ) {
+        // The work loop is suspended. During a synchronous render, we don't
+        // yield to the main thread. Immediately unwind the stack. This will
+        // trigger either a fallback or an error boundary.
+        // TODO: For discrete and "default" updates (anything that's not
+        // flushSync), we want to wait for the microtasks the flush before
+        // unwinding. Will probably implement this using renderRootConcurrent,
+        // or merge renderRootSync and renderRootConcurrent into the same
+        // function and fork the behavior some other way.
+        var unitOfWork = workInProgress;
+        var thrownValue = workInProgressThrownValue;
 
-          if (isTimedOutSuspense) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var primaryChildFragment = workInProgress.child;
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnHydration: {
+            // Selective hydration. An update flowed into a dehydrated tree.
+            // Interrupt the current render so the work loop can switch to the
+            // hydration lane.
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootDidNotComplete;
+            break outer;
+          }
 
-            if (primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                primaryChildFragment.treeBaseDuration;
-            }
+          default: {
+            // Continue with the normal work loop.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
           }
         }
       }
 
-      return false;
-    } else {
-      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration
-      // state since we're now exiting out of it. popHydrationState doesn't do that for us.
-      resetHydrationState();
+      workLoopSync();
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
+    }
+  } while (true);
 
-      if ((workInProgress.flags & DidCapture) === NoFlags$1) {
-        // This boundary did not suspend so it's now hydrated and unsuspended.
-        workInProgress.memoizedState = null;
-      } // If nothing suspended, we need to schedule an effect to mark this boundary
-      // as having hydrated so events know that they're free to be invoked.
-      // It's also a signal to replay events and the suspense callback.
-      // If something suspended, schedule an effect to attach retry listeners.
-      // So we might as well always mark this.
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
 
-      workInProgress.flags |= Update;
-      bubbleProperties(workInProgress);
+  if (workInProgress !== null) {
+    // This is a sync render, so we should have finished the whole tree.
+    throw new Error(
+      "Cannot commit an incomplete root. This error is likely caused by a " +
+        "bug in React. Please file an issue."
+    );
+  }
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          var _isTimedOutSuspense = nextState !== null;
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
+  }
 
-          if (_isTimedOutSuspense) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var _primaryChildFragment = workInProgress.child;
+  if (enableSchedulingProfiler) {
+    markRenderStopped();
+  } // Set this to null to indicate there's no in-progress render.
 
-            if (_primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                _primaryChildFragment.treeBaseDuration;
-            }
-          }
-        }
-      }
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
 
-      return false;
-    }
-  } else {
-    // Successfully completed this tree. If this was a forced client render,
-    // there may have been recoverable errors during first hydration
-    // attempt. If so, add them to a queue so we can log them in the
-    // commit phase.
-    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+} // The work loop is an extremely hot path. Tell Closure not to inline it.
 
-    return true;
+/** @noinline */
+
+function workLoopSync() {
+  // Perform work without checking if we need to yield between fiber.
+  while (workInProgress !== null) {
+    performUnitOfWork(workInProgress);
   }
 }
 
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
+function renderRootConcurrent(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= RenderContext;
+  var prevDispatcher = pushDispatcher(root.containerInfo);
+  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
+  // and prepare a fresh one. Otherwise we'll continue where we left off.
+
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+    {
+      if (isDevToolsPresent) {
+        var memoizedUpdaters = root.memoizedUpdaters;
+
+        if (memoizedUpdaters.size > 0) {
+          restorePendingUpdaters(root, workInProgressRootRenderLanes);
+          memoizedUpdaters.clear();
+        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
+        // If we bailout on this work, we'll move them back (like above).
+        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
+        // That way we can keep the current update and future updates separate.
 
-  popTreeContext(workInProgress);
+        movePendingFibersToMemoized(root, lanes);
+      }
+    }
 
-  switch (workInProgress.tag) {
-    case IndeterminateComponent:
-    case LazyComponent:
-    case SimpleMemoComponent:
-    case FunctionComponent:
-    case ForwardRef:
-    case Fragment:
-    case Mode:
-    case Profiler:
-    case ContextConsumer:
-    case MemoComponent:
-      bubbleProperties(workInProgress);
-      return null;
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
+    resetRenderTimer();
+    prepareFreshStack(root, lanes);
+  }
 
-    case ClassComponent: {
-      bubbleProperties(workInProgress);
-      return null;
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
     }
+  }
 
-    case HostRoot: {
-      var fiberRoot = workInProgress.stateNode;
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
 
-      if (enableTransitionTracing) {
-        var transitions = getWorkInProgressTransitions(); // We set the Passive flag here because if there are new transitions,
-        // we will need to schedule callbacks and process the transitions,
-        // which we do in the passive phase
+  outer: do {
+    try {
+      if (
+        workInProgressSuspendedReason !== NotSuspended &&
+        workInProgress !== null
+      ) {
+        // The work loop is suspended. We need to either unwind the stack or
+        // replay the suspended component.
+        var unitOfWork = workInProgress;
+        var thrownValue = workInProgressThrownValue;
 
-        if (transitions !== null) {
-          workInProgress.flags |= Passive$1;
-        }
-      }
+        switch (workInProgressSuspendedReason) {
+          case SuspendedOnError: {
+            // Unwind then continue with the normal work loop.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
+          }
 
-      {
-        var previousCache = null;
+          case SuspendedOnData: {
+            var thenable = thrownValue;
 
-        if (current !== null) {
-          previousCache = current.memoizedState.cache;
-        }
+            if (isThenableResolved(thenable)) {
+              // The data resolved. Try rendering the component again.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(unitOfWork);
+              break;
+            } // The work loop is suspended on data. We should wait for it to
+            // resolve before continuing to render.
+            // TODO: Handle the case where the promise resolves synchronously.
+            // Usually this is handled when we instrument the promise to add a
+            // `status` field, but if the promise already has a status, we won't
+            // have added a listener until right here.
 
-        var cache = workInProgress.memoizedState.cache;
+            var onResolution = function () {
+              // Check if the root is still suspended on this promise.
+              if (
+                workInProgressSuspendedReason === SuspendedOnData &&
+                workInProgressRoot === root
+              ) {
+                // Mark the root as ready to continue rendering.
+                workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+              } // Ensure the root is scheduled. We should do this even if we're
+              // currently working on a different root, so that we resume
+              // rendering later.
 
-        if (cache !== previousCache) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
-        }
+              ensureRootIsScheduled(root, now$1());
+            };
 
-        popCacheProvider(workInProgress);
-      }
+            thenable.then(onResolution, onResolution);
+            break outer;
+          }
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(workInProgress);
-      }
+          case SuspendedOnImmediate: {
+            // If this fiber just suspended, it's possible the data is already
+            // cached. Yield to the main thread to give it a chance to ping. If
+            // it does, we can retry immediately without unwinding the stack.
+            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+            break outer;
+          }
 
-      popRootTransition(workInProgress);
-      popHostContainer(workInProgress);
-      resetWorkInProgressVersions();
+          case SuspendedAndReadyToContinue: {
+            var _thenable = thrownValue;
 
-      if (fiberRoot.pendingContext) {
-        fiberRoot.context = fiberRoot.pendingContext;
-        fiberRoot.pendingContext = null;
-      }
+            if (isThenableResolved(_thenable)) {
+              // The data resolved. Try rendering the component again.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(unitOfWork);
+            } else {
+              // Otherwise, unwind then continue with the normal work loop.
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            }
 
-      if (current === null || current.child === null) {
-        // If we hydrated, pop so that we can delete any remaining children
-        // that weren't hydrated.
-        var wasHydrated = popHydrationState(workInProgress);
+            break;
+          }
 
-        if (wasHydrated) {
-          // If we hydrated, then we'll need to schedule an update for
-          // the commit side-effects on the root.
-          markUpdate(workInProgress);
-        } else {
-          if (current !== null) {
-            var prevState = current.memoizedState;
+          case SuspendedOnDeprecatedThrowPromise: {
+            // Suspended by an old implementation that uses the `throw promise`
+            // pattern. The newer replaying behavior can cause subtle issues
+            // like infinite ping loops. So we maintain the old behavior and
+            // always unwind.
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
+            break;
+          }
 
-            if (
-              // Check if this is a client root
-              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)
-              (workInProgress.flags & ForceClientRender) !== NoFlags$1
-            ) {
-              // Schedule an effect to clear this container at the start of the
-              // next commit. This handles the case of React rendering into a
-              // container with previous children. It's also safe to do for
-              // updates too, because current.child would only be null if the
-              // previous render was null (so the container would already
-              // be empty).
-              workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been
-              // recoverable errors during first hydration attempt. If so, add
-              // them to a queue so we can log them in the commit phase.
+          case SuspendedOnHydration: {
+            // Selective hydration. An update flowed into a dehydrated tree.
+            // Interrupt the current render so the work loop can switch to the
+            // hydration lane.
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootDidNotComplete;
+            break outer;
+          }
 
-              upgradeHydrationErrorsToRecoverable();
-            }
+          default: {
+            throw new Error(
+              "Unexpected SuspendedReason. This is a bug in React."
+            );
           }
         }
       }
-      bubbleProperties(workInProgress);
 
-      if (enableTransitionTracing) {
-        if ((workInProgress.subtreeFlags & Visibility) !== NoFlags$1) {
-          // If any of our suspense children toggle visibility, this means that
-          // the pending boundaries array needs to be updated, which we only
-          // do in the passive phase.
-          workInProgress.flags |= Passive$1;
-        }
+      if (true && ReactCurrentActQueue.current !== null) {
+        // `act` special case: If we're inside an `act` scope, don't consult
+        // `shouldYield`. Always keep working until the render is complete.
+        // This is not just an optimization: in a unit test environment, we
+        // can't trust the result of `shouldYield`, because the host I/O is
+        // likely mocked.
+        workLoopSync();
+      } else {
+        workLoopConcurrent();
       }
 
-      return null;
+      break;
+    } catch (thrownValue) {
+      handleThrow(root, thrownValue);
     }
+  } while (true);
 
-    case HostHoistable: {
-      {
-        var currentRef = current ? current.ref : null;
-
-        if (currentRef !== workInProgress.ref) {
-          markRef(workInProgress);
-        }
+  resetContextDependencies();
+  popDispatcher(prevDispatcher);
+  popCacheDispatcher(prevCacheDispatcher);
+  executionContext = prevExecutionContext;
 
-        if (
-          // We are mounting and must Update this Hoistable in this commit
-          current === null || // We are transitioning to, from, or between Hoistable Resources
-          // and require an update
-          current.memoizedState !== workInProgress.memoizedState
-        ) {
-          markUpdate(workInProgress);
-        } else if (workInProgress.memoizedState === null) {
-          // We may have props to update on the Hoistable instance. We use the
-          // updateHostComponent path becuase it produces the update queue
-          // we need for Hoistables
-          updateHostComponent(
-            current,
-            workInProgress,
-            workInProgress.type,
-            workInProgress.pendingProps
-          );
-        }
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
+  } // Check if the tree has completed.
 
-        bubbleProperties(workInProgress);
-        return null;
-      }
+  if (workInProgress !== null) {
+    // Still work remaining.
+    if (enableSchedulingProfiler) {
+      markRenderYielded();
     }
-    // eslint-disable-next-line-no-fallthrough
 
-    case HostSingleton: {
-      {
-        popHostContext(workInProgress);
-        var rootContainerInstance = getRootHostContainer();
-        var type = workInProgress.type;
+    return RootInProgress;
+  } else {
+    // Completed the tree.
+    if (enableSchedulingProfiler) {
+      markRenderStopped();
+    } // Set this to null to indicate there's no in-progress render.
 
-        if (current !== null && workInProgress.stateNode != null) {
-          updateHostComponent(current, workInProgress, type, newProps);
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
 
-          if (current.ref !== workInProgress.ref) {
-            markRef(workInProgress);
-          }
-        } else {
-          if (!newProps) {
-            if (workInProgress.stateNode === null) {
-              throw new Error(
-                "We must have new props for new mounts. This error is likely " +
-                  "caused by a bug in React. Please file an issue."
-              );
-            } // This can happen when we abort work.
+    finishQueueingConcurrentUpdates(); // Return the final exit status.
 
-            bubbleProperties(workInProgress);
-            return null;
-          }
+    return workInProgressRootExitStatus;
+  }
+}
+/** @noinline */
 
-          var currentHostContext = getHostContext();
+function workLoopConcurrent() {
+  // Perform work until Scheduler asks us to yield
+  while (workInProgress !== null && !shouldYield()) {
+    // $FlowFixMe[incompatible-call] found when upgrading Flow
+    performUnitOfWork(workInProgress);
+  }
+}
 
-          var _wasHydrated = popHydrationState(workInProgress);
+function performUnitOfWork(unitOfWork) {
+  // The current, flushed, state of this fiber is the alternate. 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 = unitOfWork.alternate;
+  setCurrentFiber(unitOfWork);
+  var next;
 
-          if (_wasHydrated) {
-            // We ignore the boolean indicating there is an updateQueue because
-            // it is used only to set text children and HostSingletons do not
-            // use them.
-            prepareToHydrateHostInstance(workInProgress, currentHostContext);
-          } else {
-            workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              rootContainerInstance,
-              currentHostContext,
-              true
-            );
-            markUpdate(workInProgress);
-          }
+  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
+    startProfilerTimer(unitOfWork);
+    next = beginWork(current, unitOfWork, renderLanes);
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } else {
+    next = beginWork(current, unitOfWork, renderLanes);
+  }
 
-          if (workInProgress.ref !== null) {
-            // If there is a ref on a host node we need to schedule a callback
-            markRef(workInProgress);
-          }
-        }
+  resetCurrentFiber();
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
 
-        bubbleProperties(workInProgress);
-        return null;
-      }
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
+
+  ReactCurrentOwner.current = null;
+}
+
+function replaySuspendedUnitOfWork(unitOfWork) {
+  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
+  // just suspended.
+  //
+  var current = unitOfWork.alternate;
+  setCurrentFiber(unitOfWork);
+  var next;
+  setCurrentFiber(unitOfWork);
+  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+
+  if (isProfilingMode) {
+    startProfilerTimer(unitOfWork);
+  }
+
+  switch (unitOfWork.tag) {
+    case IndeterminateComponent: {
+      // Because it suspended with `use`, we can assume it's a
+      // function component.
+      unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
     }
-    // eslint-disable-next-line-no-fallthrough
+    // eslint-disable-next-line no-fallthrough
 
-    case HostComponent: {
-      popHostContext(workInProgress);
-      var _type = workInProgress.type;
+    case FunctionComponent:
+    case ForwardRef: {
+      // Resolve `defaultProps`. This logic is copied from `beginWork`.
+      // TODO: Consider moving this switch statement into that module. Also,
+      // could maybe use this as an opportunity to say `use` doesn't work with
+      // `defaultProps` :)
+      var Component = unitOfWork.type;
+      var unresolvedProps = unitOfWork.pendingProps;
+      var resolvedProps =
+        unitOfWork.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      next = replayFunctionComponent(
+        current,
+        unitOfWork,
+        resolvedProps,
+        Component,
+        workInProgressRootRenderLanes
+      );
+      break;
+    }
 
-      if (current !== null && workInProgress.stateNode != null) {
-        updateHostComponent(current, workInProgress, _type, newProps);
+    case SimpleMemoComponent: {
+      var _Component = unitOfWork.type;
+      var nextProps = unitOfWork.pendingProps;
+      next = replayFunctionComponent(
+        current,
+        unitOfWork,
+        nextProps,
+        _Component,
+        workInProgressRootRenderLanes
+      );
+      break;
+    }
 
-        if (current.ref !== workInProgress.ref) {
-          markRef(workInProgress);
-        }
-      } else {
-        if (!newProps) {
-          if (workInProgress.stateNode === null) {
-            throw new Error(
-              "We must have new props for new mounts. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          } // This can happen when we abort work.
+    default: {
+      // Other types besides function components are reset completely before
+      // being replayed. Currently this only happens when a Usable type is
+      // reconciled — the reconciler will suspend.
+      //
+      // We reset the fiber back to its original state; however, this isn't
+      // a full "unwind" because we're going to reuse the promises that were
+      // reconciled previously. So it's intentional that we don't call
+      // resetSuspendedWorkLoopOnUnwind here.
+      unwindInterruptedWork(current, unitOfWork);
+      unitOfWork = workInProgress = resetWorkInProgress(
+        unitOfWork,
+        renderLanes
+      );
+      next = beginWork(current, unitOfWork, renderLanes);
+      break;
+    }
+  }
 
-          bubbleProperties(workInProgress);
-          return null;
-        }
+  if (isProfilingMode) {
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } // The begin phase finished successfully without suspending. Return to the
+  // normal work loop.
 
-        var _currentHostContext2 = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context
-        // "stack" as the parent. Then append children as we go in beginWork
-        // or completeWork depending on whether we want to add them top->down or
-        // bottom->up. Top->down is faster in IE11.
+  resetCurrentFiber();
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
 
-        var _wasHydrated2 = popHydrationState(workInProgress);
+  if (next === null) {
+    // If this doesn't spawn new work, complete the current work.
+    completeUnitOfWork(unitOfWork);
+  } else {
+    workInProgress = next;
+  }
 
-        if (_wasHydrated2) {
-          // TODO: Move this and createInstance step into the beginPhase
-          // to consolidate.
-          if (
-            prepareToHydrateHostInstance(workInProgress, _currentHostContext2)
-          ) {
-            // If changes to the hydrated node need to be applied at the
-            // commit-phase we mark this as such.
-            markUpdate(workInProgress);
-          }
-        } else {
-          var _rootContainerInstance = getRootHostContainer();
+  ReactCurrentOwner.current = null;
+}
 
-          var instance = createInstance(
-            _type,
-            newProps,
-            _rootContainerInstance,
-            _currentHostContext2,
-            workInProgress
-          );
-          appendAllChildren(instance, workInProgress);
-          workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.
-          // (eg DOM renderer supports auto-focus for certain elements).
-          // Make sure such renderers get scheduled for later work.
+function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
+  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
+  // that threw an exception.
+  //
+  // Return to the normal work loop. This will unwind the stack, and potentially
+  // result in showing a fallback.
+  resetSuspendedWorkLoopOnUnwind();
+  var returnFiber = unitOfWork.return;
 
-          if (finalizeInitialChildren(instance, _type, newProps)) {
-            markUpdate(workInProgress);
-          }
-        }
+  if (returnFiber === null || workInProgressRoot === null) {
+    // Expected to be working on a non-root fiber. This is a fatal error
+    // because there's no ancestor that can handle it; the root is
+    // supposed to capture all errors that weren't caught by an error
+    // boundary.
+    workInProgressRootExitStatus = RootFatalErrored;
+    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
+    // sibling, or the parent if there are no siblings. But since the root
+    // has no siblings nor a parent, we set it to null. Usually this is
+    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
+    // intentionally not calling those, we need set it here.
+    // TODO: Consider calling `unwindWork` to pop the contexts.
+
+    workInProgress = null;
+    return;
+  }
+
+  try {
+    // Find and mark the nearest Suspense or error boundary that can handle
+    // this "exception".
+    throwException(
+      workInProgressRoot,
+      returnFiber,
+      unitOfWork,
+      thrownValue,
+      workInProgressRootRenderLanes
+    );
+  } catch (error) {
+    // We had trouble processing the error. An example of this happening is
+    // when accessing the `componentDidCatch` property of an error boundary
+    // throws an error. A weird edge case. There's a regression test for this.
+    // To prevent an infinite loop, bubble the error up to the next parent.
+    workInProgress = returnFiber;
+    throw error;
+  } // Return to the normal work loop.
 
-        if (workInProgress.ref !== null) {
-          // If there is a ref on a host node we need to schedule a callback
-          markRef(workInProgress);
-        }
-      }
+  completeUnitOfWork(unitOfWork);
+}
 
-      bubbleProperties(workInProgress);
-      return null;
-    }
+function completeUnitOfWork(unitOfWork) {
+  // Attempt to complete the current unit of work, then move to the next
+  // sibling. If there are no more siblings, return to the parent fiber.
+  var completedWork = unitOfWork;
 
-    case HostText: {
-      var newText = newProps;
+  do {
+    // The current, flushed, state of this fiber is the alternate. 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 = completedWork.alternate;
+    var returnFiber = completedWork.return; // Check if the work completed or if something threw.
 
-      if (current && workInProgress.stateNode != null) {
-        var oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need
-        // to schedule a side-effect to do the updates.
+    if ((completedWork.flags & Incomplete) === NoFlags$1) {
+      setCurrentFiber(completedWork);
+      var next = void 0;
 
-        updateHostText(current, workInProgress, oldText, newText);
+      if ((completedWork.mode & ProfileMode) === NoMode) {
+        next = completeWork(current, completedWork, renderLanes);
       } else {
-        if (typeof newText !== "string") {
-          if (workInProgress.stateNode === null) {
-            throw new Error(
-              "We must have new props for new mounts. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          } // This can happen when we abort work.
-        }
+        startProfilerTimer(completedWork);
+        next = completeWork(current, completedWork, renderLanes); // Update render duration assuming we didn't error.
 
-        var _rootContainerInstance2 = getRootHostContainer();
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
+      }
 
-        var _currentHostContext3 = getHostContext();
+      resetCurrentFiber();
 
-        var _wasHydrated3 = popHydrationState(workInProgress);
+      if (next !== null) {
+        // Completing this fiber spawned new work. Work on that next.
+        workInProgress = next;
+        return;
+      }
+    } else {
+      // This fiber did not complete because something threw. Pop values off
+      // the stack without entering the complete phase. If this is a boundary,
+      // capture values if possible.
+      var _next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.
 
-        if (_wasHydrated3) {
-          if (prepareToHydrateHostTextInstance(workInProgress)) {
-            markUpdate(workInProgress);
-          }
-        } else {
-          workInProgress.stateNode = createTextInstance(
-            newText,
-            _rootContainerInstance2,
-            _currentHostContext3,
-            workInProgress
-          );
-        }
+      if (_next !== null) {
+        // 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
+        // from the effect tag.
+        _next.flags &= HostEffectMask;
+        workInProgress = _next;
+        return;
       }
 
-      bubbleProperties(workInProgress);
-      return null;
-    }
+      if ((completedWork.mode & ProfileMode) !== NoMode) {
+        // Record the render duration for the fiber that errored.
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
 
-    case SuspenseComponent: {
-      popSuspenseHandler(workInProgress);
-      var nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this
-      // to its own fiber type so that we can add other kinds of hydration
-      // boundaries that aren't associated with a Suspense tree. In anticipation
-      // of such a refactor, all the hydration logic is contained in
-      // this branch.
+        var actualDuration = completedWork.actualDuration;
+        var child = completedWork.child;
 
-      if (
-        current === null ||
-        (current.memoizedState !== null &&
-          current.memoizedState.dehydrated !== null)
-      ) {
-        var fallthroughToNormalSuspensePath =
-          completeDehydratedSuspenseBoundary(
-            current,
-            workInProgress,
-            nextState
-          );
+        while (child !== null) {
+          // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
+          actualDuration += child.actualDuration;
+          child = child.sibling;
+        }
 
-        if (!fallthroughToNormalSuspensePath) {
-          if (workInProgress.flags & ShouldCapture) {
-            // Special case. There were remaining unhydrated nodes. We treat
-            // this as a mismatch. Revert to client rendering.
-            return workInProgress;
-          } else {
-            // Did not finish hydrating, either because this is the initial
-            // render or because something suspended.
-            return null;
-          }
-        } // Continue with the normal Suspense path.
+        completedWork.actualDuration = actualDuration;
       }
 
-      if ((workInProgress.flags & DidCapture) !== NoFlags$1) {
-        // Something suspended. Re-render with the fallback children.
-        workInProgress.lanes = renderLanes; // Do not reset the effect list.
-
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        } // Don't bubble properties in this case.
-
-        return workInProgress;
+      if (returnFiber !== null) {
+        // Mark the parent fiber as incomplete and clear its subtree flags.
+        returnFiber.flags |= Incomplete;
+        returnFiber.subtreeFlags = NoFlags$1;
+        returnFiber.deletions = null;
+      } else {
+        // We've unwound all the way to the root.
+        workInProgressRootExitStatus = RootDidNotComplete;
+        workInProgress = null;
+        return;
       }
+    }
 
-      var nextDidTimeout = nextState !== null;
-      var prevDidTimeout = current !== null && current.memoizedState !== null;
+    var siblingFiber = completedWork.sibling;
 
-      if (nextDidTimeout) {
-        var offscreenFiber = workInProgress.child;
-        var _previousCache = null;
+    if (siblingFiber !== null) {
+      // If there is more work to do in this returnFiber, do that next.
+      workInProgress = siblingFiber;
+      return;
+    } // Otherwise, return to the parent
+    // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-        if (
-          offscreenFiber.alternate !== null &&
-          offscreenFiber.alternate.memoizedState !== null &&
-          offscreenFiber.alternate.memoizedState.cachePool !== null
-        ) {
-          _previousCache =
-            offscreenFiber.alternate.memoizedState.cachePool.pool;
-        }
+    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
 
-        var _cache = null;
+    workInProgress = completedWork;
+  } while (completedWork !== null); // We've reached the root.
 
-        if (
-          offscreenFiber.memoizedState !== null &&
-          offscreenFiber.memoizedState.cachePool !== null
-        ) {
-          _cache = offscreenFiber.memoizedState.cachePool.pool;
-        }
+  if (workInProgressRootExitStatus === RootInProgress) {
+    workInProgressRootExitStatus = RootCompleted;
+  }
+}
 
-        if (_cache !== _previousCache) {
-          // Run passive effects to retain/release the cache.
-          offscreenFiber.flags |= Passive$1;
-        }
-      } // If the suspended state of the boundary changes, we need to schedule
-      // a passive effect, which is when we process the transitions
+function commitRoot(root, recoverableErrors, transitions) {
+  // TODO: This no longer makes any sense. We already wrap the mutation and
+  // layout phases. Should be able to remove.
+  var previousUpdateLanePriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig$1.transition;
 
-      if (nextDidTimeout !== prevDidTimeout) {
-        if (enableTransitionTracing) {
-          var _offscreenFiber = workInProgress.child;
-          _offscreenFiber.flags |= Passive$1;
-        } // If the suspended state of the boundary changes, we need to schedule
-        // an effect to toggle the subtree's visibility. When we switch from
-        // fallback -> primary, the inner Offscreen fiber schedules this effect
-        // as part of its normal complete phase. But when we switch from
-        // primary -> fallback, the inner Offscreen fiber does not have a complete
-        // phase. So we need to schedule its effect here.
-        //
-        // We also use this flag to connect/disconnect the effects, but the same
-        // logic applies: when re-connecting, the Offscreen fiber's complete
-        // phase will handle scheduling the effect. It's only when the fallback
-        // is active that we have to do anything special.
+  try {
+    ReactCurrentBatchConfig$1.transition = null;
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    commitRootImpl(
+      root,
+      recoverableErrors,
+      transitions,
+      previousUpdateLanePriority
+    );
+  } finally {
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+    setCurrentUpdatePriority(previousUpdateLanePriority);
+  }
 
-        if (nextDidTimeout) {
-          var _offscreenFiber2 = workInProgress.child;
-          _offscreenFiber2.flags |= Visibility;
-        }
-      }
+  return null;
+}
 
-      var wakeables = workInProgress.updateQueue;
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
+) {
+  do {
+    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
+    // means `flushPassiveEffects` will sometimes result in additional
+    // passive effects. So we need to keep flushing in a loop until there are
+    // no more pending effects.
+    // TODO: Might be better if `flushPassiveEffects` did not automatically
+    // flush synchronous work at the end, to avoid factoring hazards like this.
+    flushPassiveEffects();
+  } while (rootWithPendingPassiveEffects !== null);
 
-      if (wakeables !== null) {
-        // Schedule an effect to attach a retry listener to the promise.
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+  flushRenderPhaseStrictModeWarningsInDEV();
 
-      if (
-        workInProgress.updateQueue !== null &&
-        workInProgress.memoizedProps.suspenseCallback != null
-      ) {
-        // Always notify the callback
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Should not already be working.");
+  }
 
-      bubbleProperties(workInProgress);
+  var finishedWork = root.finishedWork;
+  var lanes = root.finishedLanes;
 
-      {
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          if (nextDidTimeout) {
-            // Don't count time spent in a timed out Suspense subtree as part of the base duration.
-            var primaryChildFragment = workInProgress.child;
+  {
+    if (enableDebugTracing) {
+      logCommitStarted(lanes);
+    }
+  }
 
-            if (primaryChildFragment !== null) {
-              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
-              workInProgress.treeBaseDuration -=
-                primaryChildFragment.treeBaseDuration;
-            }
-          }
-        }
-      }
+  if (enableSchedulingProfiler) {
+    markCommitStarted(lanes);
+  }
 
-      return null;
+  if (finishedWork === null) {
+    {
+      if (enableDebugTracing) {
+        logCommitStopped();
+      }
     }
 
-    case HostPortal:
-      popHostContainer(workInProgress);
+    if (enableSchedulingProfiler) {
+      markCommitStopped();
+    }
 
-      if (current === null) {
-        preparePortalMount(workInProgress.stateNode.containerInfo);
+    return null;
+  } else {
+    {
+      if (lanes === NoLanes) {
+        error(
+          "root.finishedLanes should not be empty during a commit. This is a " +
+            "bug in React."
+        );
       }
+    }
+  }
 
-      bubbleProperties(workInProgress);
-      return null;
+  root.finishedWork = null;
+  root.finishedLanes = NoLanes;
 
-    case ContextProvider:
-      // Pop provider fiber
-      var context = workInProgress.type._context;
-      popProvider(context, workInProgress);
-      bubbleProperties(workInProgress);
-      return null;
+  if (finishedWork === root.current) {
+    throw new Error(
+      "Cannot commit the same tree as before. This error is likely caused by " +
+        "a bug in React. Please file an issue."
+    );
+  } // commitRoot never returns a continuation; it always finishes synchronously.
+  // So we can clear these now to allow a new callback to be scheduled.
 
-    case IncompleteClassComponent: {
-      bubbleProperties(workInProgress);
-      return null;
-    }
+  root.callbackNode = null;
+  root.callbackPriority = NoLane; // Check which lanes no longer have any work scheduled on them, and mark
+  // those as finished.
 
-    case SuspenseListComponent: {
-      popSuspenseListContext(workInProgress);
-      var renderState = workInProgress.memoizedState;
+  var remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
+  // during the render phase; don't mark them as finished.
 
-      if (renderState === null) {
-        // We're running in the default, "independent" mode.
-        // We don't do anything in this mode.
-        bubbleProperties(workInProgress);
-        return null;
-      }
+  var concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
+  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
+  markRootFinished(root, remainingLanes);
 
-      var didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags$1;
-      var renderedTail = renderState.rendering;
+  if (root === workInProgressRoot) {
+    // We can reset these now that they are finished.
+    workInProgressRoot = null;
+    workInProgress = null;
+    workInProgressRootRenderLanes = NoLanes;
+  } // If there are pending passive effects, schedule a callback to process them.
+  // Do this as early as possible, so it is queued before anything else that
+  // might get scheduled in the commit phase. (See #16714.)
+  // TODO: Delete all other places that schedule the passive effect callback
+  // They're redundant.
 
-      if (renderedTail === null) {
-        // We just rendered the head.
-        if (!didSuspendAlready) {
-          // This is the first pass. We need to figure out if anything is still
-          // suspended in the rendered set.
-          // If new content unsuspended, but there's still some content that
-          // didn't. Then we need to do a second pass that forces everything
-          // to keep showing their fallbacks.
-          // We might be suspended if something in this render pass suspended, or
-          // something in the previous committed pass suspended. Otherwise,
-          // there's no chance so we can skip the expensive call to
-          // findFirstSuspended.
-          var cannotBeSuspended =
-            renderHasNotSuspendedYet() &&
-            (current === null || (current.flags & DidCapture) === NoFlags$1);
+  if (
+    (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 ||
+    (finishedWork.flags & PassiveMask) !== NoFlags$1
+  ) {
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
+      // to store it in pendingPassiveTransitions until they get processed
+      // We need to pass this through as an argument to commitRoot
+      // because workInProgressTransitions might have changed between
+      // the previous render and commit if we throttle the commit
+      // with setTimeout
 
-          if (!cannotBeSuspended) {
-            var row = workInProgress.child;
+      pendingPassiveTransitions = transitions;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
+        // *after* passive effects fire to avoid freeing a cache pool that may
+        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
 
-            while (row !== null) {
-              var suspended = findFirstSuspended(row);
+        return null;
+      });
+    }
+  } // Check if there are any effects in the whole tree.
+  // TODO: This is left over from the effect list implementation, where we had
+  // to check for the existence of `firstEffect` to satisfy Flow. I think the
+  // only other reason this optimization exists is because it affects profiling.
+  // Reconsider whether this is necessary.
 
-              if (suspended !== null) {
-                didSuspendAlready = true;
-                workInProgress.flags |= DidCapture;
-                cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as
-                // part of the second pass. In that case nothing will subscribe to
-                // its thenables. Instead, we'll transfer its thenables to the
-                // SuspenseList so that it can retry if they resolve.
-                // There might be multiple of these in the list but since we're
-                // going to wait for all of them anyway, it doesn't really matter
-                // which ones gets to ping. In theory we could get clever and keep
-                // track of how many dependencies remain but it gets tricky because
-                // in the meantime, we can add/remove/change items and dependencies.
-                // We might bail out of the loop before finding any but that
-                // doesn't matter since that means that the other boundaries that
-                // we did find already has their listeners attached.
+  var subtreeHasEffects =
+    (finishedWork.subtreeFlags &
+      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
+    NoFlags$1;
+  var rootHasEffect =
+    (finishedWork.flags &
+      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
+    NoFlags$1;
 
-                var newThenables = suspended.updateQueue;
+  if (subtreeHasEffects || rootHasEffect) {
+    var prevTransition = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = getCurrentUpdatePriority();
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    var prevExecutionContext = executionContext;
+    executionContext |= CommitContext; // Reset this to null before calling lifecycles
 
-                if (newThenables !== null) {
-                  workInProgress.updateQueue = newThenables;
-                  workInProgress.flags |= Update;
-                } // Rerender the whole list, but this time, we'll force fallbacks
-                // to stay in place.
-                // Reset the effect flags before doing the second pass since that's now invalid.
-                // Reset the child fibers to their original state.
+    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
+    // of the effect list for each phase: all mutation effects come before all
+    // layout effects, and so on.
+    // The first phase a "before mutation" phase. We use this phase to read the
+    // state of the host tree right before we mutate it. This is where
+    // getSnapshotBeforeUpdate is called.
 
-                workInProgress.subtreeFlags = NoFlags$1;
-                resetChildFibers(workInProgress, renderLanes); // Set up the Suspense List Context to force suspense and
-                // immediately rerender the children.
+    var shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
 
-                pushSuspenseListContext(
-                  workInProgress,
-                  setShallowSuspenseListContext(
-                    suspenseStackCursor.current,
-                    ForceSuspenseFallback
-                  )
-                ); // Don't bubble properties in this case.
+    {
+      // Mark the current commit time to be shared by all Profilers in this
+      // batch. This enables them to be grouped later.
+      recordCommitTime();
+    }
 
-                return workInProgress.child;
-              }
+    if (enableProfilerNestedUpdateScheduledHook) {
+      // Track the root here, rather than in commitLayoutEffects(), because of ref setters.
+      // Updates scheduled during ref detachment should also be flagged.
+      rootCommittingMutationOrLayoutEffects = root;
+    } // The next phase is the mutation phase, where we mutate the host tree.
 
-              row = row.sibling;
-            }
-          }
+    commitMutationEffects(root, finishedWork, lanes);
 
-          if (renderState.tail !== null && now$1() > getRenderTargetTime()) {
-            // We have already passed our CPU deadline but we still have rows
-            // left in the tail. We'll just give up further attempts to render
-            // the main content and only render fallbacks.
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true;
-            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
-            // to get it started back up to attempt the next item. While in terms
-            // of priority this work has the same priority as this current render,
-            // it's not part of the same transition once the transition has
-            // committed. If it's sync, we still want to yield so that it can be
-            // painted. Conceptually, this is really the same as pinging.
-            // We can use any RetryLane even if it's the one currently rendering
-            // since we're leaving it behind on this node.
+    {
+      if (shouldFireAfterActiveInstanceBlur) {
+        afterActiveInstanceBlur();
+      }
+    }
+
+    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
+    // the mutation phase, so that the previous tree is still current during
+    // componentWillUnmount, but before the layout phase, so that the finished
+    // work is current during componentDidMount/Update.
+
+    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
+    // the host tree after it's been mutated. The idiomatic use case for this is
+    // layout, but class component lifecycles also fire here for legacy reasons.
+
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStarted(lanes);
+      }
+    }
 
-            workInProgress.lanes = SomeRetryLane;
-          }
-        } else {
-          cutOffTailIfNeeded(renderState, false);
-        } // Next we're going to render the tail.
-      } else {
-        // Append the rendered row to the child list.
-        if (!didSuspendAlready) {
-          var _suspended = findFirstSuspended(renderedTail);
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStarted(lanes);
+    }
 
-          if (_suspended !== null) {
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't
-            // get lost if this row ends up dropped during a second pass.
+    commitLayoutEffects(finishedWork, root, lanes);
 
-            var _newThenables = _suspended.updateQueue;
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStopped();
+      }
+    }
 
-            if (_newThenables !== null) {
-              workInProgress.updateQueue = _newThenables;
-              workInProgress.flags |= Update;
-            }
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStopped();
+    }
 
-            cutOffTailIfNeeded(renderState, true); // This might have been modified.
+    if (enableProfilerNestedUpdateScheduledHook) {
+      rootCommittingMutationOrLayoutEffects = null;
+    } // Tell Scheduler to yield at the end of the frame, so the browser has an
+    // opportunity to paint.
 
-            if (
-              renderState.tail === null &&
-              renderState.tailMode === "hidden" &&
-              !renderedTail.alternate &&
-              !getIsHydrating() // We don't cut it if we're hydrating.
-            ) {
-              // We're done.
-              bubbleProperties(workInProgress);
-              return null;
-            }
-          } else if (
-            // The time it took to render last row is greater than the remaining
-            // time we have to render. So rendering one more row would likely
-            // exceed it.
-            now$1() * 2 - renderState.renderingStartTime >
-              getRenderTargetTime() &&
-            renderLanes !== OffscreenLane
-          ) {
-            // We have now passed our CPU deadline and we'll just give up further
-            // attempts to render the main content and only render fallbacks.
-            // The assumption is that this is usually faster.
-            workInProgress.flags |= DidCapture;
-            didSuspendAlready = true;
-            cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this
-            // to get it started back up to attempt the next item. While in terms
-            // of priority this work has the same priority as this current render,
-            // it's not part of the same transition once the transition has
-            // committed. If it's sync, we still want to yield so that it can be
-            // painted. Conceptually, this is really the same as pinging.
-            // We can use any RetryLane even if it's the one currently rendering
-            // since we're leaving it behind on this node.
+    requestPaint();
+    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
 
-            workInProgress.lanes = SomeRetryLane;
-          }
-        }
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig$1.transition = prevTransition;
+  } else {
+    // No effects.
+    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
+    // no effects.
+    // TODO: Maybe there's a better way to report this.
 
-        if (renderState.isBackwards) {
-          // The effect list of the backwards tail will have been added
-          // to the end. This breaks the guarantee that life-cycles fire in
-          // sibling order but that isn't a strong guarantee promised by React.
-          // Especially since these might also just pop in during future commits.
-          // Append to the beginning of the list.
-          renderedTail.sibling = workInProgress.child;
-          workInProgress.child = renderedTail;
-        } else {
-          var previousSibling = renderState.last;
+    {
+      recordCommitTime();
+    }
+  }
 
-          if (previousSibling !== null) {
-            previousSibling.sibling = renderedTail;
-          } else {
-            workInProgress.child = renderedTail;
-          }
+  var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
 
-          renderState.last = renderedTail;
-        }
-      }
+  if (rootDoesHavePassiveEffects) {
+    // This commit has passive effects. Stash a reference to them. But don't
+    // schedule a callback until after flushing layout work.
+    rootDoesHavePassiveEffects = false;
+    rootWithPendingPassiveEffects = root;
+    pendingPassiveEffectsLanes = lanes;
+  } else {
+    // There were no passive effects, so we can immediately release the cache
+    // pool for this render.
+    releaseRootPooledCache(root, remainingLanes);
 
-      if (renderState.tail !== null) {
-        // We still have tail rows to render.
-        // Pop a row.
-        var next = renderState.tail;
-        renderState.rendering = next;
-        renderState.tail = next.sibling;
-        renderState.renderingStartTime = now$1();
-        next.sibling = null; // Restore the context.
-        // TODO: We can probably just avoid popping it instead and only
-        // setting it the first time we go from not suspended to suspended.
+    {
+      nestedPassiveUpdateCount = 0;
+      rootWithPassiveNestedUpdates = null;
+    }
+  } // Read this again, since an effect might have updated it
 
-        var suspenseContext = suspenseStackCursor.current;
+  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
+  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
+  // is to detect whether something might have called setState inside
+  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
+  // inside `componentDidCatch` is itself flawed — that's why we recommend
+  // `getDerivedStateFromError` instead. However, it could be improved by
+  // checking if remainingLanes includes Sync work, instead of whether there's
+  // any work remaining at all (which would also include stuff like Suspense
+  // retries or transitions). It's been like this for a while, though, so fixing
+  // it probably isn't that urgent.
 
-        if (didSuspendAlready) {
-          suspenseContext = setShallowSuspenseListContext(
-            suspenseContext,
-            ForceSuspenseFallback
-          );
-        } else {
-          suspenseContext =
-            setDefaultShallowSuspenseListContext(suspenseContext);
-        }
+  if (remainingLanes === NoLanes) {
+    // If there's no remaining work, we can clear the set of already failed
+    // error boundaries.
+    legacyErrorBoundariesThatAlreadyFailed = null;
+  }
 
-        pushSuspenseListContext(workInProgress, suspenseContext); // Do a pass over the next row.
-        // Don't bubble properties in this case.
+  {
+    if (!rootDidHavePassiveEffects) {
+      commitDoubleInvokeEffectsInDEV(root, false);
+    }
+  }
 
-        return next;
-      }
+  onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
 
-      bubbleProperties(workInProgress);
-      return null;
+  {
+    if (isDevToolsPresent) {
+      root.memoizedUpdaters.clear();
     }
+  }
 
-    case ScopeComponent: {
-      {
-        if (current === null) {
-          var scopeInstance = createScopeInstance();
-          workInProgress.stateNode = scopeInstance;
-          prepareScopeUpdate(scopeInstance, workInProgress);
+  {
+    onCommitRoot();
+  } // Always call this before exiting `commitRoot`, to ensure that any
+  // additional work on this root is scheduled.
 
-          if (workInProgress.ref !== null) {
-            markRef(workInProgress);
-            markUpdate(workInProgress);
-          }
-        } else {
-          if (workInProgress.ref !== null) {
-            markUpdate(workInProgress);
-          }
+  ensureRootIsScheduled(root, now$1());
 
-          if (current.ref !== workInProgress.ref) {
-            markRef(workInProgress);
-          }
-        }
+  if (recoverableErrors !== null) {
+    // There were errors during this render, but recovered from them without
+    // needing to surface it to the UI. We log them here.
+    var onRecoverableError = root.onRecoverableError;
 
-        bubbleProperties(workInProgress);
-        return null;
-      }
+    for (var i = 0; i < recoverableErrors.length; i++) {
+      var recoverableError = recoverableErrors[i];
+      var errorInfo = makeErrorInfo(
+        recoverableError.digest,
+        recoverableError.stack
+      );
+      onRecoverableError(recoverableError.value, errorInfo);
     }
+  }
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      popSuspenseHandler(workInProgress);
-      popHiddenContext(workInProgress);
-      var _nextState = workInProgress.memoizedState;
-      var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
+  if (hasUncaughtError) {
+    hasUncaughtError = false;
+    var error$1 = firstUncaughtError;
+    firstUncaughtError = null;
+    throw error$1;
+  } // If the passive effects are the result of a discrete render, flush them
+  // synchronously at the end of the current task so that the result is
+  // immediately observable. Otherwise, we assume that they are not
+  // order-dependent and do not need to be observed by external systems, so we
+  // can wait until after paint.
+  // TODO: We can optimize this by not scheduling the callback earlier. Since we
+  // currently schedule the callback in multiple places, will wait until those
+  // are consolidated.
 
-      if (workInProgress.tag === LegacyHiddenComponent);
-      else {
-        if (current !== null) {
-          var _prevState = current.memoizedState;
-          var prevIsHidden = _prevState !== null;
+  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
+    flushPassiveEffects();
+  } // Read this again, since a passive effect might have updated it
 
-          if (prevIsHidden !== nextIsHidden) {
-            workInProgress.flags |= Visibility;
-          }
-        } else {
-          // On initial mount, we only need a Visibility effect if the tree
-          // is hidden.
-          if (nextIsHidden) {
-            workInProgress.flags |= Visibility;
-          }
-        }
-      }
+  remainingLanes = root.pendingLanes;
 
-      if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {
-        bubbleProperties(workInProgress);
-      } else {
-        // Don't bubble properties for hidden children unless we're rendering
-        // at offscreen priority.
-        if (
-          includesSomeLane(renderLanes, OffscreenLane) && // Also don't bubble if the tree suspended
-          (workInProgress.flags & DidCapture) === NoLanes
-        ) {
-          bubbleProperties(workInProgress); // Check if there was an insertion or update in the hidden subtree.
-          // If so, we need to hide those nodes in the commit phase, so
-          // schedule a visibility effect.
+  if (includesSyncLane(remainingLanes)) {
+    {
+      markNestedUpdateScheduled();
+    } // Count the number of times the root synchronously re-renders without
+    // finishing. If there are too many, it indicates an infinite update loop.
 
-          if (
-            workInProgress.tag !== LegacyHiddenComponent &&
-            workInProgress.subtreeFlags & (Placement | Update)
-          ) {
-            workInProgress.flags |= Visibility;
-          }
-        }
-      }
+    if (root === rootWithNestedUpdates) {
+      nestedUpdateCount++;
+    } else {
+      nestedUpdateCount = 0;
+      rootWithNestedUpdates = root;
+    }
+  } else {
+    nestedUpdateCount = 0;
+  } // If layout work was scheduled, flush it now.
 
-      if (workInProgress.updateQueue !== null) {
-        // Schedule an effect to attach Suspense retry listeners
-        // TODO: Move to passive phase
-        workInProgress.flags |= Update;
-      }
+  flushSyncCallbacks();
 
-      {
-        var _previousCache2 = null;
+  {
+    if (enableDebugTracing) {
+      logCommitStopped();
+    }
+  }
 
-        if (
-          current !== null &&
-          current.memoizedState !== null &&
-          current.memoizedState.cachePool !== null
-        ) {
-          _previousCache2 = current.memoizedState.cachePool.pool;
-        }
+  if (enableSchedulingProfiler) {
+    markCommitStopped();
+  }
 
-        var _cache2 = null;
+  if (enableTransitionTracing) {
+    // We process transitions during passive effects. However, passive effects can be
+    // processed synchronously during the commit phase as well as asynchronously after
+    // paint. At the end of the commit phase, we schedule a callback that will be called
+    // after the next paint. If the transitions have already been processed (passive
+    // effect phase happened synchronously), we will schedule a callback to process
+    // the transitions. However, if we don't have any pending transition callbacks, this
+    // means that the transitions have yet to be processed (passive effects processed after paint)
+    // so we will store the end time of paint so that we can process the transitions
+    // and then call the callback via the correct end time.
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
 
-        if (
-          workInProgress.memoizedState !== null &&
-          workInProgress.memoizedState.cachePool !== null
-        ) {
-          _cache2 = workInProgress.memoizedState.cachePool.pool;
-        }
+    if (prevRootTransitionCallbacks !== null) {
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
 
-        if (_cache2 !== _previousCache2) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
+        if (prevPendingTransitionCallbacks !== null) {
+          currentPendingTransitionCallbacks = null;
+          scheduleCallback(IdlePriority, function () {
+            processTransitionCallbacks(
+              prevPendingTransitionCallbacks,
+              endTime,
+              prevRootTransitionCallbacks
+            );
+          });
+        } else {
+          currentEndTime = endTime;
         }
-      }
-
-      popTransition(workInProgress, current);
-      return null;
+      });
     }
+  }
 
-    case CacheComponent: {
-      {
-        var _previousCache3 = null;
+  return null;
+}
 
-        if (current !== null) {
-          _previousCache3 = current.memoizedState.cache;
-        }
+function makeErrorInfo(digest, componentStack) {
+  {
+    var errorInfo = {
+      componentStack: componentStack,
+      digest: digest
+    };
+    Object.defineProperty(errorInfo, "digest", {
+      configurable: false,
+      enumerable: true,
+      get: function () {
+        error(
+          'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
+            " This property is deprecated and will be removed in a future version of React." +
+            " To access the digest of an Error look for this property on the Error instance itself."
+        );
 
-        var _cache3 = workInProgress.memoizedState.cache;
+        return digest;
+      }
+    });
+    return errorInfo;
+  }
+}
 
-        if (_cache3 !== _previousCache3) {
-          // Run passive effects to retain/release the cache.
-          workInProgress.flags |= Passive$1;
-        }
+function releaseRootPooledCache(root, remainingLanes) {
+  {
+    var pooledCacheLanes = (root.pooledCacheLanes &= remainingLanes);
 
-        popCacheProvider(workInProgress);
-        bubbleProperties(workInProgress);
-      }
+    if (pooledCacheLanes === NoLanes) {
+      // None of the remaining work relies on the cache pool. Clear it so
+      // subsequent requests get a new cache
+      var pooledCache = root.pooledCache;
 
-      return null;
+      if (pooledCache != null) {
+        root.pooledCache = null;
+        releaseCache(pooledCache);
+      }
     }
+  }
+}
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        var _instance3 = workInProgress.stateNode;
+function flushPassiveEffects() {
+  // Returns whether passive effects were flushed.
+  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
+  // probably just combine the two functions. I believe they were only separate
+  // in the first place because we used to wrap it with
+  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
+  // priority within React itself, so we can mutate the variable directly.
+  if (rootWithPendingPassiveEffects !== null) {
+    // Cache the root since rootWithPendingPassiveEffects is cleared in
+    // flushPassiveEffectsImpl
+    var root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
+    // method can be called from various places, not always from commitRoot
+    // where the remaining lanes are known
 
-        if (_instance3 !== null) {
-          popMarkerInstance(workInProgress);
-        }
+    var remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = NoLanes;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
+    var prevTransition = ReactCurrentBatchConfig$1.transition;
+    var previousPriority = getCurrentUpdatePriority();
 
-        bubbleProperties(workInProgress);
-      }
+    try {
+      ReactCurrentBatchConfig$1.transition = null;
+      setCurrentUpdatePriority(priority);
+      return flushPassiveEffectsImpl();
+    } finally {
+      setCurrentUpdatePriority(previousPriority);
+      ReactCurrentBatchConfig$1.transition = prevTransition; // Once passive effects have run for the tree - giving components a
+      // chance to retain cache instances they use - release the pooled
+      // cache at the root (if there is one)
 
-      return null;
+      releaseRootPooledCache(root, remainingLanes);
     }
   }
 
-  throw new Error(
-    "Unknown unit of work tag (" +
-      workInProgress.tag +
-      "). This error is likely caused by a bug in " +
-      "React. Please file an issue."
-  );
+  return false;
 }
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  {
+    pendingPassiveProfilerEffects.push(fiber);
 
-function unwindWork(current, workInProgress, renderLanes) {
-  // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
-  popTreeContext(workInProgress);
-
-  switch (workInProgress.tag) {
-    case ClassComponent: {
-      var flags = workInProgress.flags;
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects();
+        return null;
+      });
+    }
+  }
+}
 
-      if (flags & ShouldCapture) {
-        workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
+function flushPassiveEffectsImpl() {
+  if (rootWithPendingPassiveEffects === null) {
+    return false;
+  } // Cache and clear the transitions flag
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        }
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects;
+  var lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
+  // Figure out why and fix it. It's not causing any known issues (probably
+  // because it's only used for profiling), but it's a refactor hazard.
 
-        return workInProgress;
-      }
+  pendingPassiveEffectsLanes = NoLanes;
 
-      return null;
-    }
+  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
+    throw new Error("Cannot flush passive effects while already rendering.");
+  }
 
-    case HostRoot: {
-      {
-        popCacheProvider(workInProgress);
-      }
+  {
+    isFlushingPassiveEffects = true;
+    didScheduleUpdateDuringPassiveEffects = false;
 
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(workInProgress);
-      }
+    if (enableDebugTracing) {
+      logPassiveEffectsStarted(lanes);
+    }
+  }
 
-      popRootTransition(workInProgress);
-      popHostContainer(workInProgress);
-      resetWorkInProgressVersions();
-      var _flags = workInProgress.flags;
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStarted(lanes);
+  }
 
-      if (
-        (_flags & ShouldCapture) !== NoFlags$1 &&
-        (_flags & DidCapture) === NoFlags$1
-      ) {
-        // There was an error during render that wasn't captured by a suspense
-        // boundary. Do a second pass on the root to unmount the children.
-        workInProgress.flags = (_flags & ~ShouldCapture) | DidCapture;
-        return workInProgress;
-      } // We unwound to the root without completing it. Exit.
+  var prevExecutionContext = executionContext;
+  executionContext |= CommitContext;
+  commitPassiveUnmountEffects(root.current);
+  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
 
-      return null;
-    }
+  {
+    var profilerEffects = pendingPassiveProfilerEffects;
+    pendingPassiveProfilerEffects = [];
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      // TODO: popHydrationState
-      popHostContext(workInProgress);
-      return null;
+    for (var i = 0; i < profilerEffects.length; i++) {
+      var fiber = profilerEffects[i];
+      commitPassiveEffectDurations(root, fiber);
     }
+  }
 
-    case SuspenseComponent: {
-      popSuspenseHandler(workInProgress);
-      var suspenseState = workInProgress.memoizedState;
+  {
+    if (enableDebugTracing) {
+      logPassiveEffectsStopped();
+    }
+  }
 
-      if (suspenseState !== null && suspenseState.dehydrated !== null) {
-        if (workInProgress.alternate === null) {
-          throw new Error(
-            "Threw in newly mounted dehydrated component. This is likely a bug in " +
-              "React. Please file an issue."
-          );
-        }
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStopped();
+  }
 
-        resetHydrationState();
-      }
+  {
+    commitDoubleInvokeEffectsInDEV(root, true);
+  }
 
-      var _flags2 = workInProgress.flags;
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
 
-      if (_flags2 & ShouldCapture) {
-        workInProgress.flags = (_flags2 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    var prevEndTime = currentEndTime;
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        }
+    if (
+      prevPendingTransitionCallbacks !== null &&
+      prevRootTransitionCallbacks !== null &&
+      prevEndTime !== null
+    ) {
+      currentPendingTransitionCallbacks = null;
+      currentEndTime = null;
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
+        );
+      });
+    }
+  }
 
-        return workInProgress;
+  {
+    // If additional passive effects were scheduled, increment a counter. If this
+    // exceeds the limit, we'll fire a warning.
+    if (didScheduleUpdateDuringPassiveEffects) {
+      if (root === rootWithPassiveNestedUpdates) {
+        nestedPassiveUpdateCount++;
+      } else {
+        nestedPassiveUpdateCount = 0;
+        rootWithPassiveNestedUpdates = root;
       }
-
-      return null;
+    } else {
+      nestedPassiveUpdateCount = 0;
     }
 
-    case SuspenseListComponent: {
-      popSuspenseListContext(workInProgress); // SuspenseList doesn't actually catch anything. It should've been
-      // caught by a nested boundary. If not, it should bubble through.
+    isFlushingPassiveEffects = false;
+    didScheduleUpdateDuringPassiveEffects = false;
+  } // TODO: Move to commitPassiveMountEffects
 
-      return null;
-    }
+  onPostCommitRoot(root);
 
-    case HostPortal:
-      popHostContainer(workInProgress);
-      return null;
+  {
+    var stateNode = root.current.stateNode;
+    stateNode.effectDuration = 0;
+    stateNode.passiveEffectDuration = 0;
+  }
 
-    case ContextProvider:
-      var context = workInProgress.type._context;
-      popProvider(context, workInProgress);
-      return null;
+  return true;
+}
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent: {
-      popSuspenseHandler(workInProgress);
-      popHiddenContext(workInProgress);
-      popTransition(workInProgress, current);
-      var _flags3 = workInProgress.flags;
+function isAlreadyFailedLegacyErrorBoundary(instance) {
+  return (
+    legacyErrorBoundariesThatAlreadyFailed !== null &&
+    legacyErrorBoundariesThatAlreadyFailed.has(instance)
+  );
+}
+function markLegacyErrorBoundaryAsFailed(instance) {
+  if (legacyErrorBoundariesThatAlreadyFailed === null) {
+    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+  } else {
+    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+  }
+}
 
-      if (_flags3 & ShouldCapture) {
-        workInProgress.flags = (_flags3 & ~ShouldCapture) | DidCapture; // Captured a suspense effect. Re-render the boundary.
+function prepareToThrowUncaughtError(error) {
+  if (!hasUncaughtError) {
+    hasUncaughtError = true;
+    firstUncaughtError = error;
+  }
+}
 
-        if ((workInProgress.mode & ProfileMode) !== NoMode) {
-          transferActualDuration(workInProgress);
-        }
+var onUncaughtError = prepareToThrowUncaughtError;
 
-        return workInProgress;
-      }
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  var errorInfo = createCapturedValueAtFiber(error, sourceFiber);
+  var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
+  var root = enqueueUpdate(rootFiber, update, SyncLane);
+  var eventTime = requestEventTime();
 
-      return null;
-    }
+  if (root !== null) {
+    markRootUpdated(root, SyncLane, eventTime);
+    ensureRootIsScheduled(root, eventTime);
+  }
+}
 
-    case CacheComponent:
-      {
-        popCacheProvider(workInProgress);
-      }
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
+  {
+    reportUncaughtErrorInDEV(error$1);
+    setIsRunningInsertionEffect(false);
+  }
 
-      return null;
+  if (sourceFiber.tag === HostRoot) {
+    // Error was thrown at the root. There is no parent, so the root
+    // itself should capture it.
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error$1);
+    return;
+  }
 
-    case TracingMarkerComponent:
-      if (enableTransitionTracing) {
-        if (workInProgress.stateNode !== null) {
-          popMarkerInstance(workInProgress);
+  var fiber = null;
+
+  if (skipUnmountedBoundaries) {
+    fiber = nearestMountedAncestor;
+  } else {
+    fiber = sourceFiber.return;
+  }
+
+  while (fiber !== null) {
+    if (fiber.tag === HostRoot) {
+      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error$1);
+      return;
+    } else if (fiber.tag === ClassComponent) {
+      var ctor = fiber.type;
+      var instance = fiber.stateNode;
+
+      if (
+        typeof ctor.getDerivedStateFromError === "function" ||
+        (typeof instance.componentDidCatch === "function" &&
+          !isAlreadyFailedLegacyErrorBoundary(instance))
+      ) {
+        var errorInfo = createCapturedValueAtFiber(error$1, sourceFiber);
+        var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
+        var root = enqueueUpdate(fiber, update, SyncLane);
+        var eventTime = requestEventTime();
+
+        if (root !== null) {
+          markRootUpdated(root, SyncLane, eventTime);
+          ensureRootIsScheduled(root, eventTime);
         }
+
+        return;
       }
+    }
 
-      return null;
+    fiber = fiber.return;
+  }
 
-    default:
-      return null;
+  {
+    // TODO: Until we re-land skipUnmountedBoundaries (see #20147), this warning
+    // will fire for errors that are thrown by destroy functions inside deleted
+    // trees. What it should instead do is propagate the error to the parent of
+    // the deleted tree. In the meantime, do not add this warning to the
+    // allowlist; this is only for our internal use.
+    error(
+      "Internal React error: Attempted to capture a commit phase error " +
+        "inside a detached tree. This indicates a bug in React. Likely " +
+        "causes include deleting the same fiber more than once, committing an " +
+        "already-finished tree, or an inconsistent return pointer.\n\n" +
+        "Error message:\n\n%s",
+      error$1
+    );
   }
 }
+function attachPingListener(root, wakeable, lanes) {
+  // Attach a ping listener
+  //
+  // The data might resolve before we have a chance to commit the fallback. Or,
+  // in the case of a refresh, we'll never commit a fallback. So we need to
+  // attach a listener now. When it resolves ("pings"), we can decide whether to
+  // try rendering the tree again.
+  //
+  // Only attach a listener if one does not already exist for the lanes
+  // we're currently rendering (which acts like a "thread ID" here).
+  //
+  // We only need to do this in concurrent mode. Legacy Suspense always
+  // commits fallbacks synchronously, so there are no pings.
+  var pingCache = root.pingCache;
+  var threadIDs;
 
-function unwindInterruptedWork(current, interruptedWork, renderLanes) {
-  // Note: This intentionally doesn't check if we're hydrating because comparing
-  // to the current tree provider fiber is just as fast and less error-prone.
-  // Ideally we would have a special version of the work loop only
-  // for hydration.
-  popTreeContext(interruptedWork);
+  if (pingCache === null) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else {
+    threadIDs = pingCache.get(wakeable);
 
-  switch (interruptedWork.tag) {
-    case ClassComponent: {
-      break;
+    if (threadIDs === undefined) {
+      threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
     }
+  }
 
-    case HostRoot: {
-      {
-        popCacheProvider(interruptedWork);
-      }
-
-      if (enableTransitionTracing) {
-        popRootMarkerInstance(interruptedWork);
-      }
+  if (!threadIDs.has(lanes)) {
+    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
 
-      popRootTransition(interruptedWork);
-      popHostContainer(interruptedWork);
-      resetWorkInProgressVersions();
-      break;
-    }
+    threadIDs.add(lanes);
+    var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      popHostContext(interruptedWork);
-      break;
+    {
+      if (isDevToolsPresent) {
+        // If we have pending work still, restore the original updaters
+        restorePendingUpdaters(root, lanes);
+      }
     }
 
-    case HostPortal:
-      popHostContainer(interruptedWork);
-      break;
-
-    case SuspenseComponent:
-      popSuspenseHandler(interruptedWork);
-      break;
+    wakeable.then(ping, ping);
+  }
+}
 
-    case SuspenseListComponent:
-      popSuspenseListContext(interruptedWork);
-      break;
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
 
-    case ContextProvider:
-      var context = interruptedWork.type._context;
-      popProvider(context, interruptedWork);
-      break;
+  if (pingCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    pingCache.delete(wakeable);
+  }
 
-    case OffscreenComponent:
-    case LegacyHiddenComponent:
-      popSuspenseHandler(interruptedWork);
-      popHiddenContext(interruptedWork);
-      popTransition(interruptedWork, current);
-      break;
+  var eventTime = requestEventTime();
+  markRootPinged(root, pingedLanes);
+  warnIfSuspenseResolutionNotWrappedWithActDEV(root);
 
-    case CacheComponent:
-      {
-        popCacheProvider(interruptedWork);
+  if (
+    workInProgressRoot === root &&
+    isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)
+  ) {
+    // Received a ping at the same priority level at which we're currently
+    // rendering. We might want to restart this render. This should mirror
+    // the logic of whether or not a root suspends once it completes.
+    // TODO: If we're rendering sync either due to Sync, Batched or expired,
+    // we should probably never restart.
+    // If we're suspended with delay, or if it's a retry, we'll always suspend
+    // so we can always restart.
+    if (
+      workInProgressRootExitStatus === RootSuspendedWithDelay ||
+      (workInProgressRootExitStatus === RootSuspended &&
+        includesOnlyRetries(workInProgressRootRenderLanes) &&
+        now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
+    ) {
+      // Force a restart from the root by unwinding the stack. Unless this is
+      // being called from the render phase, because that would cause a crash.
+      if ((executionContext & RenderContext) === NoContext) {
+        prepareFreshStack(root, NoLanes);
       }
+    } else {
+      // Even though we can't restart right now, we might get an
+      // opportunity later. So we mark this render as having a ping.
+      workInProgressRootPingedLanes = mergeLanes(
+        workInProgressRootPingedLanes,
+        pingedLanes
+      );
+    }
+  }
 
-      break;
+  ensureRootIsScheduled(root, eventTime);
+}
 
-    case TracingMarkerComponent:
-      if (enableTransitionTracing) {
-        var instance = interruptedWork.stateNode;
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  // The boundary fiber (a Suspense component or SuspenseList component)
+  // previously was rendered in its fallback state. One of the promises that
+  // suspended it has resolved, which means at least part of the tree was
+  // likely unblocked. Try rendering again, at a new lanes.
+  if (retryLane === NoLane) {
+    // TODO: Assign this to `suspenseState.retryLane`? to avoid
+    // unnecessary entanglement?
+    retryLane = requestRetryLane(boundaryFiber);
+  } // TODO: Special case idle priority?
 
-        if (instance !== null) {
-          popMarkerInstance(interruptedWork);
-        }
-      }
+  var eventTime = requestEventTime();
+  var root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
 
-      break;
+  if (root !== null) {
+    markRootUpdated(root, retryLane, eventTime);
+    ensureRootIsScheduled(root, eventTime);
   }
 }
 
-var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState;
+  var retryLane = NoLane;
 
-{
-  didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
-} // Used during the commit phase to track the state of the Offscreen component stack.
-// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+  if (suspenseState !== null) {
+    retryLane = suspenseState.retryLane;
+  }
 
-var offscreenSubtreeIsHidden = false;
-var offscreenSubtreeWasHidden = false;
-var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
-var nextEffect = null; // Used for Profiling builds to track updaters.
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = NoLane; // Default
 
-var inProgressLanes = null;
-var inProgressRoot = null;
+  var retryCache;
 
-function shouldProfile(current) {
-  return (
-    (current.mode & ProfileMode) !== NoMode &&
-    (getExecutionContext() & CommitContext) !== NoContext
-  );
-}
+  switch (boundaryFiber.tag) {
+    case SuspenseComponent:
+      retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
 
-function reportUncaughtErrorInDEV(error) {
-  // Wrapping each small part of the commit phase into a guarded
-  // callback is a bit too slow (https://github.com/facebook/react/pull/21666).
-  // But we rely on it to surface errors to DEV tools like overlays
-  // (https://github.com/facebook/react/issues/21712).
-  // As a compromise, rethrow only caught errors in a guard.
-  {
-    invokeGuardedCallback(null, function () {
-      throw error;
-    });
-    clearCaughtError();
-  }
-}
+      if (suspenseState !== null) {
+        retryLane = suspenseState.retryLane;
+      }
 
-function callComponentWillUnmountWithTimer(current, instance) {
-  instance.props = current.memoizedProps;
-  instance.state = current.memoizedState;
+      break;
 
-  if (shouldProfile(current)) {
-    try {
-      startLayoutEffectTimer();
-      instance.componentWillUnmount();
-    } finally {
-      recordLayoutEffectDuration(current);
+    case SuspenseListComponent:
+      retryCache = boundaryFiber.stateNode;
+      break;
+
+    case OffscreenComponent: {
+      var instance = boundaryFiber.stateNode;
+      retryCache = instance._retryCache;
+      break;
     }
-  } else {
-    instance.componentWillUnmount();
-  }
-} // Capture errors so they don't interrupt unmounting.
 
-function safelyCallComponentWillUnmount(
-  current,
-  nearestMountedAncestor,
-  instance
-) {
-  try {
-    callComponentWillUnmountWithTimer(current, instance);
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+    default:
+      throw new Error(
+        "Pinged unknown suspense boundary type. " +
+          "This is probably a bug in React."
+      );
   }
-} // Capture errors so they don't interrupt mounting.
 
-function safelyAttachRef(current, nearestMountedAncestor) {
-  try {
-    commitAttachRef(current);
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  if (retryCache !== null) {
+    // The wakeable resolved, so we no longer need to memoize, because it will
+    // never be thrown again.
+    retryCache.delete(wakeable);
   }
-}
 
-function safelyDetachRef(current, nearestMountedAncestor) {
-  var ref = current.ref;
-  var refCleanup = current.refCleanup;
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+} // Computes the next Just Noticeable Difference (JND) boundary.
+// The theory is that a person can't tell the difference between small differences in time.
+// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
+// difference in the experience. However, waiting for longer might mean that we can avoid
+// showing an intermediate loading state. The longer we have already waited, the harder it
+// is to tell small differences in time. Therefore, the longer we've already waited,
+// the longer we can wait additionally. At some point we have to give up though.
+// We pick a train model where the next boundary commits at a consistent schedule.
+// These particular numbers are vague estimates. We expect to adjust them based on research.
 
-  if (ref !== null) {
-    if (typeof refCleanup === "function") {
-      try {
-        if (shouldProfile(current)) {
-          try {
-            startLayoutEffectTimer();
-            refCleanup();
-          } finally {
-            recordLayoutEffectDuration(current);
-          }
-        } else {
-          refCleanup();
-        }
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      } finally {
-        // `refCleanup` has been called. Nullify all references to it to prevent double invocation.
-        current.refCleanup = null;
-        var finishedWork = current.alternate;
+function jnd(timeElapsed) {
+  return timeElapsed < 120
+    ? 120
+    : timeElapsed < 480
+    ? 480
+    : timeElapsed < 1080
+    ? 1080
+    : timeElapsed < 1920
+    ? 1920
+    : timeElapsed < 3000
+    ? 3000
+    : timeElapsed < 4320
+    ? 4320
+    : ceil(timeElapsed / 1960) * 1960;
+}
 
-        if (finishedWork != null) {
-          finishedWork.refCleanup = null;
-        }
-      }
-    } else if (typeof ref === "function") {
-      var retVal;
+function throwIfInfiniteUpdateLoopDetected() {
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    nestedUpdateCount = 0;
+    nestedPassiveUpdateCount = 0;
+    rootWithNestedUpdates = null;
+    rootWithPassiveNestedUpdates = null;
+    throw new Error(
+      "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."
+    );
+  }
 
-      try {
-        if (shouldProfile(current)) {
-          try {
-            startLayoutEffectTimer();
-            retVal = ref(null);
-          } finally {
-            recordLayoutEffectDuration(current);
-          }
-        } else {
-          retVal = ref(null);
-        }
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      }
+  {
+    if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
+      nestedPassiveUpdateCount = 0;
+      rootWithPassiveNestedUpdates = null;
 
-      {
-        if (typeof retVal === "function") {
-          error(
-            "Unexpected return value from a callback ref in %s. " +
-              "A callback ref should not return a function.",
-            getComponentNameFromFiber(current)
-          );
-        }
-      }
-    } else {
-      // $FlowFixMe unable to narrow type to RefObject
-      ref.current = null;
+      error(
+        "Maximum update depth exceeded. This can happen when a component " +
+          "calls setState inside useEffect, but useEffect either doesn't " +
+          "have a dependency array, or one of the dependencies changes on " +
+          "every render."
+      );
     }
   }
 }
 
-function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
-  try {
-    destroy();
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+function flushRenderPhaseStrictModeWarningsInDEV() {
+  {
+    ReactStrictModeWarnings.flushLegacyContextWarning();
+    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
   }
 }
 
-var focusedInstanceHandle = null;
-var shouldFireAfterActiveInstanceBlur = false;
-function commitBeforeMutationEffects(root, firstChild) {
-  focusedInstanceHandle = prepareForCommit();
-  nextEffect = firstChild;
-  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber
-
-  var shouldFire = shouldFireAfterActiveInstanceBlur;
-  shouldFireAfterActiveInstanceBlur = false;
-  focusedInstanceHandle = null;
-  return shouldFire;
+function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
+  {
+    {
+      legacyCommitDoubleInvokeEffectsInDEV(root.current, hasPassiveEffects);
+    }
+  }
 }
 
-function commitBeforeMutationEffects_begin() {
-  while (nextEffect !== null) {
-    var fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.
-    // Let's skip the whole loop if it's off.
+function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
+  // TODO (StrictEffects) Should we set a marker on the root if it contains strict effects
+  // so we don't traverse unnecessarily? similar to subtreeFlags but just at the root level.
+  // Maybe not a big deal since this is DEV only behavior.
+  setCurrentFiber(fiber);
+  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectUnmountInDEV);
 
-    {
-      // TODO: Should wrap this in flags check, too, as optimization
-      var deletions = fiber.deletions;
+  if (hasPassiveEffects) {
+    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectUnmountInDEV);
+  }
 
-      if (deletions !== null) {
-        for (var i = 0; i < deletions.length; i++) {
-          var deletion = deletions[i];
-          commitBeforeMutationEffectsDeletion(deletion);
-        }
-      }
-    }
+  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectMountInDEV);
 
-    var child = fiber.child;
+  if (hasPassiveEffects) {
+    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectMountInDEV);
+  }
+
+  resetCurrentFiber();
+}
+
+function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
+  var current = firstChild;
+  var subtreeRoot = null;
+
+  while (current != null) {
+    var primarySubtreeFlag = current.subtreeFlags & fiberFlags;
 
     if (
-      (fiber.subtreeFlags & BeforeMutationMask) !== NoFlags$1 &&
-      child !== null
+      current !== subtreeRoot &&
+      current.child != null &&
+      primarySubtreeFlag !== NoFlags$1
     ) {
-      child.return = fiber;
-      nextEffect = child;
+      current = current.child;
     } else {
-      commitBeforeMutationEffects_complete();
+      if ((current.flags & fiberFlags) !== NoFlags$1) {
+        invokeEffectFn(current);
+      }
+
+      if (current.sibling !== null) {
+        current = current.sibling;
+      } else {
+        current = subtreeRoot = current.return;
+      }
     }
   }
 }
 
-function commitBeforeMutationEffects_complete() {
-  while (nextEffect !== null) {
-    var fiber = nextEffect;
-    setCurrentFiber(fiber);
+var didWarnStateUpdateForNotYetMountedComponent = null;
+function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
+  {
+    if ((executionContext & RenderContext) !== NoContext) {
+      // We let the other warning about render phase updates deal with this one.
+      return;
+    }
 
-    try {
-      commitBeforeMutationEffectsOnFiber(fiber);
-    } catch (error) {
-      captureCommitPhaseError(fiber, fiber.return, error);
+    if (!(fiber.mode & ConcurrentMode)) {
+      return;
     }
 
-    resetCurrentFiber();
-    var sibling = fiber.sibling;
+    var tag = fiber.tag;
 
-    if (sibling !== null) {
-      sibling.return = fiber.return;
-      nextEffect = sibling;
+    if (
+      tag !== IndeterminateComponent &&
+      tag !== HostRoot &&
+      tag !== ClassComponent &&
+      tag !== FunctionComponent &&
+      tag !== ForwardRef &&
+      tag !== MemoComponent &&
+      tag !== SimpleMemoComponent
+    ) {
+      // Only warn for user-defined components, not internal ones like Suspense.
       return;
+    } // 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 = getComponentNameFromFiber(fiber) || "ReactComponent";
+
+    if (didWarnStateUpdateForNotYetMountedComponent !== null) {
+      if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
+        return;
+      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+      didWarnStateUpdateForNotYetMountedComponent.add(componentName);
+    } else {
+      didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
     }
 
-    nextEffect = fiber.return;
+    var previousFiber = current;
+
+    try {
+      setCurrentFiber(fiber);
+
+      error(
+        "Can't perform a React state update on a component that hasn't mounted yet. " +
+          "This indicates that you have a side-effect in your render function that " +
+          "asynchronously later calls tries to update the component. Move this work to " +
+          "useEffect instead."
+      );
+    } finally {
+      if (previousFiber) {
+        setCurrentFiber(fiber);
+      } else {
+        resetCurrentFiber();
+      }
+    }
   }
 }
+var beginWork;
 
-function commitBeforeMutationEffectsOnFiber(finishedWork) {
-  var current = finishedWork.alternate;
-  var flags = finishedWork.flags;
+if (replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+  var dummyFiber = null;
 
-  {
-    if (!shouldFireAfterActiveInstanceBlur && focusedInstanceHandle !== null) {
-      // Check to see if the focused element was inside of a hidden (Suspense) subtree.
-      // TODO: Move this out of the hot path using a dedicated effect tag.
+  beginWork = function (current, unitOfWork, lanes) {
+    // If a component throws an error, we replay it again in a synchronously
+    // dispatched event, so that the debugger will treat it as an uncaught
+    // error See ReactErrorUtils for more information.
+    // Before entering the begin phase, copy the work-in-progress onto a dummy
+    // fiber. If beginWork throws, we'll use this to reset the state.
+    var originalWorkInProgressCopy = assignFiberPropertiesInDEV(
+      dummyFiber,
+      unitOfWork
+    );
+
+    try {
+      return beginWork$1(current, unitOfWork, lanes);
+    } catch (originalError) {
       if (
-        finishedWork.tag === SuspenseComponent &&
-        isSuspenseBoundaryBeingHidden(current, finishedWork) && // $FlowFixMe[incompatible-call] found when upgrading Flow
-        doesFiberContain(finishedWork, focusedInstanceHandle)
+        didSuspendOrErrorWhileHydratingDEV() ||
+        originalError === SuspenseException ||
+        originalError === SelectiveHydrationException ||
+        (originalError !== null &&
+          typeof originalError === "object" &&
+          typeof originalError.then === "function")
       ) {
-        shouldFireAfterActiveInstanceBlur = true;
-        beforeActiveInstanceBlur(finishedWork);
-      }
-    }
-  }
+        // Don't replay promises.
+        // Don't replay errors if we are hydrating and have already suspended or handled an error
+        throw originalError;
+      } // Don't reset current debug fiber, since we're about to work on the
+      // same fiber again.
+      // Unwind the failed stack frame
 
-  if ((flags & Snapshot) !== NoFlags$1) {
-    setCurrentFiber(finishedWork);
-  }
+      resetSuspendedWorkLoopOnUnwind();
+      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
 
-  switch (finishedWork.tag) {
-    case FunctionComponent: {
-      {
-        if ((flags & Update) !== NoFlags$1) {
-          commitUseEffectEventMount(finishedWork);
+      assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
+
+      if (unitOfWork.mode & ProfileMode) {
+        // Reset the profiler timer.
+        startProfilerTimer(unitOfWork);
+      } // Run beginWork again.
+
+      invokeGuardedCallback(
+        null,
+        beginWork$1,
+        null,
+        current,
+        unitOfWork,
+        lanes
+      );
+
+      if (hasCaughtError()) {
+        var replayError = clearCaughtError();
+
+        if (
+          typeof replayError === "object" &&
+          replayError !== null &&
+          replayError._suppressLogging &&
+          typeof originalError === "object" &&
+          originalError !== null &&
+          !originalError._suppressLogging
+        ) {
+          // If suppressed, let the flag carry over to the original error which is the one we'll rethrow.
+          originalError._suppressLogging = true;
         }
-      }
+      } // We always throw the original error in case the second render pass is not idempotent.
+      // This can happen if a memoized function or CommonJS module doesn't throw after first invocation.
 
-      break;
+      throw originalError;
     }
+  };
+} else {
+  beginWork = beginWork$1;
+}
 
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      break;
-    }
+var didWarnAboutUpdateInRender = false;
+var didWarnAboutUpdateInRenderForAnotherComponent;
 
-    case ClassComponent: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        if (current !== null) {
-          var prevProps = current.memoizedProps;
-          var prevState = current.memoizedState;
-          var instance = finishedWork.stateNode; // We could update instance props and state here,
-          // but instead we rely on them being set during last render.
-          // TODO: revisit this when we implement resuming.
+{
+  didWarnAboutUpdateInRenderForAnotherComponent = new Set();
+}
 
-          {
-            if (
-              finishedWork.type === finishedWork.elementType &&
-              !didWarnAboutReassigningProps
-            ) {
-              if (instance.props !== finishedWork.memoizedProps) {
-                error(
-                  "Expected %s props to match memoized props before " +
-                    "getSnapshotBeforeUpdate. " +
-                    "This might either be because of a bug in React, or because " +
-                    "a component reassigns its own `this.props`. " +
-                    "Please file an issue.",
-                  getComponentNameFromFiber(finishedWork) || "instance"
-                );
-              }
+function warnAboutRenderPhaseUpdatesInDEV(fiber) {
+  {
+    if (isRendering) {
+      switch (fiber.tag) {
+        case FunctionComponent:
+        case ForwardRef:
+        case SimpleMemoComponent: {
+          var renderingComponentName =
+            (workInProgress && getComponentNameFromFiber(workInProgress)) ||
+            "Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
 
-              if (instance.state !== finishedWork.memoizedState) {
-                error(
-                  "Expected %s state to match memoized state before " +
-                    "getSnapshotBeforeUpdate. " +
-                    "This might either be because of a bug in React, or because " +
-                    "a component reassigns its own `this.state`. " +
-                    "Please file an issue.",
-                  getComponentNameFromFiber(finishedWork) || "instance"
-                );
-              }
-            }
-          }
+          var dedupeKey = renderingComponentName;
 
-          var snapshot = instance.getSnapshotBeforeUpdate(
-            finishedWork.elementType === finishedWork.type
-              ? prevProps
-              : resolveDefaultProps(finishedWork.type, prevProps),
-            prevState
-          );
+          if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
+            didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
+            var setStateComponentName =
+              getComponentNameFromFiber(fiber) || "Unknown";
 
-          {
-            var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
+            error(
+              "Cannot update a component (`%s`) while rendering a " +
+                "different component (`%s`). To locate the bad setState() call inside `%s`, " +
+                "follow the stack trace as described in https://reactjs.org/link/setstate-in-render",
+              setStateComponentName,
+              renderingComponentName,
+              renderingComponentName
+            );
+          }
 
-            if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
-              didWarnSet.add(finishedWork.type);
+          break;
+        }
 
-              error(
-                "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
-                  "must be returned. You have returned undefined.",
-                getComponentNameFromFiber(finishedWork)
-              );
-            }
+        case ClassComponent: {
+          if (!didWarnAboutUpdateInRender) {
+            error(
+              "Cannot update during an existing state transition (such as " +
+                "within `render`). Render methods should be a pure " +
+                "function of props and state."
+            );
+
+            didWarnAboutUpdateInRender = true;
           }
 
-          instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+          break;
         }
       }
+    }
+  }
+}
 
-      break;
+function restorePendingUpdaters(root, lanes) {
+  {
+    if (isDevToolsPresent) {
+      var memoizedUpdaters = root.memoizedUpdaters;
+      memoizedUpdaters.forEach(function (schedulingFiber) {
+        addFiberToLanesMap(root, schedulingFiber, lanes);
+      }); // This function intentionally does not clear memoized updaters.
+      // Those may still be relevant to the current commit
+      // and a future one (e.g. Suspense).
     }
+  }
+}
+var fakeActCallbackNode = {}; // $FlowFixMe[missing-local-annot]
 
-    case HostRoot: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        {
-          var root = finishedWork.stateNode;
-          clearContainer(root.containerInfo);
-        }
+function scheduleCallback(priorityLevel, callback) {
+  {
+    // If we're currently inside an `act` scope, bypass Scheduler and push to
+    // the `act` queue instead.
+    var actQueue = ReactCurrentActQueue.current;
+
+    if (actQueue !== null) {
+      actQueue.push(callback);
+      return fakeActCallbackNode;
+    } else {
+      return scheduleCallback$2(priorityLevel, callback);
+    }
+  }
+}
+
+function cancelCallback(callbackNode) {
+  if (callbackNode === fakeActCallbackNode) {
+    return;
+  } // In production, always call Scheduler. This function will be stripped out.
+
+  return cancelCallback$1(callbackNode);
+}
+
+function shouldForceFlushFallbacksInDEV() {
+  // Never force flush in production. This function should get stripped out.
+  return ReactCurrentActQueue.current !== null;
+}
+
+function warnIfUpdatesNotWrappedWithActDEV(fiber) {
+  {
+    if (fiber.mode & ConcurrentMode) {
+      if (!isConcurrentActEnvironment()) {
+        // Not in an act environment. No need to warn.
+        return;
+      }
+    } else {
+      // Legacy mode has additional cases where we suppress a warning.
+      if (!isLegacyActEnvironment()) {
+        // Not in an act environment. No need to warn.
+        return;
       }
 
-      break;
+      if (executionContext !== NoContext) {
+        // Legacy mode doesn't warn if the update is batched, i.e.
+        // batchedUpdates or flushSync.
+        return;
+      }
+
+      if (
+        fiber.tag !== FunctionComponent &&
+        fiber.tag !== ForwardRef &&
+        fiber.tag !== SimpleMemoComponent
+      ) {
+        // For backwards compatibility with pre-hooks code, legacy mode only
+        // warns for updates that originate from a hook.
+        return;
+      }
     }
 
-    case HostComponent:
-    case HostHoistable:
-    case HostSingleton:
-    case HostText:
-    case HostPortal:
-    case IncompleteClassComponent:
-      // Nothing to do for these component types
-      break;
+    if (ReactCurrentActQueue.current === null) {
+      var previousFiber = current;
 
-    default: {
-      if ((flags & Snapshot) !== NoFlags$1) {
-        throw new Error(
-          "This unit of work tag should not have side-effects. This error is " +
-            "likely caused by a bug in React. Please file an issue."
+      try {
+        setCurrentFiber(fiber);
+
+        error(
+          "An update to %s inside a test was not wrapped in act(...).\n\n" +
+            "When testing, code that causes React state updates should be " +
+            "wrapped into act(...):\n\n" +
+            "act(() => {\n" +
+            "  /* fire events that update state */\n" +
+            "});\n" +
+            "/* assert on the output */\n\n" +
+            "This ensures that you're testing the behavior the user would see " +
+            "in the browser." +
+            " Learn more at https://reactjs.org/link/wrap-tests-with-act",
+          getComponentNameFromFiber(fiber)
         );
+      } finally {
+        if (previousFiber) {
+          setCurrentFiber(fiber);
+        } else {
+          resetCurrentFiber();
+        }
       }
     }
   }
+}
+
+function warnIfSuspenseResolutionNotWrappedWithActDEV(root) {
+  {
+    if (
+      root.tag !== LegacyRoot &&
+      isConcurrentActEnvironment() &&
+      ReactCurrentActQueue.current === null
+    ) {
+      error(
+        "A suspended resource finished loading inside a test, but the event " +
+          "was not wrapped in act(...).\n\n" +
+          "When testing, code that resolves suspended data should be wrapped " +
+          "into act(...):\n\n" +
+          "act(() => {\n" +
+          "  /* finish loading suspended data */\n" +
+          "});\n" +
+          "/* assert on the output */\n\n" +
+          "This ensures that you're testing the behavior the user would see " +
+          "in the browser." +
+          " Learn more at https://reactjs.org/link/wrap-tests-with-act"
+      );
+    }
+  }
+}
 
-  if ((flags & Snapshot) !== NoFlags$1) {
-    resetCurrentFiber();
+function setIsRunningInsertionEffect(isRunning) {
+  {
+    isRunningInsertionEffect = isRunning;
   }
 }
 
-function commitBeforeMutationEffectsDeletion(deletion) {
+/* eslint-disable react-internal/prod-error-codes */
+// Used by React Refresh runtime through DevTools Global Hook.
+
+var resolveFamily = null;
+var failedBoundaries = null;
+var setRefreshHandler = function (handler) {
   {
-    // TODO (effects) It would be nice to avoid calling doesFiberContain()
-    // Maybe we can repurpose one of the subtreeFlags positions for this instead?
-    // Use it to store which part of the tree the focused instance is in?
-    // This assumes we can safely determine that instance during the "render" phase.
-    if (doesFiberContain(deletion, focusedInstanceHandle)) {
-      shouldFireAfterActiveInstanceBlur = true;
-      beforeActiveInstanceBlur(deletion);
-    }
+    resolveFamily = handler;
   }
-}
+};
+function resolveFunctionForHotReloading(type) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return type;
+    }
 
-function commitHookEffectListUnmount(
-  flags,
-  finishedWork,
-  nearestMountedAncestor
-) {
-  var updateQueue = finishedWork.updateQueue;
-  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+    var family = resolveFamily(type);
 
-  if (lastEffect !== null) {
-    var firstEffect = lastEffect.next;
-    var effect = firstEffect;
+    if (family === undefined) {
+      return type;
+    } // Use the latest known implementation.
 
-    do {
-      if ((effect.tag & flags) === flags) {
-        // Unmount
-        var destroy = effect.destroy;
-        effect.destroy = undefined;
+    return family.current;
+  }
+}
+function resolveClassForHotReloading(type) {
+  // No implementation differences.
+  return resolveFunctionForHotReloading(type);
+}
+function resolveForwardRefForHotReloading(type) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return type;
+    }
 
-        if (destroy !== undefined) {
-          if (enableSchedulingProfiler) {
-            if ((flags & Passive) !== NoFlags) {
-              markComponentPassiveEffectUnmountStarted(finishedWork);
-            } else if ((flags & Layout) !== NoFlags) {
-              markComponentLayoutEffectUnmountStarted(finishedWork);
-            }
-          }
+    var family = resolveFamily(type);
 
-          {
-            if ((flags & Insertion) !== NoFlags) {
-              setIsRunningInsertionEffect(true);
-            }
-          }
+    if (family === undefined) {
+      // Check if we're dealing with a real forwardRef. Don't want to crash early.
+      if (
+        type !== null &&
+        type !== undefined &&
+        typeof type.render === "function"
+      ) {
+        // ForwardRef is special because its resolved .type is an object,
+        // but it's possible that we only have its inner render function in the map.
+        // If that inner render function is different, we'll build a new forwardRef type.
+        var currentRender = resolveFunctionForHotReloading(type.render);
 
-          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+        if (type.render !== currentRender) {
+          var syntheticType = {
+            $$typeof: REACT_FORWARD_REF_TYPE,
+            render: currentRender
+          };
 
-          {
-            if ((flags & Insertion) !== NoFlags) {
-              setIsRunningInsertionEffect(false);
-            }
+          if (type.displayName !== undefined) {
+            syntheticType.displayName = type.displayName;
           }
 
-          if (enableSchedulingProfiler) {
-            if ((flags & Passive) !== NoFlags) {
-              markComponentPassiveEffectUnmountStopped();
-            } else if ((flags & Layout) !== NoFlags) {
-              markComponentLayoutEffectUnmountStopped();
-            }
-          }
+          return syntheticType;
         }
       }
 
-      effect = effect.next;
-    } while (effect !== firstEffect);
+      return type;
+    } // Use the latest known implementation.
+
+    return family.current;
   }
 }
+function isCompatibleFamilyForHotReloading(fiber, element) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return false;
+    }
 
-function commitHookEffectListMount(flags, finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
-
-  if (lastEffect !== null) {
-    var firstEffect = lastEffect.next;
-    var effect = firstEffect;
-
-    do {
-      if ((effect.tag & flags) === flags) {
-        if (enableSchedulingProfiler) {
-          if ((flags & Passive) !== NoFlags) {
-            markComponentPassiveEffectMountStarted(finishedWork);
-          } else if ((flags & Layout) !== NoFlags) {
-            markComponentLayoutEffectMountStarted(finishedWork);
-          }
-        } // Mount
+    var prevType = fiber.elementType;
+    var nextType = element.type; // If we got here, we know types aren't === equal.
 
-        var create = effect.create;
+    var needsCompareFamilies = false;
+    var $$typeofNextType =
+      typeof nextType === "object" && nextType !== null
+        ? nextType.$$typeof
+        : null;
 
-        {
-          if ((flags & Insertion) !== NoFlags) {
-            setIsRunningInsertionEffect(true);
-          }
+    switch (fiber.tag) {
+      case ClassComponent: {
+        if (typeof nextType === "function") {
+          needsCompareFamilies = true;
         }
 
-        effect.destroy = create();
+        break;
+      }
 
-        {
-          if ((flags & Insertion) !== NoFlags) {
-            setIsRunningInsertionEffect(false);
-          }
+      case FunctionComponent: {
+        if (typeof nextType === "function") {
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          // We don't know the inner type yet.
+          // We're going to assume that the lazy inner type is stable,
+          // and so it is sufficient to avoid reconciling it away.
+          // We're not going to unwrap or actually use the new lazy type.
+          needsCompareFamilies = true;
         }
 
-        if (enableSchedulingProfiler) {
-          if ((flags & Passive) !== NoFlags) {
-            markComponentPassiveEffectMountStopped();
-          } else if ((flags & Layout) !== NoFlags) {
-            markComponentLayoutEffectMountStopped();
-          }
+        break;
+      }
+
+      case ForwardRef: {
+        if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          needsCompareFamilies = true;
         }
 
-        {
-          var destroy = effect.destroy;
+        break;
+      }
 
-          if (destroy !== undefined && typeof destroy !== "function") {
-            var hookName = void 0;
+      case MemoComponent:
+      case SimpleMemoComponent: {
+        if ($$typeofNextType === REACT_MEMO_TYPE) {
+          // TODO: if it was but can no longer be simple,
+          // we shouldn't set this.
+          needsCompareFamilies = true;
+        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
+          needsCompareFamilies = true;
+        }
 
-            if ((effect.tag & Layout) !== NoFlags$1) {
-              hookName = "useLayoutEffect";
-            } else if ((effect.tag & Insertion) !== NoFlags$1) {
-              hookName = "useInsertionEffect";
-            } else {
-              hookName = "useEffect";
-            }
+        break;
+      }
 
-            var addendum = void 0;
+      default:
+        return false;
+    } // Check if both types have a family and it's the same one.
 
-            if (destroy === null) {
-              addendum =
-                " You returned null. If your effect does not require clean " +
-                "up, return undefined (or nothing).";
-            } else if (typeof destroy.then === "function") {
-              addendum =
-                "\n\nIt looks like you wrote " +
-                hookName +
-                "(async () => ...) or returned a Promise. " +
-                "Instead, write the async function inside your effect " +
-                "and call it immediately:\n\n" +
-                hookName +
-                "(() => {\n" +
-                "  async function fetchData() {\n" +
-                "    // You can await here\n" +
-                "    const response = await MyAPI.getData(someId);\n" +
-                "    // ...\n" +
-                "  }\n" +
-                "  fetchData();\n" +
-                "}, [someId]); // Or [] if effect doesn't need props or state\n\n" +
-                "Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching";
-            } else {
-              addendum = " You returned: " + destroy;
-            }
+    if (needsCompareFamilies) {
+      // Note: memo() and forwardRef() we'll compare outer rather than inner type.
+      // This means both of them need to be registered to preserve state.
+      // If we unwrapped and compared the inner types for wrappers instead,
+      // then we would risk falsely saying two separate memo(Foo)
+      // calls are equivalent because they wrap the same Foo function.
+      var prevFamily = resolveFamily(prevType); // $FlowFixMe[not-a-function] found when upgrading Flow
 
-            error(
-              "%s must not return anything besides a function, " +
-                "which is used for clean-up.%s",
-              hookName,
-              addendum
-            );
-          }
-        }
+      if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
+        return true;
       }
+    }
 
-      effect = effect.next;
-    } while (effect !== firstEffect);
+    return false;
   }
 }
+function markFailedErrorBoundaryForHotReloading(fiber) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return;
+    }
 
-function commitUseEffectEventMount(finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  var eventPayloads = updateQueue !== null ? updateQueue.events : null;
+    if (typeof WeakSet !== "function") {
+      return;
+    }
 
-  if (eventPayloads !== null) {
-    for (var ii = 0; ii < eventPayloads.length; ii++) {
-      var _eventPayloads$ii = eventPayloads[ii],
-        ref = _eventPayloads$ii.ref,
-        nextImpl = _eventPayloads$ii.nextImpl;
-      ref.impl = nextImpl;
+    if (failedBoundaries === null) {
+      failedBoundaries = new WeakSet();
     }
+
+    failedBoundaries.add(fiber);
   }
 }
+var scheduleRefresh = function (root, update) {
+  {
+    if (resolveFamily === null) {
+      // Hot reloading is disabled.
+      return;
+    }
 
-function commitPassiveEffectDurations(finishedRoot, finishedWork) {
-  if (getExecutionContext() & CommitContext) {
-    // Only Profilers with work in their subtree will have an Update effect scheduled.
-    if ((finishedWork.flags & Update) !== NoFlags$1) {
-      switch (finishedWork.tag) {
-        case Profiler: {
-          var passiveEffectDuration =
-            finishedWork.stateNode.passiveEffectDuration;
-          var _finishedWork$memoize = finishedWork.memoizedProps,
-            id = _finishedWork$memoize.id,
-            onPostCommit = _finishedWork$memoize.onPostCommit; // This value will still reflect the previous commit phase.
-          // It does not get reset until the start of the next commit phase.
+    var staleFamilies = update.staleFamilies,
+      updatedFamilies = update.updatedFamilies;
+    flushPassiveEffects();
+    flushSync$1(function () {
+      scheduleFibersWithFamiliesRecursively(
+        root.current,
+        updatedFamilies,
+        staleFamilies
+      );
+    });
+  }
+};
+var scheduleRoot = function (root, element) {
+  {
+    if (root.context !== emptyContextObject) {
+      // Super edge case: root has a legacy _renderSubtree context
+      // but we don't know the parentComponent so we can't pass it.
+      // Just ignore. We'll delete this with _renderSubtree code path later.
+      return;
+    }
 
-          var commitTime = getCommitTime();
-          var phase = finishedWork.alternate === null ? "mount" : "update";
+    flushPassiveEffects();
+    flushSync$1(function () {
+      updateContainer(element, root, null, null);
+    });
+  }
+};
 
-          {
-            if (isCurrentUpdateNested()) {
-              phase = "nested-update";
-            }
-          }
+function scheduleFibersWithFamiliesRecursively(
+  fiber,
+  updatedFamilies,
+  staleFamilies
+) {
+  {
+    var alternate = fiber.alternate,
+      child = fiber.child,
+      sibling = fiber.sibling,
+      tag = fiber.tag,
+      type = fiber.type;
+    var candidateType = null;
 
-          if (typeof onPostCommit === "function") {
-            onPostCommit(id, phase, passiveEffectDuration, commitTime);
-          } // Bubble times to the next nearest ancestor Profiler.
-          // After we process that Profiler, we'll bubble further up.
+    switch (tag) {
+      case FunctionComponent:
+      case SimpleMemoComponent:
+      case ClassComponent:
+        candidateType = type;
+        break;
 
-          var parentFiber = finishedWork.return;
+      case ForwardRef:
+        candidateType = type.render;
+        break;
+    }
 
-          outer: while (parentFiber !== null) {
-            switch (parentFiber.tag) {
-              case HostRoot:
-                var root = parentFiber.stateNode;
-                root.passiveEffectDuration += passiveEffectDuration;
-                break outer;
+    if (resolveFamily === null) {
+      throw new Error("Expected resolveFamily to be set during hot reload.");
+    }
 
-              case Profiler:
-                var parentStateNode = parentFiber.stateNode;
-                parentStateNode.passiveEffectDuration += passiveEffectDuration;
-                break outer;
-            }
+    var needsRender = false;
+    var needsRemount = false;
 
-            parentFiber = parentFiber.return;
-          }
+    if (candidateType !== null) {
+      var family = resolveFamily(candidateType);
 
-          break;
+      if (family !== undefined) {
+        if (staleFamilies.has(family)) {
+          needsRemount = true;
+        } else if (updatedFamilies.has(family)) {
+          if (tag === ClassComponent) {
+            needsRemount = true;
+          } else {
+            needsRender = true;
+          }
         }
       }
     }
+
+    if (failedBoundaries !== null) {
+      if (
+        failedBoundaries.has(fiber) || // $FlowFixMe[incompatible-use] found when upgrading Flow
+        (alternate !== null && failedBoundaries.has(alternate))
+      ) {
+        needsRemount = true;
+      }
+    }
+
+    if (needsRemount) {
+      fiber._debugNeedsRemount = true;
+    }
+
+    if (needsRemount || needsRender) {
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
+    }
+
+    if (child !== null && !needsRemount) {
+      scheduleFibersWithFamiliesRecursively(
+        child,
+        updatedFamilies,
+        staleFamilies
+      );
+    }
+
+    if (sibling !== null) {
+      scheduleFibersWithFamiliesRecursively(
+        sibling,
+        updatedFamilies,
+        staleFamilies
+      );
+    }
   }
 }
 
-function commitHookLayoutEffects(finishedWork, hookFlags) {
-  // At this point layout effects have already been destroyed (during mutation phase).
-  // This is done to prevent sibling component effects from interfering with each other,
-  // e.g. a destroy function in one component should never override a ref set
-  // by a create function in another component during the same commit.
-  if (shouldProfile(finishedWork)) {
-    try {
-      startLayoutEffectTimer();
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+var findHostInstancesForRefresh = function (root, families) {
+  {
+    var hostInstances = new Set();
+    var types = new Set(
+      families.map(function (family) {
+        return family.current;
+      })
+    );
+    findHostInstancesForMatchingFibersRecursively(
+      root.current,
+      types,
+      hostInstances
+    );
+    return hostInstances;
+  }
+};
+
+function findHostInstancesForMatchingFibersRecursively(
+  fiber,
+  types,
+  hostInstances
+) {
+  {
+    var child = fiber.child,
+      sibling = fiber.sibling,
+      tag = fiber.tag,
+      type = fiber.type;
+    var candidateType = null;
+
+    switch (tag) {
+      case FunctionComponent:
+      case SimpleMemoComponent:
+      case ClassComponent:
+        candidateType = type;
+        break;
+
+      case ForwardRef:
+        candidateType = type.render;
+        break;
+    }
+
+    var didMatch = false;
+
+    if (candidateType !== null) {
+      if (types.has(candidateType)) {
+        didMatch = true;
+      }
+    }
+
+    if (didMatch) {
+      // We have a match. This only drills down to the closest host components.
+      // There's no need to search deeper because for the purpose of giving
+      // visual feedback, "flashing" outermost parent rectangles is sufficient.
+      findHostInstancesForFiberShallowly(fiber, hostInstances);
+    } else {
+      // If there's no match, maybe there will be one further down in the child tree.
+      if (child !== null) {
+        findHostInstancesForMatchingFibersRecursively(
+          child,
+          types,
+          hostInstances
+        );
+      }
     }
 
-    recordLayoutEffectDuration(finishedWork);
-  } else {
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    if (sibling !== null) {
+      findHostInstancesForMatchingFibersRecursively(
+        sibling,
+        types,
+        hostInstances
+      );
     }
   }
 }
 
-function commitClassLayoutLifecycles(finishedWork, current) {
-  var instance = finishedWork.stateNode;
-
-  if (current === null) {
-    // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
-    {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "componentDidMount. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+function findHostInstancesForFiberShallowly(fiber, hostInstances) {
+  {
+    var foundHostInstances = findChildHostInstancesForFiberShallowly(
+      fiber,
+      hostInstances
+    );
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "componentDidMount. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
-      }
-    }
+    if (foundHostInstances) {
+      return;
+    } // If we didn't find any host children, fallback to closest host parent.
 
-    if (shouldProfile(finishedWork)) {
-      try {
-        startLayoutEffectTimer();
-        instance.componentDidMount();
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
+    var node = fiber;
 
-      recordLayoutEffectDuration(finishedWork);
-    } else {
-      try {
-        instance.componentDidMount();
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
-    }
-  } else {
-    var prevProps =
-      finishedWork.elementType === finishedWork.type
-        ? current.memoizedProps
-        : resolveDefaultProps(finishedWork.type, current.memoizedProps);
-    var prevState = current.memoizedState; // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
+    while (true) {
+      switch (node.tag) {
+        case HostSingleton:
+        case HostComponent:
+          hostInstances.add(node.stateNode);
+          return;
 
-    {
-      if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
-      ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "componentDidUpdate. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+        case HostPortal:
+          hostInstances.add(node.stateNode.containerInfo);
+          return;
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "componentDidUpdate. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+        case HostRoot:
+          hostInstances.add(node.stateNode.containerInfo);
+          return;
       }
-    }
 
-    if (shouldProfile(finishedWork)) {
-      try {
-        startLayoutEffectTimer();
-        instance.componentDidUpdate(
-          prevProps,
-          prevState,
-          instance.__reactInternalSnapshotBeforeUpdate
-        );
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      if (node.return === null) {
+        throw new Error("Expected to reach root first.");
       }
 
-      recordLayoutEffectDuration(finishedWork);
-    } else {
-      try {
-        instance.componentDidUpdate(
-          prevProps,
-          prevState,
-          instance.__reactInternalSnapshotBeforeUpdate
-        );
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
-      }
+      node = node.return;
     }
   }
 }
 
-function commitClassCallbacks(finishedWork) {
-  // TODO: I think this is now always non-null by the time it reaches the
-  // commit phase. Consider removing the type check.
-  var updateQueue = finishedWork.updateQueue;
-
-  if (updateQueue !== null) {
-    var instance = finishedWork.stateNode;
+function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
+  {
+    var node = fiber;
+    var foundHostInstances = false;
 
-    {
+    while (true) {
       if (
-        finishedWork.type === finishedWork.elementType &&
-        !didWarnAboutReassigningProps
+        node.tag === HostComponent ||
+        node.tag === HostHoistable ||
+        node.tag === HostSingleton
       ) {
-        if (instance.props !== finishedWork.memoizedProps) {
-          error(
-            "Expected %s props to match memoized props before " +
-              "processing the update queue. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.props`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
-        }
+        // We got a match.
+        foundHostInstances = true;
+        hostInstances.add(node.stateNode); // There may still be more, so keep searching.
+      } else if (node.child !== null) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
 
-        if (instance.state !== finishedWork.memoizedState) {
-          error(
-            "Expected %s state to match memoized state before " +
-              "processing the update queue. " +
-              "This might either be because of a bug in React, or because " +
-              "a component reassigns its own `this.state`. " +
-              "Please file an issue.",
-            getComponentNameFromFiber(finishedWork) || "instance"
-          );
+      if (node === fiber) {
+        return foundHostInstances;
+      }
+
+      while (node.sibling === null) {
+        if (node.return === null || node.return === fiber) {
+          return foundHostInstances;
         }
+
+        node = node.return;
       }
-    } // We could update instance props and state here,
-    // but instead we rely on them being set during last render.
-    // TODO: revisit this when we implement resuming.
 
-    try {
-      commitCallbacks(updateQueue, instance);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      node.sibling.return = node.return;
+      node = node.sibling;
     }
   }
+
+  return false;
 }
 
-function commitHostComponentMount(finishedWork) {
-  var type = finishedWork.type;
-  var props = finishedWork.memoizedProps;
-  var instance = finishedWork.stateNode;
+var hasBadMapPolyfill;
+
+{
+  hasBadMapPolyfill = false;
 
   try {
-    commitMount(instance, type, props, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    var nonExtensibleObject = Object.preventExtensions({});
+    /* eslint-disable no-new */
+
+    new Map([[nonExtensibleObject, null]]);
+    new Set([nonExtensibleObject]);
+    /* eslint-enable no-new */
+  } catch (e) {
+    // TODO: Consider warning about bad polyfills
+    hasBadMapPolyfill = true;
   }
 }
 
-function commitProfilerUpdate(finishedWork, current) {
-  if (getExecutionContext() & CommitContext) {
-    try {
-      var _finishedWork$memoize2 = finishedWork.memoizedProps,
-        onCommit = _finishedWork$memoize2.onCommit,
-        onRender = _finishedWork$memoize2.onRender;
-      var effectDuration = finishedWork.stateNode.effectDuration;
-      var commitTime = getCommitTime();
-      var phase = current === null ? "mount" : "update";
-
-      if (enableProfilerNestedUpdatePhase) {
-        if (isCurrentUpdateNested()) {
-          phase = "nested-update";
-        }
-      }
-
-      if (typeof onRender === "function") {
-        onRender(
-          finishedWork.memoizedProps.id,
-          phase,
-          finishedWork.actualDuration,
-          finishedWork.treeBaseDuration,
-          finishedWork.actualStartTime,
-          commitTime
-        );
-      }
+function FiberNode(tag, pendingProps, key, mode) {
+  // Instance
+  this.tag = tag;
+  this.key = key;
+  this.elementType = null;
+  this.type = null;
+  this.stateNode = null; // Fiber
 
-      if (enableProfilerCommitHooks) {
-        if (typeof onCommit === "function") {
-          onCommit(
-            finishedWork.memoizedProps.id,
-            phase,
-            effectDuration,
-            commitTime
-          );
-        } // Schedule a passive effect for this Profiler to call onPostCommit hooks.
-        // This effect should be scheduled even if there is no onPostCommit callback for this Profiler,
-        // because the effect is also where times bubble to parent Profilers.
+  this.return = null;
+  this.child = null;
+  this.sibling = null;
+  this.index = 0;
+  this.ref = null;
+  this.refCleanup = null;
+  this.pendingProps = pendingProps;
+  this.memoizedProps = null;
+  this.updateQueue = null;
+  this.memoizedState = null;
+  this.dependencies = null;
+  this.mode = mode; // Effects
 
-        enqueuePendingPassiveProfilerEffect(finishedWork); // Propagate layout effect durations to the next nearest Profiler ancestor.
-        // Do not reset these values until the next render so DevTools has a chance to read them first.
+  this.flags = NoFlags$1;
+  this.subtreeFlags = NoFlags$1;
+  this.deletions = null;
+  this.lanes = NoLanes;
+  this.childLanes = NoLanes;
+  this.alternate = null;
 
-        var parentFiber = finishedWork.return;
+  {
+    // Note: The following is done to avoid a v8 performance cliff.
+    //
+    // Initializing the fields below to smis and later updating them with
+    // double values will cause Fibers to end up having separate shapes.
+    // This behavior/bug has something to do with Object.preventExtension().
+    // Fortunately this only impacts DEV builds.
+    // Unfortunately it makes React unusably slow for some applications.
+    // To work around this, initialize the fields below with doubles.
+    //
+    // Learn more about this here:
+    // https://github.com/facebook/react/issues/14365
+    // https://bugs.chromium.org/p/v8/issues/detail?id=8538
+    this.actualDuration = Number.NaN;
+    this.actualStartTime = Number.NaN;
+    this.selfBaseDuration = Number.NaN;
+    this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
+    // This won't trigger the performance cliff mentioned above,
+    // and it simplifies other profiler code (including DevTools).
 
-        outer: while (parentFiber !== null) {
-          switch (parentFiber.tag) {
-            case HostRoot:
-              var root = parentFiber.stateNode;
-              root.effectDuration += effectDuration;
-              break outer;
+    this.actualDuration = 0;
+    this.actualStartTime = -1;
+    this.selfBaseDuration = 0;
+    this.treeBaseDuration = 0;
+  }
 
-            case Profiler:
-              var parentStateNode = parentFiber.stateNode;
-              parentStateNode.effectDuration += effectDuration;
-              break outer;
-          }
+  {
+    // This isn't directly used but is handy for debugging internals:
+    this._debugSource = null;
+    this._debugOwner = null;
+    this._debugNeedsRemount = false;
+    this._debugHookTypes = null;
 
-          parentFiber = parentFiber.return;
-        }
-      }
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
+      Object.preventExtensions(this);
     }
   }
-}
+} // This is a constructor function, rather than a POJO constructor, still
+// please ensure we do the following:
+// 1) Nobody should add any instance methods on this. Instance methods can be
+//    more difficult to predict when they get optimized and they are almost
+//    never inlined properly in static compilers.
+// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
+//    always know when it is a fiber.
+// 3) We might want to experiment with using numeric keys since they are easier
+//    to optimize in a non-JIT environment.
+// 4) We can easily go from a constructor to a createFiber object literal if that
+//    is faster.
+// 5) It should be easy to port this to a C struct and keep a C implementation
+//    compatible.
 
-function commitLayoutEffectOnFiber(
-  finishedRoot,
-  current,
-  finishedWork,
-  committedLanes
-) {
-  // When updating this function, also update reappearLayoutEffects, which does
-  // most of the same things when an offscreen tree goes from hidden -> visible.
-  var flags = finishedWork.flags;
+function createFiber(tag, pendingProps, key, mode) {
+  // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
+  return new FiberNode(tag, pendingProps, key, mode);
+}
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+function shouldConstruct(Component) {
+  var prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
 
-      if (flags & Update) {
-        commitHookLayoutEffects(finishedWork, Layout | HasEffect);
-      }
+function isSimpleFunctionComponent(type) {
+  return (
+    typeof type === "function" &&
+    !shouldConstruct(type) &&
+    type.defaultProps === undefined
+  );
+}
+function resolveLazyComponentTag(Component) {
+  if (typeof Component === "function") {
+    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+  } else if (Component !== undefined && Component !== null) {
+    var $$typeof = Component.$$typeof;
 
-      break;
+    if ($$typeof === REACT_FORWARD_REF_TYPE) {
+      return ForwardRef;
     }
 
-    case ClassComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    if ($$typeof === REACT_MEMO_TYPE) {
+      return MemoComponent;
+    }
+  }
 
-      if (flags & Update) {
-        commitClassLayoutLifecycles(finishedWork, current);
-      }
+  return IndeterminateComponent;
+} // This is used to create an alternate fiber to do work on.
 
-      if (flags & Callback) {
-        commitClassCallbacks(finishedWork);
-      }
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
 
-      if (flags & Ref) {
-        safelyAttachRef(finishedWork, finishedWork.return);
-      }
+  if (workInProgress === null) {
+    // We use a double buffering pooling technique because we know that we'll
+    // only ever need at most two versions of a tree. We pool the "other" unused
+    // node that we're free to reuse. This is lazily created to avoid allocating
+    // extra objects for things that are never updated. It also allow us to
+    // reclaim the extra memory if needed.
+    workInProgress = createFiber(
+      current.tag,
+      pendingProps,
+      current.key,
+      current.mode
+    );
+    workInProgress.elementType = current.elementType;
+    workInProgress.type = current.type;
+    workInProgress.stateNode = current.stateNode;
 
-      break;
+    {
+      // DEV-only fields
+      workInProgress._debugSource = current._debugSource;
+      workInProgress._debugOwner = current._debugOwner;
+      workInProgress._debugHookTypes = current._debugHookTypes;
     }
 
-    case HostRoot: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    workInProgress.alternate = current;
+    current.alternate = workInProgress;
+  } else {
+    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
 
-      if (flags & Callback) {
-        // TODO: I think this is now always non-null by the time it reaches the
-        // commit phase. Consider removing the type check.
-        var updateQueue = finishedWork.updateQueue;
+    workInProgress.type = current.type; // We already have an alternate.
+    // Reset the effect tag.
 
-        if (updateQueue !== null) {
-          var instance = null;
+    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
 
-          if (finishedWork.child !== null) {
-            switch (finishedWork.child.tag) {
-              case HostSingleton:
-              case HostComponent:
-                instance = getPublicInstance(finishedWork.child.stateNode);
-                break;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
 
-              case ClassComponent:
-                instance = finishedWork.child.stateNode;
-                break;
-            }
-          }
+    {
+      // We intentionally reset, rather than copy, actualDuration & actualStartTime.
+      // This prevents time from endlessly accumulating in new commits.
+      // This has the downside of resetting values for different priority renders,
+      // But works for yielding (the common case) and should support resuming.
+      workInProgress.actualDuration = 0;
+      workInProgress.actualStartTime = -1;
+    }
+  } // Reset all effects except static ones.
+  // Static effects are not specific to a render.
 
-          try {
-            commitCallbacks(updateQueue, instance);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
+  workInProgress.flags = current.flags & StaticMask;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
+  // it cannot be shared with the current fiber.
 
-      break;
-    }
+  var currentDependencies = current.dependencies;
+  workInProgress.dependencies =
+    currentDependencies === null
+      ? null
+      : {
+          lanes: currentDependencies.lanes,
+          firstContext: currentDependencies.firstContext
+        }; // These will be overridden during the parent's reconciliation
+
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+
+  {
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
+  }
+
+  {
+    workInProgress._debugNeedsRemount = current._debugNeedsRemount;
 
-    case HostHoistable: {
-      {
-        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    switch (workInProgress.tag) {
+      case IndeterminateComponent:
+      case FunctionComponent:
+      case SimpleMemoComponent:
+        workInProgress.type = resolveFunctionForHotReloading(current.type);
+        break;
 
-        if (flags & Ref) {
-          safelyAttachRef(finishedWork, finishedWork.return);
-        }
+      case ClassComponent:
+        workInProgress.type = resolveClassForHotReloading(current.type);
+        break;
 
+      case ForwardRef:
+        workInProgress.type = resolveForwardRefForHotReloading(current.type);
         break;
-      }
     }
-    // eslint-disable-next-line-no-fallthrough
+  }
 
-    case HostSingleton:
-    case HostComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // Renderers may schedule work to be done after host components are mounted
-      // (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.
+  return workInProgress;
+} // Used to reuse a Fiber for a second pass.
 
-      if (current === null && flags & Update) {
-        commitHostComponentMount(finishedWork);
-      }
+function resetWorkInProgress(workInProgress, renderLanes) {
+  // This resets the Fiber to what createFiber or createWorkInProgress would
+  // have set the values to before during the first pass. Ideally this wouldn't
+  // be necessary but unfortunately many code paths reads from the workInProgress
+  // when they should be reading from current and writing to workInProgress.
+  // We assume pendingProps, index, key, ref, return are still untouched to
+  // avoid doing another reconciliation.
+  // Reset the effect flags but keep any Placement tags, since that's something
+  // that child fiber is setting, not the reconciliation.
+  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
 
-      if (flags & Ref) {
-        safelyAttachRef(finishedWork, finishedWork.return);
-      }
+  var current = workInProgress.alternate;
 
-      break;
+  if (current === null) {
+    // Reset to createFiber's initial values.
+    workInProgress.childLanes = NoLanes;
+    workInProgress.lanes = renderLanes;
+    workInProgress.child = null;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.memoizedProps = null;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.dependencies = null;
+    workInProgress.stateNode = null;
+
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = 0;
+      workInProgress.treeBaseDuration = 0;
     }
+  } else {
+    // Reset to the cloned values that createWorkInProgress would've.
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.subtreeFlags = NoFlags$1;
+    workInProgress.deletions = null;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
 
-    case Profiler: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork); // TODO: Should this fire inside an offscreen tree? Or should it wait to
-      // fire when the tree becomes visible again.
+    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
+    // it cannot be shared with the current fiber.
 
-      if (flags & Update) {
-        commitProfilerUpdate(finishedWork, current);
-      }
+    var currentDependencies = current.dependencies;
+    workInProgress.dependencies =
+      currentDependencies === null
+        ? null
+        : {
+            lanes: currentDependencies.lanes,
+            firstContext: currentDependencies.firstContext
+          };
 
-      break;
+    {
+      // Note: We don't reset the actualTime counts. It's useful to accumulate
+      // actual time across multiple render passes.
+      workInProgress.selfBaseDuration = current.selfBaseDuration;
+      workInProgress.treeBaseDuration = current.treeBaseDuration;
     }
+  }
 
-    case SuspenseComponent: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+  return workInProgress;
+}
+function createHostRootFiber(
+  tag,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride
+) {
+  var mode;
 
-      if (flags & Update) {
-        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
-      }
+  if (tag === ConcurrentRoot) {
+    mode = ConcurrentMode;
 
-      break;
+    if (isStrictMode === true || createRootStrictEffectsByDefault) {
+      mode |= StrictLegacyMode | StrictEffectsMode;
     }
 
-    case OffscreenComponent: {
-      var isModernRoot = (finishedWork.mode & ConcurrentMode) !== NoMode;
-
-      if (isModernRoot) {
-        var isHidden = finishedWork.memoizedState !== null;
-        var newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+    if (
+      // Only for internal experiments.
+      concurrentUpdatesByDefaultOverride
+    ) {
+      mode |= ConcurrentUpdatesByDefaultMode;
+    }
+  } else {
+    mode = NoMode;
+  }
 
-        if (newOffscreenSubtreeIsHidden);
-        else {
-          // The Offscreen tree is visible.
-          var wasHidden = current !== null && current.memoizedState !== null;
-          var newOffscreenSubtreeWasHidden =
-            wasHidden || offscreenSubtreeWasHidden;
-          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
-          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-          offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+  if (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;
+  }
 
-          if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
-            // This is the root of a reappearing boundary. As we continue
-            // traversing the layout effects, we must also re-mount layout
-            // effects that were unmounted when the Offscreen subtree was
-            // hidden. So this is a superset of the normal commitLayoutEffects.
-            var includeWorkInProgressEffects =
-              (finishedWork.subtreeFlags & LayoutMask) !== NoFlags$1;
-            recursivelyTraverseReappearLayoutEffects(
-              finishedRoot,
-              finishedWork,
-              includeWorkInProgressEffects
-            );
-          } else {
-            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-          }
+  return createFiber(HostRoot, null, null, mode);
+}
+function createFiberFromTypeAndProps(
+  type, // React$ElementType
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
+) {
+  var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
 
-          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-        }
-      } else {
-        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      }
+  var resolvedType = type;
 
-      if (flags & Ref) {
-        var props = finishedWork.memoizedProps;
+  if (typeof type === "function") {
+    if (shouldConstruct(type)) {
+      fiberTag = ClassComponent;
 
-        if (props.mode === "manual") {
-          safelyAttachRef(finishedWork, finishedWork.return);
-        } else {
-          safelyDetachRef(finishedWork, finishedWork.return);
-        }
+      {
+        resolvedType = resolveClassForHotReloading(resolvedType);
+      }
+    } else {
+      {
+        resolvedType = resolveFunctionForHotReloading(resolvedType);
       }
-
-      break;
     }
-
-    default: {
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      break;
+  } else if (typeof type === "string") {
+    {
+      var hostContext = getHostContext();
+      fiberTag = isHostHoistableType(type, pendingProps, hostContext)
+        ? HostHoistable
+        : isHostSingletonType(type)
+        ? HostSingleton
+        : HostComponent;
     }
-  }
-}
+  } else {
+    getTag: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
 
-function abortRootTransitions(
-  root,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var rootTransitions = root.incompleteTransitions;
-    deletedTransitions.forEach(function (transition) {
-      if (rootTransitions.has(transition)) {
-        var transitionInstance = rootTransitions.get(transition);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = Mode;
+        mode |= StrictLegacyMode;
 
-        if (transitionInstance.aborts === null) {
-          transitionInstance.aborts = [];
+        if ((mode & ConcurrentMode) !== NoMode) {
+          // Strict effects should never run on legacy roots
+          mode |= StrictEffectsMode;
         }
 
-        transitionInstance.aborts.push(abort);
+        break;
 
-        if (deletedOffscreenInstance !== null) {
-          if (
-            transitionInstance.pendingBoundaries !== null &&
-            transitionInstance.pendingBoundaries.has(deletedOffscreenInstance)
-          ) {
-            // $FlowFixMe[incompatible-use] found when upgrading Flow
-            transitionInstance.pendingBoundaries.delete(
-              deletedOffscreenInstance
-            );
-          }
-        }
-      }
-    });
-  }
-}
+      case REACT_PROFILER_TYPE:
+        return createFiberFromProfiler(pendingProps, mode, lanes, key);
 
-function abortTracingMarkerTransitions(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var markerInstance = abortedFiber.stateNode;
-    var markerTransitions = markerInstance.transitions;
-    var pendingBoundaries = markerInstance.pendingBoundaries;
+      case REACT_SUSPENSE_TYPE:
+        return createFiberFromSuspense(pendingProps, mode, lanes, key);
 
-    if (markerTransitions !== null) {
-      // TODO: Refactor this code. Is there a way to move this code to
-      // the deletions phase instead of calculating it here while making sure
-      // complete is called appropriately?
-      deletedTransitions.forEach(function (transition) {
-        // If one of the transitions on the tracing marker is a transition
-        // that was in an aborted subtree, we will abort that tracing marker
-        if (
-          abortedFiber !== null &&
-          markerTransitions.has(transition) &&
-          (markerInstance.aborts === null ||
-            !markerInstance.aborts.includes(abort))
-        ) {
-          if (markerInstance.transitions !== null) {
-            if (markerInstance.aborts === null) {
-              markerInstance.aborts = [abort];
-              addMarkerIncompleteCallbackToPendingTransition(
-                abortedFiber.memoizedProps.name,
-                markerInstance.transitions,
-                markerInstance.aborts
-              );
-            } else {
-              markerInstance.aborts.push(abort);
-            } // We only want to call onTransitionProgress when the marker hasn't been
-            // deleted
+      case REACT_SUSPENSE_LIST_TYPE:
+        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
 
-            if (
-              deletedOffscreenInstance !== null &&
-              !isInDeletedTree &&
-              pendingBoundaries !== null &&
-              pendingBoundaries.has(deletedOffscreenInstance)
-            ) {
-              pendingBoundaries.delete(deletedOffscreenInstance);
-              addMarkerProgressCallbackToPendingTransition(
-                abortedFiber.memoizedProps.name,
-                deletedTransitions,
-                pendingBoundaries
-              );
-            }
-          }
-        }
-      });
-    }
-  }
-}
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
 
-function abortParentMarkerTransitionsForDeletedFiber(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    // Find all pending markers that are waiting on child suspense boundaries in the
-    // aborted subtree and cancels them
-    var fiber = abortedFiber;
+      case REACT_LEGACY_HIDDEN_TYPE: {
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      }
 
-    while (fiber !== null) {
-      switch (fiber.tag) {
-        case TracingMarkerComponent:
-          abortTracingMarkerTransitions(
-            fiber,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance,
-            isInDeletedTree
-          );
-          break;
+      // eslint-disable-next-line no-fallthrough
 
-        case HostRoot:
-          var root = fiber.stateNode;
-          abortRootTransitions(
-            root,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance
-          );
-          break;
+      case REACT_SCOPE_TYPE: {
+        return createFiberFromScope(type, pendingProps, mode, lanes, key);
       }
 
-      fiber = fiber.return;
-    }
-  }
-}
+      // eslint-disable-next-line no-fallthrough
 
-function commitTransitionProgress(offscreenFiber) {
-  if (enableTransitionTracing) {
-    // This function adds suspense boundaries to the root
-    // or tracing marker's pendingBoundaries map.
-    // When a suspense boundary goes from a resolved to a fallback
-    // state we add the boundary to the map, and when it goes from
-    // a fallback to a resolved state, we remove the boundary from
-    // the map.
-    // We use stateNode on the Offscreen component as a stable object
-    // that doesnt change from render to render. This way we can
-    // distinguish between different Offscreen instances (vs. the same
-    // Offscreen instance with different fibers)
-    var offscreenInstance = offscreenFiber.stateNode;
-    var prevState = null;
-    var previousFiber = offscreenFiber.alternate;
+      case REACT_CACHE_TYPE: {
+        return createFiberFromCache(pendingProps, mode, lanes, key);
+      }
 
-    if (previousFiber !== null && previousFiber.memoizedState !== null) {
-      prevState = previousFiber.memoizedState;
-    }
+      // eslint-disable-next-line no-fallthrough
 
-    var nextState = offscreenFiber.memoizedState;
-    var wasHidden = prevState !== null;
-    var isHidden = nextState !== null;
-    var pendingMarkers = offscreenInstance._pendingMarkers; // If there is a name on the suspense boundary, store that in
-    // the pending boundaries.
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing) {
+          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
+        }
 
-    var name = null;
-    var parent = offscreenFiber.return;
+      // eslint-disable-next-line no-fallthrough
 
-    if (
-      parent !== null &&
-      parent.tag === SuspenseComponent &&
-      parent.memoizedProps.unstable_name
-    ) {
-      name = parent.memoizedProps.unstable_name;
-    }
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = Mode;
+          mode |= DebugTracingMode;
+          break;
+        }
 
-    if (!wasHidden && isHidden) {
-      // The suspense boundaries was just hidden. Add the boundary
-      // to the pending boundary set if it's there
-      if (pendingMarkers !== null) {
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries;
-          var transitions = markerInstance.transitions;
-          var markerName = markerInstance.name;
+      // eslint-disable-next-line no-fallthrough
 
-          if (
-            pendingBoundaries !== null &&
-            !pendingBoundaries.has(offscreenInstance)
-          ) {
-            pendingBoundaries.set(offscreenInstance, {
-              name: name
-            });
+      default: {
+        if (typeof type === "object" && type !== null) {
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = ContextProvider;
+              break getTag;
 
-            if (transitions !== null) {
-              if (
-                markerInstance.tag === TransitionTracingMarker &&
-                markerName !== null
-              ) {
-                addMarkerProgressCallbackToPendingTransition(
-                  markerName,
-                  transitions,
-                  pendingBoundaries
-                );
-              } else if (markerInstance.tag === TransitionRoot) {
-                transitions.forEach(function (transition) {
-                  addTransitionProgressCallbackToPendingTransition(
-                    transition,
-                    pendingBoundaries
-                  );
-                });
+            case REACT_CONTEXT_TYPE:
+              // This is a consumer
+              fiberTag = ContextConsumer;
+              break getTag;
+
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = ForwardRef;
+
+              {
+                resolvedType = resolveForwardRefForHotReloading(resolvedType);
               }
-            }
+
+              break getTag;
+
+            case REACT_MEMO_TYPE:
+              fiberTag = MemoComponent;
+              break getTag;
+
+            case REACT_LAZY_TYPE:
+              fiberTag = LazyComponent;
+              resolvedType = null;
+              break getTag;
           }
-        });
-      }
-    } else if (wasHidden && !isHidden) {
-      // The suspense boundary went from hidden to visible. Remove
-      // the boundary from the pending suspense boundaries set
-      // if it's there
-      if (pendingMarkers !== null) {
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries;
-          var transitions = markerInstance.transitions;
-          var markerName = markerInstance.name;
+        }
+
+        var info = "";
 
+        {
           if (
-            pendingBoundaries !== null &&
-            pendingBoundaries.has(offscreenInstance)
+            type === undefined ||
+            (typeof type === "object" &&
+              type !== null &&
+              Object.keys(type).length === 0)
           ) {
-            pendingBoundaries.delete(offscreenInstance);
-
-            if (transitions !== null) {
-              if (
-                markerInstance.tag === TransitionTracingMarker &&
-                markerName !== null
-              ) {
-                addMarkerProgressCallbackToPendingTransition(
-                  markerName,
-                  transitions,
-                  pendingBoundaries
-                ); // If there are no more unresolved suspense boundaries, the interaction
-                // is considered finished
-
-                if (pendingBoundaries.size === 0) {
-                  if (markerInstance.aborts === null) {
-                    addMarkerCompleteCallbackToPendingTransition(
-                      markerName,
-                      transitions
-                    );
-                  }
+            info +=
+              " You likely forgot to export your component from the file " +
+              "it's defined in, or you might have mixed up default and " +
+              "named imports.";
+          }
 
-                  markerInstance.transitions = null;
-                  markerInstance.pendingBoundaries = null;
-                  markerInstance.aborts = null;
-                }
-              } else if (markerInstance.tag === TransitionRoot) {
-                transitions.forEach(function (transition) {
-                  addTransitionProgressCallbackToPendingTransition(
-                    transition,
-                    pendingBoundaries
-                  );
-                });
-              }
-            }
+          var ownerName = owner ? getComponentNameFromFiber(owner) : null;
+
+          if (ownerName) {
+            info += "\n\nCheck the render method of `" + ownerName + "`.";
           }
-        });
+        }
+
+        throw new Error(
+          "Element type is invalid: expected a string (for built-in " +
+            "components) or a class/function (for composite components) " +
+            ("but got: " + (type == null ? type : typeof type) + "." + info)
+        );
       }
     }
   }
-}
 
-function hideOrUnhideAllChildren(finishedWork, isHidden) {
-  // Only hide or unhide the top-most host nodes.
-  var hostSubtreeRoot = null;
+  var fiber = createFiber(fiberTag, pendingProps, key, mode);
+  fiber.elementType = type;
+  fiber.type = resolvedType;
+  fiber.lanes = lanes;
 
   {
-    // We only have the top Fiber that was inserted but we need to recurse down its
-    // children to find all the terminal nodes.
-    var node = finishedWork;
+    fiber._debugOwner = owner;
+  }
 
-    while (true) {
-      if (
-        node.tag === HostComponent ||
-        node.tag === HostHoistable ||
-        node.tag === HostSingleton
-      ) {
-        if (hostSubtreeRoot === null) {
-          hostSubtreeRoot = node;
+  return fiber;
+}
+function createFiberFromElement(element, mode, lanes) {
+  var owner = null;
 
-          try {
-            var instance = node.stateNode;
+  {
+    owner = element._owner;
+  }
 
-            if (isHidden) {
-              hideInstance(instance);
-            } else {
-              unhideInstance(node.stateNode, node.memoizedProps);
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      } else if (node.tag === HostText) {
-        if (hostSubtreeRoot === null) {
-          try {
-            var _instance = node.stateNode;
+  var type = element.type;
+  var key = element.key;
+  var pendingProps = element.props;
+  var fiber = createFiberFromTypeAndProps(
+    type,
+    key,
+    pendingProps,
+    owner,
+    mode,
+    lanes
+  );
 
-            if (isHidden) {
-              hideTextInstance(_instance);
-            } else {
-              unhideTextInstance(_instance, node.memoizedProps);
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      } else if (
-        (node.tag === OffscreenComponent ||
-          node.tag === LegacyHiddenComponent) &&
-        node.memoizedState !== null &&
-        node !== finishedWork
-      );
-      else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
+  {
+    fiber._debugSource = element._source;
+    fiber._debugOwner = element._owner;
+  }
 
-      if (node === finishedWork) {
-        return;
-      }
+  return fiber;
+}
+function createFiberFromFragment(elements, mode, lanes, key) {
+  var fiber = createFiber(Fragment, elements, key, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
 
-      while (node.sibling === null) {
-        if (node.return === null || node.return === finishedWork) {
-          return;
-        }
+function createFiberFromScope(scope, pendingProps, mode, lanes, key) {
+  var fiber = createFiber(ScopeComponent, pendingProps, key, mode);
+  fiber.type = scope;
+  fiber.elementType = scope;
+  fiber.lanes = lanes;
+  return fiber;
+}
 
-        if (hostSubtreeRoot === node) {
-          hostSubtreeRoot = null;
-        }
+function createFiberFromProfiler(pendingProps, mode, lanes, key) {
+  {
+    if (typeof pendingProps.id !== "string") {
+      error(
+        'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
+        typeof pendingProps.id
+      );
+    }
+  }
 
-        node = node.return;
-      }
+  var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+  fiber.elementType = REACT_PROFILER_TYPE;
+  fiber.lanes = lanes;
 
-      if (hostSubtreeRoot === node) {
-        hostSubtreeRoot = null;
-      }
+  {
+    fiber.stateNode = {
+      effectDuration: 0,
+      passiveEffectDuration: 0
+    };
+  }
 
-      node.sibling.return = node.return;
-      node = node.sibling;
+  return fiber;
+}
+
+function createFiberFromSuspense(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_OFFSCREEN_TYPE;
+  fiber.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
+    }
+  };
+  fiber.stateNode = primaryChildInstance;
+  return fiber;
+}
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(LegacyHiddenComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  fiber.lanes = lanes; // Adding a stateNode for legacy hidden because it's currently using
+  // the offscreen implementation, which depends on a state node
+
+  var instance = {
+    _visibility: OffscreenVisible,
+    _pendingVisibility: OffscreenVisible,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
     }
+  };
+  fiber.stateNode = instance;
+  return fiber;
+}
+function createFiberFromCache(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(CacheComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_CACHE_TYPE;
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromTracingMarker(pendingProps, mode, lanes, key) {
+  var fiber = createFiber(TracingMarkerComponent, pendingProps, key, mode);
+  fiber.elementType = REACT_TRACING_MARKER_TYPE;
+  fiber.lanes = lanes;
+  var tracingMarkerInstance = {
+    tag: TransitionTracingMarker,
+    transitions: null,
+    pendingBoundaries: null,
+    aborts: null,
+    name: pendingProps.name
+  };
+  fiber.stateNode = tracingMarkerInstance;
+  return fiber;
+}
+function createFiberFromText(content, mode, lanes) {
+  var fiber = createFiber(HostText, content, null, mode);
+  fiber.lanes = lanes;
+  return fiber;
+}
+function createFiberFromHostInstanceForDeletion() {
+  var fiber = createFiber(HostComponent, null, null, NoMode);
+  fiber.elementType = "DELETED";
+  return fiber;
+}
+function createFiberFromDehydratedFragment(dehydratedNode) {
+  var fiber = createFiber(DehydratedFragment, null, null, NoMode);
+  fiber.stateNode = dehydratedNode;
+  return fiber;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  var pendingProps = portal.children !== null ? portal.children : [];
+  var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+  fiber.lanes = lanes;
+  fiber.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    // Used by persistent updates
+    implementation: portal.implementation
+  };
+  return fiber;
+} // Used for stashing WIP properties to replay failed work in DEV.
+
+function assignFiberPropertiesInDEV(target, source) {
+  if (target === null) {
+    // This Fiber's initial properties will always be overwritten.
+    // We only use a Fiber to ensure the same hidden class so DEV isn't slow.
+    target = createFiber(IndeterminateComponent, null, null, NoMode);
+  } // This is intentionally written as a list of all properties.
+  // We tried to use Object.assign() instead but this is called in
+  // the hottest path, and Object.assign() was too slow:
+  // https://github.com/facebook/react/issues/12502
+  // This code is DEV-only so size is not a concern.
+
+  target.tag = source.tag;
+  target.key = source.key;
+  target.elementType = source.elementType;
+  target.type = source.type;
+  target.stateNode = source.stateNode;
+  target.return = source.return;
+  target.child = source.child;
+  target.sibling = source.sibling;
+  target.index = source.index;
+  target.ref = source.ref;
+  target.refCleanup = source.refCleanup;
+  target.pendingProps = source.pendingProps;
+  target.memoizedProps = source.memoizedProps;
+  target.updateQueue = source.updateQueue;
+  target.memoizedState = source.memoizedState;
+  target.dependencies = source.dependencies;
+  target.mode = source.mode;
+  target.flags = source.flags;
+  target.subtreeFlags = source.subtreeFlags;
+  target.deletions = source.deletions;
+  target.lanes = source.lanes;
+  target.childLanes = source.childLanes;
+  target.alternate = source.alternate;
+
+  {
+    target.actualDuration = source.actualDuration;
+    target.actualStartTime = source.actualStartTime;
+    target.selfBaseDuration = source.selfBaseDuration;
+    target.treeBaseDuration = source.treeBaseDuration;
   }
+
+  target._debugSource = source._debugSource;
+  target._debugOwner = source._debugOwner;
+  target._debugNeedsRemount = source._debugNeedsRemount;
+  target._debugHookTypes = source._debugHookTypes;
+  return target;
 }
 
-function commitAttachRef(finishedWork) {
-  var ref = finishedWork.ref;
+function FiberRootNode(
+  containerInfo, // $FlowFixMe[missing-local-annot]
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
+) {
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.pendingChildren = null;
+  this.current = null;
+  this.pingCache = null;
+  this.finishedWork = null;
+  this.timeoutHandle = noTimeout;
+  this.context = null;
+  this.pendingContext = null;
+  this.callbackNode = null;
+  this.callbackPriority = NoLane;
+  this.eventTimes = createLaneMap(NoLanes);
+  this.expirationTimes = createLaneMap(NoTimestamp);
+  this.pendingLanes = NoLanes;
+  this.suspendedLanes = NoLanes;
+  this.pingedLanes = NoLanes;
+  this.expiredLanes = NoLanes;
+  this.mutableReadLanes = NoLanes;
+  this.finishedLanes = NoLanes;
+  this.errorRecoveryDisabledLanes = NoLanes;
+  this.entangledLanes = NoLanes;
+  this.entanglements = createLaneMap(NoLanes);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
 
-  if (ref !== null) {
-    var instance = finishedWork.stateNode;
-    var instanceToUse;
+  {
+    this.pooledCache = null;
+    this.pooledCacheLanes = NoLanes;
+  }
 
-    switch (finishedWork.tag) {
-      case HostHoistable:
-      case HostSingleton:
-      case HostComponent:
-        instanceToUse = getPublicInstance(instance);
-        break;
+  {
+    this.mutableSourceEagerHydrationData = null;
+  }
 
-      default:
-        instanceToUse = instance;
-    } // Moved outside to ensure DCE works with this flag
+  {
+    this.hydrationCallbacks = null;
+  }
 
-    if (finishedWork.tag === ScopeComponent) {
-      instanceToUse = instance;
+  this.incompleteTransitions = new Map();
+
+  if (enableTransitionTracing) {
+    this.transitionCallbacks = null;
+    var transitionLanesMap = (this.transitionLanes = []);
+
+    for (var i = 0; i < TotalLanes; i++) {
+      transitionLanesMap.push(null);
     }
+  }
 
-    if (typeof ref === "function") {
-      if (shouldProfile(finishedWork)) {
-        try {
-          startLayoutEffectTimer();
-          finishedWork.refCleanup = ref(instanceToUse);
-        } finally {
-          recordLayoutEffectDuration(finishedWork);
-        }
-      } else {
-        finishedWork.refCleanup = ref(instanceToUse);
-      }
-    } else {
-      {
-        if (!ref.hasOwnProperty("current")) {
-          error(
-            "Unexpected ref object provided for %s. " +
-              "Use either a ref-setter function or React.createRef().",
-            getComponentNameFromFiber(finishedWork)
-          );
-        }
-      } // $FlowFixMe unable to narrow type to the non-function case
+  {
+    this.effectDuration = 0;
+    this.passiveEffectDuration = 0;
+  }
 
-      ref.current = instanceToUse;
+  {
+    this.memoizedUpdaters = new Set();
+    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
+
+    for (var _i = 0; _i < TotalLanes; _i++) {
+      pendingUpdatersLaneMap.push(new Set());
+    }
+  }
+
+  {
+    switch (tag) {
+      case ConcurrentRoot:
+        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
+        break;
+
+      case LegacyRoot:
+        this._debugRootType = hydrate ? "hydrate()" : "render()";
+        break;
     }
   }
 }
 
-function detachFiberMutation(fiber) {
-  // Cut off the return pointer to disconnect it from the tree.
-  // This enables us to detect and warn against state updates on an unmounted component.
-  // It also prevents events from bubbling from within disconnected components.
-  //
-  // Ideally, we should also 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.
-  //
-  // Note that we can't clear child or sibling pointers yet.
-  // They're needed for passive effects and for findDOMNode.
-  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).
-  //
-  // Don't reset the alternate yet, either. We need that so we can detach the
-  // alternate's fields in the passive phase. Clearing the return pointer is
-  // sufficient for findDOMNode semantics.
-  var alternate = fiber.alternate;
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
+  // host config, but because they are passed in at runtime, we have to thread
+  // them through the root constructor. Perhaps we should put them all into a
+  // single type, like a DynamicHostConfig that is defined by the renderer.
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
+  var root = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
+  );
 
-  if (alternate !== null) {
-    alternate.return = null;
+  {
+    root.hydrationCallbacks = hydrationCallbacks;
   }
 
-  fiber.return = null;
-}
+  if (enableTransitionTracing) {
+    root.transitionCallbacks = transitionCallbacks;
+  } // Cyclic construction. This cheats the type system right now because
+  // stateNode is any.
 
-function detachFiberAfterEffects(fiber) {
-  var alternate = fiber.alternate;
+  var uninitializedFiber = createHostRootFiber(
+    tag,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride
+  );
+  root.current = uninitializedFiber;
+  uninitializedFiber.stateNode = root;
 
-  if (alternate !== null) {
-    fiber.alternate = null;
-    detachFiberAfterEffects(alternate);
-  } // Clear cyclical Fiber fields. This level alone is designed to roughly
-  // approximate the planned Fiber refactor. In that world, `setState` will be
-  // bound to a special "instance" object instead of a Fiber. The Instance
-  // object will not have any of these fields. It will only be connected to
-  // the fiber tree via a single link at the root. So if this level alone is
-  // sufficient to fix memory issues, that bodes well for our plans.
+  {
+    var initialCache = createCache();
+    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
+    // for newly mounted boundaries during a render. In general, the
+    // pooledCache is always cleared from the root at the end of a render:
+    // it is either released when render commits, or moved to an Offscreen
+    // component if rendering suspends. Because the lifetime of the pooled
+    // cache is distinct from the main memoizedState.cache, it must be
+    // retained separately.
 
-  fiber.child = null;
-  fiber.deletions = null;
-  fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host
-  // tree, which has its own pointers to children, parents, and siblings.
-  // The other host nodes also point back to fibers, so we should detach that
-  // one, too.
+    root.pooledCache = initialCache;
+    retainCache(initialCache);
+    var initialState = {
+      element: initialChildren,
+      isDehydrated: hydrate,
+      cache: initialCache
+    };
+    uninitializedFiber.memoizedState = initialState;
+  }
+
+  initializeUpdateQueue(uninitializedFiber);
+  return root;
+}
 
-  if (fiber.tag === HostComponent) {
-    var hostInstance = fiber.stateNode;
+var ReactVersion = "18.3.0-www-modern-2bd137fc";
 
-    if (hostInstance !== null) {
-      detachDeletedInstance(hostInstance);
-    }
+function createPortal$1(
+  children,
+  containerInfo, // TODO: figure out the API for cross-renderer implementation.
+  implementation
+) {
+  var key =
+    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+  {
+    checkKeyStringCoercion(key);
   }
 
-  fiber.stateNode = null;
+  return {
+    // This tag allow us to uniquely identify this as a React Portal
+    $$typeof: REACT_PORTAL_TYPE,
+    key: key == null ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
+}
 
-  {
-    fiber._debugOwner = null;
-  } // Theoretically, nothing in here should be necessary, because we already
-  // disconnected the fiber from the tree. So even if something leaks this
-  // particular fiber, it won't leak anything else.
+// Might add PROFILE later.
 
-  fiber.return = null;
-  fiber.dependencies = null;
-  fiber.memoizedProps = null;
-  fiber.memoizedState = null;
-  fiber.pendingProps = null;
-  fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.
+var didWarnAboutNestedUpdates;
 
-  fiber.updateQueue = null;
+{
+  didWarnAboutNestedUpdates = false;
 }
 
-function getHostParentFiber(fiber) {
-  var parent = fiber.return;
+function getContextForSubtree(parentComponent) {
+  if (!parentComponent) {
+    return emptyContextObject;
+  }
 
-  while (parent !== null) {
-    if (isHostParent(parent)) {
-      return parent;
-    }
+  var fiber = get(parentComponent);
+  var parentContext = findCurrentUnmaskedContext();
 
-    parent = parent.return;
+  if (fiber.tag === ClassComponent) {
+    var Component = fiber.type;
+
+    if (isContextProvider()) {
+      return processChildContext(fiber, Component, parentContext);
+    }
   }
 
-  throw new Error(
-    "Expected to find a host parent. This error is likely caused by a bug " +
-      "in React. Please file an issue."
-  );
+  return parentContext;
 }
 
-function isHostParent(fiber) {
-  return (
-    fiber.tag === HostComponent ||
-    fiber.tag === HostRoot ||
-    fiber.tag === HostHoistable ||
-    fiber.tag === HostSingleton ||
-    fiber.tag === HostPortal
+function createContainer(
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  var hydrate = false;
+  var initialChildren = null;
+  return createFiberRoot(
+    containerInfo,
+    tag,
+    hydrate,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
   );
 }
+function createHydrationContainer(
+  initialChildren, // TODO: Remove `callback` when we delete legacy mode.
+  callback,
+  containerInfo,
+  tag,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  var hydrate = true;
+  var root = createFiberRoot(
+    containerInfo,
+    tag,
+    hydrate,
+    initialChildren,
+    hydrationCallbacks,
+    isStrictMode,
+    concurrentUpdatesByDefaultOverride,
+    identifierPrefix,
+    onRecoverableError,
+    transitionCallbacks
+  ); // TODO: Move this to FiberRoot constructor
 
-function getHostSibling(fiber) {
-  // We're going to search forward into the tree until we find a sibling host
-  // node. Unfortunately, if multiple insertions are done in a row we have to
-  // search past them. This leads to exponential search for the next sibling.
-  // TODO: Find a more efficient way to do this.
-  var node = fiber;
-
-  siblings: while (true) {
-    // If we didn't find anything, let's try the next sibling.
-    while (node.sibling === null) {
-      if (node.return === null || isHostParent(node.return)) {
-        // If we pop out of the root or hit the parent the fiber we are the
-        // last sibling.
-        return null;
-      } // $FlowFixMe[incompatible-type] found when upgrading Flow
+  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
+  // a regular update because the initial render must match was was rendered
+  // on the server.
+  // NOTE: This update intentionally doesn't have a payload. We're only using
+  // the update to schedule work on the root fiber (and, for legacy roots, to
+  // enqueue the callback if one is provided).
 
-      node = node.return;
-    }
+  var current = root.current;
+  var lane = requestUpdateLane(current);
+  var update = createUpdate(lane);
+  update.callback =
+    callback !== undefined && callback !== null ? callback : null;
+  var eventTime = requestEventTime();
+  enqueueUpdate(current, update, lane);
+  scheduleInitialHydrationOnRoot(root, lane, eventTime);
+  return root;
+}
+function updateContainer(element, container, parentComponent, callback) {
+  {
+    onScheduleRoot(container, element);
+  }
 
-    node.sibling.return = node.return;
-    node = node.sibling;
+  var current$1 = container.current;
+  var lane = requestUpdateLane(current$1);
 
-    while (
-      node.tag !== HostComponent &&
-      node.tag !== HostText &&
-      node.tag !== HostSingleton &&
-      node.tag !== DehydratedFragment
-    ) {
-      // If it is not host node and, we might have a host node inside it.
-      // Try to search down until we find one.
-      if (node.flags & Placement) {
-        // If we don't have a child, try the siblings instead.
-        continue siblings;
-      } // If we don't have a child, try the siblings instead.
-      // We also skip portals because they are not part of this host tree.
+  if (enableSchedulingProfiler) {
+    markRenderScheduled(lane);
+  }
 
-      if (node.child === null || node.tag === HostPortal) {
-        continue siblings;
-      } else {
-        node.child.return = node;
-        node = node.child;
-      }
-    } // Check if this host node is stable or about to be placed.
+  var context = getContextForSubtree(parentComponent);
 
-    if (!(node.flags & Placement)) {
-      // Found it!
-      return node.stateNode;
-    }
+  if (container.context === null) {
+    container.context = context;
+  } else {
+    container.pendingContext = context;
   }
-}
 
-function commitPlacement(finishedWork) {
   {
-    if (finishedWork.tag === HostSingleton) {
-      // Singletons are already in the Host and don't need to be placed
-      // Since they operate somewhat like Portals though their children will
-      // have Placement and will get placed inside them
-      return;
+    if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
+      didWarnAboutNestedUpdates = true;
+
+      error(
+        "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.",
+        getComponentNameFromFiber(current) || "Unknown"
+      );
     }
-  } // Recursively insert all host nodes into the parent.
+  }
 
-  var parentFiber = getHostParentFiber(finishedWork);
+  var update = createUpdate(lane); // Caution: React DevTools currently depends on this property
+  // being called "element".
 
-  switch (parentFiber.tag) {
-    case HostSingleton: {
-      {
-        var parent = parentFiber.stateNode;
-        var before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
-        // children to find all the terminal nodes.
+  update.payload = {
+    element: element
+  };
+  callback = callback === undefined ? null : callback;
 
-        insertOrAppendPlacementNode(finishedWork, before, parent);
-        break;
+  if (callback !== null) {
+    {
+      if (typeof callback !== "function") {
+        error(
+          "render(...): Expected the last optional `callback` argument to be a " +
+            "function. Instead received: %s.",
+          callback
+        );
       }
     }
-    // eslint-disable-next-line no-fallthrough
 
-    case HostComponent: {
-      var _parent = parentFiber.stateNode;
+    update.callback = callback;
+  }
 
-      if (parentFiber.flags & ContentReset) {
-        // Reset the text content of the parent before doing any insertions
-        resetTextContent(_parent); // Clear ContentReset from the effect tag
+  var root = enqueueUpdate(current$1, update, lane);
 
-        parentFiber.flags &= ~ContentReset;
-      }
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, current$1, lane, eventTime);
+    entangleTransitions(root, current$1, lane);
+  }
 
-      var _before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its
-      // children to find all the terminal nodes.
+  return lane;
+}
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case HostRoot: {
+      var root = fiber.stateNode;
+
+      if (isRootDehydrated(root)) {
+        // Flush the first scheduled "update".
+        var lanes = getHighestPriorityPendingLanes(root);
+        flushRoot(root, lanes);
+      }
 
-      insertOrAppendPlacementNode(finishedWork, _before, _parent);
       break;
     }
 
-    case HostRoot:
-    case HostPortal: {
-      var _parent2 = parentFiber.stateNode.containerInfo;
+    case SuspenseComponent: {
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-      var _before2 = getHostSibling(finishedWork);
+        if (root !== null) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);
+        }
+      }); // If we're still blocked after this, we need to increase
+      // the priority of any promises resolving within this
+      // boundary so that they next attempt also has higher pri.
 
-      insertOrAppendPlacementNodeIntoContainer(
-        finishedWork,
-        _before2,
-        _parent2
-      );
+      var retryLane = SyncLane;
+      markRetryLaneIfNotHydrated(fiber, retryLane);
       break;
     }
-    // eslint-disable-next-line-no-fallthrough
+  }
+}
 
-    default:
-      throw new Error(
-        "Invalid host parent fiber. This error is likely caused by a bug " +
-          "in React. Please file an issue."
-      );
+function markRetryLaneImpl(fiber, retryLane) {
+  var suspenseState = fiber.memoizedState;
+
+  if (suspenseState !== null && suspenseState.dehydrated !== null) {
+    suspenseState.retryLane = higherPriorityLane(
+      suspenseState.retryLane,
+      retryLane
+    );
+  }
+} // Increases the priority of thenables when they resolve within this boundary.
+
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  var alternate = fiber.alternate;
+
+  if (alternate) {
+    markRetryLaneImpl(alternate, retryLane);
   }
 }
 
-function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
-  var tag = node.tag;
-  var isHost = tag === HostComponent || tag === HostText;
+function attemptDiscreteHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
 
-  if (isHost) {
-    var stateNode = node.stateNode;
+  var lane = SyncLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
 
-    if (before) {
-      insertInContainerBefore(parent, stateNode, before);
-    } else {
-      appendChildToContainer(parent, stateNode);
-    }
-  } else if (tag === HostPortal || tag === HostSingleton);
-  else {
-    var child = node.child;
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+  }
 
-    if (child !== null) {
-      insertOrAppendPlacementNodeIntoContainer(child, before, parent);
-      var sibling = child.sibling;
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
+function attemptContinuousHydration(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority and they should not suspend on I/O,
+    // since you have to wrap anything that might suspend in
+    // Suspense.
+    return;
+  }
 
-      while (sibling !== null) {
-        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);
-        sibling = sibling.sibling;
-      }
-    }
+  var lane = SelectiveHydrationLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
   }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
 }
+function attemptHydrationAtCurrentPriority(fiber) {
+  if (fiber.tag !== SuspenseComponent) {
+    // We ignore HostRoots here because we can't increase
+    // their priority other than synchronously flush it.
+    return;
+  }
 
-function insertOrAppendPlacementNode(node, before, parent) {
-  var tag = node.tag;
-  var isHost = tag === HostComponent || tag === HostText;
+  var lane = requestUpdateLane(fiber);
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
 
-  if (isHost) {
-    var stateNode = node.stateNode;
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+  }
 
-    if (before) {
-      insertBefore(parent, stateNode, before);
-    } else {
-      appendChild(parent, stateNode);
-    }
-  } else if (tag === HostPortal || tag === HostSingleton);
-  else {
-    var child = node.child;
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
 
-    if (child !== null) {
-      insertOrAppendPlacementNode(child, before, parent);
-      var sibling = child.sibling;
+var shouldErrorImpl = function (fiber) {
+  return null;
+};
 
-      while (sibling !== null) {
-        insertOrAppendPlacementNode(sibling, before, parent);
-        sibling = sibling.sibling;
+function shouldError(fiber) {
+  return shouldErrorImpl(fiber);
+}
+
+var shouldSuspendImpl = function (fiber) {
+  return false;
+};
+
+function shouldSuspend(fiber) {
+  return shouldSuspendImpl(fiber);
+}
+var overrideHookState = null;
+var overrideHookStateDeletePath = null;
+var overrideHookStateRenamePath = null;
+var overrideProps = null;
+var overridePropsDeletePath = null;
+var overridePropsRenamePath = null;
+var scheduleUpdate = null;
+var setErrorHandler = null;
+var setSuspenseHandler = null;
+
+{
+  var copyWithDeleteImpl = function (obj, path, index) {
+    var key = path[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+
+    if (index + 1 === path.length) {
+      if (isArray(updated)) {
+        updated.splice(key, 1);
+      } else {
+        delete updated[key];
       }
-    }
-  }
-} // These are tracked on the stack as we recursively traverse a
-// deleted subtree.
-// TODO: Update these during the whole mutation phase, not just during
-// a deletion.
 
-var hostParent = null;
-var hostParentIsContainer = false;
+      return updated;
+    } // $FlowFixMe number or string is fine here
 
-function commitDeletionEffects(root, returnFiber, deletedFiber) {
-  {
-    // We only have the top Fiber that was deleted but we need to recurse down its
-    // children to find all the terminal nodes.
-    // Recursively delete all host nodes from the parent, detach refs, clean
-    // up mounted layout effects, and call componentWillUnmount.
-    // We only need to remove the topmost host child in each branch. But then we
-    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We
-    // could split this into two separate traversals functions, where the second
-    // one doesn't include any removeChild logic. This is maybe the same
-    // function as "disappearLayoutEffects" (or whatever that turns into after
-    // the layout phase is refactored to use recursion).
-    // Before starting, find the nearest host parent on the stack so we know
-    // which instance/container to remove the children from.
-    // TODO: Instead of searching up the fiber return path on every deletion, we
-    // can track the nearest host component on the JS stack as we traverse the
-    // tree during the commit phase. This would make insertions faster, too.
-    var parent = returnFiber;
+    updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
+    return updated;
+  };
 
-    findParent: while (parent !== null) {
-      switch (parent.tag) {
-        case HostSingleton:
-        case HostComponent: {
-          hostParent = parent.stateNode;
-          hostParentIsContainer = false;
-          break findParent;
-        }
+  var copyWithDelete = function (obj, path) {
+    return copyWithDeleteImpl(obj, path, 0);
+  };
 
-        case HostRoot: {
-          hostParent = parent.stateNode.containerInfo;
-          hostParentIsContainer = true;
-          break findParent;
-        }
+  var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
+    var oldKey = oldPath[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+
+    if (index + 1 === oldPath.length) {
+      var newKey = newPath[index]; // $FlowFixMe number or string is fine here
+
+      updated[newKey] = updated[oldKey];
+
+      if (isArray(updated)) {
+        updated.splice(oldKey, 1);
+      } else {
+        delete updated[oldKey];
+      }
+    } else {
+      // $FlowFixMe number or string is fine here
+      updated[oldKey] = copyWithRenameImpl(
+        // $FlowFixMe number or string is fine here
+        obj[oldKey],
+        oldPath,
+        newPath,
+        index + 1
+      );
+    }
+
+    return updated;
+  };
+
+  var copyWithRename = function (obj, oldPath, newPath) {
+    if (oldPath.length !== newPath.length) {
+      warn("copyWithRename() expects paths of the same length");
+
+      return;
+    } else {
+      for (var i = 0; i < newPath.length - 1; i++) {
+        if (oldPath[i] !== newPath[i]) {
+          warn(
+            "copyWithRename() expects paths to be the same except for the deepest key"
+          );
 
-        case HostPortal: {
-          hostParent = parent.stateNode.containerInfo;
-          hostParentIsContainer = true;
-          break findParent;
+          return;
         }
       }
+    }
 
-      parent = parent.return;
+    return copyWithRenameImpl(obj, oldPath, newPath, 0);
+  };
+
+  var copyWithSetImpl = function (obj, path, index, value) {
+    if (index >= path.length) {
+      return value;
     }
 
-    if (hostParent === null) {
-      throw new Error(
-        "Expected to find a host parent. This error is likely caused by " +
-          "a bug in React. Please file an issue."
-      );
+    var key = path[index];
+    var updated = isArray(obj) ? obj.slice() : assign({}, obj); // $FlowFixMe number or string is fine here
+
+    updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
+    return updated;
+  };
+
+  var copyWithSet = function (obj, path, value) {
+    return copyWithSetImpl(obj, path, 0, value);
+  };
+
+  var findHook = function (fiber, id) {
+    // For now, the "id" of stateful hooks is just the stateful hook index.
+    // This may change in the future with e.g. nested hooks.
+    var currentHook = fiber.memoizedState;
+
+    while (currentHook !== null && id > 0) {
+      currentHook = currentHook.next;
+      id--;
     }
 
-    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
-    hostParent = null;
-    hostParentIsContainer = false;
-  }
+    return currentHook;
+  }; // Support DevTools editable values for useState and useReducer.
 
-  detachFiberMutation(deletedFiber);
-}
+  overrideHookState = function (fiber, id, path, value) {
+    var hook = findHook(fiber, id);
 
-function recursivelyTraverseDeletionEffects(
-  finishedRoot,
-  nearestMountedAncestor,
-  parent
-) {
-  // TODO: Use a static flag to skip trees that don't have unmount effects
-  var child = parent.child;
+    if (hook !== null) {
+      var newState = copyWithSet(hook.memoizedState, path, value);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
 
-  while (child !== null) {
-    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);
-    child = child.sibling;
-  }
-}
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-function commitDeletionEffectsOnFiber(
-  finishedRoot,
-  nearestMountedAncestor,
-  deletedFiber
-) {
-  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse
-  // into their subtree. There are simpler cases in the inner switch
-  // that don't modify the stack.
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      }
+    }
+  };
 
-  switch (deletedFiber.tag) {
-    case HostHoistable: {
-      {
-        if (!offscreenSubtreeWasHidden) {
-          safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        }
+  overrideHookStateDeletePath = function (fiber, id, path) {
+    var hook = findHook(fiber, id);
 
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
+    if (hook !== null) {
+      var newState = copyWithDelete(hook.memoizedState, path);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
 
-        if (deletedFiber.memoizedState) {
-          releaseResource(deletedFiber.memoizedState);
-        } else if (deletedFiber.stateNode) {
-          unmountHoistable(deletedFiber.stateNode);
-        }
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-        return;
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
       }
     }
-    // eslint-disable-next-line no-fallthrough
+  };
 
-    case HostSingleton: {
-      {
-        if (!offscreenSubtreeWasHidden) {
-          safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        }
+  overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
+    var hook = findHook(fiber, id);
 
-        var prevHostParent = hostParent;
-        var prevHostParentIsContainer = hostParentIsContainer;
-        hostParent = deletedFiber.stateNode;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        ); // Normally this is called in passive unmount effect phase however with
-        // HostSingleton we warn if you acquire one that is already associated to
-        // a different fiber. To increase our chances of avoiding this, specifically
-        // if you keyed a HostSingleton so there will be a delete followed by a Placement
-        // we treat detach eagerly here
+    if (hook !== null) {
+      var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
+      hook.memoizedState = newState;
+      hook.baseState = newState; // We aren't actually adding an update to the queue,
+      // because there is no update we can add for useReducer hooks that won't trigger an error.
+      // (There's no appropriate action type for DevTools overrides.)
+      // As a result though, React will see the scheduled update as a noop and bailout.
+      // Shallow cloning props works as a workaround for now to bypass the bailout check.
 
-        releaseSingletonInstance(deletedFiber.stateNode);
-        hostParent = prevHostParent;
-        hostParentIsContainer = prevHostParentIsContainer;
-        return;
+      fiber.memoizedProps = assign({}, fiber.memoizedProps);
+      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+      if (root !== null) {
+        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
       }
     }
-    // eslint-disable-next-line no-fallthrough
+  }; // Support DevTools props for function components, forwardRef, memo, host components, etc.
 
-    case HostComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      } // Intentional fallthrough to next branch
+  overrideProps = function (fiber, path, value) {
+    fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
     }
-    // eslint-disable-next-line-no-fallthrough
 
-    case HostText: {
-      // We only need to remove the nearest host child. Set the host parent
-      // to `null` on the stack to indicate that nested children don't
-      // need to be removed.
-      {
-        var _prevHostParent = hostParent;
-        var _prevHostParentIsContainer = hostParentIsContainer;
-        hostParent = null;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        hostParent = _prevHostParent;
-        hostParentIsContainer = _prevHostParentIsContainer;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-        if (hostParent !== null) {
-          // Now that all the child effects have unmounted, we can remove the
-          // node from the tree.
-          if (hostParentIsContainer) {
-            removeChildFromContainer(hostParent, deletedFiber.stateNode);
-          } else {
-            removeChild(hostParent, deletedFiber.stateNode);
-          }
-        }
-      }
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    }
+  };
 
-      return;
+  overridePropsDeletePath = function (fiber, path) {
+    fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
+
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
     }
 
-    case DehydratedFragment: {
-      {
-        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-        if (hydrationCallbacks !== null) {
-          var onDeleted = hydrationCallbacks.onDeleted;
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    }
+  };
 
-          if (onDeleted) {
-            onDeleted(deletedFiber.stateNode);
-          }
-        }
-      } // Dehydrated fragments don't have any children
-      // Delete the dehydrated suspense boundary and all of its content.
+  overridePropsRenamePath = function (fiber, oldPath, newPath) {
+    fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
 
-      {
-        if (hostParent !== null) {
-          if (hostParentIsContainer) {
-            clearSuspenseBoundaryFromContainer(
-              hostParent,
-              deletedFiber.stateNode
-            );
-          } else {
-            clearSuspenseBoundary(hostParent, deletedFiber.stateNode);
-          }
-        }
-      }
+    if (fiber.alternate) {
+      fiber.alternate.pendingProps = fiber.pendingProps;
+    }
 
-      return;
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
     }
+  };
 
-    case HostPortal: {
-      {
-        // When we go into a portal, it becomes the parent to remove from.
-        var _prevHostParent2 = hostParent;
-        var _prevHostParentIsContainer2 = hostParentIsContainer;
-        hostParent = deletedFiber.stateNode.containerInfo;
-        hostParentIsContainer = true;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        hostParent = _prevHostParent2;
-        hostParentIsContainer = _prevHostParentIsContainer2;
-      }
+  scheduleUpdate = function (fiber) {
+    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
 
-      return;
+    if (root !== null) {
+      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
     }
+  };
 
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        var updateQueue = deletedFiber.updateQueue;
+  setErrorHandler = function (newShouldErrorImpl) {
+    shouldErrorImpl = newShouldErrorImpl;
+  };
 
-        if (updateQueue !== null) {
-          var lastEffect = updateQueue.lastEffect;
+  setSuspenseHandler = function (newShouldSuspendImpl) {
+    shouldSuspendImpl = newShouldSuspendImpl;
+  };
+}
 
-          if (lastEffect !== null) {
-            var firstEffect = lastEffect.next;
-            var effect = firstEffect;
+function findHostInstanceByFiber(fiber) {
+  var hostFiber = findCurrentHostFiber(fiber);
 
-            do {
-              var _effect = effect,
-                destroy = _effect.destroy,
-                tag = _effect.tag;
+  if (hostFiber === null) {
+    return null;
+  }
 
-              if (destroy !== undefined) {
-                if ((tag & Insertion) !== NoFlags) {
-                  safelyCallDestroy(
-                    deletedFiber,
-                    nearestMountedAncestor,
-                    destroy
-                  );
-                } else if ((tag & Layout) !== NoFlags) {
-                  if (enableSchedulingProfiler) {
-                    markComponentLayoutEffectUnmountStarted(deletedFiber);
-                  }
+  return hostFiber.stateNode;
+}
 
-                  if (shouldProfile(deletedFiber)) {
-                    startLayoutEffectTimer();
-                    safelyCallDestroy(
-                      deletedFiber,
-                      nearestMountedAncestor,
-                      destroy
-                    );
-                    recordLayoutEffectDuration(deletedFiber);
-                  } else {
-                    safelyCallDestroy(
-                      deletedFiber,
-                      nearestMountedAncestor,
-                      destroy
-                    );
-                  }
+function emptyFindFiberByHostInstance(instance) {
+  return null;
+}
 
-                  if (enableSchedulingProfiler) {
-                    markComponentLayoutEffectUnmountStopped();
-                  }
-                }
-              }
+function getCurrentFiberForDevTools() {
+  return current;
+}
 
-              effect = effect.next;
-            } while (effect !== firstEffect);
-          }
-        }
-      }
+function injectIntoDevTools(devToolsConfig) {
+  var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+  var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+  return injectInternals({
+    bundleType: devToolsConfig.bundleType,
+    version: devToolsConfig.version,
+    rendererPackageName: devToolsConfig.rendererPackageName,
+    rendererConfig: devToolsConfig.rendererConfig,
+    overrideHookState: overrideHookState,
+    overrideHookStateDeletePath: overrideHookStateDeletePath,
+    overrideHookStateRenamePath: overrideHookStateRenamePath,
+    overrideProps: overrideProps,
+    overridePropsDeletePath: overridePropsDeletePath,
+    overridePropsRenamePath: overridePropsRenamePath,
+    setErrorHandler: setErrorHandler,
+    setSuspenseHandler: setSuspenseHandler,
+    scheduleUpdate: scheduleUpdate,
+    currentDispatcherRef: ReactCurrentDispatcher,
+    findHostInstanceByFiber: findHostInstanceByFiber,
+    findFiberByHostInstance:
+      findFiberByHostInstance || emptyFindFiberByHostInstance,
+    // React Refresh
+    findHostInstancesForRefresh: findHostInstancesForRefresh,
+    scheduleRefresh: scheduleRefresh,
+    scheduleRoot: scheduleRoot,
+    setRefreshHandler: setRefreshHandler,
+    // Enables DevTools to append owner stacks to error messages in DEV mode.
+    getCurrentFiber: getCurrentFiberForDevTools,
+    // Enables DevTools to detect reconciler version rather than renderer version
+    // which may not match for third party renderers.
+    reconcilerVersion: ReactVersion
+  });
+}
 
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
-    }
+// the renderer. Such as when we're dispatching events or if third party
+// libraries need to call batchedUpdates. Eventually, this API will go away when
+// everything is batched by default. We'll then have a similar API to opt-out of
+// scheduled work and instead do synchronous work.
 
-    case ClassComponent: {
-      if (!offscreenSubtreeWasHidden) {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-        var instance = deletedFiber.stateNode;
+var isInsideEventHandler = false;
 
-        if (typeof instance.componentWillUnmount === "function") {
-          safelyCallComponentWillUnmount(
-            deletedFiber,
-            nearestMountedAncestor,
-            instance
-          );
-        }
-      }
+function finishEventHandler() {
+  // Here we wait until all updates have propagated, which is important
+  // when using controlled components within layers:
+  // https://github.com/facebook/react/issues/1698
+  // Then we restore state of any controlled component.
+  var controlledComponentsHavePendingUpdates = needsStateRestore();
 
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
-    }
+  if (controlledComponentsHavePendingUpdates) {
+    // If a controlled event was fired, we may need to restore the state of
+    // the DOM node back to the controlled value. This is necessary when React
+    // bails out of the update without touching the DOM.
+    // TODO: Restore state in the microtask, after the discrete updates flush,
+    // instead of early flushing them here.
+    flushSync$1();
+    restoreStateIfNeeded();
+  }
+}
 
-    case ScopeComponent: {
-      {
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      }
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) {
+    // If we are currently inside another batch, we need to wait until it
+    // fully completes before restoring state.
+    return fn(a, b);
+  }
 
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
-    }
+  isInsideEventHandler = true;
 
-    case OffscreenComponent: {
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    isInsideEventHandler = false;
+    finishEventHandler();
+  }
+} // TODO: Replace with flushSync
 
-      if (deletedFiber.mode & ConcurrentMode) {
-        // If this offscreen component is hidden, we already unmounted it. Before
-        // deleting the children, track that it's already unmounted so that we
-        // don't attempt to unmount the effects again.
-        // TODO: If the tree is hidden, in most cases we should be able to skip
-        // over the nested children entirely. An exception is we haven't yet found
-        // the topmost host node to delete, which we already track on the stack.
-        // But the other case is portals, which need to be detached no matter how
-        // deeply they are nested. We should use a subtree flag to track whether a
-        // subtree includes a nested portal.
-        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-        offscreenSubtreeWasHidden =
-          prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-      } else {
-        recursivelyTraverseDeletionEffects(
-          finishedRoot,
-          nearestMountedAncestor,
-          deletedFiber
-        );
-      }
+function isInteractive(tag) {
+  return (
+    tag === "button" ||
+    tag === "input" ||
+    tag === "select" ||
+    tag === "textarea"
+  );
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+  switch (name) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      return !!(props.disabled && isInteractive(type));
+
+    default:
+      return false;
+  }
+}
+/**
+ * @param {object} inst The instance, which is the source of events.
+ * @param {string} registrationName Name of listener (e.g. `onClick`).
+ * @return {?function} The stored callback.
+ */
+
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
+
+  if (stateNode === null) {
+    // Work in progress (ex: onload events in incremental mode).
+    return null;
+  }
+
+  var props = getFiberCurrentPropsFromNode(stateNode);
+
+  if (props === null) {
+    // Work in progress.
+    return null;
+  }
 
-      break;
-    }
+  var listener = props[registrationName];
 
-    default: {
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      return;
-    }
+  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
+    return null;
   }
-}
 
-function commitSuspenseCallback(finishedWork) {
-  // TODO: Move this to passive phase
-  var newState = finishedWork.memoizedState;
+  if (listener && typeof listener !== "function") {
+    throw new Error(
+      "Expected `" +
+        registrationName +
+        "` listener to be a function, instead got a value of `" +
+        typeof listener +
+        "` type."
+    );
+  }
 
-  if (newState !== null) {
-    var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
+  return listener;
+}
 
-    if (typeof suspenseCallback === "function") {
-      var wakeables = finishedWork.updateQueue;
+var passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners
+// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
 
-      if (wakeables !== null) {
-        suspenseCallback(new Set(wakeables));
-      }
-    } else {
-      if (suspenseCallback !== undefined) {
-        error("Unexpected type for suspenseCallback.");
+if (canUseDOM) {
+  try {
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = true;
       }
-    }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = false;
   }
 }
 
-function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
-  var newState = finishedWork.memoizedState;
+// has this definition built-in.
 
-  if (newState === null) {
-    var current = finishedWork.alternate;
+var hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.
 
-    if (current !== null) {
-      var prevState = current.memoizedState;
+var queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.
+// if the last target was dehydrated.
 
-      if (prevState !== null) {
-        var suspenseInstance = prevState.dehydrated;
+var queuedFocus = null;
+var queuedDrag = null;
+var queuedMouse = null; // For pointer events there can be one latest event per pointerId.
 
-        if (suspenseInstance !== null) {
-          try {
-            commitHydratedSuspenseInstance(suspenseInstance);
+var queuedPointers = new Map();
+var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
 
-            if (enableSuspenseCallback) {
-              var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+var queuedExplicitHydrationTargets = [];
+function hasQueuedDiscreteEvents() {
+  return queuedDiscreteEvents.length > 0;
+}
+var discreteReplayableEvents = [
+  "mousedown",
+  "mouseup",
+  "touchcancel",
+  "touchend",
+  "touchstart",
+  "auxclick",
+  "dblclick",
+  "pointercancel",
+  "pointerdown",
+  "pointerup",
+  "dragend",
+  "dragstart",
+  "drop",
+  "compositionend",
+  "compositionstart",
+  "keydown",
+  "keypress",
+  "keyup",
+  "input",
+  "textInput", // Intentionally camelCase
+  "copy",
+  "cut",
+  "paste",
+  "click",
+  "change",
+  "contextmenu",
+  "reset",
+  "submit"
+];
+function isDiscreteEventThatRequiresHydration(eventType) {
+  return discreteReplayableEvents.indexOf(eventType) > -1;
+}
 
-              if (hydrationCallbacks !== null) {
-                var onHydrated = hydrationCallbacks.onHydrated;
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return {
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
+  };
+}
 
-                if (onHydrated) {
-                  onHydrated(suspenseInstance);
-                }
-              }
-            }
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
-    }
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    return;
   }
-}
 
-function getRetryCache(finishedWork) {
-  // TODO: Unify the interface for the retry cache so we don't have to switch
-  // on the tag like this.
-  switch (finishedWork.tag) {
-    case SuspenseComponent:
-    case SuspenseListComponent: {
-      var retryCache = finishedWork.stateNode;
+  var queuedEvent = createQueuedReplayableEvent(
+    blockedOn,
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
+  queuedDiscreteEvents.push(queuedEvent);
 
-      if (retryCache === null) {
-        retryCache = finishedWork.stateNode = new PossiblyWeakSet();
+  if (queuedDiscreteEvents.length === 1) {
+    // If this was the first discrete event, we might be able to
+    // synchronously unblock it so that preventDefault still works.
+    while (queuedEvent.blockedOn !== null) {
+      var fiber = getInstanceFromNode$1(queuedEvent.blockedOn);
+
+      if (fiber === null) {
+        break;
       }
 
-      return retryCache;
-    }
+      attemptSynchronousHydration(fiber);
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-      var _retryCache = instance._retryCache;
+      if (queuedEvent.blockedOn === null) {
+        // We got unblocked by hydration. Let's try again.
+        replayUnblockedEvents(); // If we're reblocked, on an inner boundary, we might need
+        // to attempt hydrating that one.
 
-      if (_retryCache === null) {
-        _retryCache = instance._retryCache = new PossiblyWeakSet();
+        continue;
+      } else {
+        // We're still blocked from hydration, we have to give up
+        // and replay later.
+        break;
       }
+    }
+  }
+} // Resets the replaying for this type of continuous event to no event.
 
-      return _retryCache;
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
+
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
+
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
+
+    case "pointerover":
+    case "pointerout": {
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.delete(pointerId);
+      break;
     }
 
-    default: {
-      throw new Error(
-        "Unexpected Suspense handler tag (" +
-          finishedWork.tag +
-          "). This is a " +
-          "bug in React."
-      );
+    case "gotpointercapture":
+    case "lostpointercapture": {
+      var _pointerId = nativeEvent.pointerId;
+      queuedPointerCaptures.delete(_pointerId);
+      break;
     }
   }
 }
 
-function detachOffscreenInstance(instance) {
-  var fiber = instance._current;
-
-  if (fiber === null) {
-    throw new Error(
-      "Calling Offscreen.detach before instance handle has been set."
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (
+    existingQueuedEvent === null ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
+  ) {
+    var queuedEvent = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
     );
-  }
 
-  if ((instance._pendingVisibility & OffscreenDetached) !== NoFlags$1) {
-    // The instance is already detached, this is a noop.
-    return;
-  } // TODO: There is an opportunity to optimise this by not entering commit phase
-  // and unmounting effects directly.
+    if (blockedOn !== null) {
+      var fiber = getInstanceFromNode$1(blockedOn);
 
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+      if (fiber !== null) {
+        // Attempt to increase the priority of this target.
+        attemptContinuousHydration(fiber);
+      }
+    }
 
-  if (root !== null) {
-    instance._pendingVisibility |= OffscreenDetached;
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    return queuedEvent;
+  } // If we have already queued this exact event, then it's because
+  // the different event systems have different DOM event listeners.
+  // We can accumulate the flags, and the targetContainers, and
+  // store a single event to be replayed.
+
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  var targetContainers = existingQueuedEvent.targetContainers;
+
+  if (
+    targetContainer !== null &&
+    targetContainers.indexOf(targetContainer) === -1
+  ) {
+    targetContainers.push(targetContainer);
   }
+
+  return existingQueuedEvent;
 }
-function attachOffscreenInstance(instance) {
-  var fiber = instance._current;
 
-  if (fiber === null) {
-    throw new Error(
-      "Calling Offscreen.detach before instance handle has been set."
-    );
-  }
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // These set relatedTarget to null because the replayed event will be treated as if we
+  // moved from outside the window (no target) onto the target once it hydrates.
+  // Instead of mutating we could clone the event.
+  switch (domEventName) {
+    case "focusin": {
+      var focusEvent = nativeEvent;
+      queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedFocus,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        focusEvent
+      );
+      return true;
+    }
 
-  if ((instance._pendingVisibility & OffscreenDetached) === NoFlags$1) {
-    // The instance is already attached, this is a noop.
-    return;
-  }
+    case "dragenter": {
+      var dragEvent = nativeEvent;
+      queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedDrag,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        dragEvent
+      );
+      return true;
+    }
 
-  var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    case "mouseover": {
+      var mouseEvent = nativeEvent;
+      queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+        queuedMouse,
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        mouseEvent
+      );
+      return true;
+    }
 
-  if (root !== null) {
-    instance._pendingVisibility &= ~OffscreenDetached;
-    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    case "pointerover": {
+      var pointerEvent = nativeEvent;
+      var pointerId = pointerEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          pointerEvent
+        )
+      );
+      return true;
+    }
+
+    case "gotpointercapture": {
+      var _pointerEvent = nativeEvent;
+      var _pointerId2 = _pointerEvent.pointerId;
+      queuedPointerCaptures.set(
+        _pointerId2,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointerCaptures.get(_pointerId2) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          _pointerEvent
+        )
+      );
+      return true;
+    }
   }
-}
 
-function attachSuspenseRetryListeners(finishedWork, wakeables) {
-  // If this boundary just timed out, then it will have a set of wakeables.
-  // For each wakeable, attach a listener so that when it resolves, React
-  // attempts to re-render the boundary in the primary (pre-timeout) state.
-  var retryCache = getRetryCache(finishedWork);
-  wakeables.forEach(function (wakeable) {
-    // Memoize using the boundary fiber to prevent redundant listeners.
-    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+  return false;
+} // Check if this target is unblocked. Returns true if it's unblocked.
 
-    if (!retryCache.has(wakeable)) {
-      retryCache.add(wakeable);
+function attemptExplicitHydrationTarget(queuedTarget) {
+  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.
+  // Try to unify them. It's a bit tricky since it would require two return
+  // values.
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
 
-      {
-        if (isDevToolsPresent) {
-          if (inProgressLanes !== null && inProgressRoot !== null) {
-            // If we have pending work still, associate the original updaters with it.
-            restorePendingUpdaters(inProgressRoot, inProgressLanes);
-          } else {
-            throw Error(
-              "Expected finished root and lanes to be set. This is a bug in React."
-            );
-          }
+  if (targetInst !== null) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
+
+    if (nearestMounted !== null) {
+      var tag = nearestMounted.tag;
+
+      if (tag === SuspenseComponent) {
+        var instance = getSuspenseInstanceFromFiber(nearestMounted);
+
+        if (instance !== null) {
+          // We're blocked on hydrating this boundary.
+          // Increase its priority.
+          queuedTarget.blockedOn = instance;
+          runWithPriority(queuedTarget.priority, function () {
+            attemptHydrationAtCurrentPriority(nearestMounted);
+          });
+          return;
         }
-      }
+      } else if (tag === HostRoot) {
+        var root = nearestMounted.stateNode;
 
-      wakeable.then(retry, retry);
+        if (isRootDehydrated(root)) {
+          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of
+          // a root other than sync.
+
+          return;
+        }
+      }
     }
-  });
-} // This function detects when a Suspense boundary goes from visible to hidden.
-// It returns false if the boundary is already hidden.
-// TODO: Use an effect tag.
+  }
 
-function isSuspenseBoundaryBeingHidden(current, finishedWork) {
-  if (current !== null) {
-    var oldState = current.memoizedState;
+  queuedTarget.blockedOn = null;
+}
 
-    if (oldState === null || oldState.dehydrated !== null) {
-      var newState = finishedWork.memoizedState;
-      return newState !== null && newState.dehydrated === null;
+function queueExplicitHydrationTarget(target) {
+  // TODO: This will read the priority if it's dispatched by the React
+  // event system but not native events. Should read window.event.type, like
+  // we do for updates (getCurrentEventPriority).
+  var updatePriority = getCurrentUpdatePriority();
+  var queuedTarget = {
+    blockedOn: null,
+    target: target,
+    priority: updatePriority
+  };
+  var i = 0;
+
+  for (; i < queuedExplicitHydrationTargets.length; i++) {
+    // Stop once we hit the first target with lower priority than
+    if (
+      !isHigherEventPriority(
+        updatePriority,
+        queuedExplicitHydrationTargets[i].priority
+      )
+    ) {
+      break;
     }
   }
 
-  return false;
-}
-function commitMutationEffects(root, finishedWork, committedLanes) {
-  inProgressLanes = committedLanes;
-  inProgressRoot = root;
-  setCurrentFiber(finishedWork);
-  commitMutationEffectsOnFiber(finishedWork, root);
-  setCurrentFiber(finishedWork);
-  inProgressLanes = null;
-  inProgressRoot = null;
+  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);
+
+  if (i === 0) {
+    attemptExplicitHydrationTarget(queuedTarget);
+  }
 }
 
-function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects hae fired.
-  var deletions = parentFiber.deletions;
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (queuedEvent.blockedOn !== null) {
+    return false;
+  }
 
-  if (deletions !== null) {
-    for (var i = 0; i < deletions.length; i++) {
-      var childToDelete = deletions[i];
+  var targetContainers = queuedEvent.targetContainers;
 
-      try {
-        commitDeletionEffects(root, parentFiber, childToDelete);
-      } catch (error) {
-        captureCommitPhaseError(childToDelete, parentFiber, error);
+  while (targetContainers.length > 0) {
+    var targetContainer = targetContainers[0];
+    var nextBlockedOn = findInstanceBlockingEvent(
+      queuedEvent.domEventName,
+      queuedEvent.eventSystemFlags,
+      targetContainer,
+      queuedEvent.nativeEvent
+    );
+
+    if (nextBlockedOn === null) {
+      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+        var nativeEvent = queuedEvent.nativeEvent;
+        var nativeEventClone = new nativeEvent.constructor(
+          nativeEvent.type,
+          nativeEvent
+        );
+        setReplayingEvent(nativeEventClone);
+        nativeEvent.target.dispatchEvent(nativeEventClone);
+        resetReplayingEvent();
+      } else {
+        setReplayingEvent(queuedEvent.nativeEvent);
+        dispatchEventForPluginEventSystem(
+          queuedEvent.domEventName,
+          queuedEvent.eventSystemFlags,
+          queuedEvent.nativeEvent,
+          return_targetInst,
+          targetContainer
+        );
+        resetReplayingEvent();
       }
-    }
-  }
+    } else {
+      // We're still blocked. Try again later.
+      var fiber = getInstanceFromNode$1(nextBlockedOn);
 
-  var prevDebugFiber = getCurrentFiber();
+      if (fiber !== null) {
+        attemptContinuousHydration(fiber);
+      }
 
-  if (parentFiber.subtreeFlags & MutationMask) {
-    var child = parentFiber.child;
+      queuedEvent.blockedOn = nextBlockedOn;
+      return false;
+    } // This target container was successfully dispatched. Try the next.
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitMutationEffectsOnFiber(child, root);
-      child = child.sibling;
-    }
+    targetContainers.shift();
   }
 
-  setCurrentFiber(prevDebugFiber);
+  return true;
 }
 
-var currentHoistableRoot = null;
-
-function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
-  var current = finishedWork.alternate;
-  var flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,
-  // because the fiber tag is more specific. An exception is any flag related
-  // to reconciliation, because those can be set on all fiber types.
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {
+    map.delete(key);
+  }
+}
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = false;
 
-      if (flags & Update) {
-        try {
-          commitHookEffectListUnmount(
-            Insertion | HasEffect,
-            finishedWork,
-            finishedWork.return
-          );
-          commitHookEffectListMount(Insertion | HasEffect, finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        } // Layout effects are destroyed during the mutation phase so that all
-        // destroy functions for all fibers are called before any create functions.
-        // This prevents sibling component effects from interfering with each other,
-        // e.g. a destroy function in one component should never override a ref set
-        // by a create function in another component during the same commit.
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    // First replay discrete events.
+    while (queuedDiscreteEvents.length > 0) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
 
-        if (shouldProfile(finishedWork)) {
-          try {
-            startLayoutEffectTimer();
-            commitHookEffectListUnmount(
-              Layout | HasEffect,
-              finishedWork,
-              finishedWork.return
-            );
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
+      if (nextDiscreteEvent.blockedOn !== null) {
+        // We're still blocked.
+        // Increase the priority of this boundary to unblock
+        // the next discrete event.
+        var fiber = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
 
-          recordLayoutEffectDuration(finishedWork);
-        } else {
-          try {
-            commitHookEffectListUnmount(
-              Layout | HasEffect,
-              finishedWork,
-              finishedWork.return
-            );
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
+        if (fiber !== null) {
+          attemptDiscreteHydration(fiber);
         }
-      }
 
-      return;
-    }
+        break;
+      }
 
-    case ClassComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+      var targetContainers = nextDiscreteEvent.targetContainers;
 
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
-      }
+      while (targetContainers.length > 0) {
+        var targetContainer = targetContainers[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          targetContainer,
+          nextDiscreteEvent.nativeEvent
+        );
 
-      if (flags & Callback && offscreenSubtreeIsHidden) {
-        var updateQueue = finishedWork.updateQueue;
+        if (nextBlockedOn === null) {
+          // This whole function is in !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
+          // so we don't need the new replay behavior code branch.
+          setReplayingEvent(nextDiscreteEvent.nativeEvent);
+          dispatchEventForPluginEventSystem(
+            nextDiscreteEvent.domEventName,
+            nextDiscreteEvent.eventSystemFlags,
+            nextDiscreteEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          );
+          resetReplayingEvent();
+        } else {
+          // We're still blocked. Try again later.
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
+          break;
+        } // This target container was successfully dispatched. Try the next.
 
-        if (updateQueue !== null) {
-          deferHiddenCallbacks(updateQueue);
-        }
+        targetContainers.shift();
       }
 
-      return;
+      if (nextDiscreteEvent.blockedOn === null) {
+        // We've successfully replayed the first event. Let's try the next one.
+        queuedDiscreteEvents.shift();
+      }
     }
+  } // Next replay any continuous events.
 
-    case HostHoistable: {
-      {
-        // We cast because we always set the root at the React root and so it cannot be
-        // null while we are processing mutation effects
-        var hoistableRoot = currentHoistableRoot;
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork);
+  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {
+    queuedFocus = null;
+  }
 
-        if (flags & Ref) {
-          if (current !== null) {
-            safelyDetachRef(current, current.return);
-          }
-        }
+  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {
+    queuedDrag = null;
+  }
 
-        if (flags & Update) {
-          var currentResource = current !== null ? current.memoizedState : null;
-          var newResource = finishedWork.memoizedState;
+  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {
+    queuedMouse = null;
+  }
 
-          if (current === null) {
-            // We are mounting a new HostHoistable Fiber. We fork the mount
-            // behavior based on whether this instance is a Hoistable Instance
-            // or a Hoistable Resource
-            if (newResource === null) {
-              if (finishedWork.stateNode === null) {
-                finishedWork.stateNode = hydrateHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.memoizedProps,
-                  finishedWork
-                );
-              } else {
-                mountHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.stateNode
-                );
-              }
-            } else {
-              finishedWork.stateNode = acquireResource(
-                hoistableRoot,
-                newResource,
-                finishedWork.memoizedProps
-              );
-            }
-          } else if (currentResource !== newResource) {
-            // We are moving to or from Hoistable Resource, or between different Hoistable Resources
-            if (currentResource === null) {
-              if (current.stateNode !== null) {
-                unmountHoistable(current.stateNode);
-              }
-            } else {
-              releaseResource(currentResource);
-            }
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
 
-            if (newResource === null) {
-              mountHoistable(
-                hoistableRoot,
-                finishedWork.type,
-                finishedWork.stateNode
-              );
-            } else {
-              acquireResource(
-                hoistableRoot,
-                newResource,
-                finishedWork.memoizedProps
-              );
-            }
-          } else if (newResource === null && finishedWork.stateNode !== null) {
-            // We may have an update on a Hoistable element
-            var updatePayload = finishedWork.updateQueue;
-            finishedWork.updateQueue = null;
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  if (queuedEvent.blockedOn === unblocked) {
+    queuedEvent.blockedOn = null;
 
-            if (updatePayload !== null) {
-              try {
-                commitUpdate(
-                  finishedWork.stateNode,
-                  updatePayload,
-                  finishedWork.type,
-                  current.memoizedProps,
-                  finishedWork.memoizedProps,
-                  finishedWork
-                );
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
+    if (!hasScheduledReplayAttempt) {
+      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are
+      // now unblocked. This first might not actually be unblocked yet.
+      // We could check it early to avoid scheduling an unnecessary callback.
 
-        return;
-      }
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      );
     }
-    // eslint-disable-next-line-no-fallthrough
+  }
+}
 
-    case HostSingleton: {
-      {
-        if (flags & Update) {
-          var previousWork = finishedWork.alternate;
+function retryIfBlockedOn(unblocked) {
+  // Mark anything that was blocked on this as no longer blocked
+  // and eligible for a replay.
+  if (queuedDiscreteEvents.length > 0) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's
+    // worth it because we expect very few discrete events to queue up and once
+    // we are actually fully unblocked it will be fast to replay them.
 
-          if (previousWork === null) {
-            var singleton = finishedWork.stateNode;
-            var props = finishedWork.memoizedProps; // This was a new mount, we need to clear and set initial properties
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent = queuedDiscreteEvents[i];
 
-            clearSingleton(singleton);
-            acquireSingletonInstance(
-              finishedWork.type,
-              props,
-              singleton,
-              finishedWork
-            );
-          }
-        }
+      if (queuedEvent.blockedOn === unblocked) {
+        queuedEvent.blockedOn = null;
       }
     }
-    // eslint-disable-next-line-no-fallthrough
+  }
 
-    case HostComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+  if (queuedFocus !== null) {
+    scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  }
 
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
-      }
+  if (queuedDrag !== null) {
+    scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  }
 
-      {
-        // TODO: ContentReset gets cleared by the children during the commit
-        // phase. This is a refactor hazard because it means we must read
-        // flags the flags after `commitReconciliationEffects` has already run;
-        // the order matters. We should refactor so that ContentReset does not
-        // rely on mutating the flag during commit. Like by setting a flag
-        // during the render phase instead.
-        if (finishedWork.flags & ContentReset) {
-          var instance = finishedWork.stateNode;
+  if (queuedMouse !== null) {
+    scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  }
 
-          try {
-            resetTextContent(instance);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
+  var unblock = function (queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  };
 
-        if (flags & Update) {
-          var _instance2 = finishedWork.stateNode;
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
 
-          if (_instance2 != null) {
-            // Commit the work prepared earlier.
-            var newProps = finishedWork.memoizedProps; // 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.
+  for (var _i = 0; _i < queuedExplicitHydrationTargets.length; _i++) {
+    var queuedTarget = queuedExplicitHydrationTargets[_i];
 
-            var oldProps = current !== null ? current.memoizedProps : newProps;
-            var type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.
+    if (queuedTarget.blockedOn === unblocked) {
+      queuedTarget.blockedOn = null;
+    }
+  }
 
-            var _updatePayload = finishedWork.updateQueue;
-            finishedWork.updateQueue = null;
+  while (queuedExplicitHydrationTargets.length > 0) {
+    var nextExplicitTarget = queuedExplicitHydrationTargets[0];
 
-            if (_updatePayload !== null) {
-              try {
-                commitUpdate(
-                  _instance2,
-                  _updatePayload,
-                  type,
-                  oldProps,
-                  newProps,
-                  finishedWork
-                );
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
-      }
+    if (nextExplicitTarget.blockedOn !== null) {
+      // We're still blocked.
+      break;
+    } else {
+      attemptExplicitHydrationTarget(nextExplicitTarget);
 
-      return;
+      if (nextExplicitTarget.blockedOn === null) {
+        // We're unblocked.
+        queuedExplicitHydrationTargets.shift();
+      }
     }
+  }
+}
 
-    case HostText: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?
 
-      if (flags & Update) {
-        {
-          if (finishedWork.stateNode === null) {
-            throw new Error(
-              "This should have a text node initialized. This error is likely " +
-                "caused by a bug in React. Please file an issue."
-            );
-          }
+var _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.
+// We'd like to remove this but it's not clear if this is safe.
 
-          var textInstance = finishedWork.stateNode;
-          var newText = finishedWork.memoizedProps; // 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.
+function setEnabled(enabled) {
+  _enabled = !!enabled;
+}
+function isEnabled() {
+  return _enabled;
+}
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
+) {
+  var eventPriority = getEventPriority(domEventName);
+  var listenerWrapper;
 
-          var oldText = current !== null ? current.memoizedProps : newText;
+  switch (eventPriority) {
+    case DiscreteEventPriority:
+      listenerWrapper = dispatchDiscreteEvent;
+      break;
 
-          try {
-            commitTextUpdate(textInstance, oldText, newText);
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        }
-      }
+    case ContinuousEventPriority:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
 
-      return;
-    }
+    case DefaultEventPriority:
+    default:
+      listenerWrapper = dispatchEvent;
+      break;
+  }
+
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
+  );
+}
+
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(DiscreteEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = getCurrentUpdatePriority();
+  var prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+
+  try {
+    setCurrentUpdatePriority(ContinuousEventPriority);
+    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    setCurrentUpdatePriority(previousPriority);
+    ReactCurrentBatchConfig.transition = prevTransition;
+  }
+}
+
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (!_enabled) {
+    return;
+  }
+
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+  } else {
+    dispatchEventOriginal(
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+  }
+}
 
-    case HostRoot: {
-      {
-        prepareToCommitHoistables();
-        var previousHoistableRoot = currentHoistableRoot;
-        currentHoistableRoot = getHoistableRoot(root.containerInfo);
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        currentHoistableRoot = previousHoistableRoot;
-        commitReconciliationEffects(finishedWork);
-      }
+function dispatchEventOriginal(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // TODO: replaying capture phase events is currently broken
+  // because we used to do it during top-level native bubble handlers
+  // but now we use different bubble and capture handlers.
+  // In eager mode, we attach capture listeners early, so we need
+  // to filter them out until we fix the logic to handle them correctly.
+  var allowReplay = (eventSystemFlags & IS_CAPTURE_PHASE) === 0;
 
-      if (flags & Update) {
-        {
-          if (current !== null) {
-            var prevRootState = current.memoizedState;
+  if (
+    allowReplay &&
+    hasQueuedDiscreteEvents() &&
+    isDiscreteEventThatRequiresHydration(domEventName)
+  ) {
+    // If we already have a queue of discrete events, and this is another discrete
+    // event, then we can't dispatch it regardless of its target, since they
+    // need to dispatch in order.
+    queueDiscreteEvent(
+      null, // Flags that we're not actually blocked on anything as far as we know.
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    );
+    return;
+  }
 
-            if (prevRootState.isDehydrated) {
-              try {
-                commitHydratedContainer(root.containerInfo);
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
-            }
-          }
-        }
-      }
+  var blockedOn = findInstanceBlockingEvent(
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
 
-      return;
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      return_targetInst,
+      targetContainer
+    );
+
+    if (allowReplay) {
+      clearIfContinuousEvent(domEventName, nativeEvent);
     }
 
-    case HostPortal: {
-      {
-        var _previousHoistableRoot = currentHoistableRoot;
-        currentHoistableRoot = getHoistableRoot(
-          finishedWork.stateNode.containerInfo
-        );
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork);
-        currentHoistableRoot = _previousHoistableRoot;
-      }
+    return;
+  }
 
+  if (allowReplay) {
+    if (isDiscreteEventThatRequiresHydration(domEventName)) {
+      // This to be replayed later once the target is available.
+      queueDiscreteEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
       return;
     }
 
-    case SuspenseComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      var offscreenFiber = finishedWork.child;
+    if (
+      queueIfContinuousEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )
+    ) {
+      return;
+    } // We need to clear only if we didn't queue because
+    // queueing is accumulative.
 
-      if (offscreenFiber.flags & Visibility) {
-        var newState = offscreenFiber.memoizedState;
-        var isHidden = newState !== null;
+    clearIfContinuousEvent(domEventName, nativeEvent);
+  } // This is not replayable so we'll invoke it but without a target,
+  // in case the event system needs to trace it.
 
-        if (isHidden) {
-          var wasHidden =
-            offscreenFiber.alternate !== null &&
-            offscreenFiber.alternate.memoizedState !== null;
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
 
-          if (!wasHidden) {
-            // TODO: Move to passive phase
-            markCommitTimeOfFallback();
-          }
-        }
-      }
+function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  var blockedOn = findInstanceBlockingEvent(
+    domEventName,
+    eventSystemFlags,
+    targetContainer,
+    nativeEvent
+  );
 
-      if (flags & Update) {
-        try {
-          commitSuspenseCallback(finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
+  if (blockedOn === null) {
+    dispatchEventForPluginEventSystem(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      return_targetInst,
+      targetContainer
+    );
+    clearIfContinuousEvent(domEventName, nativeEvent);
+    return;
+  }
 
-        var wakeables = finishedWork.updateQueue;
+  if (
+    queueIfContinuousEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )
+  ) {
+    nativeEvent.stopPropagation();
+    return;
+  } // We need to clear only if we didn't queue because
+  // queueing is accumulative.
 
-        if (wakeables !== null) {
-          finishedWork.updateQueue = null;
-          attachSuspenseRetryListeners(finishedWork, wakeables);
-        }
-      }
+  clearIfContinuousEvent(domEventName, nativeEvent);
 
-      return;
-    }
+  if (
+    eventSystemFlags & IS_CAPTURE_PHASE &&
+    isDiscreteEventThatRequiresHydration(domEventName)
+  ) {
+    while (blockedOn !== null) {
+      var fiber = getInstanceFromNode$1(blockedOn);
 
-    case OffscreenComponent: {
-      if (flags & Ref) {
-        if (current !== null) {
-          safelyDetachRef(current, current.return);
-        }
+      if (fiber !== null) {
+        attemptSynchronousHydration(fiber);
       }
 
-      var _newState = finishedWork.memoizedState;
-
-      var _isHidden = _newState !== null;
-
-      var _wasHidden = current !== null && current.memoizedState !== null;
+      var nextBlockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      );
 
-      if (finishedWork.mode & ConcurrentMode) {
-        // Before committing the children, track on the stack whether this
-        // offscreen subtree was already hidden, so that we don't unmount the
-        // effects again.
-        var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
-        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || _isHidden;
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || _wasHidden;
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
-        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-      } else {
-        recursivelyTraverseMutationEffects(root, finishedWork);
+      if (nextBlockedOn === null) {
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        );
       }
 
-      commitReconciliationEffects(finishedWork);
-      var offscreenInstance = finishedWork.stateNode; // TODO: Add explicit effect flag to set _current.
-
-      offscreenInstance._current = finishedWork; // Offscreen stores pending changes to visibility in `_pendingVisibility`. This is
-      // to support batching of `attach` and `detach` calls.
-
-      offscreenInstance._visibility &= ~OffscreenDetached;
-      offscreenInstance._visibility |=
-        offscreenInstance._pendingVisibility & OffscreenDetached;
-
-      if (flags & Visibility) {
-        // Track the current state on the Offscreen instance so we can
-        // read it during an event
-        if (_isHidden) {
-          offscreenInstance._visibility &= ~OffscreenVisible;
-        } else {
-          offscreenInstance._visibility |= OffscreenVisible;
-        }
-
-        if (_isHidden) {
-          var isUpdate = current !== null;
-          var wasHiddenByAncestorOffscreen =
-            offscreenSubtreeIsHidden || offscreenSubtreeWasHidden; // Only trigger disapper layout effects if:
-          //   - This is an update, not first mount.
-          //   - This Offscreen was not hidden before.
-          //   - Ancestor Offscreen was not hidden in previous commit.
-
-          if (isUpdate && !_wasHidden && !wasHiddenByAncestorOffscreen) {
-            if ((finishedWork.mode & ConcurrentMode) !== NoMode) {
-              // Disappear the layout effects of all the children
-              recursivelyTraverseDisappearLayoutEffects(finishedWork);
-            }
-          }
-        } // Offscreen with manual mode manages visibility manually.
+      if (nextBlockedOn === blockedOn) {
+        break;
+      }
 
-        if (!isOffscreenManual(finishedWork)) {
-          // TODO: This needs to run whenever there's an insertion or update
-          // inside a hidden Offscreen tree.
-          hideOrUnhideAllChildren(finishedWork, _isHidden);
-        }
-      } // TODO: Move to passive phase
+      blockedOn = nextBlockedOn;
+    }
 
-      if (flags & Update) {
-        var offscreenQueue = finishedWork.updateQueue;
+    if (blockedOn !== null) {
+      nativeEvent.stopPropagation();
+    }
 
-        if (offscreenQueue !== null) {
-          var _wakeables = offscreenQueue.wakeables;
+    return;
+  } // This is not replayable so we'll invoke it but without a target,
+  // in case the event system needs to trace it.
 
-          if (_wakeables !== null) {
-            offscreenQueue.wakeables = null;
-            attachSuspenseRetryListeners(finishedWork, _wakeables);
-          }
-        }
-      }
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
 
-      return;
-    }
+var return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.
+// The return_targetInst field above is conceptually part of the return value.
 
-    case SuspenseListComponent: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  // TODO: Warn if _enabled is false.
+  return_targetInst = null;
+  var nativeEventTarget = getEventTarget(nativeEvent);
+  var targetInst = getClosestInstanceFromNode(nativeEventTarget);
 
-      if (flags & Update) {
-        var _wakeables2 = finishedWork.updateQueue;
+  if (targetInst !== null) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
 
-        if (_wakeables2 !== null) {
-          finishedWork.updateQueue = null;
-          attachSuspenseRetryListeners(finishedWork, _wakeables2);
-        }
-      }
+    if (nearestMounted === null) {
+      // This tree has been unmounted already. Dispatch without a target.
+      targetInst = null;
+    } else {
+      var tag = nearestMounted.tag;
 
-      return;
-    }
+      if (tag === SuspenseComponent) {
+        var instance = getSuspenseInstanceFromFiber(nearestMounted);
 
-    case ScopeComponent: {
-      {
-        recursivelyTraverseMutationEffects(root, finishedWork);
-        commitReconciliationEffects(finishedWork); // TODO: This is a temporary solution that allowed us to transition away
-        // from React Flare on www.
+        if (instance !== null) {
+          // Queue the event to be replayed later. Abort dispatching since we
+          // don't want this event dispatched twice through the event system.
+          // TODO: If this is the first discrete event in the queue. Schedule an increased
+          // priority for this boundary.
+          return instance;
+        } // This shouldn't happen, something went wrong but to avoid blocking
+        // the whole system, dispatch the event without a target.
+        // TODO: Warn.
 
-        if (flags & Ref) {
-          if (current !== null) {
-            safelyDetachRef(finishedWork, finishedWork.return);
-          }
+        targetInst = null;
+      } else if (tag === HostRoot) {
+        var root = nearestMounted.stateNode;
 
-          safelyAttachRef(finishedWork, finishedWork.return);
+        if (isRootDehydrated(root)) {
+          // If this happens during a replay something went wrong and it might block
+          // the whole system.
+          return getContainerFromFiber(nearestMounted);
         }
 
-        if (flags & Update) {
-          var scopeInstance = finishedWork.stateNode;
-          prepareScopeUpdate(scopeInstance, finishedWork);
-        }
+        targetInst = null;
+      } else if (nearestMounted !== targetInst) {
+        // If we get an event (ex: img onload) before committing that
+        // component's mount, ignore it for now (that is, treat it as if it was an
+        // event on a non-React tree). We might also consider queueing events and
+        // dispatching them after the mount.
+        targetInst = null;
       }
-
-      return;
-    }
-
-    default: {
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      return;
     }
   }
-}
 
-function commitReconciliationEffects(finishedWork) {
-  // Placement effects (insertions, reorders) can be scheduled on any fiber
-  // type. They needs to happen after the children effects have fired, but
-  // before the effects on this fiber have fired.
-  var flags = finishedWork.flags;
+  return_targetInst = targetInst; // We're not blocked on anything.
 
-  if (flags & Placement) {
-    try {
-      commitPlacement(finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    } // Clear the "placement" from effect tag so that we know that this is
-    // inserted, before any life-cycles like componentDidMount gets called.
-    // TODO: findDOMNode doesn't rely on this any more but isMounted does
-    // and isMounted is deprecated anyway so we should be able to kill this.
+  return null;
+}
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    // Used by SimpleEventPlugin:
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange": // Used by polyfills:
+    // eslint-disable-next-line no-fallthrough
 
-    finishedWork.flags &= ~Placement;
-  }
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate": // Only enableCreateEventHandleAPI:
+    // eslint-disable-next-line no-fallthrough
 
-  if (flags & Hydrating) {
-    finishedWork.flags &= ~Hydrating;
-  }
-}
+    case "beforeblur":
+    case "afterblur": // Not used by React but could be by user code:
+    // eslint-disable-next-line no-fallthrough
 
-function commitLayoutEffects(finishedWork, root, committedLanes) {
-  inProgressLanes = committedLanes;
-  inProgressRoot = root;
-  var current = finishedWork.alternate;
-  commitLayoutEffectOnFiber(root, current, finishedWork);
-  inProgressLanes = null;
-  inProgressRoot = null;
-}
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return DiscreteEventPriority;
 
-function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
-  var prevDebugFiber = getCurrentFiber();
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel": // Not used by React but could be by user code:
+    // eslint-disable-next-line no-fallthrough
 
-  if (parentFiber.subtreeFlags & LayoutMask) {
-    var child = parentFiber.child;
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return ContinuousEventPriority;
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      var current = child.alternate;
-      commitLayoutEffectOnFiber(root, current, child);
-      child = child.sibling;
-    }
-  }
+    case "message": {
+      // We might be in the Scheduler callback.
+      // Eventually this mechanism will be replaced by a check
+      // of the current priority on the native scheduler.
+      var schedulerPriority = getCurrentPriorityLevel();
 
-  setCurrentFiber(prevDebugFiber);
-}
+      switch (schedulerPriority) {
+        case ImmediatePriority:
+          return DiscreteEventPriority;
 
-function disappearLayoutEffects(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case MemoComponent:
-    case SimpleMemoComponent: {
-      // TODO (Offscreen) Check: flags & LayoutStatic
-      if (shouldProfile(finishedWork)) {
-        try {
-          startLayoutEffectTimer();
-          commitHookEffectListUnmount(
-            Layout,
-            finishedWork,
-            finishedWork.return
-          );
-        } finally {
-          recordLayoutEffectDuration(finishedWork);
-        }
-      } else {
-        commitHookEffectListUnmount(Layout, finishedWork, finishedWork.return);
-      }
+        case UserBlockingPriority:
+          return ContinuousEventPriority;
 
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
-    }
+        case NormalPriority$1:
+        case LowPriority:
+          // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.
+          return DefaultEventPriority;
 
-    case ClassComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      var instance = finishedWork.stateNode;
+        case IdlePriority:
+          return IdleEventPriority;
 
-      if (typeof instance.componentWillUnmount === "function") {
-        safelyCallComponentWillUnmount(
-          finishedWork,
-          finishedWork.return,
-          instance
-        );
+        default:
+          return DefaultEventPriority;
       }
-
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
     }
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      break;
-    }
+    default:
+      return DefaultEventPriority;
+  }
+}
 
-    case OffscreenComponent: {
-      // TODO (Offscreen) Check: flags & RefStatic
-      safelyDetachRef(finishedWork, finishedWork.return);
-      var isHidden = finishedWork.memoizedState !== null;
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, false);
+  return listener;
+}
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, true);
+  return listener;
+}
+function addEventCaptureListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, {
+    capture: true,
+    passive: passive
+  });
+  return listener;
+}
+function addEventBubbleListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, {
+    passive: passive
+  });
+  return listener;
+}
+function removeEventListener(target, eventType, listener, capture) {
+  target.removeEventListener(eventType, listener, capture);
+}
 
-      if (isHidden);
-      else {
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-      }
+/**
+ * These variables store information about text content of a target node,
+ * allowing comparison of content before and after a given event.
+ *
+ * Identify the node where selection currently begins, then observe
+ * both its text content and its current position in the DOM. Since the
+ * browser may natively replace the target node during composition, we can
+ * use its position to find its replacement.
+ *
+ *
+ */
+var root = null;
+var startText = null;
+var fallbackText = null;
+function initialize(nativeEventTarget) {
+  root = nativeEventTarget;
+  startText = getText();
+  return true;
+}
+function reset() {
+  root = null;
+  startText = null;
+  fallbackText = null;
+}
+function getData() {
+  if (fallbackText) {
+    return fallbackText;
+  }
+
+  var start;
+  var startValue = startText;
+  var startLength = startValue.length;
+  var end;
+  var endValue = getText();
+  var endLength = endValue.length;
 
+  for (start = 0; start < startLength; start++) {
+    if (startValue[start] !== endValue[start]) {
       break;
     }
+  }
 
-    default: {
-      recursivelyTraverseDisappearLayoutEffects(finishedWork);
+  var minEnd = startLength - start;
+
+  for (end = 1; end <= minEnd; end++) {
+    if (startValue[startLength - end] !== endValue[endLength - end]) {
       break;
     }
   }
-}
-
-function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
-  // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
-  var child = parentFiber.child;
 
-  while (child !== null) {
-    disappearLayoutEffects(child);
-    child = child.sibling;
+  var sliceTail = end > 1 ? 1 - end : undefined;
+  fallbackText = endValue.slice(start, sliceTail);
+  return fallbackText;
+}
+function getText() {
+  if ("value" in root) {
+    return root.value;
   }
+
+  return root.textContent;
 }
 
-function reappearLayoutEffects(
-  finishedRoot,
-  current,
-  finishedWork, // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  includeWorkInProgressEffects
-) {
-  // Turn on layout effects in a tree that previously disappeared.
-  var flags = finishedWork.flags;
+/**
+ * `charCode` represents the actual "character code" and is safe to use with
+ * `String.fromCharCode`. As such, only keys that correspond to printable
+ * characters produce a valid `charCode`, the only exception to this is Enter.
+ * The Tab-key is considered non-printable and does not have a `charCode`,
+ * presumably because it does not produce a tab-character in browsers.
+ *
+ * @param {object} nativeEvent Native browser event.
+ * @return {number} Normalized `charCode` property.
+ */
+function getEventCharCode(nativeEvent) {
+  var charCode;
+  var keyCode = nativeEvent.keyCode;
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Check flags & LayoutStatic
+  if ("charCode" in nativeEvent) {
+    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.
 
-      commitHookLayoutEffects(finishedWork, Layout);
-      break;
+    if (charCode === 0 && keyCode === 13) {
+      charCode = 13;
     }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)
+  // report Enter as charCode 10 when ctrl is pressed.
 
-    case ClassComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Check for LayoutStatic flag
+  if (charCode === 10) {
+    charCode = 13;
+  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
 
-      var instance = finishedWork.stateNode;
+  if (charCode >= 32 || charCode === 13) {
+    return charCode;
+  }
 
-      if (typeof instance.componentDidMount === "function") {
-        try {
-          instance.componentDidMount();
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
-      } // Commit any callbacks that would have fired while the component
-      // was hidden.
+  return 0;
+}
 
-      var updateQueue = finishedWork.updateQueue;
+function functionThatReturnsTrue() {
+  return true;
+}
 
-      if (updateQueue !== null) {
-        commitHiddenCallbacks(updateQueue, instance);
-      } // If this is newly finished work, check for setState callbacks
+function functionThatReturnsFalse() {
+  return false;
+} // This is intentionally a factory so that we have different returned constructors.
+// If we had a single constructor, it would be megamorphic and engines would deopt.
 
-      if (includeWorkInProgressEffects && flags & Callback) {
-        commitClassCallbacks(finishedWork);
-      } // TODO: Check flags & RefStatic
+function createSyntheticEvent(Interface) {
+  /**
+   * Synthetic events are dispatched by event plugins, typically in response to a
+   * top-level event delegation handler.
+   *
+   * These systems should generally use pooling to reduce the frequency of garbage
+   * collection. The system should check `isPersistent` to determine whether the
+   * event should be released into the pool after being dispatched. Users that
+   * need a persisted event should invoke `persist`.
+   *
+   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+   * normalizing browser quirks. Subclasses do not necessarily have to implement a
+   * DOM interface; custom application-specific events can also subclass this.
+   */
+  // $FlowFixMe[missing-this-annot]
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  ) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    }
-    // Unlike commitLayoutEffectsOnFiber, we don't need to handle HostRoot
-    // because this function only visits nodes that are inside an
-    // Offscreen fiber.
-    // case HostRoot: {
-    //  ...
-    // }
+    for (var propName in Interface) {
+      if (!Interface.hasOwnProperty(propName)) {
+        continue;
+      }
 
-    case HostHoistable:
-    case HostSingleton:
-    case HostComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // Renderers may schedule work to be done after host components are mounted
-      // (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.
+      var normalize = Interface[propName];
 
-      if (includeWorkInProgressEffects && current === null && flags & Update) {
-        commitHostComponentMount(finishedWork);
-      } // TODO: Check flags & Ref
+      if (normalize) {
+        this[propName] = normalize(nativeEvent);
+      } else {
+        this[propName] = nativeEvent[propName];
+      }
+    }
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
+    var defaultPrevented =
+      nativeEvent.defaultPrevented != null
+        ? nativeEvent.defaultPrevented
+        : nativeEvent.returnValue === false;
+
+    if (defaultPrevented) {
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    } else {
+      this.isDefaultPrevented = functionThatReturnsFalse;
     }
 
-    case Profiler: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Figure out how Profiler updates should work with Offscreen
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  } // $FlowFixMe[prop-missing] found when upgrading Flow
 
-      if (includeWorkInProgressEffects && flags & Update) {
-        commitProfilerUpdate(finishedWork, current);
+  assign(SyntheticBaseEvent.prototype, {
+    // $FlowFixMe[missing-this-annot]
+    preventDefault: function () {
+      this.defaultPrevented = true;
+      var event = this.nativeEvent;
+
+      if (!event) {
+        return;
       }
 
-      break;
-    }
+      if (event.preventDefault) {
+        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
+      } else if (typeof event.returnValue !== "unknown") {
+        event.returnValue = false;
+      }
 
-    case SuspenseComponent: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      ); // TODO: Figure out how Suspense hydration callbacks should work
-      // with Offscreen.
+      this.isDefaultPrevented = functionThatReturnsTrue;
+    },
+    // $FlowFixMe[missing-this-annot]
+    stopPropagation: function () {
+      var event = this.nativeEvent;
 
-      if (includeWorkInProgressEffects && flags & Update) {
-        commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+      if (!event) {
+        return;
       }
 
-      break;
-    }
-
-    case OffscreenComponent: {
-      var offscreenState = finishedWork.memoizedState;
-      var isHidden = offscreenState !== null;
+      if (event.stopPropagation) {
+        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
+      } else if (typeof event.cancelBubble !== "unknown") {
+        // The ChangeEventPlugin registers a "propertychange" event for
+        // IE. This event does not support bubbling or cancelling, and
+        // any references to cancelBubble throw "Member not found".  A
+        // typeof check of "unknown" circumvents this issue (and is also
+        // IE specific).
+        event.cancelBubble = true;
+      }
 
-      if (isHidden);
-      else {
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-      } // TODO: Check flags & Ref
+      this.isPropagationStopped = functionThatReturnsTrue;
+    },
 
-      safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    }
+    /**
+     * We release all dispatched `SyntheticEvent`s after each event loop, adding
+     * them back into the pool. This allows a way to hold onto a reference that
+     * won't be added back into the pool.
+     */
+    persist: function () {
+      // Modern event system doesn't use pooling.
+    },
 
-    default: {
-      recursivelyTraverseReappearLayoutEffects(
-        finishedRoot,
-        finishedWork,
-        includeWorkInProgressEffects
-      );
-      break;
-    }
-  }
+    /**
+     * Checks if this event should be released back into the pool.
+     *
+     * @return {boolean} True if this should not be released, false otherwise.
+     */
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
 }
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-function recursivelyTraverseReappearLayoutEffects(
-  finishedRoot,
-  parentFiber,
-  includeWorkInProgressEffects
-) {
-  // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  var childShouldIncludeWorkInProgressEffects =
-    includeWorkInProgressEffects &&
-    (parentFiber.subtreeFlags & LayoutMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
-
-  var prevDebugFiber = getCurrentFiber();
-  var child = parentFiber.child;
+var EventInterface = {
+  eventPhase: 0,
+  bubbles: 0,
+  cancelable: 0,
+  timeStamp: function (event) {
+    return event.timeStamp || Date.now();
+  },
+  defaultPrevented: 0,
+  isTrusted: 0
+};
+var SyntheticEvent = createSyntheticEvent(EventInterface);
 
-  while (child !== null) {
-    var current = child.alternate;
-    reappearLayoutEffects(
-      finishedRoot,
-      current,
-      child,
-      childShouldIncludeWorkInProgressEffects
-    );
-    child = child.sibling;
-  }
+var UIEventInterface = assign({}, EventInterface, {
+  view: 0,
+  detail: 0
+});
 
-  setCurrentFiber(prevDebugFiber);
-}
+var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
+var lastMovementX;
+var lastMovementY;
+var lastMouseEvent;
 
-function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  if (shouldProfile(finishedWork)) {
-    startPassiveEffectTimer();
+function updateMouseMovementPolyfillState(event) {
+  if (event !== lastMouseEvent) {
+    if (lastMouseEvent && event.type === "mousemove") {
+      // $FlowFixMe assuming this is a number
+      lastMovementX = event.screenX - lastMouseEvent.screenX; // $FlowFixMe assuming this is a number
 
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      lastMovementY = event.screenY - lastMouseEvent.screenY;
+    } else {
+      lastMovementX = 0;
+      lastMovementY = 0;
     }
 
-    recordPassiveEffectDuration(finishedWork);
-  } else {
-    try {
-      commitHookEffectListMount(hookFlags, finishedWork);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
+    lastMouseEvent = event;
   }
 }
+/**
+ * @interface MouseEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
-  {
-    var previousCache = null;
-
-    if (
-      current !== null &&
-      current.memoizedState !== null &&
-      current.memoizedState.cachePool !== null
-    ) {
-      previousCache = current.memoizedState.cachePool.pool;
+var MouseEventInterface = assign({}, UIEventInterface, {
+  screenX: 0,
+  screenY: 0,
+  clientX: 0,
+  clientY: 0,
+  pageX: 0,
+  pageY: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  getModifierState: getEventModifierState,
+  button: 0,
+  buttons: 0,
+  relatedTarget: function (event) {
+    if (event.relatedTarget === undefined)
+      return event.fromElement === event.srcElement
+        ? event.toElement
+        : event.fromElement;
+    return event.relatedTarget;
+  },
+  movementX: function (event) {
+    if ("movementX" in event) {
+      return event.movementX;
     }
 
-    var nextCache = null;
+    updateMouseMovementPolyfillState(event);
+    return lastMovementX;
+  },
+  movementY: function (event) {
+    if ("movementY" in event) {
+      return event.movementY;
+    } // Don't need to call updateMouseMovementPolyfillState() here
+    // because it's guaranteed to have already run when movementX
+    // was copied.
 
-    if (
-      finishedWork.memoizedState !== null &&
-      finishedWork.memoizedState.cachePool !== null
-    ) {
-      nextCache = finishedWork.memoizedState.cachePool.pool;
-    } // Retain/release the cache used for pending (suspended) nodes.
-    // Note that this is only reached in the non-suspended/visible case:
-    // when the content is suspended/hidden, the retain/release occurs
-    // via the parent Suspense component (see case above).
+    return lastMovementY;
+  }
+});
 
-    if (nextCache !== previousCache) {
-      if (nextCache != null) {
-        retainCache(nextCache);
-      }
+var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
+/**
+ * @interface DragEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-      if (previousCache != null) {
-        releaseCache(previousCache);
-      }
-    }
-  }
+var DragEventInterface = assign({}, MouseEventInterface, {
+  dataTransfer: 0
+});
 
-  if (enableTransitionTracing) {
-    // TODO: Pre-rendering should not be counted as part of a transition. We
-    // may add separate logs for pre-rendering, but it's not part of the
-    // primary metrics.
-    var offscreenState = finishedWork.memoizedState;
-    var queue = finishedWork.updateQueue;
-    var isHidden = offscreenState !== null;
+var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
+/**
+ * @interface FocusEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-    if (queue !== null) {
-      if (isHidden) {
-        var transitions = queue.transitions;
+var FocusEventInterface = assign({}, UIEventInterface, {
+  relatedTarget: 0
+});
 
-        if (transitions !== null) {
-          transitions.forEach(function (transition) {
-            // Add all the transitions saved in the update queue during
-            // the render phase (ie the transitions associated with this boundary)
-            // into the transitions set.
-            if (instance._transitions === null) {
-              instance._transitions = new Set();
-            }
+var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+ */
 
-            instance._transitions.add(transition);
-          });
-        }
+var AnimationEventInterface = assign({}, EventInterface, {
+  animationName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
 
-        var markerInstances = queue.markerInstances;
+var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/clipboard-apis/
+ */
 
-        if (markerInstances !== null) {
-          markerInstances.forEach(function (markerInstance) {
-            var markerTransitions = markerInstance.transitions; // There should only be a few tracing marker transitions because
-            // they should be only associated with the transition that
-            // caused them
+var ClipboardEventInterface = assign({}, EventInterface, {
+  clipboardData: function (event) {
+    return "clipboardData" in event
+      ? event.clipboardData
+      : window.clipboardData;
+  }
+});
 
-            if (markerTransitions !== null) {
-              markerTransitions.forEach(function (transition) {
-                if (instance._transitions === null) {
-                  instance._transitions = new Set();
-                } else if (instance._transitions.has(transition)) {
-                  if (markerInstance.pendingBoundaries === null) {
-                    markerInstance.pendingBoundaries = new Map();
-                  }
+var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+ */
 
-                  if (instance._pendingMarkers === null) {
-                    instance._pendingMarkers = new Set();
-                  }
+var CompositionEventInterface = assign({}, EventInterface, {
+  data: 0
+});
 
-                  instance._pendingMarkers.add(markerInstance);
-                }
-              });
-            }
-          });
-        }
-      }
+var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+ *      /#events-inputevents
+ */
+// Happens to share the same list for now.
 
-      finishedWork.updateQueue = null;
-    }
+var SyntheticInputEvent = SyntheticCompositionEvent;
+/**
+ * Normalization of deprecated HTML5 `key` values
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
 
-    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
+var normalizeKey = {
+  Esc: "Escape",
+  Spacebar: " ",
+  Left: "ArrowLeft",
+  Up: "ArrowUp",
+  Right: "ArrowRight",
+  Down: "ArrowDown",
+  Del: "Delete",
+  Win: "OS",
+  Menu: "ContextMenu",
+  Apps: "ContextMenu",
+  Scroll: "ScrollLock",
+  MozPrintableKey: "Unidentified"
+};
+/**
+ * Translation from legacy `keyCode` to HTML5 `key`
+ * Only special keys supported, all others depend on keyboard layout or browser
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+ */
 
-    if (!isHidden) {
-      instance._transitions = null;
-      instance._pendingMarkers = null;
-    }
-  }
-}
+var translateToKey = {
+  "8": "Backspace",
+  "9": "Tab",
+  "12": "Clear",
+  "13": "Enter",
+  "16": "Shift",
+  "17": "Control",
+  "18": "Alt",
+  "19": "Pause",
+  "20": "CapsLock",
+  "27": "Escape",
+  "32": " ",
+  "33": "PageUp",
+  "34": "PageDown",
+  "35": "End",
+  "36": "Home",
+  "37": "ArrowLeft",
+  "38": "ArrowUp",
+  "39": "ArrowRight",
+  "40": "ArrowDown",
+  "45": "Insert",
+  "46": "Delete",
+  "112": "F1",
+  "113": "F2",
+  "114": "F3",
+  "115": "F4",
+  "116": "F5",
+  "117": "F6",
+  "118": "F7",
+  "119": "F8",
+  "120": "F9",
+  "121": "F10",
+  "122": "F11",
+  "123": "F12",
+  "144": "NumLock",
+  "145": "ScrollLock",
+  "224": "Meta"
+};
+/**
+ * @param {object} nativeEvent Native browser event.
+ * @return {string} Normalized `key` property.
+ */
 
-function commitCachePassiveMountEffect(current, finishedWork) {
-  {
-    var previousCache = null;
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    var key = normalizeKey[nativeEvent.key] || nativeEvent.key; // $FlowFixMe unable to index with a `mixed` value
 
-    if (finishedWork.alternate !== null) {
-      previousCache = finishedWork.alternate.memoizedState.cache;
+    if (key !== "Unidentified") {
+      return key;
     }
+  } // Browser does not implement `key`, polyfill as much of it as we can.
 
-    var nextCache = finishedWork.memoizedState.cache; // Retain/release the cache. In theory the cache component
-    // could be "borrowing" a cache instance owned by some parent,
-    // in which case we could avoid retaining/releasing. But it
-    // is non-trivial to determine when that is the case, so we
-    // always retain/release.
-
-    if (nextCache !== previousCache) {
-      retainCache(nextCache);
+  if (nativeEvent.type === "keypress") {
+    var charCode = getEventCharCode(
+      // $FlowFixMe unable to narrow to `KeyboardEvent`
+      nativeEvent
+    ); // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
 
-      if (previousCache != null) {
-        releaseCache(previousCache);
-      }
-    }
+    return charCode === 13 ? "Enter" : String.fromCharCode(charCode);
   }
-}
-
-function commitTracingMarkerPassiveMountEffect(finishedWork) {
-  // Get the transitions that were initiatized during the render
-  // and add a start transition callback for each of them
-  // We will only call this on initial mount of the tracing marker
-  // only if there are no suspense children
-  var instance = finishedWork.stateNode;
 
-  if (instance.transitions !== null && instance.pendingBoundaries === null) {
-    addMarkerCompleteCallbackToPendingTransition(
-      finishedWork.memoizedProps.name,
-      instance.transitions
-    );
-    instance.transitions = null;
-    instance.pendingBoundaries = null;
-    instance.aborts = null;
-    instance.name = null;
+  if (nativeEvent.type === "keydown" || nativeEvent.type === "keyup") {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    // $FlowFixMe unable to index with a `mixed` value
+    return translateToKey[nativeEvent.keyCode] || "Unidentified";
   }
-}
 
-function commitPassiveMountEffects(
-  root,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  setCurrentFiber(finishedWork);
-  commitPassiveMountOnFiber(
-    root,
-    finishedWork,
-    committedLanes,
-    committedTransitions
-  );
-  resetCurrentFiber();
+  return "";
 }
+/**
+ * Translation from modifier key to the associated property in the event.
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+ */
 
-function recursivelyTraversePassiveMountEffects(
-  root,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  var prevDebugFiber = getCurrentFiber();
+var modifierKeyToProp = {
+  Alt: "altKey",
+  Control: "ctrlKey",
+  Meta: "metaKey",
+  Shift: "shiftKey"
+}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support
+// getModifierState. If getModifierState is not supported, we map it to a set of
+// modifier keys exposed by the event. In this case, Lock-keys are not supported.
+// $FlowFixMe[missing-local-annot]
+// $FlowFixMe[missing-this-annot]
 
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+function modifierStateGetter(keyArg) {
+  var syntheticEvent = this;
+  var nativeEvent = syntheticEvent.nativeEvent;
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitPassiveMountOnFiber(
-        root,
-        child,
-        committedLanes,
-        committedTransitions
-      );
-      child = child.sibling;
-    }
+  if (nativeEvent.getModifierState) {
+    return nativeEvent.getModifierState(keyArg);
   }
 
-  setCurrentFiber(prevDebugFiber);
+  var keyProp = modifierKeyToProp[keyArg];
+  return keyProp ? !!nativeEvent[keyProp] : false;
 }
 
-function commitPassiveMountOnFiber(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  // When updating this function, also update reconnectPassiveEffects, which does
-  // most of the same things when an offscreen tree goes from hidden -> visible,
-  // or when toggling effects inside a hidden tree.
-  var flags = finishedWork.flags;
+function getEventModifierState(nativeEvent) {
+  return modifierStateGetter;
+}
+/**
+ * @interface KeyboardEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+  key: getEventKey,
+  code: 0,
+  location: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  altKey: 0,
+  metaKey: 0,
+  repeat: 0,
+  locale: 0,
+  getModifierState: getEventModifierState,
+  // Legacy Interface
+  charCode: function (event) {
+    // `charCode` is the result of a KeyPress event and represents the value of
+    // the actual printable character.
+    // KeyPress is deprecated, but its replacement is not yet final and not
+    // implemented in any major browser. Only KeyPress has charCode.
+    if (event.type === "keypress") {
+      return getEventCharCode(
+        // $FlowFixMe unable to narrow to `KeyboardEvent`
+        event
       );
+    }
 
-      if (flags & Passive$1) {
-        commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
-      }
-
-      break;
+    return 0;
+  },
+  keyCode: function (event) {
+    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+    // physical keyboard key.
+    // The actual meaning of the value depends on the users' keyboard layout
+    // which cannot be detected. Assuming that it is a US keyboard layout
+    // provides a surprisingly accurate mapping for US and European users.
+    // Due to this, it is left to the user to implement at this time.
+    if (event.type === "keydown" || event.type === "keyup") {
+      return event.keyCode;
     }
 
-    case HostRoot: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+    return 0;
+  },
+  which: function (event) {
+    // `which` is an alias for either `keyCode` or `charCode` depending on the
+    // type of the event.
+    if (event.type === "keypress") {
+      return getEventCharCode(
+        // $FlowFixMe unable to narrow to `KeyboardEvent`
+        event
       );
+    }
 
-      if (flags & Passive$1) {
-        {
-          var previousCache = null;
-
-          if (finishedWork.alternate !== null) {
-            previousCache = finishedWork.alternate.memoizedState.cache;
-          }
-
-          var nextCache = finishedWork.memoizedState.cache; // Retain/release the root cache.
-          // Note that on initial mount, previousCache and nextCache will be the same
-          // and this retain won't occur. To counter this, we instead retain the HostRoot's
-          // initial cache when creating the root itself (see createFiberRoot() in
-          // ReactFiberRoot.js). Subsequent updates that change the cache are reflected
-          // here, such that previous/next caches are retained correctly.
-
-          if (nextCache !== previousCache) {
-            retainCache(nextCache);
-
-            if (previousCache != null) {
-              releaseCache(previousCache);
-            }
-          }
-        }
-
-        if (enableTransitionTracing) {
-          // Get the transitions that were initiatized during the render
-          // and add a start transition callback for each of them
-          var root = finishedWork.stateNode;
-          var incompleteTransitions = root.incompleteTransitions; // Initial render
-
-          if (committedTransitions !== null) {
-            committedTransitions.forEach(function (transition) {
-              addTransitionStartCallbackToPendingTransition(transition);
-            });
-            clearTransitionsForLanes(finishedRoot, committedLanes);
-          }
-
-          incompleteTransitions.forEach(function (markerInstance, transition) {
-            var pendingBoundaries = markerInstance.pendingBoundaries;
+    if (event.type === "keydown" || event.type === "keyup") {
+      return event.keyCode;
+    }
 
-            if (pendingBoundaries === null || pendingBoundaries.size === 0) {
-              if (markerInstance.aborts === null) {
-                addTransitionCompleteCallbackToPendingTransition(transition);
-              }
+    return 0;
+  }
+});
 
-              incompleteTransitions.delete(transition);
-            }
-          });
-          clearTransitionsForLanes(finishedRoot, committedLanes);
-        }
-      }
+var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
+/**
+ * @interface PointerEvent
+ * @see http://www.w3.org/TR/pointerevents/
+ */
 
-      break;
-    }
+var PointerEventInterface = assign({}, MouseEventInterface, {
+  pointerId: 0,
+  width: 0,
+  height: 0,
+  pressure: 0,
+  tangentialPressure: 0,
+  tiltX: 0,
+  tiltY: 0,
+  twist: 0,
+  pointerType: 0,
+  isPrimary: 0
+});
 
-    case LegacyHiddenComponent: {
-      {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
-        );
+var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
+/**
+ * @interface TouchEvent
+ * @see http://www.w3.org/TR/touch-events/
+ */
 
-        if (flags & Passive$1) {
-          var current = finishedWork.alternate;
-          var instance = finishedWork.stateNode;
-          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-        }
-      }
+var TouchEventInterface = assign({}, UIEventInterface, {
+  touches: 0,
+  targetTouches: 0,
+  changedTouches: 0,
+  altKey: 0,
+  metaKey: 0,
+  ctrlKey: 0,
+  shiftKey: 0,
+  getModifierState: getEventModifierState
+});
 
-      break;
-    }
+var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
+/**
+ * @interface Event
+ * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+ */
 
-    case OffscreenComponent: {
-      // TODO: Pass `current` as argument to this function
-      var _instance3 = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+var TransitionEventInterface = assign({}, EventInterface, {
+  propertyName: 0,
+  elapsedTime: 0,
+  pseudoElement: 0
+});
 
-      if (isHidden) {
-        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          );
-        } else {
-          if (finishedWork.mode & ConcurrentMode) {
-            // The effects are currently disconnected. Since the tree is hidden,
-            // don't connect them. This also applies to the initial render.
-            {
-              // "Atomic" effects are ones that need to fire on every commit,
-              // even during pre-rendering. An example is updating the reference
-              // count on cache instances.
-              recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              );
-            }
-          } else {
-            // Legacy Mode: Fire the effects even if the tree is hidden.
-            _instance3._visibility |= OffscreenPassiveEffectsConnected;
-            recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            );
-          }
-        }
-      } else {
-        // Tree is visible
-        if (_instance3._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          );
-        } else {
-          // The effects are currently disconnected. Reconnect them, while also
-          // firing effects inside newly mounted trees. This also applies to
-          // the initial render.
-          _instance3._visibility |= OffscreenPassiveEffectsConnected;
-          var includeWorkInProgressEffects =
-            (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1;
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
-          );
-        }
-      }
+var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
+/**
+ * @interface WheelEvent
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/
+ */
 
-      if (flags & Passive$1) {
-        var _current = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
-      }
+var WheelEventInterface = assign({}, MouseEventInterface, {
+  deltaX: function (event) {
+    return "deltaX" in event
+      ? event.deltaX // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+      : "wheelDeltaX" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDeltaX
+      : 0;
+  },
+  deltaY: function (event) {
+    return "deltaY" in event
+      ? event.deltaY // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+      : "wheelDeltaY" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDeltaY // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+      : "wheelDelta" in event // $FlowFixMe assuming this is a number
+      ? -event.wheelDelta
+      : 0;
+  },
+  deltaZ: 0,
+  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+  deltaMode: 0
+});
 
-      break;
-    }
+var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
 
-    case CacheComponent: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
+var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current2 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current2, finishedWork);
-      }
+var START_KEYCODE = 229;
+var canUseCompositionEvent = canUseDOM && "CompositionEvent" in window;
+var documentMode = null;
 
-      break;
-    }
+if (canUseDOM && "documentMode" in document) {
+  documentMode = document.documentMode;
+} // Webkit offers a very useful `textInput` event that can be used to
+// directly represent `beforeInput`. The IE `textinput` event is not as
+// useful, so we don't use it.
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
-        );
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied
+// by the native compositionend event may be incorrect. Japanese ideographic
+// spaces, for instance (\u3000) are not recorded correctly.
 
-        if (flags & Passive$1) {
-          commitTracingMarkerPassiveMountEffect(finishedWork);
-        }
+var useFallbackCompositionData =
+  canUseDOM &&
+  (!canUseCompositionEvent ||
+    (documentMode && documentMode > 8 && documentMode <= 11));
+var SPACEBAR_CODE = 32;
+var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
 
-        break;
-      } // Intentional fallthrough to next branch
-    }
-    // eslint-disable-next-line-no-fallthrough
+function registerEvents$3() {
+  registerTwoPhaseEvent("onBeforeInput", [
+    "compositionend",
+    "keypress",
+    "textInput",
+    "paste"
+  ]);
+  registerTwoPhaseEvent("onCompositionEnd", [
+    "compositionend",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+  registerTwoPhaseEvent("onCompositionStart", [
+    "compositionstart",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+  registerTwoPhaseEvent("onCompositionUpdate", [
+    "compositionupdate",
+    "focusout",
+    "keydown",
+    "keypress",
+    "keyup",
+    "mousedown"
+  ]);
+} // Track whether we've ever handled a keypress on the space key.
 
-    default: {
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
-      break;
-    }
-  }
+var hasSpaceKeypress = false;
+/**
+ * Return whether a native keypress event is assumed to be a command.
+ * This is required because Firefox fires `keypress` events for key commands
+ * (cut, copy, select-all, etc.) even though no character is inserted.
+ */
+
+function isKeypressCommand(nativeEvent) {
+  return (
+    (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+    !(nativeEvent.ctrlKey && nativeEvent.altKey)
+  );
 }
+/**
+ * Translate native top level events into event types.
+ */
 
-function recursivelyTraverseReconnectPassiveEffects(
-  finishedRoot,
-  parentFiber,
-  committedLanes,
-  committedTransitions,
-  includeWorkInProgressEffects
-) {
-  // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  var childShouldIncludeWorkInProgressEffects =
-    includeWorkInProgressEffects &&
-    (parentFiber.subtreeFlags & PassiveMask) !== NoFlags$1; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+function getCompositionEventType(domEventName) {
+  switch (domEventName) {
+    case "compositionstart":
+      return "onCompositionStart";
 
-  var prevDebugFiber = getCurrentFiber();
-  var child = parentFiber.child;
+    case "compositionend":
+      return "onCompositionEnd";
 
-  while (child !== null) {
-    reconnectPassiveEffects(
-      finishedRoot,
-      child,
-      committedLanes,
-      committedTransitions,
-      childShouldIncludeWorkInProgressEffects
-    );
-    child = child.sibling;
+    case "compositionupdate":
+      return "onCompositionUpdate";
   }
-
-  setCurrentFiber(prevDebugFiber);
 }
+/**
+ * Does our fallback best-guess model think this event signifies that
+ * composition has begun?
+ */
 
-function reconnectPassiveEffects(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions, // This function visits both newly finished work and nodes that were re-used
-  // from a previously committed tree. We cannot check non-static flags if the
-  // node was reused.
-  includeWorkInProgressEffects
-) {
-  var flags = finishedWork.flags;
-
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      ); // TODO: Check for PassiveStatic flag
+function isFallbackCompositionStart(domEventName, nativeEvent) {
+  return domEventName === "keydown" && nativeEvent.keyCode === START_KEYCODE;
+}
+/**
+ * Does our fallback mode think that this event is the end of composition?
+ */
 
-      commitHookPassiveMountEffects(finishedWork, Passive);
-      break;
-    }
-    // Unlike commitPassiveMountOnFiber, we don't need to handle HostRoot
-    // because this function only visits nodes that are inside an
-    // Offscreen fiber.
-    // case HostRoot: {
-    //  ...
-    // }
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      // Command keys insert or clear IME input.
+      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
 
-    case LegacyHiddenComponent: {
-      {
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
+    case "keydown":
+      // Expect IME keyCode on each keydown. If we get any other
+      // code we must have exited earlier.
+      return nativeEvent.keyCode !== START_KEYCODE;
 
-        if (includeWorkInProgressEffects && flags & Passive$1) {
-          // TODO: Pass `current` as argument to this function
-          var current = finishedWork.alternate;
-          var instance = finishedWork.stateNode;
-          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
-        }
-      }
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      // Events are not possible without cancelling IME.
+      return true;
 
-      break;
-    }
+    default:
+      return false;
+  }
+}
+/**
+ * Google Input Tools provides composition data via a CustomEvent,
+ * with the `data` property populated in the `detail` object. If this
+ * is available on the event object, use it. If not, this is a plain
+ * composition event and we have nothing special to extract.
+ *
+ * @param {object} nativeEvent
+ * @return {?string}
+ */
 
-    case OffscreenComponent: {
-      var _instance4 = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+function getDataFromCustomEvent(nativeEvent) {
+  var detail = nativeEvent.detail;
 
-      if (isHidden) {
-        if (_instance4._visibility & OffscreenPassiveEffectsConnected) {
-          // The effects are currently connected. Update them.
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
-          );
-        } else {
-          if (finishedWork.mode & ConcurrentMode) {
-            // The effects are currently disconnected. Since the tree is hidden,
-            // don't connect them. This also applies to the initial render.
-            {
-              // "Atomic" effects are ones that need to fire on every commit,
-              // even during pre-rendering. An example is updating the reference
-              // count on cache instances.
-              recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              );
-            }
-          } else {
-            // Legacy Mode: Fire the effects even if the tree is hidden.
-            _instance4._visibility |= OffscreenPassiveEffectsConnected;
-            recursivelyTraverseReconnectPassiveEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions,
-              includeWorkInProgressEffects
-            );
-          }
-        }
-      } else {
-        // Tree is visible
-        // Since we're already inside a reconnecting tree, it doesn't matter
-        // whether the effects are currently connected. In either case, we'll
-        // continue traversing the tree and firing all the effects.
-        //
-        // We do need to set the "connected" flag on the instance, though.
-        _instance4._visibility |= OffscreenPassiveEffectsConnected;
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
-      }
+  if (typeof detail === "object" && "data" in detail) {
+    return detail.data;
+  }
 
-      if (includeWorkInProgressEffects && flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current3 = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
-      }
+  return null;
+}
+/**
+ * Check if a composition event was triggered by Korean IME.
+ * Our fallback mode does not work well with IE's Korean IME,
+ * so just use native composition events when Korean IME is used.
+ * Although CompositionEvent.locale property is deprecated,
+ * it is available in IE, where our fallback mode is enabled.
+ *
+ * @param {object} nativeEvent
+ * @return {boolean}
+ */
 
-      break;
-    }
+function isUsingKoreanIME(nativeEvent) {
+  return nativeEvent.locale === "ko";
+} // Track the current IME composition status, if any.
 
-    case CacheComponent: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      );
+var isComposing = false;
+/**
+ * @return {?object} A SyntheticCompositionEvent.
+ */
 
-      if (includeWorkInProgressEffects && flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current4 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current4, finishedWork);
-      }
+function extractCompositionEvent(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget
+) {
+  var eventType;
+  var fallbackData;
 
-      break;
+  if (canUseCompositionEvent) {
+    eventType = getCompositionEventType(domEventName);
+  } else if (!isComposing) {
+    if (isFallbackCompositionStart(domEventName, nativeEvent)) {
+      eventType = "onCompositionStart";
     }
+  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {
+    eventType = "onCompositionEnd";
+  }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
-        );
-
-        if (includeWorkInProgressEffects && flags & Passive$1) {
-          commitTracingMarkerPassiveMountEffect(finishedWork);
-        }
-
-        break;
-      } // Intentional fallthrough to next branch
-    }
-    // eslint-disable-next-line-no-fallthrough
+  if (!eventType) {
+    return null;
+  }
 
-    default: {
-      recursivelyTraverseReconnectPassiveEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions,
-        includeWorkInProgressEffects
-      );
-      break;
+  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {
+    // The current composition is stored statically and must not be
+    // overwritten while composition continues.
+    if (!isComposing && eventType === "onCompositionStart") {
+      isComposing = initialize(nativeEventTarget);
+    } else if (eventType === "onCompositionEnd") {
+      if (isComposing) {
+        fallbackData = getData();
+      }
     }
   }
-}
 
-function recursivelyTraverseAtomicPassiveEffects(
-  finishedRoot,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  // "Atomic" effects are ones that need to fire on every commit, even during
-  // pre-rendering. We call this function when traversing a hidden tree whose
-  // regular effects are currently disconnected.
-  var prevDebugFiber = getCurrentFiber(); // TODO: Add special flag for atomic effects
+  var listeners = accumulateTwoPhaseListeners(targetInst, eventType);
+
+  if (listeners.length > 0) {
+    var event = new SyntheticCompositionEvent(
+      eventType,
+      domEventName,
+      null,
+      nativeEvent,
+      nativeEventTarget
+    );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
 
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+    if (fallbackData) {
+      // Inject data generated from fallback path into the synthetic event.
+      // This matches the property of native CompositionEventInterface.
+      // $FlowFixMe[incompatible-use]
+      event.data = fallbackData;
+    } else {
+      var customData = getDataFromCustomEvent(nativeEvent);
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitAtomicPassiveEffects(finishedRoot, child);
-      child = child.sibling;
+      if (customData !== null) {
+        // $FlowFixMe[incompatible-use]
+        event.data = customData;
+      }
     }
   }
-
-  setCurrentFiber(prevDebugFiber);
 }
 
-function commitAtomicPassiveEffects(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  // "Atomic" effects are ones that need to fire on every commit, even during
-  // pre-rendering. We call this function when traversing a hidden tree whose
-  // regular effects are currently disconnected.
-  var flags = finishedWork.flags;
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
 
-  switch (finishedWork.tag) {
-    case OffscreenComponent: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+    case "keypress":
+      /**
+       * If native `textInput` events are available, our goal is to make
+       * use of them. However, there is a special case: the spacebar key.
+       * In Webkit, preventing default on a spacebar `textInput` event
+       * cancels character insertion, but it *also* causes the browser
+       * to fall back to its default spacebar behavior of scrolling the
+       * page.
+       *
+       * Tracking at:
+       * https://code.google.com/p/chromium/issues/detail?id=355103
+       *
+       * To avoid this issue, use the keypress event as if no `textInput`
+       * event is available.
+       */
+      var which = nativeEvent.which;
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var current = finishedWork.alternate;
-        var instance = finishedWork.stateNode;
-        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+      if (which !== SPACEBAR_CODE) {
+        return null;
       }
 
-      break;
-    }
+      hasSpaceKeypress = true;
+      return SPACEBAR_CHAR;
 
-    case CacheComponent: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+    case "textInput":
+      // Record the characters to be added to the DOM.
+      var chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled
+      // it at the keypress level and bail immediately. Android Chrome
+      // doesn't give us keycodes, so we need to ignore it.
 
-      if (flags & Passive$1) {
-        // TODO: Pass `current` as argument to this function
-        var _current5 = finishedWork.alternate;
-        commitCachePassiveMountEffect(_current5, finishedWork);
+      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+        return null;
       }
 
-      break;
-    }
-    // eslint-disable-next-line-no-fallthrough
+      return chars;
 
-    default: {
-      recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-      break;
-    }
+    default:
+      // For other native event types, do nothing.
+      return null;
   }
 }
+/**
+ * For browsers that do not provide the `textInput` event, extract the
+ * appropriate string to use for SyntheticInputEvent.
+ */
 
-function commitPassiveUnmountEffects(finishedWork) {
-  setCurrentFiber(finishedWork);
-  commitPassiveUnmountOnFiber(finishedWork);
-  resetCurrentFiber();
-}
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  // If we are currently composing (IME) and using a fallback to do so,
+  // try to extract the composed characters from the fallback object.
+  // If composition event is available, we extract a string only at
+  // compositionevent, otherwise extract it at fallback events.
+  if (isComposing) {
+    if (
+      domEventName === "compositionend" ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+    ) {
+      var chars = getData();
+      reset();
+      isComposing = false;
+      return chars;
+    }
 
-function detachAlternateSiblings(parentFiber) {
-  // A fiber was deleted from this parent fiber, but it's still part of the
-  // previous (alternate) parent fiber's list of children. Because children
-  // are a linked list, an earlier sibling that's still alive will be
-  // connected to the deleted fiber via its `alternate`:
-  //
-  //   live fiber --alternate--> previous live fiber --sibling--> deleted
-  //   fiber
-  //
-  // We can't disconnect `alternate` on nodes that haven't been deleted yet,
-  // but we can disconnect the `sibling` and `child` pointers.
-  var previousFiber = parentFiber.alternate;
+    return null;
+  }
 
-  if (previousFiber !== null) {
-    var detachedChild = previousFiber.child;
+  switch (domEventName) {
+    case "paste":
+      // If a paste event occurs after a keypress, throw out the input
+      // chars. Paste events should not lead to BeforeInput events.
+      return null;
 
-    if (detachedChild !== null) {
-      previousFiber.child = null;
+    case "keypress":
+      /**
+       * As of v27, Firefox may fire keypress events even when no character
+       * will be inserted. A few possibilities:
+       *
+       * - `which` is `0`. Arrow keys, Esc key, etc.
+       *
+       * - `which` is the pressed key code, but no char is available.
+       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+       *   this key combination and no character is inserted into the
+       *   document, but FF fires the keypress for char code `100` anyway.
+       *   No `input` event will occur.
+       *
+       * - `which` is the pressed key code, but a command combination is
+       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+       *   `input` event will occur.
+       */
+      if (!isKeypressCommand(nativeEvent)) {
+        // IE fires the `keypress` event when a user types an emoji via
+        // Touch keyboard of Windows.  In such a case, the `char` property
+        // holds an emoji character like `\uD83D\uDE0A`.  Because its length
+        // is 2, the property `which` does not represent an emoji correctly.
+        // In such a case, we directly return the `char` property instead of
+        // using `which`.
+        if (nativeEvent.char && nativeEvent.char.length > 1) {
+          return nativeEvent.char;
+        } else if (nativeEvent.which) {
+          return String.fromCharCode(nativeEvent.which);
+        }
+      }
 
-      do {
-        // $FlowFixMe[incompatible-use] found when upgrading Flow
-        var detachedSibling = detachedChild.sibling; // $FlowFixMe[incompatible-use] found when upgrading Flow
+      return null;
 
-        detachedChild.sibling = null;
-        detachedChild = detachedSibling;
-      } while (detachedChild !== null);
-    }
+    case "compositionend":
+      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)
+        ? null
+        : nativeEvent.data;
+
+    default:
+      return null;
   }
 }
+/**
+ * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+ * `textInput` or fallback behavior.
+ *
+ * @return {?object} A SyntheticInputEvent.
+ */
 
-function commitHookPassiveUnmountEffects(
-  finishedWork,
-  nearestMountedAncestor,
-  hookFlags
+function extractBeforeInputEvent(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget
 ) {
-  if (shouldProfile(finishedWork)) {
-    startPassiveEffectTimer();
-    commitHookEffectListUnmount(
-      hookFlags,
-      finishedWork,
-      nearestMountedAncestor
-    );
-    recordPassiveEffectDuration(finishedWork);
+  var chars;
+
+  if (canUseTextInputEvent) {
+    chars = getNativeBeforeInputChars(domEventName, nativeEvent);
   } else {
-    commitHookEffectListUnmount(
-      hookFlags,
-      finishedWork,
-      nearestMountedAncestor
+    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);
+  } // If no characters are being inserted, no BeforeInput event should
+  // be fired.
+
+  if (!chars) {
+    return null;
+  }
+
+  var listeners = accumulateTwoPhaseListeners(targetInst, "onBeforeInput");
+
+  if (listeners.length > 0) {
+    var event = new SyntheticInputEvent(
+      "onBeforeInput",
+      "beforeinput",
+      null,
+      nativeEvent,
+      nativeEventTarget
     );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    }); // $FlowFixMe[incompatible-use]
+
+    event.data = chars;
   }
 }
+/**
+ * Create an `onBeforeInput` event to match
+ * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+ *
+ * This event plugin is based on the native `textInput` event
+ * available in Chrome, Safari, Opera, and IE. This event fires after
+ * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+ *
+ * `beforeInput` is spec'd but not implemented in any browsers, and
+ * the `input` event does not provide any useful information about what has
+ * actually been added, contrary to the spec. Thus, `textInput` is the best
+ * available event to identify the characters that have actually been inserted
+ * into the target node.
+ *
+ * This plugin is also responsible for emitting `composition` events, thus
+ * allowing us to share composition fallback code for both `beforeInput` and
+ * `composition` event types.
+ */
+
+function extractEvents$5(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  extractCompositionEvent(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  );
+  extractBeforeInputEvent(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  );
+}
 
-function recursivelyTraversePassiveUnmountEffects(parentFiber) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects have fired.
-  var deletions = parentFiber.deletions;
+/**
+ * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
+ */
+var supportedInputTypes = {
+  color: true,
+  date: true,
+  datetime: true,
+  "datetime-local": true,
+  email: true,
+  month: true,
+  number: true,
+  password: true,
+  range: true,
+  search: true,
+  tel: true,
+  text: true,
+  time: true,
+  url: true,
+  week: true
+};
 
-  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
-    if (deletions !== null) {
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
 
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    }
+  if (nodeName === "input") {
+    return !!supportedInputTypes[elem.type];
+  }
 
-    detachAlternateSiblings(parentFiber);
+  if (nodeName === "textarea") {
+    return true;
   }
 
-  var prevDebugFiber = getCurrentFiber(); // TODO: Split PassiveMask into separate masks for mount and unmount?
+  return false;
+}
 
-  if (parentFiber.subtreeFlags & PassiveMask) {
-    var child = parentFiber.child;
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
 
-    while (child !== null) {
-      setCurrentFiber(child);
-      commitPassiveUnmountOnFiber(child);
-      child = child.sibling;
-    }
+function isEventSupported(eventNameSuffix) {
+  if (!canUseDOM) {
+    return false;
   }
 
-  setCurrentFiber(prevDebugFiber);
+  var eventName = "on" + eventNameSuffix;
+  var isSupported = eventName in document;
+
+  if (!isSupported) {
+    var element = document.createElement("div");
+    element.setAttribute(eventName, "return;");
+    isSupported = typeof element[eventName] === "function";
+  }
+
+  return isSupported;
 }
 
-function commitPassiveUnmountOnFiber(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
+function registerEvents$2() {
+  registerTwoPhaseEvent("onChange", [
+    "change",
+    "click",
+    "focusin",
+    "focusout",
+    "input",
+    "keydown",
+    "keyup",
+    "selectionchange"
+  ]);
+}
 
-      if (finishedWork.flags & Passive$1) {
-        commitHookPassiveUnmountEffects(
-          finishedWork,
-          finishedWork.return,
-          Passive | HasEffect
-        );
-      }
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
+) {
+  // Flag this event loop as needing state restore.
+  enqueueStateRestore(target);
+  var listeners = accumulateTwoPhaseListeners(inst, "onChange");
 
-      break;
-    }
+  if (listeners.length > 0) {
+    var event = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    );
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
+  }
+}
+/**
+ * For IE shims
+ */
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
-      var nextState = finishedWork.memoizedState;
-      var isHidden = nextState !== null;
+var activeElement$1 = null;
+var activeElementInst$1 = null;
+/**
+ * SECTION: handle `change` event
+ */
 
-      if (
-        isHidden &&
-        instance._visibility & OffscreenPassiveEffectsConnected && // For backwards compatibility, don't unmount when a tree suspends. In
-        // the future we may change this to unmount after a delay.
-        (finishedWork.return === null ||
-          finishedWork.return.tag !== SuspenseComponent)
-      ) {
-        // The effects are currently connected. Disconnect them.
-        // TODO: Add option or heuristic to delay before disconnecting the
-        // effects. Then if the tree reappears before the delay has elapsed, we
-        // can skip toggling the effects entirely.
-        instance._visibility &= ~OffscreenPassiveEffectsConnected;
-        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      } else {
-        recursivelyTraversePassiveUnmountEffects(finishedWork);
-      }
+function shouldUseChangeEvent(elem) {
+  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName === "select" || (nodeName === "input" && elem.type === "file")
+  );
+}
 
-      break;
-    }
+function manualDispatchChangeEvent(nativeEvent) {
+  var dispatchQueue = [];
+  createAndAccumulateChangeEvent(
+    dispatchQueue,
+    activeElementInst$1,
+    nativeEvent,
+    getEventTarget(nativeEvent)
+  ); // If change and propertychange bubbled, we'd just bind to it like all the
+  // other events and have it go through ReactBrowserEventEmitter. Since it
+  // doesn't, we manually listen for the events and so we have to enqueue and
+  // process the abstract event manually.
+  //
+  // Batching is necessary here in order to ensure that all event handlers run
+  // before the next rerender (including event handlers attached to ancestor
+  // elements instead of directly on the input). Without this, controlled
+  // components don't work properly in conjunction with event bubbling because
+  // the component is rerendered and the value reverted before all the event
+  // handlers can run. See https://github.com/facebook/react/issues/708.
 
-    default: {
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-      break;
-    }
+  batchedUpdates(runEventInBatch, dispatchQueue);
+}
+
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
+
+  if (updateValueIfChanged(targetNode)) {
+    return targetInst;
   }
 }
 
-function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
-  // Deletions effects can be scheduled on any fiber type. They need to happen
-  // before the children effects have fired.
-  var deletions = parentFiber.deletions;
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if (domEventName === "change") {
+    return targetInst;
+  }
+}
+/**
+ * SECTION: handle `input` event
+ */
 
-  if ((parentFiber.flags & ChildDeletion) !== NoFlags$1) {
-    if (deletions !== null) {
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i]; // TODO: Convert this to use recursion
+var isInputEventSupported = false;
+
+if (canUseDOM) {
+  // IE9 claims to support the input event but fails to trigger it when
+  // deleting text, so we ignore its input events.
+  isInputEventSupported =
+    isEventSupported("input") &&
+    (!document.documentMode || document.documentMode > 9);
+}
+/**
+ * (For IE <=9) Starts tracking propertychange events on the passed-in element
+ * and override the value property so that we can distinguish user events from
+ * value changes in JS.
+ */
 
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    }
+function startWatchingForValueChange(target, targetInst) {
+  activeElement$1 = target;
+  activeElementInst$1 = targetInst;
+  activeElement$1.attachEvent("onpropertychange", handlePropertyChange);
+}
+/**
+ * (For IE <=9) Removes the event listeners from the currently-tracked element,
+ * if any exists.
+ */
 
-    detachAlternateSiblings(parentFiber);
+function stopWatchingForValueChange() {
+  if (!activeElement$1) {
+    return;
   }
 
-  var prevDebugFiber = getCurrentFiber(); // TODO: Check PassiveStatic flag
+  activeElement$1.detachEvent("onpropertychange", handlePropertyChange);
+  activeElement$1 = null;
+  activeElementInst$1 = null;
+}
+/**
+ * (For IE <=9) Handles a propertychange event, sending a `change` event if
+ * the value of the active element has changed.
+ */
+// $FlowFixMe[missing-local-annot]
 
-  var child = parentFiber.child;
+function handlePropertyChange(nativeEvent) {
+  if (nativeEvent.propertyName !== "value") {
+    return;
+  }
 
-  while (child !== null) {
-    setCurrentFiber(child);
-    disconnectPassiveEffect(child);
-    child = child.sibling;
+  if (getInstIfValueChanged(activeElementInst$1)) {
+    manualDispatchChangeEvent(nativeEvent);
   }
+}
 
-  setCurrentFiber(prevDebugFiber);
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  if (domEventName === "focusin") {
+    // In IE9, propertychange fires for most input events but is buggy and
+    // doesn't fire when text is deleted, but conveniently, selectionchange
+    // appears to fire in all of the remaining cases so we catch those and
+    // forward the event if the value has changed
+    // In either case, we don't want to call the event handler if the value
+    // is changed from JS so we redefine a setter for `.value` that updates
+    // our activeElementValue variable, allowing us to ignore those changes
+    //
+    // stopWatching() should be a noop here but we call it just in case we
+    // missed a blur event somehow.
+    stopWatchingForValueChange();
+    startWatchingForValueChange(target, targetInst);
+  } else if (domEventName === "focusout") {
+    stopWatchingForValueChange();
+  }
+} // For IE8 and IE9.
+
+function getTargetInstForInputEventPolyfill(domEventName, targetInst) {
+  if (
+    domEventName === "selectionchange" ||
+    domEventName === "keyup" ||
+    domEventName === "keydown"
+  ) {
+    // On the selectionchange event, the target is just document which isn't
+    // helpful for us so just check activeElement instead.
+    //
+    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
+    // propertychange on the first input event after setting `value` from a
+    // script and fires only keydown, keypress, keyup. Catching keyup usually
+    // gets it and catching keydown lets us fire an event for the first
+    // keystroke if user does a key repeat (it'll be a little delayed: right
+    // before the second keystroke). Other input methods (e.g., paste) seem to
+    // fire selectionchange normally.
+    return getInstIfValueChanged(activeElementInst$1);
+  }
 }
+/**
+ * SECTION: handle `click` event
+ */
 
-function disconnectPassiveEffect(finishedWork) {
-  switch (finishedWork.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      // TODO: Check PassiveStatic flag
-      commitHookPassiveUnmountEffects(
-        finishedWork,
-        finishedWork.return,
-        Passive
-      ); // When disconnecting passive effects, we fire the effects in the same
-      // order as during a deletiong: parent before child
+function shouldUseClickEvent(elem) {
+  // Use the `click` event to detect changes to checkbox and radio inputs.
+  // This approach works across all browsers, whereas `change` does not fire
+  // until `blur` in IE8.
+  var nodeName = elem.nodeName;
+  return (
+    nodeName &&
+    nodeName.toLowerCase() === "input" &&
+    (elem.type === "checkbox" || elem.type === "radio")
+  );
+}
 
-      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      break;
-    }
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if (domEventName === "click") {
+    return getInstIfValueChanged(targetInst);
+  }
+}
 
-    case OffscreenComponent: {
-      var instance = finishedWork.stateNode;
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if (domEventName === "input" || domEventName === "change") {
+    return getInstIfValueChanged(targetInst);
+  }
+}
 
-      if (instance._visibility & OffscreenPassiveEffectsConnected) {
-        instance._visibility &= ~OffscreenPassiveEffectsConnected;
-        recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      }
+function handleControlledInputBlur(node) {
+  var state = node._wrapperState;
 
-      break;
-    }
+  if (!state || !state.controlled || node.type !== "number") {
+    return;
+  }
 
-    default: {
-      recursivelyTraverseDisconnectPassiveEffects(finishedWork);
-      break;
-    }
+  if (!disableInputAttributeSyncing) {
+    // If controlled, assign the value attribute to the current value on blur
+    setDefaultValue(node, "number", node.value);
   }
 }
+/**
+ * This plugin creates an `onChange` event that normalizes change events
+ * across form elements. This event fires at a time when it's possible to
+ * change the element's value without seeing a flicker.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - select
+ */
 
-function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-  deletedSubtreeRoot,
-  nearestMountedAncestor
+function extractEvents$4(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
 ) {
-  while (nextEffect !== null) {
-    var fiber = nextEffect; // Deletion effects fire in parent -> child order
-    // TODO: Check if fiber has a PassiveStatic flag
-
-    setCurrentFiber(fiber);
-    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
-    resetCurrentFiber();
-    var child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag.
+  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
+  var getTargetInstFunc, handleEventFunc;
 
-    if (child !== null) {
-      child.return = fiber;
-      nextEffect = child;
+  if (shouldUseChangeEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  } else if (isTextInputElement(targetNode)) {
+    if (isInputEventSupported) {
+      getTargetInstFunc = getTargetInstForInputOrChangeEvent;
     } else {
-      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
-        deletedSubtreeRoot
-      );
+      getTargetInstFunc = getTargetInstForInputEventPolyfill;
+      handleEventFunc = handleEventsForInputEventPolyfill;
     }
+  } else if (shouldUseClickEvent(targetNode)) {
+    getTargetInstFunc = getTargetInstForClickEvent;
+  } else if (
+    enableCustomElementPropertySupport &&
+    targetInst &&
+    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
+  ) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
   }
-}
-
-function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(
-  deletedSubtreeRoot
-) {
-  while (nextEffect !== null) {
-    var fiber = nextEffect;
-    var sibling = fiber.sibling;
-    var returnFiber = fiber.return; // Recursively traverse the entire deleted tree and clean up fiber fields.
-    // This is more aggressive than ideal, and the long term goal is to only
-    // have to detach the deleted tree at the root.
 
-    detachFiberAfterEffects(fiber);
+  if (getTargetInstFunc) {
+    var inst = getTargetInstFunc(domEventName, targetInst);
 
-    if (fiber === deletedSubtreeRoot) {
-      nextEffect = null;
+    if (inst) {
+      createAndAccumulateChangeEvent(
+        dispatchQueue,
+        inst,
+        nativeEvent,
+        nativeEventTarget
+      );
       return;
     }
+  }
 
-    if (sibling !== null) {
-      sibling.return = returnFiber;
-      nextEffect = sibling;
-      return;
-    }
+  if (handleEventFunc) {
+    handleEventFunc(domEventName, targetNode, targetInst);
+  } // When blurring, set the value attribute for number inputs
 
-    nextEffect = returnFiber;
+  if (domEventName === "focusout") {
+    handleControlledInputBlur(targetNode);
   }
 }
 
-function commitPassiveUnmountInsideDeletedTreeOnFiber(
-  current,
-  nearestMountedAncestor
-) {
-  switch (current.tag) {
-    case FunctionComponent:
-    case ForwardRef:
-    case SimpleMemoComponent: {
-      commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
-      break;
-    }
-    // TODO: run passive unmount effects when unmounting a root.
-    // Because passive unmount effects are not currently run,
-    // the cache instance owned by the root will never be freed.
-    // When effects are run, the cache should be freed here:
-    // case HostRoot: {
-    //   if (enableCache) {
-    //     const cache = current.memoizedState.cache;
-    //     releaseCache(cache);
-    //   }
-    //   break;
-    // }
-
-    case LegacyHiddenComponent:
-    case OffscreenComponent: {
-      {
-        if (
-          current.memoizedState !== null &&
-          current.memoizedState.cachePool !== null
-        ) {
-          var cache = current.memoizedState.cachePool.pool; // Retain/release the cache used for pending (suspended) nodes.
-          // Note that this is only reached in the non-suspended/visible case:
-          // when the content is suspended/hidden, the retain/release occurs
-          // via the parent Suspense component (see case above).
-
-          if (cache != null) {
-            retainCache(cache);
-          }
-        }
-      }
-
-      break;
-    }
-
-    case SuspenseComponent: {
-      if (enableTransitionTracing) {
-        // We need to mark this fiber's parents as deleted
-        var offscreenFiber = current.child;
-        var instance = offscreenFiber.stateNode;
-        var transitions = instance._transitions;
-
-        if (transitions !== null) {
-          var abortReason = {
-            reason: "suspense",
-            name: current.memoizedProps.unstable_name || null
-          };
-
-          if (
-            current.memoizedState === null ||
-            current.memoizedState.dehydrated === null
-          ) {
-            abortParentMarkerTransitionsForDeletedFiber(
-              offscreenFiber,
-              abortReason,
-              transitions,
-              instance,
-              true
-            );
+function registerEvents$1() {
+  registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+  registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+  registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+  registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+}
+/**
+ * For almost every interaction we care about, there will be both a top-level
+ * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
+ * we do not extract duplicate events. However, moving the mouse into the
+ * browser from outside will not fire a `mouseout` event. In this case, we use
+ * the `mouseover` top-level event.
+ */
 
-            if (nearestMountedAncestor !== null) {
-              abortParentMarkerTransitionsForDeletedFiber(
-                nearestMountedAncestor,
-                abortReason,
-                transitions,
-                instance,
-                false
-              );
-            }
-          }
-        }
-      }
+function extractEvents$3(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var isOverEvent =
+    domEventName === "mouseover" || domEventName === "pointerover";
+  var isOutEvent = domEventName === "mouseout" || domEventName === "pointerout";
 
-      break;
-    }
+  if (isOverEvent && !isReplayingEvent(nativeEvent)) {
+    // If this is an over event with a target, we might have already dispatched
+    // the event in the out event of the other target. If this is replayed,
+    // then it's because we couldn't dispatch against this target previously
+    // so we have to do it now instead.
+    var related = nativeEvent.relatedTarget || nativeEvent.fromElement;
 
-    case CacheComponent: {
-      {
-        var _cache = current.memoizedState.cache;
-        releaseCache(_cache);
+    if (related) {
+      // If the related node is managed by React, we can assume that we have
+      // already dispatched the corresponding events during its mouseout.
+      if (
+        getClosestInstanceFromNode(related) ||
+        isContainerMarkedAsRoot(related)
+      ) {
+        return;
       }
-
-      break;
     }
+  }
 
-    case TracingMarkerComponent: {
-      if (enableTransitionTracing) {
-        // We need to mark this fiber's parents as deleted
-        var _instance5 = current.stateNode;
-        var _transitions = _instance5.transitions;
+  if (!isOutEvent && !isOverEvent) {
+    // Must not be a mouse or pointer in or out - ignoring.
+    return;
+  }
 
-        if (_transitions !== null) {
-          var _abortReason = {
-            reason: "marker",
-            name: current.memoizedProps.name
-          };
-          abortParentMarkerTransitionsForDeletedFiber(
-            current,
-            _abortReason,
-            _transitions,
-            null,
-            true
-          );
+  var win; // TODO: why is this nullable in the types but we read from it?
 
-          if (nearestMountedAncestor !== null) {
-            abortParentMarkerTransitionsForDeletedFiber(
-              nearestMountedAncestor,
-              _abortReason,
-              _transitions,
-              null,
-              false
-            );
-          }
-        }
-      }
+  if (nativeEventTarget.window === nativeEventTarget) {
+    // `nativeEventTarget` is probably a window object.
+    win = nativeEventTarget;
+  } else {
+    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+    var doc = nativeEventTarget.ownerDocument;
 
-      break;
+    if (doc) {
+      win = doc.defaultView || doc.parentWindow;
+    } else {
+      win = window;
     }
   }
-}
 
-function invokeLayoutEffectMountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListMount(Layout | HasEffect, fiber);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
+  var from;
+  var to;
 
-        break;
-      }
+  if (isOutEvent) {
+    var _related = nativeEvent.relatedTarget || nativeEvent.toElement;
 
-      case ClassComponent: {
-        var instance = fiber.stateNode;
+    from = targetInst;
+    to = _related ? getClosestInstanceFromNode(_related) : null;
 
-        try {
-          instance.componentDidMount();
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
+    if (to !== null) {
+      var nearestMounted = getNearestMountedFiber(to);
+      var tag = to.tag;
 
-        break;
+      if (
+        to !== nearestMounted ||
+        (tag !== HostComponent && tag !== HostSingleton && tag !== HostText)
+      ) {
+        to = null;
       }
     }
+  } else {
+    // Moving to a node from outside the window.
+    from = null;
+    to = targetInst;
   }
-}
-
-function invokePassiveEffectMountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListMount(Passive | HasEffect, fiber);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
 
-        break;
-      }
-    }
+  if (from === to) {
+    // Nothing pertains to our managed components.
+    return;
   }
-}
 
-function invokeLayoutEffectUnmountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
+  var SyntheticEventCtor = SyntheticMouseEvent;
+  var leaveEventType = "onMouseLeave";
+  var enterEventType = "onMouseEnter";
+  var eventTypePrefix = "mouse";
 
-        break;
-      }
+  if (domEventName === "pointerout" || domEventName === "pointerover") {
+    SyntheticEventCtor = SyntheticPointerEvent;
+    leaveEventType = "onPointerLeave";
+    enterEventType = "onPointerEnter";
+    eventTypePrefix = "pointer";
+  }
 
-      case ClassComponent: {
-        var instance = fiber.stateNode;
+  var fromNode = from == null ? win : getNodeFromInstance(from);
+  var toNode = to == null ? win : getNodeFromInstance(to);
+  var leave = new SyntheticEventCtor(
+    leaveEventType,
+    eventTypePrefix + "leave",
+    from,
+    nativeEvent,
+    nativeEventTarget
+  );
+  leave.target = fromNode;
+  leave.relatedTarget = toNode;
+  var enter = null; // We should only process this nativeEvent if we are processing
+  // the first ancestor. Next time, we will ignore the event.
 
-        if (typeof instance.componentWillUnmount === "function") {
-          safelyCallComponentWillUnmount(fiber, fiber.return, instance);
-        }
+  var nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);
 
-        break;
-      }
-    }
+  if (nativeTargetInst === targetInst) {
+    var enterEvent = new SyntheticEventCtor(
+      enterEventType,
+      eventTypePrefix + "enter",
+      to,
+      nativeEvent,
+      nativeEventTarget
+    );
+    enterEvent.target = toNode;
+    enterEvent.relatedTarget = fromNode;
+    enter = enterEvent;
   }
+
+  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);
 }
 
-function invokePassiveEffectUnmountInDEV(fiber) {
-  {
-    // We don't need to re-check StrictEffectsMode here.
-    // This function is only called if that check has already passed.
-    switch (fiber.tag) {
-      case FunctionComponent:
-      case ForwardRef:
-      case SimpleMemoComponent: {
-        try {
-          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
-        } catch (error) {
-          captureCommitPhaseError(fiber, fiber.return, error);
-        }
-      }
-    }
+/**
+ * Given any node return the first leaf node without children.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {DOMElement|DOMTextNode}
+ */
+
+function getLeafNode(node) {
+  while (node && node.firstChild) {
+    node = node.firstChild;
   }
-}
 
-function getCacheSignal() {
-  var cache = readContext(CacheContext);
-  return cache.controller.signal;
+  return node;
 }
+/**
+ * Get the next sibling within a container. This will walk up the
+ * DOM if a node's siblings have been exhausted.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @return {?DOMElement|DOMTextNode}
+ */
 
-function getCacheForType(resourceType) {
-  var cache = readContext(CacheContext);
-  var cacheForType = cache.data.get(resourceType);
+function getSiblingNode(node) {
+  while (node) {
+    if (node.nextSibling) {
+      return node.nextSibling;
+    }
 
-  if (cacheForType === undefined) {
-    cacheForType = resourceType();
-    cache.data.set(resourceType, cacheForType);
+    node = node.parentNode;
   }
-
-  return cacheForType;
 }
+/**
+ * Get object describing the nodes which contain characters at offset.
+ *
+ * @param {DOMElement|DOMTextNode} root
+ * @param {number} offset
+ * @return {?object}
+ */
 
-var DefaultCacheDispatcher = {
-  getCacheSignal: getCacheSignal,
-  getCacheForType: getCacheForType
-};
+function getNodeForCharacterOffset(root, offset) {
+  var node = getLeafNode(root);
+  var nodeStart = 0;
+  var nodeEnd = 0;
 
-var COMPONENT_TYPE = 0;
-var HAS_PSEUDO_CLASS_TYPE = 1;
-var ROLE_TYPE = 2;
-var TEST_NAME_TYPE = 3;
-var TEXT_TYPE = 4;
+  while (node) {
+    if (node.nodeType === TEXT_NODE) {
+      nodeEnd = nodeStart + node.textContent.length;
 
-if (typeof Symbol === "function" && Symbol.for) {
-  var symbolFor = Symbol.for;
-  COMPONENT_TYPE = symbolFor("selector.component");
-  HAS_PSEUDO_CLASS_TYPE = symbolFor("selector.has_pseudo_class");
-  ROLE_TYPE = symbolFor("selector.role");
-  TEST_NAME_TYPE = symbolFor("selector.test_id");
-  TEXT_TYPE = symbolFor("selector.text");
-}
+      if (nodeStart <= offset && nodeEnd >= offset) {
+        return {
+          node: node,
+          offset: offset - nodeStart
+        };
+      }
 
-function createComponentSelector(component) {
-  return {
-    $$typeof: COMPONENT_TYPE,
-    value: component
-  };
-}
-function createHasPseudoClassSelector(selectors) {
-  return {
-    $$typeof: HAS_PSEUDO_CLASS_TYPE,
-    value: selectors
-  };
-}
-function createRoleSelector(role) {
-  return {
-    $$typeof: ROLE_TYPE,
-    value: role
-  };
-}
-function createTextSelector(text) {
-  return {
-    $$typeof: TEXT_TYPE,
-    value: text
-  };
-}
-function createTestNameSelector(id) {
-  return {
-    $$typeof: TEST_NAME_TYPE,
-    value: id
-  };
+      nodeStart = nodeEnd;
+    }
+
+    node = getLeafNode(getSiblingNode(node));
+  }
 }
 
-function findFiberRootForHostRoot(hostRoot) {
-  var maybeFiber = getInstanceFromNode(hostRoot);
+/**
+ * @param {DOMElement} outerNode
+ * @return {?object}
+ */
 
-  if (maybeFiber != null) {
-    if (typeof maybeFiber.memoizedProps["data-testname"] !== "string") {
-      throw new Error(
-        "Invalid host root specified. Should be either a React container or a node with a testname attribute."
-      );
-    }
+function getOffsets(outerNode) {
+  var ownerDocument = outerNode.ownerDocument;
+  var win = (ownerDocument && ownerDocument.defaultView) || window;
+  var selection = win.getSelection && win.getSelection();
 
-    return maybeFiber;
-  } else {
-    var fiberRoot = findFiberRoot(hostRoot);
+  if (!selection || selection.rangeCount === 0) {
+    return null;
+  }
 
-    if (fiberRoot === null) {
-      throw new Error(
-        "Could not find React container within specified host subtree."
-      );
-    } // The Flow type for FiberRoot is a little funky.
-    // createFiberRoot() cheats this by treating the root as :any and adding stateNode lazily.
+  var anchorNode = selection.anchorNode,
+    anchorOffset = selection.anchorOffset,
+    focusNode = selection.focusNode,
+    focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the
+  // up/down buttons on an <input type="number">. Anonymous divs do not seem to
+  // expose properties, triggering a "Permission denied error" if any of its
+  // properties are accessed. The only seemingly possible way to avoid erroring
+  // is to access a property that typically works for non-anonymous divs and
+  // catch any error that may otherwise arise. See
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
 
-    return fiberRoot.stateNode.current;
+  try {
+    /* eslint-disable ft-flow/no-unused-expressions */
+    anchorNode.nodeType;
+    focusNode.nodeType;
+    /* eslint-enable ft-flow/no-unused-expressions */
+  } catch (e) {
+    return null;
   }
-}
 
-function matchSelector(fiber, selector) {
-  var tag = fiber.tag;
-
-  switch (selector.$$typeof) {
-    case COMPONENT_TYPE:
-      if (fiber.type === selector.value) {
-        return true;
-      }
+  return getModernOffsetsFromPoints(
+    outerNode,
+    anchorNode,
+    anchorOffset,
+    focusNode,
+    focusOffset
+  );
+}
+/**
+ * Returns {start, end} where `start` is the character/codepoint index of
+ * (anchorNode, anchorOffset) within the textContent of `outerNode`, and
+ * `end` is the index of (focusNode, focusOffset).
+ *
+ * Returns null if you pass in garbage input but we should probably just crash.
+ *
+ * Exported only for testing.
+ */
 
-      break;
+function getModernOffsetsFromPoints(
+  outerNode,
+  anchorNode,
+  anchorOffset,
+  focusNode,
+  focusOffset
+) {
+  var length = 0;
+  var start = -1;
+  var end = -1;
+  var indexWithinAnchor = 0;
+  var indexWithinFocus = 0;
+  var node = outerNode;
+  var parentNode = null;
 
-    case HAS_PSEUDO_CLASS_TYPE:
-      return hasMatchingPaths(fiber, selector.value);
+  outer: while (true) {
+    var next = null;
 
-    case ROLE_TYPE:
+    while (true) {
       if (
-        tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton
+        node === anchorNode &&
+        (anchorOffset === 0 || node.nodeType === TEXT_NODE)
       ) {
-        var node = fiber.stateNode;
-
-        if (matchAccessibilityRole(node, selector.value)) {
-          return true;
-        }
+        start = length + anchorOffset;
       }
 
-      break;
-
-    case TEXT_TYPE:
       if (
-        tag === HostComponent ||
-        tag === HostText ||
-        tag === HostHoistable ||
-        tag === HostSingleton
+        node === focusNode &&
+        (focusOffset === 0 || node.nodeType === TEXT_NODE)
       ) {
-        var textContent = getTextContent(fiber);
+        end = length + focusOffset;
+      }
 
-        if (textContent !== null && textContent.indexOf(selector.value) >= 0) {
-          return true;
-        }
+      if (node.nodeType === TEXT_NODE) {
+        length += node.nodeValue.length;
       }
 
-      break;
+      if ((next = node.firstChild) === null) {
+        break;
+      } // Moving from `node` to its first child `next`.
 
-    case TEST_NAME_TYPE:
-      if (
-        tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton
-      ) {
-        var dataTestID = fiber.memoizedProps["data-testname"];
+      parentNode = node;
+      node = next;
+    }
 
-        if (
-          typeof dataTestID === "string" &&
-          dataTestID.toLowerCase() === selector.value.toLowerCase()
-        ) {
-          return true;
-        }
+    while (true) {
+      if (node === outerNode) {
+        // If `outerNode` has children, this is always the second time visiting
+        // it. If it has no children, this is still the first loop, and the only
+        // valid selection is anchorNode and focusNode both equal to this node
+        // and both offsets 0, in which case we will have handled above.
+        break outer;
       }
 
-      break;
+      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {
+        start = length;
+      }
 
-    default:
-      throw new Error("Invalid selector type specified.");
-  }
+      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {
+        end = length;
+      }
 
-  return false;
-}
+      if ((next = node.nextSibling) !== null) {
+        break;
+      }
 
-function selectorToString(selector) {
-  switch (selector.$$typeof) {
-    case COMPONENT_TYPE:
-      var displayName = getComponentNameFromType(selector.value) || "Unknown";
-      return "<" + displayName + ">";
+      node = parentNode;
+      parentNode = node.parentNode;
+    } // Moving from `node` to its next sibling `next`.
 
-    case HAS_PSEUDO_CLASS_TYPE:
-      return ":has(" + (selectorToString(selector) || "") + ")";
+    node = next;
+  }
 
-    case ROLE_TYPE:
-      return '[role="' + selector.value + '"]';
+  if (start === -1 || end === -1) {
+    // This should never happen. (Would happen if the anchor/focus nodes aren't
+    // actually inside the passed-in node.)
+    return null;
+  }
 
-    case TEXT_TYPE:
-      return '"' + selector.value + '"';
+  return {
+    start: start,
+    end: end
+  };
+}
+/**
+ * In modern non-IE browsers, we can support both forward and backward
+ * selections.
+ *
+ * Note: IE10+ supports the Selection object, but it does not support
+ * the `extend` method, which means that even in modern IE, it's not possible
+ * to programmatically create a backward selection. Thus, for all IE
+ * versions, we use the old IE API to create our selections.
+ *
+ * @param {DOMElement|DOMTextNode} node
+ * @param {object} offsets
+ */
 
-    case TEST_NAME_TYPE:
-      return '[data-testname="' + selector.value + '"]';
+function setOffsets(node, offsets) {
+  var doc = node.ownerDocument || document;
+  var win = (doc && doc.defaultView) || window; // Edge fails with "Object expected" in some scenarios.
+  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,
+  // fails when pasting 100+ items)
 
-    default:
-      throw new Error("Invalid selector type specified.");
+  if (!win.getSelection) {
+    return;
   }
-}
 
-function findPaths(root, selectors) {
-  var matchingFibers = [];
-  var stack = [root, 0];
-  var index = 0;
+  var selection = win.getSelection();
+  var length = node.textContent.length;
+  var start = Math.min(offsets.start, length);
+  var end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.
+  // Flip backward selections, so we can set with a single range.
 
-  while (index < stack.length) {
-    var fiber = stack[index++];
-    var tag = fiber.tag;
-    var selectorIndex = stack[index++];
-    var selector = selectors[selectorIndex];
+  if (!selection.extend && start > end) {
+    var temp = end;
+    end = start;
+    start = temp;
+  }
+
+  var startMarker = getNodeForCharacterOffset(node, start);
+  var endMarker = getNodeForCharacterOffset(node, end);
 
+  if (startMarker && endMarker) {
     if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      isHiddenSubtree(fiber)
+      selection.rangeCount === 1 &&
+      selection.anchorNode === startMarker.node &&
+      selection.anchorOffset === startMarker.offset &&
+      selection.focusNode === endMarker.node &&
+      selection.focusOffset === endMarker.offset
     ) {
-      continue;
-    } else {
-      while (selector != null && matchSelector(fiber, selector)) {
-        selectorIndex++;
-        selector = selectors[selectorIndex];
-      }
+      return;
     }
 
-    if (selectorIndex === selectors.length) {
-      matchingFibers.push(fiber);
+    var range = doc.createRange();
+    range.setStart(startMarker.node, startMarker.offset);
+    selection.removeAllRanges();
+
+    if (start > end) {
+      selection.addRange(range);
+      selection.extend(endMarker.node, endMarker.offset);
     } else {
-      var child = fiber.child;
+      range.setEnd(endMarker.node, endMarker.offset);
+      selection.addRange(range);
+    }
+  }
+}
 
-      while (child !== null) {
-        stack.push(child, selectorIndex);
-        child = child.sibling;
-      }
+function isTextNode(node) {
+  return node && node.nodeType === TEXT_NODE;
+}
+
+function containsNode(outerNode, innerNode) {
+  if (!outerNode || !innerNode) {
+    return false;
+  } else if (outerNode === innerNode) {
+    return true;
+  } else if (isTextNode(outerNode)) {
+    return false;
+  } else if (isTextNode(innerNode)) {
+    return containsNode(outerNode, innerNode.parentNode);
+  } else if ("contains" in outerNode) {
+    return outerNode.contains(innerNode);
+  } else if (outerNode.compareDocumentPosition) {
+    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+  } else {
+    return false;
+  }
+}
+
+function isInDocument(node) {
+  return (
+    node &&
+    node.ownerDocument &&
+    containsNode(node.ownerDocument.documentElement, node)
+  );
+}
+
+function isSameOriginFrame(iframe) {
+  try {
+    // Accessing the contentDocument of a HTMLIframeElement can cause the browser
+    // to throw, e.g. if it has a cross-origin src attribute.
+    // Safari will show an error in the console when the access results in "Blocked a frame with origin". e.g:
+    // iframe.contentDocument.defaultView;
+    // A safety way is to access one of the cross origin properties: Window or Location
+    // Which might result in "SecurityError" DOM Exception and it is compatible to Safari.
+    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl
+    return typeof iframe.contentWindow.location.href === "string";
+  } catch (err) {
+    return false;
+  }
+}
+
+function getActiveElementDeep() {
+  var win = window;
+  var element = getActiveElement();
+
+  while (element instanceof win.HTMLIFrameElement) {
+    if (isSameOriginFrame(element)) {
+      win = element.contentWindow;
+    } else {
+      return element;
     }
+
+    element = getActiveElement(win.document);
   }
 
-  return matchingFibers;
-} // Same as findPaths but with eager bailout on first match
+  return element;
+}
+/**
+ * @ReactInputSelection: React input selection module. Based on Selection.js,
+ * but modified to be suitable for react and has a couple of bug fixes (doesn't
+ * assume buttons have range selections allowed).
+ * Input selection module for React.
+ */
 
-function hasMatchingPaths(root, selectors) {
-  var stack = [root, 0];
-  var index = 0;
+/**
+ * @hasSelectionCapabilities: we get the element types that support selection
+ * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`
+ * and `selectionEnd` rows.
+ */
 
-  while (index < stack.length) {
-    var fiber = stack[index++];
-    var tag = fiber.tag;
-    var selectorIndex = stack[index++];
-    var selector = selectors[selectorIndex];
+function hasSelectionCapabilities(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName &&
+    ((nodeName === "input" &&
+      (elem.type === "text" ||
+        elem.type === "search" ||
+        elem.type === "tel" ||
+        elem.type === "url" ||
+        elem.type === "password")) ||
+      nodeName === "textarea" ||
+      elem.contentEditable === "true")
+  );
+}
+function getSelectionInformation() {
+  var focusedElem = getActiveElementDeep();
+  return {
+    focusedElem: focusedElem,
+    selectionRange: hasSelectionCapabilities(focusedElem)
+      ? getSelection$1(focusedElem)
+      : null
+  };
+}
+/**
+ * @restoreSelection: If any selection information was potentially lost,
+ * restore it. This is useful when performing operations that could remove dom
+ * nodes and place them back in, resulting in focus being lost.
+ */
+
+function restoreSelection(priorSelectionInformation) {
+  var curFocusedElem = getActiveElementDeep();
+  var priorFocusedElem = priorSelectionInformation.focusedElem;
+  var priorSelectionRange = priorSelectionInformation.selectionRange;
 
+  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
     if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      isHiddenSubtree(fiber)
+      priorSelectionRange !== null &&
+      hasSelectionCapabilities(priorFocusedElem)
     ) {
-      continue;
-    } else {
-      while (selector != null && matchSelector(fiber, selector)) {
-        selectorIndex++;
-        selector = selectors[selectorIndex];
+      setSelection(priorFocusedElem, priorSelectionRange);
+    } // Focusing a node can change the scroll position, which is undesirable
+
+    var ancestors = [];
+    var ancestor = priorFocusedElem;
+
+    while ((ancestor = ancestor.parentNode)) {
+      if (ancestor.nodeType === ELEMENT_NODE) {
+        ancestors.push({
+          element: ancestor,
+          left: ancestor.scrollLeft,
+          top: ancestor.scrollTop
+        });
       }
     }
 
-    if (selectorIndex === selectors.length) {
-      return true;
-    } else {
-      var child = fiber.child;
+    if (typeof priorFocusedElem.focus === "function") {
+      priorFocusedElem.focus();
+    }
 
-      while (child !== null) {
-        stack.push(child, selectorIndex);
-        child = child.sibling;
-      }
+    for (var i = 0; i < ancestors.length; i++) {
+      var info = ancestors[i];
+      info.element.scrollLeft = info.left;
+      info.element.scrollTop = info.top;
     }
   }
-
-  return false;
 }
+/**
+ * @getSelection: Gets the selection bounds of a focused textarea, input or
+ * contentEditable node.
+ * -@input: Look up selection bounds of this input
+ * -@return {start: selectionStart, end: selectionEnd}
+ */
 
-function findAllNodes(hostRoot, selectors) {
-  var root = findFiberRootForHostRoot(hostRoot);
-  var matchingFibers = findPaths(root, selectors);
-  var instanceRoots = [];
-  var stack = Array.from(matchingFibers);
-  var index = 0;
+function getSelection$1(input) {
+  var selection;
 
-  while (index < stack.length) {
-    var node = stack[index++];
-    var tag = node.tag;
+  if ("selectionStart" in input) {
+    // Modern browser with input or textarea.
+    selection = {
+      start: input.selectionStart,
+      end: input.selectionEnd
+    };
+  } else {
+    // Content editable or old IE textarea.
+    selection = getOffsets(input);
+  }
 
-    if (
-      tag === HostComponent ||
-      tag === HostHoistable ||
-      tag === HostSingleton
-    ) {
-      if (isHiddenSubtree(node)) {
-        continue;
-      }
+  return (
+    selection || {
+      start: 0,
+      end: 0
+    }
+  );
+}
+/**
+ * @setSelection: Sets the selection bounds of a textarea or input and focuses
+ * the input.
+ * -@input     Set selection bounds of this input or textarea
+ * -@offsets   Object of same form that is returned from get*
+ */
 
-      instanceRoots.push(node.stateNode);
-    } else {
-      var child = node.child;
+function setSelection(input, offsets) {
+  var start = offsets.start;
+  var end = offsets.end;
 
-      while (child !== null) {
-        stack.push(child);
-        child = child.sibling;
-      }
-    }
+  if (end === undefined) {
+    end = start;
   }
 
-  return instanceRoots;
+  if ("selectionStart" in input) {
+    input.selectionStart = start;
+    input.selectionEnd = Math.min(end, input.value.length);
+  } else {
+    setOffsets(input, offsets);
+  }
 }
-function getFindAllNodesFailureDescription(hostRoot, selectors) {
-  var root = findFiberRootForHostRoot(hostRoot);
-  var maxSelectorIndex = 0;
-  var matchedNames = []; // The logic of this loop should be kept in sync with findPaths()
-
-  var stack = [root, 0];
-  var index = 0;
-
-  while (index < stack.length) {
-    var fiber = stack[index++];
-    var tag = fiber.tag;
-    var selectorIndex = stack[index++];
-    var selector = selectors[selectorIndex];
 
-    if (
-      (tag === HostComponent ||
-        tag === HostHoistable ||
-        tag === HostSingleton) &&
-      isHiddenSubtree(fiber)
-    ) {
-      continue;
-    } else if (matchSelector(fiber, selector)) {
-      matchedNames.push(selectorToString(selector));
-      selectorIndex++;
+var skipSelectionChangeEvent =
+  canUseDOM && "documentMode" in document && document.documentMode <= 11;
 
-      if (selectorIndex > maxSelectorIndex) {
-        maxSelectorIndex = selectorIndex;
-      }
-    }
+function registerEvents() {
+  registerTwoPhaseEvent("onSelect", [
+    "focusout",
+    "contextmenu",
+    "dragend",
+    "focusin",
+    "keydown",
+    "keyup",
+    "mousedown",
+    "mouseup",
+    "selectionchange"
+  ]);
+}
 
-    if (selectorIndex < selectors.length) {
-      var child = fiber.child;
+var activeElement = null;
+var activeElementInst = null;
+var lastSelection = null;
+var mouseDown = false;
+/**
+ * Get an object which is a unique representation of the current selection.
+ *
+ * The return value will not be consistent across nodes or browsers, but
+ * two identical selections on the same node will return identical objects.
+ */
 
-      while (child !== null) {
-        stack.push(child, selectorIndex);
-        child = child.sibling;
-      }
-    }
+function getSelection(node) {
+  if ("selectionStart" in node && hasSelectionCapabilities(node)) {
+    return {
+      start: node.selectionStart,
+      end: node.selectionEnd
+    };
+  } else {
+    var win = (node.ownerDocument && node.ownerDocument.defaultView) || window;
+    var selection = win.getSelection();
+    return {
+      anchorNode: selection.anchorNode,
+      anchorOffset: selection.anchorOffset,
+      focusNode: selection.focusNode,
+      focusOffset: selection.focusOffset
+    };
   }
+}
+/**
+ * Get document associated with the event target.
+ */
 
-  if (maxSelectorIndex < selectors.length) {
-    var unmatchedNames = [];
+function getEventTargetDocument(eventTarget) {
+  return eventTarget.window === eventTarget
+    ? eventTarget.document
+    : eventTarget.nodeType === DOCUMENT_NODE
+    ? eventTarget
+    : eventTarget.ownerDocument;
+}
+/**
+ * Poll selection to see whether it's changed.
+ *
+ * @param {object} nativeEvent
+ * @param {object} nativeEventTarget
+ * @return {?SyntheticEvent}
+ */
 
-    for (var i = maxSelectorIndex; i < selectors.length; i++) {
-      unmatchedNames.push(selectorToString(selectors[i]));
-    }
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  // Ensure we have the right element, and that the user is not dragging a
+  // selection (this matches native `select` event behavior). In HTML5, select
+  // fires only on input and textarea thus if there's no focused element we
+  // won't dispatch.
+  var doc = getEventTargetDocument(nativeEventTarget);
 
-    return (
-      "findAllNodes was able to match part of the selector:\n" +
-      ("  " + matchedNames.join(" > ") + "\n\n") +
-      "No matching component was found for:\n" +
-      ("  " + unmatchedNames.join(" > "))
-    );
-  }
+  if (
+    mouseDown ||
+    activeElement == null ||
+    activeElement !== getActiveElement(doc)
+  ) {
+    return;
+  } // Only fire when selection has actually changed.
 
-  return null;
-}
-function findBoundingRects(hostRoot, selectors) {
-  var instanceRoots = findAllNodes(hostRoot, selectors);
-  var boundingRects = [];
+  var currentSelection = getSelection(activeElement);
 
-  for (var i = 0; i < instanceRoots.length; i++) {
-    boundingRects.push(getBoundingRect(instanceRoots[i]));
+  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+    lastSelection = currentSelection;
+    var listeners = accumulateTwoPhaseListeners(activeElementInst, "onSelect");
+
+    if (listeners.length > 0) {
+      var event = new SyntheticEvent(
+        "onSelect",
+        "select",
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
+      dispatchQueue.push({
+        event: event,
+        listeners: listeners
+      });
+      event.target = activeElement;
+    }
   }
+}
+/**
+ * This plugin creates an `onSelect` event that normalizes select events
+ * across form elements.
+ *
+ * Supported elements are:
+ * - input (see `isTextInputElement`)
+ * - textarea
+ * - contentEditable
+ *
+ * This differs from native browser implementations in the following ways:
+ * - Fires on contentEditable fields as well as inputs.
+ * - Fires for collapsed selection.
+ * - Fires after user input.
+ */
 
-  for (var _i = boundingRects.length - 1; _i > 0; _i--) {
-    var targetRect = boundingRects[_i];
-    var targetLeft = targetRect.x;
-    var targetRight = targetLeft + targetRect.width;
-    var targetTop = targetRect.y;
-    var targetBottom = targetTop + targetRect.height;
+function extractEvents$2(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var targetNode = targetInst ? getNodeFromInstance(targetInst) : window;
 
-    for (var j = _i - 1; j >= 0; j--) {
-      if (_i !== j) {
-        var otherRect = boundingRects[j];
-        var otherLeft = otherRect.x;
-        var otherRight = otherLeft + otherRect.width;
-        var otherTop = otherRect.y;
-        var otherBottom = otherTop + otherRect.height; // Merging all rects to the minimums set would be complicated,
-        // but we can handle the most common cases:
-        // 1. completely overlapping rects
-        // 2. adjacent rects that are the same width or height (e.g. items in a list)
-        //
-        // Even given the above constraints,
-        // we still won't end up with the fewest possible rects without doing multiple passes,
-        // but it's good enough for this purpose.
+  switch (domEventName) {
+    // Track the input node that has focus.
+    case "focusin":
+      if (
+        isTextInputElement(targetNode) ||
+        targetNode.contentEditable === "true"
+      ) {
+        activeElement = targetNode;
+        activeElementInst = targetInst;
+        lastSelection = null;
+      }
 
-        if (
-          targetLeft >= otherLeft &&
-          targetTop >= otherTop &&
-          targetRight <= otherRight &&
-          targetBottom <= otherBottom
-        ) {
-          // Complete overlapping rects; remove the inner one.
-          boundingRects.splice(_i, 1);
-          break;
-        } else if (
-          targetLeft === otherLeft &&
-          targetRect.width === otherRect.width &&
-          !(otherBottom < targetTop) &&
-          !(otherTop > targetBottom)
-        ) {
-          // Adjacent vertical rects; merge them.
-          if (otherTop > targetTop) {
-            otherRect.height += otherTop - targetTop;
-            otherRect.y = targetTop;
-          }
+      break;
 
-          if (otherBottom < targetBottom) {
-            otherRect.height = targetBottom - otherTop;
-          }
+    case "focusout":
+      activeElement = null;
+      activeElementInst = null;
+      lastSelection = null;
+      break;
+    // Don't fire the event while the user is dragging. This matches the
+    // semantics of the native select event.
 
-          boundingRects.splice(_i, 1);
-          break;
-        } else if (
-          targetTop === otherTop &&
-          targetRect.height === otherRect.height &&
-          !(otherRight < targetLeft) &&
-          !(otherLeft > targetRight)
-        ) {
-          // Adjacent horizontal rects; merge them.
-          if (otherLeft > targetLeft) {
-            otherRect.width += otherLeft - targetLeft;
-            otherRect.x = targetLeft;
-          }
+    case "mousedown":
+      mouseDown = true;
+      break;
 
-          if (otherRight < targetRight) {
-            otherRect.width = targetRight - otherLeft;
-          }
+    case "contextmenu":
+    case "mouseup":
+    case "dragend":
+      mouseDown = false;
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      break;
+    // Chrome and IE fire non-standard event when selection is changed (and
+    // sometimes when it hasn't). IE's event fires out of order with respect
+    // to key and input events on deletion, so we discard it.
+    //
+    // Firefox doesn't support selectionchange, so check selection status
+    // after each key entry. The selection changes after keydown and before
+    // keyup, but we check on keydown as well in the case of holding down a
+    // key, when multiple keydown events are fired but only one keyup is.
+    // This is also our approach for IE handling, for the reason above.
 
-          boundingRects.splice(_i, 1);
-          break;
-        }
+    case "selectionchange":
+      if (skipSelectionChangeEvent) {
+        break;
       }
-    }
-  }
 
-  return boundingRects;
+    // falls through
+
+    case "keydown":
+    case "keyup":
+      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+  }
 }
-function focusWithin(hostRoot, selectors) {
-  var root = findFiberRootForHostRoot(hostRoot);
-  var matchingFibers = findPaths(root, selectors);
-  var stack = Array.from(matchingFibers);
-  var index = 0;
 
-  while (index < stack.length) {
-    var fiber = stack[index++];
-    var tag = fiber.tag;
+/**
+ * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+ *
+ * @param {string} styleProp
+ * @param {string} eventName
+ * @returns {object}
+ */
 
-    if (isHiddenSubtree(fiber)) {
-      continue;
-    }
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
+}
+/**
+ * A list of event names to a configurable list of vendor prefixes.
+ */
 
-    if (
-      tag === HostComponent ||
-      tag === HostHoistable ||
-      tag === HostSingleton
-    ) {
-      var node = fiber.stateNode;
+var vendorPrefixes = {
+  animationend: makePrefixMap("Animation", "AnimationEnd"),
+  animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+  animationstart: makePrefixMap("Animation", "AnimationStart"),
+  transitionend: makePrefixMap("Transition", "TransitionEnd")
+};
+/**
+ * Event names that have already been detected and prefixed (if applicable).
+ */
 
-      if (setFocusIfFocusable(node)) {
-        return true;
-      }
-    }
+var prefixedEventNames = {};
+/**
+ * Element to check for prefixes on.
+ */
 
-    var child = fiber.child;
+var style = {};
+/**
+ * Bootstrap if a DOM exists.
+ */
 
-    while (child !== null) {
-      stack.push(child);
-      child = child.sibling;
-    }
-  }
+if (canUseDOM) {
+  style = document.createElement("div").style; // On some platforms, in particular some releases of Android 4.x,
+  // the un-prefixed "animation" and "transition" properties are defined on the
+  // style object but the events that fire will still be prefixed, so we need
+  // to check if the un-prefixed events are usable, and if not remove them from the map.
 
-  return false;
-}
-var commitHooks = [];
-function onCommitRoot() {
-  {
-    commitHooks.forEach(function (commitHook) {
-      return commitHook();
-    });
+  if (!("AnimationEvent" in window)) {
+    delete vendorPrefixes.animationend.animation;
+    delete vendorPrefixes.animationiteration.animation;
+    delete vendorPrefixes.animationstart.animation;
+  } // Same as above
+
+  if (!("TransitionEvent" in window)) {
+    delete vendorPrefixes.transitionend.transition;
   }
 }
-function observeVisibleRects(hostRoot, selectors, callback, options) {
-  var instanceRoots = findAllNodes(hostRoot, selectors);
-
-  var _setupIntersectionObs = setupIntersectionObserver(
-      instanceRoots,
-      callback,
-      options
-    ),
-    disconnect = _setupIntersectionObs.disconnect,
-    observe = _setupIntersectionObs.observe,
-    unobserve = _setupIntersectionObs.unobserve; // When React mutates the host environment, we may need to change what we're listening to.
-
-  var commitHook = function () {
-    var nextInstanceRoots = findAllNodes(hostRoot, selectors);
-    instanceRoots.forEach(function (target) {
-      if (nextInstanceRoots.indexOf(target) < 0) {
-        unobserve(target);
-      }
-    });
-    nextInstanceRoots.forEach(function (target) {
-      if (instanceRoots.indexOf(target) < 0) {
-        observe(target);
-      }
-    });
-  };
+/**
+ * Attempts to determine the correct vendor prefixed event name.
+ *
+ * @param {string} eventName
+ * @returns {string}
+ */
 
-  commitHooks.push(commitHook);
-  return {
-    disconnect: function () {
-      // Stop listening for React mutations:
-      var index = commitHooks.indexOf(commitHook);
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) {
+    return prefixedEventNames[eventName];
+  } else if (!vendorPrefixes[eventName]) {
+    return eventName;
+  }
 
-      if (index >= 0) {
-        commitHooks.splice(index, 1);
-      } // Disconnect the host observer:
+  var prefixMap = vendorPrefixes[eventName];
 
-      disconnect();
+  for (var styleProp in prefixMap) {
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
     }
-  };
+  }
+
+  return eventName;
 }
 
-var ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;
-function isLegacyActEnvironment(fiber) {
-  {
-    // Legacy mode. We preserve the behavior of React 17's act. It assumes an
-    // act environment whenever `jest` is defined, but you can still turn off
-    // spurious warnings by setting IS_REACT_ACT_ENVIRONMENT explicitly
-    // to false.
-    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
-      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
-        ? IS_REACT_ACT_ENVIRONMENT
-        : undefined; // $FlowFixMe - Flow doesn't know about jest
+var ANIMATION_END = getVendorPrefixedEventName("animationend");
+var ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration");
+var ANIMATION_START = getVendorPrefixedEventName("animationstart");
+var TRANSITION_END = getVendorPrefixedEventName("transitionend");
 
-    var jestIsDefined = typeof jest !== "undefined";
-    return jestIsDefined && isReactActEnvironmentGlobal !== false;
-  }
-}
-function isConcurrentActEnvironment() {
-  {
-    var isReactActEnvironmentGlobal = // $FlowFixMe[cannot-resolve-name] Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
-      typeof IS_REACT_ACT_ENVIRONMENT !== "undefined" // $FlowFixMe[cannot-resolve-name]
-        ? IS_REACT_ACT_ENVIRONMENT
-        : undefined;
+var topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!
+//
+// E.g. it needs "pointerDown", not "pointerdown".
+// This is because we derive both React name ("onPointerDown")
+// and DOM name ("pointerdown") from the same list.
+//
+// Exceptions that don't match this convention are listed separately.
+//
+// prettier-ignore
 
-    if (
-      !isReactActEnvironmentGlobal &&
-      ReactCurrentActQueue$1.current !== null
-    ) {
-      // TODO: Include link to relevant documentation page.
-      error(
-        "The current testing environment is not configured to support " +
-          "act(...)"
-      );
-    }
+var simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'toggle', 'touchMove', 'waiting', 'wheel'];
 
-    return isReactActEnvironmentGlobal;
-  }
+{
+  // Special case: these two events don't have on* React handler
+  // and are only accessible via the createEventHandle API.
+  topLevelEventsToReactNames.set("beforeblur", null);
+  topLevelEventsToReactNames.set("afterblur", null);
 }
 
-var postPaintCallbackScheduled = false;
-var callbacks = [];
-function schedulePostPaintCallback(callback) {
-  callbacks.push(callback);
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
+}
 
-  if (!postPaintCallbackScheduled) {
-    postPaintCallbackScheduled = true;
-    requestPostPaintCallback(function (endTime) {
-      for (var i = 0; i < callbacks.length; i++) {
-        callbacks[i](endTime);
-      }
+function registerSimpleEvents() {
+  for (var i = 0; i < simpleEventPluginEvents.length; i++) {
+    var eventName = simpleEventPluginEvents[i];
+    var domEventName = eventName.toLowerCase();
+    var capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);
+    registerSimpleEvent(domEventName, "on" + capitalizedEvent);
+  } // Special cases where event names don't match.
 
-      postPaintCallbackScheduled = false;
-      callbacks = [];
-    });
-  }
+  registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+  registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+  registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+  registerSimpleEvent("dblclick", "onDoubleClick");
+  registerSimpleEvent("focusin", "onFocus");
+  registerSimpleEvent("focusout", "onBlur");
+  registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
 }
 
-var ceil = Math.ceil;
-var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
-var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
-  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
-  ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
-var NoContext =
-  /*             */
-  0;
-var BatchedContext =
-  /*               */
-  1;
-var RenderContext =
-  /*         */
-  2;
-var CommitContext =
-  /*         */
-  4;
-var RootInProgress = 0;
-var RootFatalErrored = 1;
-var RootErrored = 2;
-var RootSuspended = 3;
-var RootSuspendedWithDelay = 4;
-var RootCompleted = 5;
-var RootDidNotComplete = 6; // Describes where we are in the React execution stack
+function extractEvents$1(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  var reactName = topLevelEventsToReactNames.get(domEventName);
 
-var executionContext = NoContext; // The root we're working on
+  if (reactName === undefined) {
+    return;
+  }
 
-var workInProgressRoot = null; // The fiber we're working on
+  var SyntheticEventCtor = SyntheticEvent;
+  var reactEventType = domEventName;
 
-var workInProgress = null; // The lanes we're rendering
+  switch (domEventName) {
+    case "keypress":
+      // Firefox creates a keypress event for function keys too. This removes
+      // the unwanted keypress events. Enter is however both printable and
+      // non-printable. One would expect Tab to be as well (but it isn't).
+      if (getEventCharCode(nativeEvent) === 0) {
+        return;
+      }
 
-var workInProgressRootRenderLanes = NoLanes;
-var NotSuspended = 0;
-var SuspendedOnError = 1;
-var SuspendedOnData = 2;
-var SuspendedOnImmediate = 3;
-var SuspendedOnDeprecatedThrowPromise = 4;
-var SuspendedAndReadyToContinue = 5;
-var SuspendedOnHydration = 6; // When this is true, the work-in-progress fiber just suspended (or errored) and
-// we've yet to unwind the stack. In some cases, we may yield to the main thread
-// after this happens. If the fiber is pinged before we resume, we can retry
-// immediately instead of unwinding the stack.
+    /* falls through */
 
-var workInProgressSuspendedReason = NotSuspended;
-var workInProgressThrownValue = null; // Whether a ping listener was attached during this render. This is slightly
-// different that whether something suspended, because we don't add multiple
-// listeners to a promise we've already seen (per root and lane).
+    case "keydown":
+    case "keyup":
+      SyntheticEventCtor = SyntheticKeyboardEvent;
+      break;
 
-var workInProgressRootDidAttachPingListener = false; // A contextual version of workInProgressRootRenderLanes. It is a superset of
-// the lanes that we started working on at the root. When we enter a subtree
-// that is currently hidden, we add the lanes that would have committed if
-// the hidden tree hadn't been deferred. This is modified by the
-// HiddenContext module.
-//
-// Most things in the work loop should deal with workInProgressRootRenderLanes.
-// Most things in begin/complete phases should deal with renderLanes.
+    case "focusin":
+      reactEventType = "focus";
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-var renderLanes = NoLanes; // Whether to root completed, errored, suspended, etc.
+    case "focusout":
+      reactEventType = "blur";
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
+    case "beforeblur":
+    case "afterblur":
+      SyntheticEventCtor = SyntheticFocusEvent;
+      break;
 
-var workInProgressRootFatalError = null; // The work left over by components that were visited during this render. Only
-// includes unprocessed updates, not work in bailed out children.
+    case "click":
+      // Firefox creates a click event on right mouse clicks. This removes the
+      // unwanted click events.
+      if (nativeEvent.button === 2) {
+        return;
+      }
 
-var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
+    /* falls through */
 
-var workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
+    case "auxclick":
+    case "dblclick":
+    case "mousedown":
+    case "mousemove":
+    case "mouseup": // TODO: Disabled elements should not respond to mouse events
 
-var workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.
+    /* falls through */
 
-var workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
-// We will log them once the tree commits.
+    case "mouseout":
+    case "mouseover":
+    case "contextmenu":
+      SyntheticEventCtor = SyntheticMouseEvent;
+      break;
 
-var workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train
-// model where we don't commit new loading states in too quick succession.
+    case "drag":
+    case "dragend":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "dragstart":
+    case "drop":
+      SyntheticEventCtor = SyntheticDragEvent;
+      break;
 
-var globalMostRecentFallbackTime = 0;
-var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
-// more and prefer CPU suspense heuristics instead.
+    case "touchcancel":
+    case "touchend":
+    case "touchmove":
+    case "touchstart":
+      SyntheticEventCtor = SyntheticTouchEvent;
+      break;
 
-var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
-// suspense heuristics and opt out of rendering more content.
+    case ANIMATION_END:
+    case ANIMATION_ITERATION:
+    case ANIMATION_START:
+      SyntheticEventCtor = SyntheticAnimationEvent;
+      break;
 
-var RENDER_TIMEOUT_MS = 500;
-var workInProgressTransitions = null;
-function getWorkInProgressTransitions() {
-  return workInProgressTransitions;
-}
-var currentPendingTransitionCallbacks = null;
-var currentEndTime = null;
-function addTransitionStartCallbackToPendingTransition(transition) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: [],
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
+    case TRANSITION_END:
+      SyntheticEventCtor = SyntheticTransitionEvent;
+      break;
 
-    if (currentPendingTransitionCallbacks.transitionStart === null) {
-      currentPendingTransitionCallbacks.transitionStart = [];
-    }
+    case "scroll":
+      SyntheticEventCtor = SyntheticUIEvent;
+      break;
 
-    currentPendingTransitionCallbacks.transitionStart.push(transition);
-  }
-}
-function addMarkerProgressCallbackToPendingTransition(
-  markerName,
-  transitions,
-  pendingBoundaries
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: new Map(),
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
+    case "wheel":
+      SyntheticEventCtor = SyntheticWheelEvent;
+      break;
 
-    if (currentPendingTransitionCallbacks.markerProgress === null) {
-      currentPendingTransitionCallbacks.markerProgress = new Map();
-    }
+    case "copy":
+    case "cut":
+    case "paste":
+      SyntheticEventCtor = SyntheticClipboardEvent;
+      break;
 
-    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
-      pendingBoundaries: pendingBoundaries,
-      transitions: transitions
-    });
+    case "gotpointercapture":
+    case "lostpointercapture":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "pointerup":
+      SyntheticEventCtor = SyntheticPointerEvent;
+      break;
   }
-}
-function addMarkerIncompleteCallbackToPendingTransition(
-  markerName,
-  transitions,
-  aborts
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: new Map(),
-        markerComplete: null
-      };
-    }
 
-    if (currentPendingTransitionCallbacks.markerIncomplete === null) {
-      currentPendingTransitionCallbacks.markerIncomplete = new Map();
-    }
+  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
 
-    currentPendingTransitionCallbacks.markerIncomplete.set(markerName, {
-      transitions: transitions,
-      aborts: aborts
-    });
-  }
-}
-function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: new Map()
-      };
-    }
+  if (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) {
+    var listeners = accumulateEventHandleNonManagedNodeListeners(
+      // TODO: this cast may not make sense for events like
+      // "focus" where React listens to e.g. "focusin".
+      reactEventType,
+      targetContainer,
+      inCapturePhase
+    );
 
-    if (currentPendingTransitionCallbacks.markerComplete === null) {
-      currentPendingTransitionCallbacks.markerComplete = new Map();
+    if (listeners.length > 0) {
+      // Intentionally create event lazily.
+      var event = new SyntheticEventCtor(
+        reactName,
+        reactEventType,
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
+      dispatchQueue.push({
+        event: event,
+        listeners: listeners
+      });
     }
+  } else {
+    // Some events don't bubble in the browser.
+    // In the past, React has always bubbled them, but this can be surprising.
+    // We're going to try aligning closer to the browser behavior by not bubbling
+    // them in React either. We'll start by not bubbling onScroll, and then expand.
+    var accumulateTargetOnly =
+      !inCapturePhase && // TODO: ideally, we'd eventually add all events from
+      // nonDelegatedEvents list in DOMPluginEventSystem.
+      // Then we can remove this special list.
+      // This is a breaking change that can wait until React 18.
+      domEventName === "scroll";
 
-    currentPendingTransitionCallbacks.markerComplete.set(
-      markerName,
-      transitions
+    var _listeners = accumulateSinglePhaseListeners(
+      targetInst,
+      reactName,
+      nativeEvent.type,
+      inCapturePhase,
+      accumulateTargetOnly,
+      nativeEvent
     );
-  }
-}
-function addTransitionProgressCallbackToPendingTransition(
-  transition,
-  boundaries
-) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: new Map(),
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
 
-    if (currentPendingTransitionCallbacks.transitionProgress === null) {
-      currentPendingTransitionCallbacks.transitionProgress = new Map();
-    }
+    if (_listeners.length > 0) {
+      // Intentionally create event lazily.
+      var _event = new SyntheticEventCtor(
+        reactName,
+        reactEventType,
+        null,
+        nativeEvent,
+        nativeEventTarget
+      );
 
-    currentPendingTransitionCallbacks.transitionProgress.set(
-      transition,
-      boundaries
-    );
+      dispatchQueue.push({
+        event: _event,
+        listeners: _listeners
+      });
+    }
   }
 }
-function addTransitionCompleteCallbackToPendingTransition(transition) {
-  if (enableTransitionTracing) {
-    if (currentPendingTransitionCallbacks === null) {
-      currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: [],
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      };
-    }
 
-    if (currentPendingTransitionCallbacks.transitionComplete === null) {
-      currentPendingTransitionCallbacks.transitionComplete = [];
-    }
+registerSimpleEvents();
+registerEvents$1();
+registerEvents$2();
+registerEvents();
+registerEvents$3();
 
-    currentPendingTransitionCallbacks.transitionComplete.push(transition);
+function extractEvents(
+  dispatchQueue,
+  domEventName,
+  targetInst,
+  nativeEvent,
+  nativeEventTarget,
+  eventSystemFlags,
+  targetContainer
+) {
+  // TODO: we should remove the concept of a "SimpleEventPlugin".
+  // This is the basic functionality of the event system. All
+  // the other plugins are essentially polyfills. So the plugin
+  // should probably be inlined somewhere and have its logic
+  // be core the to event system. This would potentially allow
+  // us to ship builds of React without the polyfilled plugins below.
+  extractEvents$1(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget,
+    eventSystemFlags,
+    targetContainer
+  );
+  var shouldProcessPolyfillPlugins =
+    (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the
+  // event's native "bubble" phase, which means that we're
+  // not in the capture phase. That's because we emulate
+  // the capture phase here still. This is a trade-off,
+  // because in an ideal world we would not emulate and use
+  // the phases properly, like we do with the SimpleEvent
+  // plugin. However, the plugins below either expect
+  // emulation (EnterLeave) or use state localized to that
+  // plugin (BeforeInput, Change, Select). The state in
+  // these modules complicates things, as you'll essentially
+  // get the case where the capture phase event might change
+  // state, only for the following bubble event to come in
+  // later and not trigger anything as the state now
+  // invalidates the heuristics of the event plugin. We
+  // could alter all these plugins to work in such ways, but
+  // that might cause other unknown side-effects that we
+  // can't foresee right now.
+
+  if (shouldProcessPolyfillPlugins) {
+    extractEvents$3(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$4(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$2(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
+    extractEvents$5(
+      dispatchQueue,
+      domEventName,
+      targetInst,
+      nativeEvent,
+      nativeEventTarget
+    );
   }
-}
-
-function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
-}
-
-function getRenderTargetTime() {
-  return workInProgressRootRenderTargetTime;
-}
-var hasUncaughtError = false;
-var firstUncaughtError = null;
-var legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
-// to track which root is currently committing layout effects.
+} // List of events that need to be individually attached to media elements.
 
-var rootCommittingMutationOrLayoutEffects = null;
-var rootDoesHavePassiveEffects = false;
-var rootWithPendingPassiveEffects = null;
-var pendingPassiveEffectsLanes = NoLanes;
-var pendingPassiveProfilerEffects = [];
-var pendingPassiveEffectsRemainingLanes = NoLanes;
-var pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
+var mediaEventTypes = [
+  "abort",
+  "canplay",
+  "canplaythrough",
+  "durationchange",
+  "emptied",
+  "encrypted",
+  "ended",
+  "error",
+  "loadeddata",
+  "loadedmetadata",
+  "loadstart",
+  "pause",
+  "play",
+  "playing",
+  "progress",
+  "ratechange",
+  "resize",
+  "seeked",
+  "seeking",
+  "stalled",
+  "suspend",
+  "timeupdate",
+  "volumechange",
+  "waiting"
+]; // We should not delegate these events to the container, but rather
+// set them on the actual target element itself. This is primarily
+// because these events do not consistently bubble in the DOM.
 
-var NESTED_UPDATE_LIMIT = 50;
-var nestedUpdateCount = 0;
-var rootWithNestedUpdates = null;
-var isFlushingPassiveEffects = false;
-var didScheduleUpdateDuringPassiveEffects = false;
-var NESTED_PASSIVE_UPDATE_LIMIT = 50;
-var nestedPassiveUpdateCount = 0;
-var rootWithPassiveNestedUpdates = null; // If two updates are scheduled within the same event, we should treat their
-// event times as simultaneous, even if the actual clock time has advanced
-// between the first and second call.
+var nonDelegatedEvents = new Set(
+  ["cancel", "close", "invalid", "load", "scroll", "toggle"].concat(
+    mediaEventTypes
+  )
+);
 
-var currentEventTime = NoTimestamp;
-var currentEventTransitionLane = NoLanes;
-var isRunningInsertionEffect = false;
-function getWorkInProgressRoot() {
-  return workInProgressRoot;
-}
-function getWorkInProgressRootRenderLanes() {
-  return workInProgressRootRenderLanes;
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+  event.currentTarget = null;
 }
-function requestEventTime() {
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    // We're inside React, so it's fine to read the actual time.
-    return now$1();
-  } // We're not inside React, so we may be in the middle of a browser event.
-
-  if (currentEventTime !== NoTimestamp) {
-    // Use the same start time for all updates until we enter React again.
-    return currentEventTime;
-  } // This is the first update since React yielded. Compute a new start time.
 
-  currentEventTime = now$1();
-  return currentEventTime;
-}
-function requestUpdateLane(fiber) {
-  // Special cases
-  var mode = fiber.mode;
+function processDispatchQueueItemsInOrder(
+  event,
+  dispatchListeners,
+  inCapturePhase
+) {
+  var previousInstance;
 
-  if ((mode & ConcurrentMode) === NoMode) {
-    return SyncLane;
-  } else if (
-    !deferRenderPhaseUpdateToNextBatch &&
-    (executionContext & RenderContext) !== NoContext &&
-    workInProgressRootRenderLanes !== NoLanes
-  ) {
-    // This is a render phase update. These are not officially supported. The
-    // old behavior is to give this the same "thread" (lanes) as
-    // whatever is currently rendering. So if you call `setState` on a component
-    // that happens later in the same render, it will flush. Ideally, we want to
-    // remove the special case and treat them as if they came from an
-    // interleaved event. Regardless, this pattern is not officially supported.
-    // This behavior is only a fallback. The flag only exists until we can roll
-    // out the setState warning, since existing code might accidentally rely on
-    // the current behavior.
-    return pickArbitraryLane(workInProgressRootRenderLanes);
-  }
+  if (inCapturePhase) {
+    for (var i = dispatchListeners.length - 1; i >= 0; i--) {
+      var _dispatchListeners$i = dispatchListeners[i],
+        instance = _dispatchListeners$i.instance,
+        currentTarget = _dispatchListeners$i.currentTarget,
+        listener = _dispatchListeners$i.listener;
 
-  var isTransition = requestCurrentTransition() !== NoTransition;
+      if (instance !== previousInstance && event.isPropagationStopped()) {
+        return;
+      }
 
-  if (isTransition) {
-    if (ReactCurrentBatchConfig.transition !== null) {
-      var transition = ReactCurrentBatchConfig.transition;
+      executeDispatch(event, listener, currentTarget);
+      previousInstance = instance;
+    }
+  } else {
+    for (var _i = 0; _i < dispatchListeners.length; _i++) {
+      var _dispatchListeners$_i = dispatchListeners[_i],
+        _instance = _dispatchListeners$_i.instance,
+        _currentTarget = _dispatchListeners$_i.currentTarget,
+        _listener = _dispatchListeners$_i.listener;
 
-      if (!transition._updatedFibers) {
-        transition._updatedFibers = new Set();
+      if (_instance !== previousInstance && event.isPropagationStopped()) {
+        return;
       }
 
-      transition._updatedFibers.add(fiber);
-    } // The algorithm for assigning an update to a lane should be stable for all
-    // updates at the same priority within the same event. To do this, the
-    // inputs to the algorithm must be the same.
-    //
-    // The trick we use is to cache the first of each of these inputs within an
-    // event. Then reset the cached values once we can be sure the event is
-    // over. Our heuristic for that is whenever we enter a concurrent work loop.
-
-    if (currentEventTransitionLane === NoLane) {
-      // All transitions within the same event are assigned the same lane.
-      currentEventTransitionLane = claimNextTransitionLane();
+      executeDispatch(event, _listener, _currentTarget);
+      previousInstance = _instance;
     }
+  }
+}
 
-    return currentEventTransitionLane;
-  } // Updates originating inside certain React methods, like flushSync, have
-  // their priority set by tracking it with a context variable.
-  //
-  // The opaque type returned by the host config is internally a lane, so we can
-  // use that directly.
-  // TODO: Move this type conversion to the event priority module.
-
-  var updateLane = getCurrentUpdatePriority$1();
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  var inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;
 
-  if (updateLane !== NoLane) {
-    return updateLane;
-  } // This update originated outside React. Ask the host environment for an
-  // appropriate priority, based on the type of event.
-  //
-  // The opaque type returned by the host config is internally a lane, so we can
-  // use that directly.
-  // TODO: Move this type conversion to the event priority module.
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event,
+      listeners = _dispatchQueue$i.listeners;
+    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.
+  } // This would be a good time to rethrow if any of the event handlers threw.
 
-  var eventLane = getCurrentEventPriority();
-  return eventLane;
+  rethrowCaughtError();
 }
 
-function requestRetryLane(fiber) {
-  // This is a fork of `requestUpdateLane` designed specifically for Suspense
-  // "retries" — a special update that attempts to flip a Suspense boundary
-  // from its placeholder state to its primary/resolved state.
-  // Special cases
-  var mode = fiber.mode;
-
-  if ((mode & ConcurrentMode) === NoMode) {
-    return SyncLane;
-  }
-
-  return claimNextRetryLane();
+function dispatchEventsForPlugins(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst,
+  targetContainer
+) {
+  var nativeEventTarget = getEventTarget(nativeEvent);
+  var dispatchQueue = [];
+  extractEvents(
+    dispatchQueue,
+    domEventName,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget,
+    eventSystemFlags,
+    targetContainer
+  );
+  processDispatchQueue(dispatchQueue, eventSystemFlags);
 }
 
-function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+function listenToNonDelegatedEvent(domEventName, targetElement) {
   {
-    if (isRunningInsertionEffect) {
-      error("useInsertionEffect must not schedule updates.");
+    if (!nonDelegatedEvents.has(domEventName)) {
+      error(
+        'Did not expect a listenToNonDelegatedEvent() call for "%s". ' +
+          "This is a bug in React. Please file an issue.",
+        domEventName
+      );
     }
   }
 
+  var isCapturePhaseListener = false;
+  var listenerSet = getEventListenerSet(targetElement);
+  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
+
+  if (!listenerSet.has(listenerSetKey)) {
+    addTrappedEventListener(
+      targetElement,
+      domEventName,
+      IS_NON_DELEGATED,
+      isCapturePhaseListener
+    );
+    listenerSet.add(listenerSetKey);
+  }
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
   {
-    if (isFlushingPassiveEffects) {
-      didScheduleUpdateDuringPassiveEffects = true;
+    if (nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener) {
+      error(
+        'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. ' +
+          "This is a bug in React. Please file an issue.",
+        domEventName
+      );
     }
-  } // Check if the work loop is currently suspended and waiting for data to
-  // finish loading.
+  }
 
-  if (
-    workInProgressSuspendedReason === SuspendedOnData &&
-    root === workInProgressRoot
-  ) {
-    // The incoming update might unblock the current render. Interrupt the
-    // current attempt and restart from the top.
-    prepareFreshStack(root, NoLanes);
-    markRootSuspended(root, workInProgressRootRenderLanes);
-  } // Mark that the root has a pending update.
+  var eventSystemFlags = 0;
 
-  markRootUpdated(root, lane, eventTime);
+  if (isCapturePhaseListener) {
+    eventSystemFlags |= IS_CAPTURE_PHASE;
+  }
 
-  if (
-    (executionContext & RenderContext) !== NoLanes &&
-    root === workInProgressRoot
-  ) {
-    // This update was dispatched during the render phase. This is a mistake
-    // if the update originates from user space (with the exception of local
-    // hook updates, which are handled differently and don't reach this
-    // function), but there are some internal React features that use this as
-    // an implementation detail, like selective hydration.
-    warnAboutRenderPhaseUpdatesInDEV(fiber); // Track lanes that were updated during the render phase
-  } else {
-    // This is a normal update, scheduled from outside the render phase. For
-    // example, during an input event.
-    {
-      if (isDevToolsPresent) {
-        addFiberToLanesMap(root, fiber, lane);
-      }
-    }
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
+} // This is only used by createEventHandle when the
+// target is not a DOM element. E.g. window.
 
-    warnIfUpdatesNotWrappedWithActDEV(fiber);
+function listenToNativeEventForNonManagedEventTarget(
+  domEventName,
+  isCapturePhaseListener,
+  target
+) {
+  var eventSystemFlags = IS_EVENT_HANDLE_NON_MANAGED_NODE;
+  var listenerSet = getEventListenerSet(target);
+  var listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      if (
-        (executionContext & CommitContext) !== NoContext &&
-        root === rootCommittingMutationOrLayoutEffects
-      ) {
-        if (fiber.mode & ProfileMode) {
-          var current = fiber;
+  if (!listenerSet.has(listenerSetKey)) {
+    if (isCapturePhaseListener) {
+      eventSystemFlags |= IS_CAPTURE_PHASE;
+    }
 
-          while (current !== null) {
-            if (current.tag === Profiler) {
-              var _current$memoizedProp = current.memoizedProps,
-                id = _current$memoizedProp.id,
-                onNestedUpdateScheduled =
-                  _current$memoizedProp.onNestedUpdateScheduled;
+    addTrappedEventListener(
+      target,
+      domEventName,
+      eventSystemFlags,
+      isCapturePhaseListener
+    );
+    listenerSet.add(listenerSetKey);
+  }
+}
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = true;
+    allNativeEvents.forEach(function (domEventName) {
+      // We handle selectionchange separately because it
+      // doesn't bubble and needs to be on the document.
+      if (domEventName !== "selectionchange") {
+        if (!nonDelegatedEvents.has(domEventName)) {
+          listenToNativeEvent(domEventName, false, rootContainerElement);
+        }
 
-              if (typeof onNestedUpdateScheduled === "function") {
-                onNestedUpdateScheduled(id);
-              }
-            }
+        listenToNativeEvent(domEventName, true, rootContainerElement);
+      }
+    });
+    var ownerDocument =
+      rootContainerElement.nodeType === DOCUMENT_NODE
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
 
-            current = current.return;
-          }
-        }
+    if (ownerDocument !== null) {
+      // The selectionchange event also needs deduplication
+      // but it is attached to the document.
+      if (!ownerDocument[listeningMarker]) {
+        ownerDocument[listeningMarker] = true;
+        listenToNativeEvent("selectionchange", false, ownerDocument);
       }
     }
+  }
+}
 
-    if (enableTransitionTracing) {
-      var transition = ReactCurrentBatchConfig.transition;
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  var listener = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  ); // If passive option is not supported, then the event will be
+  // active and not passive.
 
-      if (transition !== null && transition.name != null) {
-        if (transition.startTime === -1) {
-          transition.startTime = now$1();
-        }
+  var isPassiveListener = undefined;
 
-        addTransitionToLanesMap(root, transition, lane);
-      }
+  if (passiveBrowserEventsSupported) {
+    // Browsers introduced an intervention, making these events
+    // passive by default on document. React doesn't bind them
+    // to document anymore, but changing this now would undo
+    // the performance wins from the change. So we emulate
+    // the existing behavior manually on the roots now.
+    // https://github.com/facebook/react/issues/19651
+    if (
+      domEventName === "touchstart" ||
+      domEventName === "touchmove" ||
+      domEventName === "wheel"
+    ) {
+      isPassiveListener = true;
     }
+  }
 
-    if (root === workInProgressRoot) {
-      // Received an update to a tree that's in the middle of rendering. Mark
-      // that there was an interleaved update work on this root. Unless the
-      // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
-      // phase update. In that case, we don't treat render phase updates as if
-      // they were interleaved, for backwards compat reasons.
-      if (
-        deferRenderPhaseUpdateToNextBatch ||
-        (executionContext & RenderContext) === NoContext
-      ) {
-        workInProgressRootInterleavedUpdatedLanes = mergeLanes(
-          workInProgressRootInterleavedUpdatedLanes,
-          lane
-        );
-      }
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  var unsubscribeListener; // When legacyFBSupport is enabled, it's for when we
+  // want to add a one time event listener to a container.
+  // This should only be used with enableLegacyFBSupport
+  // due to requirement to provide compatibility with
+  // internal FB www event tooling. This works by removing
+  // the event listener as soon as it is invoked. We could
+  // also attempt to use the {once: true} param on
+  // addEventListener, but that requires support and some
+  // browsers do not support this today, and given this is
+  // to support legacy code patterns, it's likely they'll
+  // need support for such browsers.
 
-      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
-        // The root already suspended with a delay, which means this render
-        // definitely won't finish. Since we have a new update, let's mark it as
-        // suspended now, right before marking the incoming update. This has the
-        // effect of interrupting the current render and switching to the update.
-        // TODO: Make sure this doesn't override pings that happen while we've
-        // already started rendering.
-        markRootSuspended(root, workInProgressRootRenderLanes);
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = listener; // $FlowFixMe[missing-this-annot]
+    // $FlowFixMe[definition-cycle]
+
+    listener = function () {
+      removeEventListener(
+        targetContainer,
+        domEventName,
+        unsubscribeListener,
+        isCapturePhaseListener
+      );
+
+      for (
+        var _len = arguments.length, p = new Array(_len), _key = 0;
+        _key < _len;
+        _key++
+      ) {
+        p[_key] = arguments[_key];
       }
-    }
 
-    ensureRootIsScheduled(root, eventTime);
+      return originalListener.apply(this, p);
+    };
+  } // TODO: There are too many combinations here. Consolidate them.
 
-    if (
-      lane === SyncLane &&
-      executionContext === NoContext &&
-      (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
-      !ReactCurrentActQueue.isBatchingLegacy
-    ) {
-      // Flush the synchronous work now, unless we're already working or inside
-      // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
-      // scheduleCallbackForFiber to preserve the ability to schedule a callback
-      // without immediately flushing it. We only do this for user-initiated
-      // updates, to preserve historical behavior of legacy mode.
-      resetRenderTimer();
-      flushSyncCallbacksOnlyInLegacyMode();
+  if (isCapturePhaseListener) {
+    if (isPassiveListener !== undefined) {
+      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        listener,
+        isPassiveListener
+      );
+    } else {
+      unsubscribeListener = addEventCaptureListener(
+        targetContainer,
+        domEventName,
+        listener
+      );
+    }
+  } else {
+    if (isPassiveListener !== undefined) {
+      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        listener,
+        isPassiveListener
+      );
+    } else {
+      unsubscribeListener = addEventBubbleListener(
+        targetContainer,
+        domEventName,
+        listener
+      );
     }
   }
 }
-function scheduleInitialHydrationOnRoot(root, lane, eventTime) {
-  // This is a special fork of scheduleUpdateOnFiber that is only used to
-  // schedule the initial hydration of a root that has just been created. Most
-  // of the stuff in scheduleUpdateOnFiber can be skipped.
-  //
-  // The main reason for this separate path, though, is to distinguish the
-  // initial children from subsequent updates. In fully client-rendered roots
-  // (createRoot instead of hydrateRoot), all top-level renders are modeled as
-  // updates, but hydration roots are special because the initial render must
-  // match what was rendered on the server.
-  var current = root.current;
-  current.lanes = lane;
-  markRootUpdated(root, lane, eventTime);
-  ensureRootIsScheduled(root, eventTime);
+
+function deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer) {
+  // We defer all click events with legacy FB support mode on.
+  // This means we add a one time event listener to trigger
+  // after the FB delegated listeners fire.
+  var isDeferredListenerForLegacyFBSupport = true;
+  addTrappedEventListener(
+    targetContainer,
+    domEventName,
+    IS_LEGACY_FB_SUPPORT_MODE,
+    false,
+    isDeferredListenerForLegacyFBSupport
+  );
 }
-function isUnsafeClassRenderPhaseUpdate(fiber) {
-  // Check if this is a render phase update. Only called by class components,
-  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
+
+function isMatchingRootContainer(grandContainer, targetContainer) {
   return (
-    // TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We
-    // decided not to enable it.
-    (!deferRenderPhaseUpdateToNextBatch ||
-      (fiber.mode & ConcurrentMode) === NoMode) &&
-    (executionContext & RenderContext) !== NoContext
+    grandContainer === targetContainer ||
+    (grandContainer.nodeType === COMMENT_NODE &&
+      grandContainer.parentNode === targetContainer)
   );
-} // Use this function to schedule a task for a root. There's only one task per
-// root; if a task was already scheduled, we'll check to make sure the priority
-// of the existing task is the same as the priority of the next level that the
-// root has work on. This function is called on every update, and right before
-// exiting a task.
-
-function ensureRootIsScheduled(root, currentTime) {
-  var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
-  // expired so we know to work on those next.
+}
 
-  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst,
+  targetContainer
+) {
+  var ancestorInst = targetInst;
 
-  var nextLanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
-  );
+  if (
+    (eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 &&
+    (eventSystemFlags & IS_NON_DELEGATED) === 0
+  ) {
+    var targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we
+    // defer the event to the null with a one
+    // time event listener so we can defer the event.
 
-  if (nextLanes === NoLanes) {
-    // Special case: There's nothing to work on.
-    if (existingCallbackNode !== null) {
-      cancelCallback(existingCallbackNode);
+    if (
+      enableLegacyFBSupport && // If our event flags match the required flags for entering
+      // FB legacy mode and we are processing the "click" event,
+      // then we can defer the event to the "document", to allow
+      // for legacy FB support, where the expected behavior was to
+      // match React < 16 behavior of delegated clicks to the doc.
+      domEventName === "click" &&
+      (eventSystemFlags & SHOULD_NOT_DEFER_CLICK_FOR_FB_SUPPORT_MODE) === 0 &&
+      !isReplayingEvent(nativeEvent)
+    ) {
+      deferClickToDocumentForLegacyFBSupport(domEventName, targetContainer);
+      return;
     }
 
-    root.callbackNode = null;
-    root.callbackPriority = NoLane;
-    return;
-  } // If this root is currently suspended and waiting for data to resolve, don't
-  // schedule a task to render it. We'll either wait for a ping, or wait to
-  // receive an update.
-
-  if (
-    workInProgressSuspendedReason === SuspendedOnData &&
-    workInProgressRoot === root
-  ) {
-    root.callbackPriority = NoLane;
-    root.callbackNode = null;
-    return;
-  } // We use the highest priority lane to represent the priority of the callback.
+    if (targetInst !== null) {
+      // The below logic attempts to work out if we need to change
+      // the target fiber to a different ancestor. We had similar logic
+      // in the legacy event system, except the big difference between
+      // systems is that the modern event system now has an event listener
+      // attached to each React Root and React Portal Root. Together,
+      // the DOM nodes representing these roots are the "rootContainer".
+      // To figure out which ancestor instance we should use, we traverse
+      // up the fiber tree from the target instance and attempt to find
+      // root boundaries that match that of our current "rootContainer".
+      // If we find that "rootContainer", we find the parent fiber
+      // sub-tree for that root and make that our ancestor instance.
+      var node = targetInst;
 
-  var newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.
+      mainLoop: while (true) {
+        if (node === null) {
+          return;
+        }
 
-  var existingCallbackPriority = root.callbackPriority;
+        var nodeTag = node.tag;
 
-  if (
-    existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
-    // Scheduler task, rather than an `act` task, cancel it and re-scheduled
-    // on the `act` queue.
-    !(
-      ReactCurrentActQueue.current !== null &&
-      existingCallbackNode !== fakeActCallbackNode
-    )
-  ) {
-    {
-      // If we're going to re-use an existing task, it needs to exist.
-      // Assume that discrete update microtasks are non-cancellable and null.
-      // TODO: Temporary until we confirm this warning is not fired.
-      if (
-        existingCallbackNode == null &&
-        !includesSyncLane(existingCallbackPriority)
-      ) {
-        error(
-          "Expected scheduled callback to exist. This error is likely caused by a bug in React. Please file an issue."
-        );
-      }
-    } // The priority hasn't changed. We can reuse the existing task. Exit.
+        if (nodeTag === HostRoot || nodeTag === HostPortal) {
+          var container = node.stateNode.containerInfo;
 
-    return;
-  }
+          if (isMatchingRootContainer(container, targetContainerNode)) {
+            break;
+          }
 
-  if (existingCallbackNode != null) {
-    // Cancel the existing callback. We'll schedule a new one below.
-    cancelCallback(existingCallbackNode);
-  } // Schedule a new callback.
+          if (nodeTag === HostPortal) {
+            // The target is a portal, but it's not the rootContainer we're looking for.
+            // Normally portals handle their own events all the way down to the root.
+            // So we should be able to stop now. However, we don't know if this portal
+            // was part of *our* root.
+            var grandNode = node.return;
 
-  var newCallbackNode;
+            while (grandNode !== null) {
+              var grandTag = grandNode.tag;
 
-  if (includesSyncLane(newCallbackPriority)) {
-    // Special case: Sync React callbacks are scheduled on a special
-    // internal queue
-    if (root.tag === LegacyRoot) {
-      if (ReactCurrentActQueue.isBatchingLegacy !== null) {
-        ReactCurrentActQueue.didScheduleLegacyUpdate = true;
-      }
+              if (grandTag === HostRoot || grandTag === HostPortal) {
+                var grandContainer = grandNode.stateNode.containerInfo;
 
-      scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));
-    } else {
-      scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
-    }
+                if (
+                  isMatchingRootContainer(grandContainer, targetContainerNode)
+                ) {
+                  // This is the rootContainer we're looking for and we found it as
+                  // a parent of the Portal. That means we can ignore it because the
+                  // Portal will bubble through to us.
+                  return;
+                }
+              }
 
-    {
-      // Flush the queue in a microtask.
-      if (ReactCurrentActQueue.current !== null) {
-        // Inside `act`, use our internal `act` queue so that these get flushed
-        // at the end of the current scope even when using the sync version
-        // of `act`.
-        ReactCurrentActQueue.current.push(flushSyncCallbacks);
-      } else {
-        scheduleMicrotask(function () {
-          // In Safari, appending an iframe forces microtasks to run.
-          // https://github.com/facebook/react/issues/22459
-          // We don't support running callbacks in the middle of render
-          // or commit so we need to check against that.
-          if (
-            (executionContext & (RenderContext | CommitContext)) ===
-            NoContext
-          ) {
-            // Note that this would still prematurely flush the callbacks
-            // if this happens outside render or commit phase (e.g. in an event).
-            flushSyncCallbacks();
-          }
-        });
-      }
-    }
+              grandNode = grandNode.return;
+            }
+          } // Now we need to find it's corresponding host fiber in the other
+          // tree. To do this we can use getClosestInstanceFromNode, but we
+          // need to validate that the fiber is a host instance, otherwise
+          // we need to traverse up through the DOM till we find the correct
+          // node that is from the other tree.
 
-    newCallbackNode = null;
-  } else {
-    var schedulerPriorityLevel;
+          while (container !== null) {
+            var parentNode = getClosestInstanceFromNode(container);
 
-    switch (lanesToEventPriority(nextLanes)) {
-      case DiscreteEventPriority:
-        schedulerPriorityLevel = ImmediatePriority;
-        break;
+            if (parentNode === null) {
+              return;
+            }
 
-      case ContinuousEventPriority:
-        schedulerPriorityLevel = UserBlockingPriority;
-        break;
+            var parentTag = parentNode.tag;
 
-      case DefaultEventPriority:
-        schedulerPriorityLevel = NormalPriority$1;
-        break;
+            if (
+              parentTag === HostComponent ||
+              parentTag === HostText ||
+              parentTag === HostHoistable ||
+              parentTag === HostSingleton
+            ) {
+              node = ancestorInst = parentNode;
+              continue mainLoop;
+            }
 
-      case IdleEventPriority:
-        schedulerPriorityLevel = IdlePriority;
-        break;
+            container = container.parentNode;
+          }
+        }
 
-      default:
-        schedulerPriorityLevel = NormalPriority$1;
-        break;
+        node = node.return;
+      }
     }
-
-    newCallbackNode = scheduleCallback(
-      schedulerPriorityLevel,
-      performConcurrentWorkOnRoot.bind(null, root)
-    );
   }
 
-  root.callbackPriority = newCallbackPriority;
-  root.callbackNode = newCallbackNode;
-} // This is the entry point for every concurrent task, i.e. anything that
-// goes through Scheduler.
+  batchedUpdates(function () {
+    return dispatchEventsForPlugins(
+      domEventName,
+      eventSystemFlags,
+      nativeEvent,
+      ancestorInst,
+      targetContainer
+    );
+  });
+}
 
-function performConcurrentWorkOnRoot(root, didTimeout) {
-  {
-    resetNestedUpdateFlag();
-  } // Since we know we're in a React event, we can clear the current
-  // event time. The next update will compute a new event time.
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
 
-  currentEventTime = NoTimestamp;
-  currentEventTransitionLane = NoLanes;
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  var captureName = reactName !== null ? reactName + "Capture" : null;
+  var reactEventName = inCapturePhase ? captureName : reactName;
+  var listeners = [];
+  var instance = targetFiber;
+  var lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
-  } // Flush any pending passive effects before deciding which lanes to work on,
-  // in case they schedule additional work.
+  while (instance !== null) {
+    var _instance2 = instance,
+      stateNode = _instance2.stateNode,
+      tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)
 
-  var originalCallbackNode = root.callbackNode;
-  var didFlushPassiveEffects = flushPassiveEffects();
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      lastHostComponent = stateNode; // createEventHandle listeners
 
-  if (didFlushPassiveEffects) {
-    // Something in the passive effect phase may have canceled the current task.
-    // Check if the task node for this root was changed.
-    if (root.callbackNode !== originalCallbackNode) {
-      // The current task was canceled. Exit. We don't need to call
-      // `ensureRootIsScheduled` because the check above implies either that
-      // there's a new task, or that there's no remaining work on this root.
-      return null;
-    }
-  } // Determine the next lanes to work on, using the fields stored
-  // on the root.
+      {
+        var eventHandlerListeners = getEventHandlerListeners(lastHostComponent);
 
-  var lanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes
-  );
+        if (eventHandlerListeners !== null) {
+          eventHandlerListeners.forEach(function (entry) {
+            if (
+              entry.type === nativeEventType &&
+              entry.capture === inCapturePhase
+            ) {
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+            }
+          });
+        }
+      } // Standard React on* listeners, i.e. onClick or onClickCapture
 
-  if (lanes === NoLanes) {
-    // Defensive coding. This is never expected to happen.
-    return null;
-  } // We disable time-slicing in some cases: if the work has been CPU-bound
-  // for too long ("expired" work, to prevent starvation), or we're in
-  // sync-updates-by-default mode.
-  // TODO: We only check `didTimeout` defensively, to account for a Scheduler
-  // bug we're still investigating. Once the bug in Scheduler is fixed,
-  // we can remove this, since we track expiration ourselves.
+      if (reactEventName !== null) {
+        var listener = getListener(instance, reactEventName);
 
-  var shouldTimeSlice =
-    !includesBlockingLane(root, lanes) &&
-    !includesExpiredLane(root, lanes) &&
-    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
-  var exitStatus = shouldTimeSlice
-    ? renderRootConcurrent(root, lanes)
-    : renderRootSync(root, lanes);
+        if (listener != null) {
+          listeners.push(
+            createDispatchListener(instance, listener, lastHostComponent)
+          );
+        }
+      }
+    } else if (
+      tag === ScopeComponent &&
+      lastHostComponent !== null &&
+      stateNode !== null
+    ) {
+      // Scopes
+      var reactScopeInstance = stateNode;
 
-  if (exitStatus !== RootInProgress) {
-    if (exitStatus === RootErrored) {
-      // If something threw an error, try rendering one more time. We'll
-      // render synchronously to block concurrent data mutations, and we'll
-      // includes all pending updates are included. If it still fails after
-      // the second attempt, we'll give up and commit the resulting tree.
-      var originallyAttemptedLanes = lanes;
-      var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-        root,
-        originallyAttemptedLanes
-      );
+      var _eventHandlerListeners = getEventHandlerListeners(reactScopeInstance);
 
-      if (errorRetryLanes !== NoLanes) {
-        lanes = errorRetryLanes;
-        exitStatus = recoverFromConcurrentError(
-          root,
-          originallyAttemptedLanes,
-          errorRetryLanes
-        );
+      if (_eventHandlerListeners !== null) {
+        _eventHandlerListeners.forEach(function (entry) {
+          if (
+            entry.type === nativeEventType &&
+            entry.capture === inCapturePhase
+          ) {
+            listeners.push(
+              createDispatchListener(
+                instance,
+                entry.callback,
+                lastHostComponent
+              )
+            );
+          }
+        });
       }
-    }
+    } // If we are only accumulating events for the target, then we don't
+    // continue to propagate through the React fiber tree to find other
+    // listeners.
 
-    if (exitStatus === RootFatalErrored) {
-      var fatalError = workInProgressRootFatalError;
-      prepareFreshStack(root, NoLanes);
-      markRootSuspended(root, lanes);
-      ensureRootIsScheduled(root, now$1());
-      throw fatalError;
-    }
+    if (accumulateTargetOnly) {
+      break;
+    } // If we are processing the onBeforeBlur event, then we need to take
+    // into consideration that part of the React tree might have been hidden
+    // or deleted (as we're invoking this event during commit). We can find
+    // this out by checking if intercept fiber set on the event matches the
+    // current instance fiber. In which case, we should clear all existing
+    // listeners.
 
-    if (exitStatus === RootDidNotComplete) {
-      // The render unwound without completing the tree. This happens in special
-      // cases where need to exit the current render without producing a
-      // consistent tree or committing.
-      markRootSuspended(root, lanes);
-    } else {
-      // The render completed.
-      // Check if this render may have yielded to a concurrent event, and if so,
-      // confirm that any newly rendered stores are consistent.
-      // TODO: It's possible that even a concurrent render may never have yielded
-      // to the main thread, if it was fast enough, or if it expired. We could
-      // skip the consistency check in that case, too.
-      var renderWasConcurrent = !includesBlockingLane(root, lanes);
-      var finishedWork = root.current.alternate;
+    if (nativeEvent.type === "beforeblur") {
+      // $FlowFixMe[prop-missing] internal field
+      var detachedInterceptFiber = nativeEvent._detachedInterceptFiber;
 
       if (
-        renderWasConcurrent &&
-        !isRenderConsistentWithExternalStores(finishedWork)
+        detachedInterceptFiber !== null &&
+        (detachedInterceptFiber === instance ||
+          detachedInterceptFiber === instance.alternate)
       ) {
-        // A store was mutated in an interleaved event. Render again,
-        // synchronously, to block further mutations.
-        exitStatus = renderRootSync(root, lanes); // We need to check again if something threw
+        listeners = [];
+      }
+    }
 
-        if (exitStatus === RootErrored) {
-          var _originallyAttemptedLanes = lanes;
+    instance = instance.return;
+  }
 
-          var _errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-            root,
-            _originallyAttemptedLanes
-          );
+  return listeners;
+} // We should only use this function for:
+// - BeforeInputEventPlugin
+// - ChangeEventPlugin
+// - SelectEventPlugin
+// This is because we only process these plugins
+// in the bubble phase, so we need to accumulate two
+// phase event listeners (via emulation).
 
-          if (_errorRetryLanes !== NoLanes) {
-            lanes = _errorRetryLanes;
-            exitStatus = recoverFromConcurrentError(
-              root,
-              _originallyAttemptedLanes,
-              _errorRetryLanes
-            ); // We assume the tree is now consistent because we didn't yield to any
-            // concurrent events.
-          }
-        }
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  var captureName = reactName + "Capture";
+  var listeners = [];
+  var instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.
+
+  while (instance !== null) {
+    var _instance3 = instance,
+      stateNode = _instance3.stateNode,
+      tag = _instance3.tag; // Handle listeners that are on HostComponents (i.e. <div>)
+
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      var currentTarget = stateNode;
+      var captureListener = getListener(instance, captureName);
+
+      if (captureListener != null) {
+        listeners.unshift(
+          createDispatchListener(instance, captureListener, currentTarget)
+        );
+      }
 
-        if (exitStatus === RootFatalErrored) {
-          var _fatalError = workInProgressRootFatalError;
-          prepareFreshStack(root, NoLanes);
-          markRootSuspended(root, lanes);
-          ensureRootIsScheduled(root, now$1());
-          throw _fatalError;
-        } // FIXME: Need to check for RootDidNotComplete again. The factoring here
-        // isn't ideal.
-      } // We now have a consistent tree. The next step is either to commit it,
-      // or, if something suspended, wait to commit it after a timeout.
+      var bubbleListener = getListener(instance, reactName);
 
-      root.finishedWork = finishedWork;
-      root.finishedLanes = lanes;
-      finishConcurrentRender(root, exitStatus, lanes);
+      if (bubbleListener != null) {
+        listeners.push(
+          createDispatchListener(instance, bubbleListener, currentTarget)
+        );
+      }
     }
+
+    instance = instance.return;
   }
 
-  ensureRootIsScheduled(root, now$1());
+  return listeners;
+}
 
-  if (root.callbackNode === originalCallbackNode) {
-    // The task node scheduled for this root is the same one that's
-    // currently executed. Need to return a continuation.
-    return performConcurrentWorkOnRoot.bind(null, root);
+function getParent(inst) {
+  if (inst === null) {
+    return null;
+  }
+
+  do {
+    // $FlowFixMe[incompatible-use] found when upgrading Flow
+    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.
+    // That is depending on if we want nested subtrees (layers) to bubble
+    // events to their parent. We could also go through parentNode on the
+    // host node but that wouldn't work for React Native and doesn't let us
+    // do the portal feature.
+  } while (inst && inst.tag !== HostComponent && inst.tag !== HostSingleton);
+
+  if (inst) {
+    return inst;
   }
 
   return null;
 }
+/**
+ * Return the lowest common ancestor of A and B, or null if they are in
+ * different trees.
+ */
 
-function recoverFromConcurrentError(
-  root,
-  originallyAttemptedLanes,
-  errorRetryLanes
-) {
-  // If an error occurred during hydration, discard server response and fall
-  // back to client side render.
-  // Before rendering again, save the errors from the previous attempt.
-  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
-  var wasRootDehydrated = isRootDehydrated(root);
-
-  if (wasRootDehydrated) {
-    // The shell failed to hydrate. Set a flag to force a client rendering
-    // during the next attempt. To do this, we call prepareFreshStack now
-    // to create the root work-in-progress fiber. This is a bit weird in terms
-    // of factoring, because it relies on renderRootSync not calling
-    // prepareFreshStack again in the call below, which happens because the
-    // root and lanes haven't changed.
-    //
-    // TODO: I think what we should do is set ForceClientRender inside
-    // throwException, like we do for nested Suspense boundaries. The reason
-    // it's here instead is so we can switch to the synchronous work loop, too.
-    // Something to consider for a future refactor.
-    var rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
-    rootWorkInProgress.flags |= ForceClientRender;
+function getLowestCommonAncestor(instA, instB) {
+  var nodeA = instA;
+  var nodeB = instB;
+  var depthA = 0;
 
-    {
-      errorHydratingContainer(root.containerInfo);
-    }
+  for (var tempA = nodeA; tempA; tempA = getParent(tempA)) {
+    depthA++;
   }
 
-  var exitStatus = renderRootSync(root, errorRetryLanes);
+  var depthB = 0;
 
-  if (exitStatus !== RootErrored) {
-    // Successfully finished rendering on retry
-    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
-      // During the synchronous render, we attached additional ping listeners.
-      // This is highly suggestive of an uncached promise (though it's not the
-      // only reason this would happen). If it was an uncached promise, then
-      // it may have masked a downstream error from ocurring without actually
-      // fixing it. Example:
-      //
-      //    use(Promise.resolve('uncached'))
-      //    throw new Error('Oops!')
-      //
-      // When this happens, there's a conflict between blocking potential
-      // concurrent data races and unwrapping uncached promise values. We
-      // have to choose one or the other. Because the data race recovery is
-      // a last ditch effort, we'll disable it.
-      root.errorRecoveryDisabledLanes = mergeLanes(
-        root.errorRecoveryDisabledLanes,
-        originallyAttemptedLanes
-      ); // Mark the current render as suspended and force it to restart. Once
-      // these lanes finish successfully, we'll re-enable the error recovery
-      // mechanism for subsequent updates.
+  for (var tempB = nodeB; tempB; tempB = getParent(tempB)) {
+    depthB++;
+  } // If A is deeper, crawl up.
 
-      workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
-      return RootSuspendedWithDelay;
-    } // The errors from the failed first attempt have been recovered. Add
-    // them to the collection of recoverable errors. We'll log them in the
-    // commit phase.
+  while (depthA - depthB > 0) {
+    nodeA = getParent(nodeA);
+    depthA--;
+  } // If B is deeper, crawl up.
 
-    var errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
-    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
-    // from the first attempt, to preserve the causal sequence.
+  while (depthB - depthA > 0) {
+    nodeB = getParent(nodeB);
+    depthB--;
+  } // Walk in lockstep until we find a match.
 
-    if (errorsFromSecondAttempt !== null) {
-      queueRecoverableErrors(errorsFromSecondAttempt);
-    }
-  }
+  var depth = depthA;
 
-  return exitStatus;
-}
+  while (depth--) {
+    if (nodeA === nodeB || (nodeB !== null && nodeA === nodeB.alternate)) {
+      return nodeA;
+    }
 
-function queueRecoverableErrors(errors) {
-  if (workInProgressRootRecoverableErrors === null) {
-    workInProgressRootRecoverableErrors = errors;
-  } else {
-    // $FlowFixMe[method-unbinding]
-    workInProgressRootRecoverableErrors.push.apply(
-      workInProgressRootRecoverableErrors,
-      errors
-    );
+    nodeA = getParent(nodeA);
+    nodeB = getParent(nodeB);
   }
+
+  return null;
 }
 
-function finishConcurrentRender(root, exitStatus, lanes) {
-  switch (exitStatus) {
-    case RootInProgress:
-    case RootFatalErrored: {
-      throw new Error("Root did not complete. This is a bug in React.");
-    }
-    // Flow knows about invariant, so it complains if I add a break
-    // statement, but eslint doesn't know about invariant, so it complains
-    // if I do. eslint-disable-next-line no-fallthrough
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
+) {
+  var registrationName = event._reactName;
+  var listeners = [];
+  var instance = target;
 
-    case RootErrored: {
-      // We should have already attempted to retry this tree. If we reached
-      // this point, it errored again. Commit it.
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
+  while (instance !== null) {
+    if (instance === common) {
       break;
     }
 
-    case RootSuspended: {
-      markRootSuspended(root, lanes); // We have an acceptable loading state. We need to figure out if we
-      // should immediately commit it or wait a bit.
+    var _instance4 = instance,
+      alternate = _instance4.alternate,
+      stateNode = _instance4.stateNode,
+      tag = _instance4.tag;
 
-      if (
-        includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
-        !shouldForceFlushFallbacksInDEV()
-      ) {
-        // This render only included retries, no updates. Throttle committing
-        // retries so that we don't show too many loading states too quickly.
-        var msUntilTimeout =
-          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
+    if (alternate !== null && alternate === common) {
+      break;
+    }
 
-        if (msUntilTimeout > 10) {
-          var nextLanes = getNextLanes(root, NoLanes);
+    if (
+      (tag === HostComponent ||
+        tag === HostHoistable ||
+        tag === HostSingleton) &&
+      stateNode !== null
+    ) {
+      var currentTarget = stateNode;
 
-          if (nextLanes !== NoLanes) {
-            // There's additional work on this root.
-            break;
-          } // The render is suspended, it hasn't timed out, and there's no
-          // lower priority work to do. Instead of committing the fallback
-          // immediately, wait for more data to arrive.
+      if (inCapturePhase) {
+        var captureListener = getListener(instance, registrationName);
 
-          root.timeoutHandle = scheduleTimeout(
-            commitRoot.bind(
-              null,
-              root,
-              workInProgressRootRecoverableErrors,
-              workInProgressTransitions
-            ),
-            msUntilTimeout
+        if (captureListener != null) {
+          listeners.unshift(
+            createDispatchListener(instance, captureListener, currentTarget)
           );
-          break;
         }
-      } // The work expired. Commit immediately.
+      } else if (!inCapturePhase) {
+        var bubbleListener = getListener(instance, registrationName);
 
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
+        if (bubbleListener != null) {
+          listeners.push(
+            createDispatchListener(instance, bubbleListener, currentTarget)
+          );
+        }
+      }
     }
 
-    case RootSuspendedWithDelay: {
-      markRootSuspended(root, lanes);
+    instance = instance.return;
+  }
 
-      if (includesOnlyTransitions(lanes)) {
-        // This is a transition, so we should exit without committing a
-        // placeholder and without scheduling a timeout. Delay indefinitely
-        // until we receive more data.
-        break;
-      }
+  if (listeners.length !== 0) {
+    dispatchQueue.push({
+      event: event,
+      listeners: listeners
+    });
+  }
+} // We should only use this function for:
+// - EnterLeaveEventPlugin
+// This is because we only process this plugin
+// in the bubble phase, so we need to accumulate two
+// phase event listeners.
 
-      if (!shouldForceFlushFallbacksInDEV()) {
-        // This is not a transition, but we did trigger an avoided state.
-        // Schedule a placeholder to display after a short delay, using the Just
-        // Noticeable Difference.
-        // TODO: Is the JND optimization worth the added complexity? If this is
-        // the only reason we track the event time, then probably not.
-        // Consider removing.
-        var mostRecentEventTime = getMostRecentEventTime(root, lanes);
-        var eventTimeMs = mostRecentEventTime;
-        var timeElapsedMs = now$1() - eventTimeMs;
+function accumulateEnterLeaveTwoPhaseListeners(
+  dispatchQueue,
+  leaveEvent,
+  enterEvent,
+  from,
+  to
+) {
+  var common = from && to ? getLowestCommonAncestor(from, to) : null;
 
-        var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
+  if (from !== null) {
+    accumulateEnterLeaveListenersForEvent(
+      dispatchQueue,
+      leaveEvent,
+      from,
+      common,
+      false
+    );
+  }
 
-        if (_msUntilTimeout > 10) {
-          // Instead of committing the fallback immediately, wait for more data
-          // to arrive.
-          root.timeoutHandle = scheduleTimeout(
-            commitRoot.bind(
-              null,
-              root,
-              workInProgressRootRecoverableErrors,
-              workInProgressTransitions
-            ),
-            _msUntilTimeout
-          );
-          break;
-        }
-      } // Commit the placeholder.
+  if (to !== null && enterEvent !== null) {
+    accumulateEnterLeaveListenersForEvent(
+      dispatchQueue,
+      enterEvent,
+      to,
+      common,
+      true
+    );
+  }
+}
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
+) {
+  var listeners = [];
+  var eventListeners = getEventHandlerListeners(currentTarget);
 
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
-    }
+  if (eventListeners !== null) {
+    eventListeners.forEach(function (entry) {
+      if (entry.type === reactEventType && entry.capture === inCapturePhase) {
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
+        );
+      }
+    });
+  }
 
-    case RootCompleted: {
-      // The work completed. Ready to commit.
-      commitRoot(
-        root,
-        workInProgressRootRecoverableErrors,
-        workInProgressTransitions
-      );
-      break;
-    }
+  return listeners;
+}
+function getListenerSetKey(domEventName, capture) {
+  return domEventName + "__" + (capture ? "capture" : "bubble");
+}
 
-    default: {
-      throw new Error("Unknown root exit status.");
-    }
+var didWarnInvalidHydration = false;
+var didWarnScriptTags = false;
+var DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML";
+var SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning";
+var SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
+var AUTOFOCUS = "autoFocus";
+var CHILDREN = "children";
+var STYLE$1 = "style";
+var HTML = "__html";
+var warnedUnknownTags;
+var canDiffStyleForHydrationWarning;
+
+{
+  warnedUnknownTags = {
+    // There are working polyfills for <dialog>. Let people use it.
+    dialog: true,
+    // Electron ships a custom <webview> tag to display external web content in
+    // an isolated frame and process.
+    // This tag is not present in non Electron environments such as JSDom which
+    // is often used for testing purposes.
+    // @see https://electronjs.org/docs/api/webview-tag
+    webview: true
+  }; // IE 11 parses & normalizes the style attribute as opposed to other
+  // browsers. It adds spaces and sorts the properties in some
+  // non-alphabetical order. Handling that would require sorting CSS
+  // properties in the client & server versions or applying
+  // `expectedStyle` to a temporary DOM node to read its `style` attribute
+  // normalized. Since it only affects IE, we're skipping style warnings
+  // in that browser completely in favor of doing all that work.
+  // See https://github.com/facebook/react/issues/11807
+
+  canDiffStyleForHydrationWarning =
+    disableIEWorkarounds || (canUseDOM && !document.documentMode);
+}
+
+function validatePropertiesInDevelopment(type, props) {
+  {
+    validateProperties$2(type, props);
+    validateProperties$1(type, props);
+    validateProperties(type, props, {
+      registrationNameDependencies: registrationNameDependencies,
+      possibleRegistrationNames: possibleRegistrationNames
+    });
   }
 }
 
-function isRenderConsistentWithExternalStores(finishedWork) {
-  // Search the rendered tree for external store reads, and check whether the
-  // stores were mutated in a concurrent event. Intentionally using an iterative
-  // loop instead of recursion so we can exit early.
-  var node = finishedWork;
+function warnForPropDifference(propName, serverValue, clientValue) {
+  {
+    if (didWarnInvalidHydration) {
+      return;
+    }
 
-  while (true) {
-    if (node.flags & StoreConsistency) {
-      var updateQueue = node.updateQueue;
+    var normalizedClientValue = normalizeMarkupForTextOrAttribute(clientValue);
+    var normalizedServerValue = normalizeMarkupForTextOrAttribute(serverValue);
 
-      if (updateQueue !== null) {
-        var checks = updateQueue.stores;
+    if (normalizedServerValue === normalizedClientValue) {
+      return;
+    }
 
-        if (checks !== null) {
-          for (var i = 0; i < checks.length; i++) {
-            var check = checks[i];
-            var getSnapshot = check.getSnapshot;
-            var renderedValue = check.value;
+    didWarnInvalidHydration = true;
 
-            try {
-              if (!objectIs(getSnapshot(), renderedValue)) {
-                // Found an inconsistent store.
-                return false;
-              }
-            } catch (error) {
-              // If `getSnapshot` throws, return `false`. This will schedule
-              // a re-render, and the error will be rethrown during render.
-              return false;
-            }
-          }
-        }
-      }
+    error(
+      "Prop `%s` did not match. Server: %s Client: %s",
+      propName,
+      JSON.stringify(normalizedServerValue),
+      JSON.stringify(normalizedClientValue)
+    );
+  }
+}
+
+function warnForExtraAttributes(attributeNames) {
+  {
+    if (didWarnInvalidHydration) {
+      return;
     }
 
-    var child = node.child;
+    didWarnInvalidHydration = true;
+    var names = [];
+    attributeNames.forEach(function (name) {
+      names.push(name);
+    });
 
-    if (node.subtreeFlags & StoreConsistency && child !== null) {
-      child.return = node;
-      node = child;
-      continue;
-    }
+    error("Extra attributes from the server: %s", names);
+  }
+}
 
-    if (node === finishedWork) {
-      return true;
+function warnForInvalidEventListener(registrationName, listener) {
+  {
+    if (listener === false) {
+      error(
+        "Expected `%s` listener to be a function, instead got `false`.\n\n" +
+          "If you used to conditionally omit it with %s={condition && value}, " +
+          "pass %s={condition ? value : undefined} instead.",
+        registrationName,
+        registrationName,
+        registrationName
+      );
+    } else {
+      error(
+        "Expected `%s` listener to be a function, instead got a value of `%s` type.",
+        registrationName,
+        typeof listener
+      );
     }
+  }
+} // Parse the HTML and read it back to normalize the HTML string so that it
+// can be used for comparison.
 
-    while (node.sibling === null) {
-      if (node.return === null || node.return === finishedWork) {
-        return true;
-      }
+function normalizeHTML(parent, html) {
+  {
+    // We could have created a separate document here to avoid
+    // re-initializing custom elements if they exist. But this breaks
+    // how <noscript> is being handled. So we use the same document.
+    // See the discussion in https://github.com/facebook/react/pull/11157.
+    var testElement =
+      parent.namespaceURI === HTML_NAMESPACE
+        ? parent.ownerDocument.createElement(parent.tagName)
+        : parent.ownerDocument.createElementNS(
+            parent.namespaceURI,
+            parent.tagName
+          );
+    testElement.innerHTML = html;
+    return testElement.innerHTML;
+  }
+} // HTML parsing normalizes CR and CRLF to LF.
+// It also can turn \u0000 into \uFFFD inside attributes.
+// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream
+// If we have a mismatch, it might be caused by that.
+// We will still patch up in this case but not fire the warning.
 
-      node = node.return;
-    }
+var NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+var NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
 
-    node.sibling.return = node.return;
-    node = node.sibling;
-  } // Flow doesn't know this is unreachable, but eslint does
-  // eslint-disable-next-line no-unreachable
+function normalizeMarkupForTextOrAttribute(markup) {
+  {
+    checkHtmlStringCoercion(markup);
+  }
 
-  return true;
+  var markupString = typeof markup === "string" ? markup : "" + markup;
+  return markupString
+    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
+    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
 }
 
-function markRootSuspended(root, suspendedLanes) {
-  // When suspending, we should always exclude lanes that were pinged or (more
-  // rarely, since we try to avoid it) updated during the render phase.
-  // TODO: Lol maybe there's a better way to factor this besides this
-  // obnoxiously named function :)
-  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
-  suspendedLanes = removeLanes(
-    suspendedLanes,
-    workInProgressRootInterleavedUpdatedLanes
-  );
-  markRootSuspended$1(root, suspendedLanes);
-} // This is the entry point for synchronous tasks that don't go
-// through Scheduler
+function checkForUnmatchedText(
+  serverText,
+  clientText,
+  isConcurrentMode,
+  shouldWarnDev
+) {
+  var normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);
+  var normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);
 
-function performSyncWorkOnRoot(root) {
-  {
-    syncNestedUpdateFlag();
+  if (normalizedServerText === normalizedClientText) {
+    return;
   }
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
-  }
+  if (shouldWarnDev) {
+    {
+      if (!didWarnInvalidHydration) {
+        didWarnInvalidHydration = true;
 
-  flushPassiveEffects();
-  var lanes = getNextLanes(root, NoLanes);
+        error(
+          'Text content did not match. Server: "%s" Client: "%s"',
+          normalizedServerText,
+          normalizedClientText
+        );
+      }
+    }
+  }
 
-  if (!includesSyncLane(lanes)) {
-    // There's no remaining sync work left.
-    ensureRootIsScheduled(root, now$1());
-    return null;
+  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {
+    // In concurrent roots, we throw when there's a text mismatch and revert to
+    // client rendering, up to the nearest Suspense boundary.
+    throw new Error("Text content does not match server-rendered HTML.");
   }
+}
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return rootContainerElement.nodeType === DOCUMENT_NODE
+    ? rootContainerElement
+    : rootContainerElement.ownerDocument;
+}
 
-  var exitStatus = renderRootSync(root, lanes);
+function noop() {}
 
-  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
-    // If something threw an error, try rendering one more time. We'll render
-    // synchronously to block concurrent data mutations, and we'll includes
-    // all pending updates are included. If it still fails after the second
-    // attempt, we'll give up and commit the resulting tree.
-    var originallyAttemptedLanes = lanes;
-    var errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-      root,
-      originallyAttemptedLanes
-    );
+function trapClickOnNonInteractiveElement(node) {
+  // Mobile Safari does not fire properly bubble click events on
+  // non-interactive elements, which means delegated click listeners do not
+  // fire. The workaround for this bug involves attaching an empty click
+  // listener on the target node.
+  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+  // Just set it using the onclick property so that we don't have to manage any
+  // bookkeeping for it. Not sure if we need to clear it when the listener is
+  // removed.
+  // TODO: Only do this for the relevant Safaris maybe?
+  node.onclick = noop;
+}
 
-    if (errorRetryLanes !== NoLanes) {
-      lanes = errorRetryLanes;
-      exitStatus = recoverFromConcurrentError(
-        root,
-        originallyAttemptedLanes,
-        errorRetryLanes
-      );
+function setInitialDOMProperties(
+  tag,
+  domElement,
+  nextProps,
+  isCustomComponentTag
+) {
+  for (var propKey in nextProps) {
+    if (!nextProps.hasOwnProperty(propKey)) {
+      continue;
     }
-  }
-
-  if (exitStatus === RootFatalErrored) {
-    var fatalError = workInProgressRootFatalError;
-    prepareFreshStack(root, NoLanes);
-    markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now$1());
-    throw fatalError;
-  }
 
-  if (exitStatus === RootDidNotComplete) {
-    // The render unwound without completing the tree. This happens in special
-    // cases where need to exit the current render without producing a
-    // consistent tree or committing.
-    markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now$1());
-    return null;
-  } // We now have a consistent tree. Because this is a sync render, we
-  // will commit it even if something suspended.
+    var nextProp = nextProps[propKey];
 
-  var finishedWork = root.current.alternate;
-  root.finishedWork = finishedWork;
-  root.finishedLanes = lanes;
-  commitRoot(
-    root,
-    workInProgressRootRecoverableErrors,
-    workInProgressTransitions
-  ); // Before exiting, make sure there's a callback scheduled for the next
-  // pending level.
+    if (propKey === STYLE$1) {
+      {
+        if (nextProp) {
+          // Freeze the next style object so that we can assume it won't be
+          // mutated. We have already warned for this in the past.
+          Object.freeze(nextProp);
+        }
+      } // Relies on `updateStylesByID` not mutating `styleUpdates`.
 
-  ensureRootIsScheduled(root, now$1());
-  return null;
-}
+      setValueForStyles(domElement, nextProp);
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+      var nextHtml = nextProp ? nextProp[HTML] : undefined;
 
-function flushRoot(root, lanes) {
-  if (lanes !== NoLanes) {
-    markRootEntangled(root, mergeLanes(lanes, SyncLane));
-    ensureRootIsScheduled(root, now$1());
+      if (nextHtml != null) {
+        if (disableIEWorkarounds) {
+          domElement.innerHTML = nextHtml;
+        } else {
+          setInnerHTML$1(domElement, nextHtml);
+        }
+      }
+    } else if (propKey === CHILDREN) {
+      if (typeof nextProp === "string") {
+        // Avoid setting initial textContent when the text is empty. In IE11 setting
+        // textContent on a <textarea> will cause the placeholder to not
+        // show within the <textarea> until it has been focused and blurred again.
+        // https://github.com/facebook/react/issues/6731#issuecomment-254874553
+        var canSetTextContent =
+          tag !== "body" && (tag !== "textarea" || nextProp !== "");
 
-    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
-      resetRenderTimer();
-      flushSyncCallbacks();
-    }
-  }
-}
-function getExecutionContext() {
-  return executionContext;
-}
-function batchedUpdates(fn, a) {
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
+        if (canSetTextContent) {
+          setTextContent(domElement, nextProp);
+        }
+      } else if (typeof nextProp === "number") {
+        var _canSetTextContent = tag !== "body";
 
-  try {
-    return fn(a);
-  } finally {
-    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
-    // most batchedUpdates-like method.
+        if (_canSetTextContent) {
+          setTextContent(domElement, "" + nextProp);
+        }
+      }
+    } else if (
+      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+      propKey === SUPPRESS_HYDRATION_WARNING$1
+    );
+    else if (propKey === AUTOFOCUS);
+    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      if (nextProp != null) {
+        if (typeof nextProp !== "function") {
+          warnForInvalidEventListener(propKey, nextProp);
+        }
 
-    if (
-      executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
-      !ReactCurrentActQueue.isBatchingLegacy
-    ) {
-      resetRenderTimer();
-      flushSyncCallbacksOnlyInLegacyMode();
+        if (propKey === "onScroll") {
+          listenToNonDelegatedEvent("scroll", domElement);
+        }
+      }
+    } else if (nextProp != null) {
+      setValueForProperty(domElement, propKey, nextProp, isCustomComponentTag);
     }
   }
 }
-function discreteUpdates(fn, a, b, c, d) {
-  var previousPriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig.transition;
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    return fn(a, b, c, d);
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
+function updateDOMProperties(
+  domElement,
+  updatePayload,
+  wasCustomComponentTag,
+  isCustomComponentTag
+) {
+  // TODO: Handle wasCustomComponentTag
+  for (var i = 0; i < updatePayload.length; i += 2) {
+    var propKey = updatePayload[i];
+    var propValue = updatePayload[i + 1];
 
-    if (executionContext === NoContext) {
-      resetRenderTimer();
+    if (propKey === STYLE$1) {
+      setValueForStyles(domElement, propValue);
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+      if (disableIEWorkarounds) {
+        domElement.innerHTML = propValue;
+      } else {
+        setInnerHTML$1(domElement, propValue);
+      }
+    } else if (propKey === CHILDREN) {
+      setTextContent(domElement, propValue);
+    } else {
+      setValueForProperty(domElement, propKey, propValue, isCustomComponentTag);
     }
   }
-} // Overload the definition to the two valid signatures.
-// Warning, this opts-out of checking the function body.
-// eslint-disable-next-line no-unused-vars
-// eslint-disable-next-line no-redeclare
-// eslint-disable-next-line no-redeclare
-
-function flushSync$1(fn) {
-  // In legacy mode, we flush pending passive effects at the beginning of the
-  // next event, not at the end of the previous one.
-  if (
-    rootWithPendingPassiveEffects !== null &&
-    rootWithPendingPassiveEffects.tag === LegacyRoot &&
-    (executionContext & (RenderContext | CommitContext)) === NoContext
-  ) {
-    flushPassiveEffects();
-  }
-
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
-  var prevTransition = ReactCurrentBatchConfig.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
+} // creates a script element that won't execute
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
+function createPotentiallyInlineScriptElement(ownerDocument) {
+  // Create the script via .innerHTML so its "parser-inserted" flag is
+  // set to true and it does not execute
+  var div = ownerDocument.createElement("div");
 
-    if (fn) {
-      return fn();
-    } else {
-      return undefined;
-    }
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
-    // Note that this will happen even if batchedUpdates is higher up
-    // the stack.
+  {
+    if (enableTrustedTypesIntegration && !didWarnScriptTags) {
+      error(
+        "Encountered a script tag while rendering React component. " +
+          "Scripts inside React components are never executed when rendering " +
+          "on the client. Consider using template tag instead " +
+          "(https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template)."
+      );
 
-    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
-      flushSyncCallbacks();
+      didWarnScriptTags = true;
     }
   }
-}
-function isAlreadyRendering() {
-  // Used by the renderer to print a warning if certain APIs are called from
-  // the wrong context.
-  return (executionContext & (RenderContext | CommitContext)) !== NoContext;
-}
-function isInvalidExecutionContextForEventFunction() {
-  // Used to throw if certain APIs are called from the wrong context.
-  return (executionContext & RenderContext) !== NoContext;
-}
-function flushControlled(fn) {
-  var prevExecutionContext = executionContext;
-  executionContext |= BatchedContext;
-  var prevTransition = ReactCurrentBatchConfig.transition;
-  var previousPriority = getCurrentUpdatePriority$1();
-
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    fn();
-  } finally {
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-    executionContext = prevExecutionContext;
 
-    if (executionContext === NoContext) {
-      // Flush the immediate callbacks that were scheduled during this batch
-      resetRenderTimer();
-      flushSyncCallbacks();
-    }
-  }
-} // This is called by the HiddenContext module when we enter or leave a
-// hidden subtree. The stack logic is managed there because that's the only
-// place that ever modifies it. Which module it lives in doesn't matter for
-// performance because this function will get inlined regardless
+  div.innerHTML = "<script><" + "/script>"; // eslint-disable-line
+  // This is guaranteed to yield a script element.
 
-function setRenderLanes(subtreeRenderLanes) {
-  renderLanes = subtreeRenderLanes;
-}
-function getRenderLanes() {
-  return renderLanes;
+  var firstChild = div.firstChild;
+  var element = div.removeChild(firstChild);
+  return element;
 }
+function createSelectElement(props, ownerDocument) {
+  var element;
 
-function resetWorkInProgressStack() {
-  if (workInProgress === null) return;
-  var interruptedWork;
-
-  if (workInProgressSuspendedReason === NotSuspended) {
-    // Normal case. Work-in-progress hasn't started yet. Unwind all
-    // its parents.
-    interruptedWork = workInProgress.return;
+  if (typeof props.is === "string") {
+    element = ownerDocument.createElement("select", {
+      is: props.is
+    });
   } else {
-    // Work-in-progress is in suspended state. Reset the work loop and unwind
-    // both the suspended fiber and all its parents.
-    resetSuspendedWorkLoopOnUnwind();
-    interruptedWork = workInProgress;
+    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+    // See discussion in https://github.com/facebook/react/pull/6896
+    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+    element = ownerDocument.createElement("select");
   }
 
-  while (interruptedWork !== null) {
-    var current = interruptedWork.alternate;
-    unwindInterruptedWork(current, interruptedWork);
-    interruptedWork = interruptedWork.return;
+  if (props.multiple) {
+    element.multiple = true;
+  } else if (props.size) {
+    // Setting a size greater than 1 causes a select to behave like `multiple=true`, where
+    // it is possible that no option is selected.
+    //
+    // This is only necessary when a select in "single selection mode".
+    element.size = props.size;
   }
 
-  workInProgress = null;
-}
+  return element;
+} // Creates elements in the HTML namesapce
 
-function prepareFreshStack(root, lanes) {
-  root.finishedWork = null;
-  root.finishedLanes = NoLanes;
-  var timeoutHandle = root.timeoutHandle;
+function createHTMLElement(type, props, ownerDocument) {
+  {
+    switch (type) {
+      case "script":
+      case "select":
+        error(
+          'createHTMLElement was called with a "%s" type. This type has special creation logic in React and should use the create function implemented specifically for it. This is a bug in React.',
+          type
+        );
 
-  if (timeoutHandle !== noTimeout) {
-    // The root previous suspended and scheduled a timeout to commit a fallback
-    // state. Now that we have additional work, cancel the timeout.
-    root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
+        break;
 
-    cancelTimeout(timeoutHandle);
+      case "svg":
+      case "math":
+        error(
+          'createHTMLElement was called with a "%s" type. This type must be created with Document.createElementNS which this method does not implement. This is a bug in React.',
+          type
+        );
+    }
   }
 
-  resetWorkInProgressStack();
-  workInProgressRoot = root;
-  var rootWorkInProgress = createWorkInProgress(root.current, null);
-  workInProgress = rootWorkInProgress;
-  workInProgressRootRenderLanes = renderLanes = lanes;
-  workInProgressSuspendedReason = NotSuspended;
-  workInProgressThrownValue = null;
-  workInProgressRootDidAttachPingListener = false;
-  workInProgressRootExitStatus = RootInProgress;
-  workInProgressRootFatalError = null;
-  workInProgressRootSkippedLanes = NoLanes;
-  workInProgressRootInterleavedUpdatedLanes = NoLanes;
-  workInProgressRootPingedLanes = NoLanes;
-  workInProgressRootConcurrentErrors = null;
-  workInProgressRootRecoverableErrors = null;
-  finishQueueingConcurrentUpdates();
+  var isCustomComponentTag;
+  var element;
 
   {
-    ReactStrictModeWarnings.discardPendingWarnings();
-  }
+    isCustomComponentTag = isCustomComponent(type, props); // Should this check be gated by parent namespace? Not sure we want to
+    // allow <SVG> or <mATH>.
 
-  return rootWorkInProgress;
-}
+    if (!isCustomComponentTag && type !== type.toLowerCase()) {
+      error(
+        "<%s /> is using incorrect casing. " +
+          "Use PascalCase for React components, " +
+          "or lowercase for HTML elements.",
+        type
+      );
+    }
+  }
 
-function resetSuspendedWorkLoopOnUnwind() {
-  // Reset module-level state that was set during the render phase.
-  resetContextDependencies();
-  resetHooksOnUnwind();
-  resetChildReconcilerOnUnwind();
-}
+  if (typeof props.is === "string") {
+    element = ownerDocument.createElement(type, {
+      is: props.is
+    });
+  } else {
+    // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.
+    // See discussion in https://github.com/facebook/react/pull/6896
+    // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+    element = ownerDocument.createElement(type);
+  }
 
-function handleThrow(root, thrownValue) {
-  // A component threw an exception. Usually this is because it suspended, but
-  // it also includes regular program errors.
-  //
-  // We're either going to unwind the stack to show a Suspense or error
-  // boundary, or we're going to replay the component again. Like after a
-  // promise resolves.
-  //
-  // Until we decide whether we're going to unwind or replay, we should preserve
-  // the current state of the work loop without resetting anything.
-  //
-  // If we do decide to unwind the stack, module-level variables will be reset
-  // in resetSuspendedWorkLoopOnUnwind.
-  // These should be reset immediately because they're only supposed to be set
-  // when React is executing user code.
-  resetHooksAfterThrow();
-  resetCurrentFiber();
-  ReactCurrentOwner.current = null;
+  {
+    if (
+      !isCustomComponentTag && // $FlowFixMe[method-unbinding]
+      Object.prototype.toString.call(element) ===
+        "[object HTMLUnknownElement]" &&
+      !hasOwnProperty.call(warnedUnknownTags, type)
+    ) {
+      warnedUnknownTags[type] = true;
 
-  if (thrownValue === SuspenseException) {
-    // This is a special type of exception used for Suspense. For historical
-    // reasons, the rest of the Suspense implementation expects the thrown value
-    // to be a thenable, because before `use` existed that was the (unstable)
-    // API for suspending. This implementation detail can change later, once we
-    // deprecate the old API in favor of `use`.
-    thrownValue = getSuspendedThenable();
-    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
-      ? SuspendedOnData
-      : SuspendedOnImmediate;
-  } else if (thrownValue === SelectiveHydrationException) {
-    // An update flowed into a dehydrated boundary. Before we can apply the
-    // update, we need to finish hydrating. Interrupt the work-in-progress
-    // render so we can restart at the hydration lane.
-    //
-    // The ideal implementation would be able to switch contexts without
-    // unwinding the current stack.
-    //
-    // We could name this something more general but as of now it's the only
-    // case where we think this should happen.
-    workInProgressSuspendedReason = SuspendedOnHydration;
-  } else {
-    // This is a regular error.
-    var isWakeable =
-      thrownValue !== null &&
-      typeof thrownValue === "object" &&
-      typeof thrownValue.then === "function";
-    workInProgressSuspendedReason = isWakeable // A wakeable object was thrown by a legacy Suspense implementation.
-      ? // This has slightly different behavior than suspending with `use`.
-        SuspendedOnDeprecatedThrowPromise // This is a regular error. If something earlier in the component already
-      : // suspended, we must clear the thenable state to unblock the work loop.
-        SuspendedOnError;
+      error(
+        "The tag <%s> is unrecognized in this browser. " +
+          "If you meant to render a React component, start its name with " +
+          "an uppercase letter.",
+        type
+      );
+    }
   }
 
-  workInProgressThrownValue = thrownValue;
-  var erroredWork = workInProgress;
+  return element;
+}
+function createTextNode(text, rootContainerElement) {
+  return getOwnerDocumentFromRootContainer(rootContainerElement).createTextNode(
+    text
+  );
+}
+function setInitialProperties(domElement, tag, rawProps) {
+  var isCustomComponentTag = isCustomComponent(tag, rawProps);
 
-  if (erroredWork === null) {
-    // This is a fatal error
-    workInProgressRootExitStatus = RootFatalErrored;
-    workInProgressRootFatalError = thrownValue;
-    return;
-  }
+  {
+    validatePropertiesInDevelopment(tag, rawProps);
+  } // TODO: Make sure that we check isMounted before firing any of these events.
 
-  if (erroredWork.mode & ProfileMode) {
-    // Record the time spent rendering before an error was thrown. This
-    // avoids inaccurate Profiler durations in the case of a
-    // suspended render.
-    stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
-  }
+  var props;
 
-  if (enableSchedulingProfiler) {
-    markComponentRenderStopped();
+  switch (tag) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", domElement);
+      listenToNonDelegatedEvent("close", domElement);
+      props = rawProps;
+      break;
 
-    switch (workInProgressSuspendedReason) {
-      case SuspendedOnError: {
-        markComponentErrored(
-          erroredWork,
-          thrownValue,
-          workInProgressRootRenderLanes
-        );
-        break;
-      }
+    case "iframe":
+    case "object":
+    case "embed":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
 
-      case SuspendedOnData:
-      case SuspendedOnImmediate:
-      case SuspendedOnDeprecatedThrowPromise:
-      case SuspendedAndReadyToContinue: {
-        var wakeable = thrownValue;
-        markComponentSuspended(
-          erroredWork,
-          wakeable,
-          workInProgressRootRenderLanes
-        );
-        break;
+    case "video":
+    case "audio":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (var i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
       }
-    }
-  }
-}
 
-function shouldAttemptToSuspendUntilDataResolves() {
-  // Check if there are other pending updates that might possibly unblock this
-  // component from suspending. This mirrors the check in
-  // renderDidSuspendDelayIfPossible. We should attempt to unify them somehow.
-  // TODO: Consider unwinding immediately, using the
-  // SuspendedOnHydration mechanism.
-  if (
-    includesNonIdleWork(workInProgressRootSkippedLanes) ||
-    includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes)
-  ) {
-    // Suspend normally. renderDidSuspendDelayIfPossible will handle
-    // interrupting the work loop.
-    return false;
-  } // TODO: We should be able to remove the equivalent check in
-  // finishConcurrentRender, and rely just on this one.
+      props = rawProps;
+      break;
 
-  if (includesOnlyTransitions(workInProgressRootRenderLanes)) {
-    // If we're rendering inside the "shell" of the app, it's better to suspend
-    // rendering and wait for the data to resolve. Otherwise, we should switch
-    // to a fallback and continue rendering.
-    return getShellBoundary() === null;
-  }
+    case "source":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent("error", domElement);
+      props = rawProps;
+      break;
 
-  var handler = getSuspenseHandler();
+    case "img":
+    case "image":
+    case "link":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent("error", domElement);
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
 
-  if (handler === null);
-  else {
-    if (includesOnlyRetries(workInProgressRootRenderLanes)) {
-      // During a retry, we can suspend rendering if the nearest Suspense boundary
-      // is the boundary of the "shell", because we're guaranteed not to block
-      // any new content from appearing.
-      return handler === getShellBoundary();
-    }
-  } // For all other Lanes besides Transitions and Retries, we should not wait
-  // for the data to load.
-  // TODO: We should wait during Offscreen prerendering, too.
+    case "details":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent("toggle", domElement);
+      props = rawProps;
+      break;
 
-  return false;
-}
+    case "input":
+      initWrapperState$2(domElement, rawProps);
+      props = getHostProps$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-function pushDispatcher(container) {
-  prepareRendererToRender(container);
-  var prevDispatcher = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-  if (prevDispatcher === null) {
-    // The React isomorphic package does not include a default dispatcher.
-    // Instead the first renderer will lazily attach one, in order to give
-    // nicer error messages.
-    return ContextOnlyDispatcher;
-  } else {
-    return prevDispatcher;
-  }
-}
+    case "option":
+      validateProps(domElement, rawProps);
+      props = rawProps;
+      break;
 
-function popDispatcher(prevDispatcher) {
-  resetRendererAfterRender();
-  ReactCurrentDispatcher.current = prevDispatcher;
-}
+    case "select":
+      initWrapperState$1(domElement, rawProps);
+      props = getHostProps$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-function pushCacheDispatcher() {
-  {
-    var prevCacheDispatcher = ReactCurrentCache.current;
-    ReactCurrentCache.current = DefaultCacheDispatcher;
-    return prevCacheDispatcher;
-  }
-}
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-function popCacheDispatcher(prevCacheDispatcher) {
-  {
-    ReactCurrentCache.current = prevCacheDispatcher;
-  }
-}
+    case "textarea":
+      initWrapperState(domElement, rawProps);
+      props = getHostProps(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-function markCommitTimeOfFallback() {
-  globalMostRecentFallbackTime = now$1();
-}
-function markSkippedUpdateLanes(lane) {
-  workInProgressRootSkippedLanes = mergeLanes(
-    lane,
-    workInProgressRootSkippedLanes
-  );
-}
-function renderDidSuspend() {
-  if (workInProgressRootExitStatus === RootInProgress) {
-    workInProgressRootExitStatus = RootSuspended;
-  }
-}
-function renderDidSuspendDelayIfPossible() {
-  workInProgressRootExitStatus = RootSuspendedWithDelay; // Check if there are updates that we skipped tree that might have unblocked
-  // this render.
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-  if (
-    workInProgressRoot !== null &&
-    (includesNonIdleWork(workInProgressRootSkippedLanes) ||
-      includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))
-  ) {
-    // Mark the current render as suspended so that we switch to working on
-    // the updates that were skipped. Usually we only suspend at the end of
-    // the render phase.
-    // TODO: We should probably always mark the root as suspended immediately
-    // (inside this function), since by suspending at the end of the render
-    // phase introduces a potential mistake where we suspend lanes that were
-    // pinged or updated while we were rendering.
-    // TODO: Consider unwinding immediately, using the
-    // SuspendedOnHydration mechanism.
-    // $FlowFixMe[incompatible-call] need null check workInProgressRoot
-    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
-  }
-}
-function renderDidError(error) {
-  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
-    workInProgressRootExitStatus = RootErrored;
+    default:
+      props = rawProps;
   }
 
-  if (workInProgressRootConcurrentErrors === null) {
-    workInProgressRootConcurrentErrors = [error];
-  } else {
-    workInProgressRootConcurrentErrors.push(error);
-  }
-} // Called during render to determine if anything has suspended.
-// Returns false if we're not sure.
+  assertValidProps(tag, props);
+  setInitialDOMProperties(tag, domElement, props, isCustomComponentTag);
 
-function renderHasNotSuspendedYet() {
-  // If something errored or completed, we can't really be sure,
-  // so those are false.
-  return workInProgressRootExitStatus === RootInProgress;
-} // TODO: Over time, this function and renderRootConcurrent have become more
-// and more similar. Not sure it makes sense to maintain forked paths. Consider
-// unifying them again.
+  switch (tag) {
+    case "input":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper$3(domElement, rawProps, false);
+      break;
 
-function renderRootSync(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= RenderContext;
-  var prevDispatcher = pushDispatcher(root.containerInfo);
-  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
-  // and prepare a fresh one. Otherwise we'll continue where we left off.
+    case "textarea":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper(domElement);
+      break;
 
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    {
-      if (isDevToolsPresent) {
-        var memoizedUpdaters = root.memoizedUpdaters;
+    case "option":
+      postMountWrapper$2(domElement, rawProps);
+      break;
 
-        if (memoizedUpdaters.size > 0) {
-          restorePendingUpdaters(root, workInProgressRootRenderLanes);
-          memoizedUpdaters.clear();
-        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
-        // If we bailout on this work, we'll move them back (like above).
-        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
-        // That way we can keep the current update and future updates separate.
+    case "select":
+      postMountWrapper$1(domElement, rawProps);
+      break;
 
-        movePendingFibersToMemoized(root, lanes);
+    default:
+      if (typeof props.onClick === "function") {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        trapClickOnNonInteractiveElement(domElement);
       }
-    }
 
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    prepareFreshStack(root, lanes);
+      break;
   }
+} // Calculate the diff between the two objects.
 
+function diffProperties(domElement, tag, lastRawProps, nextRawProps) {
   {
-    if (enableDebugTracing) {
-      logRenderStarted(lanes);
-    }
+    validatePropertiesInDevelopment(tag, nextRawProps);
   }
 
-  if (enableSchedulingProfiler) {
-    markRenderStarted(lanes);
-  }
+  var updatePayload = null;
+  var lastProps;
+  var nextProps;
 
-  outer: do {
-    try {
-      if (
-        workInProgressSuspendedReason !== NotSuspended &&
-        workInProgress !== null
-      ) {
-        // The work loop is suspended. During a synchronous render, we don't
-        // yield to the main thread. Immediately unwind the stack. This will
-        // trigger either a fallback or an error boundary.
-        // TODO: For discrete and "default" updates (anything that's not
-        // flushSync), we want to wait for the microtasks the flush before
-        // unwinding. Will probably implement this using renderRootConcurrent,
-        // or merge renderRootSync and renderRootConcurrent into the same
-        // function and fork the behavior some other way.
-        var unitOfWork = workInProgress;
-        var thrownValue = workInProgressThrownValue;
+  switch (tag) {
+    case "input":
+      lastProps = getHostProps$2(domElement, lastRawProps);
+      nextProps = getHostProps$2(domElement, nextRawProps);
+      updatePayload = [];
+      break;
 
-        switch (workInProgressSuspendedReason) {
-          case SuspendedOnHydration: {
-            // Selective hydration. An update flowed into a dehydrated tree.
-            // Interrupt the current render so the work loop can switch to the
-            // hydration lane.
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = RootDidNotComplete;
-            break outer;
-          }
+    case "select":
+      lastProps = getHostProps$1(domElement, lastRawProps);
+      nextProps = getHostProps$1(domElement, nextRawProps);
+      updatePayload = [];
+      break;
 
-          default: {
-            // Continue with the normal work loop.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
-        }
+    case "textarea":
+      lastProps = getHostProps(domElement, lastRawProps);
+      nextProps = getHostProps(domElement, nextRawProps);
+      updatePayload = [];
+      break;
+
+    default:
+      lastProps = lastRawProps;
+      nextProps = nextRawProps;
+
+      if (
+        typeof lastProps.onClick !== "function" &&
+        typeof nextProps.onClick === "function"
+      ) {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        trapClickOnNonInteractiveElement(domElement);
       }
 
-      workLoopSync();
       break;
-    } catch (thrownValue) {
-      handleThrow(root, thrownValue);
+  }
+
+  assertValidProps(tag, nextProps);
+  var propKey;
+  var styleName;
+  var styleUpdates = null;
+
+  for (propKey in lastProps) {
+    if (
+      nextProps.hasOwnProperty(propKey) ||
+      !lastProps.hasOwnProperty(propKey) ||
+      lastProps[propKey] == null
+    ) {
+      continue;
     }
-  } while (true);
 
-  resetContextDependencies();
-  executionContext = prevExecutionContext;
-  popDispatcher(prevDispatcher);
-  popCacheDispatcher(prevCacheDispatcher);
+    if (propKey === STYLE$1) {
+      var lastStyle = lastProps[propKey];
 
-  if (workInProgress !== null) {
-    // This is a sync render, so we should have finished the whole tree.
-    throw new Error(
-      "Cannot commit an incomplete root. This error is likely caused by a " +
-        "bug in React. Please file an issue."
+      for (styleName in lastStyle) {
+        if (lastStyle.hasOwnProperty(styleName)) {
+          if (!styleUpdates) {
+            styleUpdates = {};
+          }
+
+          styleUpdates[styleName] = "";
+        }
+      }
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML || propKey === CHILDREN);
+    else if (
+      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+      propKey === SUPPRESS_HYDRATION_WARNING$1
     );
+    else if (propKey === AUTOFOCUS);
+    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      // This is a special case. If any listener updates we need to ensure
+      // that the "current" fiber pointer gets updated so we need a commit
+      // to update this element.
+      if (!updatePayload) {
+        updatePayload = [];
+      }
+    } else {
+      // For all other deleted properties we add it to the queue. We use
+      // the allowed property list in the commit phase instead.
+      (updatePayload = updatePayload || []).push(propKey, null);
+    }
   }
 
-  {
-    if (enableDebugTracing) {
-      logRenderStopped();
+  for (propKey in nextProps) {
+    var nextProp = nextProps[propKey];
+    var lastProp = lastProps != null ? lastProps[propKey] : undefined;
+
+    if (
+      !nextProps.hasOwnProperty(propKey) ||
+      nextProp === lastProp ||
+      (nextProp == null && lastProp == null)
+    ) {
+      continue;
     }
-  }
 
-  if (enableSchedulingProfiler) {
-    markRenderStopped();
-  } // Set this to null to indicate there's no in-progress render.
+    if (propKey === STYLE$1) {
+      {
+        if (nextProp) {
+          // Freeze the next style object so that we can assume it won't be
+          // mutated. We have already warned for this in the past.
+          Object.freeze(nextProp);
+        }
+      }
 
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+      if (lastProp) {
+        // Unset styles on `lastProp` but not on `nextProp`.
+        for (styleName in lastProp) {
+          if (
+            lastProp.hasOwnProperty(styleName) &&
+            (!nextProp || !nextProp.hasOwnProperty(styleName))
+          ) {
+            if (!styleUpdates) {
+              styleUpdates = {};
+            }
 
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
-} // The work loop is an extremely hot path. Tell Closure not to inline it.
+            styleUpdates[styleName] = "";
+          }
+        } // Update styles that changed since `lastProp`.
 
-/** @noinline */
+        for (styleName in nextProp) {
+          if (
+            nextProp.hasOwnProperty(styleName) &&
+            lastProp[styleName] !== nextProp[styleName]
+          ) {
+            if (!styleUpdates) {
+              styleUpdates = {};
+            }
 
-function workLoopSync() {
-  // Perform work without checking if we need to yield between fiber.
-  while (workInProgress !== null) {
-    performUnitOfWork(workInProgress);
-  }
-}
+            styleUpdates[styleName] = nextProp[styleName];
+          }
+        }
+      } else {
+        // Relies on `updateStylesByID` not mutating `styleUpdates`.
+        if (!styleUpdates) {
+          if (!updatePayload) {
+            updatePayload = [];
+          }
 
-function renderRootConcurrent(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= RenderContext;
-  var prevDispatcher = pushDispatcher(root.containerInfo);
-  var prevCacheDispatcher = pushCacheDispatcher(); // If the root or lanes have changed, throw out the existing stack
-  // and prepare a fresh one. Otherwise we'll continue where we left off.
+          updatePayload.push(propKey, styleUpdates);
+        }
 
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    {
-      if (isDevToolsPresent) {
-        var memoizedUpdaters = root.memoizedUpdaters;
+        styleUpdates = nextProp;
+      }
+    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+      var nextHtml = nextProp ? nextProp[HTML] : undefined;
+      var lastHtml = lastProp ? lastProp[HTML] : undefined;
+
+      if (nextHtml != null) {
+        if (lastHtml !== nextHtml) {
+          (updatePayload = updatePayload || []).push(propKey, nextHtml);
+        }
+      }
+    } else if (propKey === CHILDREN) {
+      if (typeof nextProp === "string" || typeof nextProp === "number") {
+        (updatePayload = updatePayload || []).push(propKey, "" + nextProp);
+      }
+    } else if (
+      propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+      propKey === SUPPRESS_HYDRATION_WARNING$1
+    );
+    else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      if (nextProp != null) {
+        // We eagerly listen to this even though we haven't committed yet.
+        if (typeof nextProp !== "function") {
+          warnForInvalidEventListener(propKey, nextProp);
+        }
 
-        if (memoizedUpdaters.size > 0) {
-          restorePendingUpdaters(root, workInProgressRootRenderLanes);
-          memoizedUpdaters.clear();
-        } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
-        // If we bailout on this work, we'll move them back (like above).
-        // It's important to move them now in case the work spawns more work at the same priority with different updaters.
-        // That way we can keep the current update and future updates separate.
+        if (propKey === "onScroll") {
+          listenToNonDelegatedEvent("scroll", domElement);
+        }
+      }
 
-        movePendingFibersToMemoized(root, lanes);
+      if (!updatePayload && lastProp !== nextProp) {
+        // This is a special case. If any listener updates we need to ensure
+        // that the "current" props pointer gets updated so we need a commit
+        // to update this element.
+        updatePayload = [];
       }
+    } else {
+      // For any other property we always add it to the queue and then we
+      // filter it out using the allowed property list during the commit.
+      (updatePayload = updatePayload || []).push(propKey, nextProp);
     }
-
-    workInProgressTransitions = getTransitionsForLanes(root, lanes);
-    resetRenderTimer();
-    prepareFreshStack(root, lanes);
   }
 
-  {
-    if (enableDebugTracing) {
-      logRenderStarted(lanes);
+  if (styleUpdates) {
+    {
+      validateShorthandPropertyCollisionInDev(styleUpdates, nextProps[STYLE$1]);
     }
-  }
 
-  if (enableSchedulingProfiler) {
-    markRenderStarted(lanes);
+    (updatePayload = updatePayload || []).push(STYLE$1, styleUpdates);
   }
 
-  outer: do {
-    try {
-      if (
-        workInProgressSuspendedReason !== NotSuspended &&
-        workInProgress !== null
-      ) {
-        // The work loop is suspended. We need to either unwind the stack or
-        // replay the suspended component.
-        var unitOfWork = workInProgress;
-        var thrownValue = workInProgressThrownValue;
+  return updatePayload;
+} // Apply the diff.
 
-        switch (workInProgressSuspendedReason) {
-          case SuspendedOnError: {
-            // Unwind then continue with the normal work loop.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
+function updateProperties(
+  domElement,
+  updatePayload,
+  tag,
+  lastRawProps,
+  nextRawProps
+) {
+  // Update checked *before* name.
+  // In the middle of an update, it is possible to have multiple checked.
+  // When a checked radio tries to change name, browser makes another radio's checked false.
+  if (
+    tag === "input" &&
+    nextRawProps.type === "radio" &&
+    nextRawProps.name != null
+  ) {
+    updateChecked(domElement, nextRawProps);
+  }
 
-          case SuspendedOnData: {
-            var thenable = thrownValue;
+  var wasCustomComponentTag = isCustomComponent(tag, lastRawProps);
+  var isCustomComponentTag = isCustomComponent(tag, nextRawProps); // Apply the diff.
 
-            if (isThenableResolved(thenable)) {
-              // The data resolved. Try rendering the component again.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(unitOfWork);
-              break;
-            } // The work loop is suspended on data. We should wait for it to
-            // resolve before continuing to render.
-            // TODO: Handle the case where the promise resolves synchronously.
-            // Usually this is handled when we instrument the promise to add a
-            // `status` field, but if the promise already has a status, we won't
-            // have added a listener until right here.
+  updateDOMProperties(
+    domElement,
+    updatePayload,
+    wasCustomComponentTag,
+    isCustomComponentTag
+  ); // TODO: Ensure that an update gets scheduled if any of the special props
+  // changed.
 
-            var onResolution = function () {
-              // Check if the root is still suspended on this promise.
-              if (
-                workInProgressSuspendedReason === SuspendedOnData &&
-                workInProgressRoot === root
-              ) {
-                // Mark the root as ready to continue rendering.
-                workInProgressSuspendedReason = SuspendedAndReadyToContinue;
-              } // Ensure the root is scheduled. We should do this even if we're
-              // currently working on a different root, so that we resume
-              // rendering later.
+  switch (tag) {
+    case "input":
+      // Update the wrapper around inputs *after* updating props. This has to
+      // happen after `updateDOMProperties`. Otherwise HTML5 input validations
+      // raise warnings and prevent the new value from being assigned.
+      updateWrapper$1(domElement, nextRawProps);
+      break;
 
-              ensureRootIsScheduled(root, now$1());
-            };
+    case "textarea":
+      updateWrapper(domElement, nextRawProps);
+      break;
 
-            thenable.then(onResolution, onResolution);
-            break outer;
-          }
+    case "select":
+      // <select> value update needs to occur after <option> children
+      // reconciliation
+      postUpdateWrapper(domElement, nextRawProps);
+      break;
+  }
+}
 
-          case SuspendedOnImmediate: {
-            // If this fiber just suspended, it's possible the data is already
-            // cached. Yield to the main thread to give it a chance to ping. If
-            // it does, we can retry immediately without unwinding the stack.
-            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
-            break outer;
-          }
+function getPossibleStandardName(propName) {
+  {
+    var lowerCasedName = propName.toLowerCase();
 
-          case SuspendedAndReadyToContinue: {
-            var _thenable = thrownValue;
+    if (!possibleStandardNames.hasOwnProperty(lowerCasedName)) {
+      return null;
+    }
 
-            if (isThenableResolved(_thenable)) {
-              // The data resolved. Try rendering the component again.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(unitOfWork);
-            } else {
-              // Otherwise, unwind then continue with the normal work loop.
-              workInProgressSuspendedReason = NotSuspended;
-              workInProgressThrownValue = null;
-              unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            }
+    return possibleStandardNames[lowerCasedName] || null;
+  }
+}
 
-            break;
-          }
+function diffHydratedProperties(
+  domElement,
+  tag,
+  rawProps,
+  isConcurrentMode,
+  shouldWarnDev,
+  parentNamespaceDev
+) {
+  var isCustomComponentTag;
+  var extraAttributeNames;
 
-          case SuspendedOnDeprecatedThrowPromise: {
-            // Suspended by an old implementation that uses the `throw promise`
-            // pattern. The newer replaying behavior can cause subtle issues
-            // like infinite ping loops. So we maintain the old behavior and
-            // always unwind.
-            workInProgressSuspendedReason = NotSuspended;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(unitOfWork, thrownValue);
-            break;
-          }
+  {
+    isCustomComponentTag = isCustomComponent(tag, rawProps);
+    validatePropertiesInDevelopment(tag, rawProps);
+  } // TODO: Make sure that we check isMounted before firing any of these events.
 
-          case SuspendedOnHydration: {
-            // Selective hydration. An update flowed into a dehydrated tree.
-            // Interrupt the current render so the work loop can switch to the
-            // hydration lane.
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = RootDidNotComplete;
-            break outer;
-          }
+  switch (tag) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", domElement);
+      listenToNonDelegatedEvent("close", domElement);
+      break;
 
-          default: {
-            throw new Error(
-              "Unexpected SuspendedReason. This is a bug in React."
-            );
-          }
-        }
-      }
+    case "iframe":
+    case "object":
+    case "embed":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the load event.
+      listenToNonDelegatedEvent("load", domElement);
+      break;
 
-      if (true && ReactCurrentActQueue.current !== null) {
-        // `act` special case: If we're inside an `act` scope, don't consult
-        // `shouldYield`. Always keep working until the render is complete.
-        // This is not just an optimization: in a unit test environment, we
-        // can't trust the result of `shouldYield`, because the host I/O is
-        // likely mocked.
-        workLoopSync();
-      } else {
-        workLoopConcurrent();
+    case "video":
+    case "audio":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for all the media events.
+      for (var i = 0; i < mediaEventTypes.length; i++) {
+        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);
       }
 
       break;
-    } catch (thrownValue) {
-      handleThrow(root, thrownValue);
-    }
-  } while (true);
-
-  resetContextDependencies();
-  popDispatcher(prevDispatcher);
-  popCacheDispatcher(prevCacheDispatcher);
-  executionContext = prevExecutionContext;
-
-  {
-    if (enableDebugTracing) {
-      logRenderStopped();
-    }
-  } // Check if the tree has completed.
 
-  if (workInProgress !== null) {
-    // Still work remaining.
-    if (enableSchedulingProfiler) {
-      markRenderYielded();
-    }
+    case "source":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the error event.
+      listenToNonDelegatedEvent("error", domElement);
+      break;
 
-    return RootInProgress;
-  } else {
-    // Completed the tree.
-    if (enableSchedulingProfiler) {
-      markRenderStopped();
-    } // Set this to null to indicate there's no in-progress render.
+    case "img":
+    case "image":
+    case "link":
+      // We listen to these events in case to ensure emulated bubble
+      // listeners still fire for error and load events.
+      listenToNonDelegatedEvent("error", domElement);
+      listenToNonDelegatedEvent("load", domElement);
+      break;
 
-    workInProgressRoot = null;
-    workInProgressRootRenderLanes = NoLanes; // It's safe to process the queue now that the render phase is complete.
+    case "details":
+      // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the toggle event.
+      listenToNonDelegatedEvent("toggle", domElement);
+      break;
 
-    finishQueueingConcurrentUpdates(); // Return the final exit status.
+    case "input":
+      initWrapperState$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-    return workInProgressRootExitStatus;
-  }
-}
-/** @noinline */
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-function workLoopConcurrent() {
-  // Perform work until Scheduler asks us to yield
-  while (workInProgress !== null && !shouldYield()) {
-    // $FlowFixMe[incompatible-call] found when upgrading Flow
-    performUnitOfWork(workInProgress);
-  }
-}
+    case "option":
+      validateProps(domElement, rawProps);
+      break;
 
-function performUnitOfWork(unitOfWork) {
-  // The current, flushed, state of this fiber is the alternate. 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 = unitOfWork.alternate;
-  setCurrentFiber(unitOfWork);
-  var next;
+    case "select":
+      initWrapperState$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-  if ((unitOfWork.mode & ProfileMode) !== NoMode) {
-    startProfilerTimer(unitOfWork);
-    next = beginWork(current, unitOfWork, renderLanes);
-    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
-  } else {
-    next = beginWork(current, unitOfWork, renderLanes);
-  }
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
 
-  resetCurrentFiber();
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+    case "textarea":
+      initWrapperState(domElement, rawProps); // We listen to this event in case to ensure emulated bubble
+      // listeners still fire for the invalid event.
 
-  if (next === null) {
-    // If this doesn't spawn new work, complete the current work.
-    completeUnitOfWork(unitOfWork);
-  } else {
-    workInProgress = next;
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
   }
 
-  ReactCurrentOwner.current = null;
-}
+  assertValidProps(tag, rawProps);
 
-function replaySuspendedUnitOfWork(unitOfWork) {
-  // This is a fork of performUnitOfWork specifcally for replaying a fiber that
-  // just suspended.
-  //
-  var current = unitOfWork.alternate;
-  setCurrentFiber(unitOfWork);
-  var next;
-  setCurrentFiber(unitOfWork);
-  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+  {
+    extraAttributeNames = new Set();
+    var attributes = domElement.attributes;
 
-  if (isProfilingMode) {
-    startProfilerTimer(unitOfWork);
-  }
+    for (var _i = 0; _i < attributes.length; _i++) {
+      var name = attributes[_i].name.toLowerCase();
 
-  switch (unitOfWork.tag) {
-    case IndeterminateComponent: {
-      // Because it suspended with `use`, we can assume it's a
-      // function component.
-      unitOfWork.tag = FunctionComponent; // Fallthrough to the next branch.
-    }
-    // eslint-disable-next-line no-fallthrough
+      switch (name) {
+        // Controlled attributes are not validated
+        // TODO: Only ignore them on controlled tags.
+        case "value":
+          break;
 
-    case FunctionComponent:
-    case ForwardRef: {
-      // Resolve `defaultProps`. This logic is copied from `beginWork`.
-      // TODO: Consider moving this switch statement into that module. Also,
-      // could maybe use this as an opportunity to say `use` doesn't work with
-      // `defaultProps` :)
-      var Component = unitOfWork.type;
-      var unresolvedProps = unitOfWork.pendingProps;
-      var resolvedProps =
-        unitOfWork.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      next = replayFunctionComponent(
-        current,
-        unitOfWork,
-        resolvedProps,
-        Component,
-        workInProgressRootRenderLanes
-      );
-      break;
-    }
+        case "checked":
+          break;
 
-    case SimpleMemoComponent: {
-      var _Component = unitOfWork.type;
-      var nextProps = unitOfWork.pendingProps;
-      next = replayFunctionComponent(
-        current,
-        unitOfWork,
-        nextProps,
-        _Component,
-        workInProgressRootRenderLanes
-      );
-      break;
-    }
+        case "selected":
+          break;
 
-    default: {
-      // Other types besides function components are reset completely before
-      // being replayed. Currently this only happens when a Usable type is
-      // reconciled — the reconciler will suspend.
-      //
-      // We reset the fiber back to its original state; however, this isn't
-      // a full "unwind" because we're going to reuse the promises that were
-      // reconciled previously. So it's intentional that we don't call
-      // resetSuspendedWorkLoopOnUnwind here.
-      unwindInterruptedWork(current, unitOfWork);
-      unitOfWork = workInProgress = resetWorkInProgress(
-        unitOfWork,
-        renderLanes
-      );
-      next = beginWork(current, unitOfWork, renderLanes);
-      break;
+        default:
+          // Intentionally use the original name.
+          // See discussion in https://github.com/facebook/react/pull/10676.
+          extraAttributeNames.add(attributes[_i].name);
+      }
     }
   }
 
-  if (isProfilingMode) {
-    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
-  } // The begin phase finished successfully without suspending. Return to the
-  // normal work loop.
+  var updatePayload = null;
 
-  resetCurrentFiber();
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  for (var propKey in rawProps) {
+    if (!rawProps.hasOwnProperty(propKey)) {
+      continue;
+    }
 
-  if (next === null) {
-    // If this doesn't spawn new work, complete the current work.
-    completeUnitOfWork(unitOfWork);
-  } else {
-    workInProgress = next;
-  }
+    var nextProp = rawProps[propKey];
 
-  ReactCurrentOwner.current = null;
-}
+    if (propKey === CHILDREN) {
+      // For text content children we compare against textContent. This
+      // might match additional HTML that is hidden when we read it using
+      // textContent. E.g. "foo" will match "f<span>oo</span>" but that still
+      // satisfies our requirement. Our requirement is not to produce perfect
+      // HTML and attributes. Ideally we should preserve structure but it's
+      // ok not to if the visible content is still enough to indicate what
+      // even listeners these nodes might be wired up to.
+      // TODO: Warn if there is more than a single textNode as a child.
+      // TODO: Should we use domElement.firstChild.nodeValue to compare?
+      if (typeof nextProp === "string") {
+        if (domElement.textContent !== nextProp) {
+          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
+            checkForUnmatchedText(
+              domElement.textContent,
+              nextProp,
+              isConcurrentMode,
+              shouldWarnDev
+            );
+          }
 
-function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
-  // This is a fork of performUnitOfWork specifcally for unwinding a fiber
-  // that threw an exception.
-  //
-  // Return to the normal work loop. This will unwind the stack, and potentially
-  // result in showing a fallback.
-  resetSuspendedWorkLoopOnUnwind();
-  var returnFiber = unitOfWork.return;
+          updatePayload = [CHILDREN, nextProp];
+        }
+      } else if (typeof nextProp === "number") {
+        if (domElement.textContent !== "" + nextProp) {
+          if (rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {
+            checkForUnmatchedText(
+              domElement.textContent,
+              nextProp,
+              isConcurrentMode,
+              shouldWarnDev
+            );
+          }
 
-  if (returnFiber === null || workInProgressRoot === null) {
-    // Expected to be working on a non-root fiber. This is a fatal error
-    // because there's no ancestor that can handle it; the root is
-    // supposed to capture all errors that weren't caught by an error
-    // boundary.
-    workInProgressRootExitStatus = RootFatalErrored;
-    workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
-    // sibling, or the parent if there are no siblings. But since the root
-    // has no siblings nor a parent, we set it to null. Usually this is
-    // handled by `completeUnitOfWork` or `unwindWork`, but since we're
-    // intentionally not calling those, we need set it here.
-    // TODO: Consider calling `unwindWork` to pop the contexts.
+          updatePayload = [CHILDREN, "" + nextProp];
+        }
+      }
+    } else if (registrationNameDependencies.hasOwnProperty(propKey)) {
+      if (nextProp != null) {
+        if (typeof nextProp !== "function") {
+          warnForInvalidEventListener(propKey, nextProp);
+        }
 
-    workInProgress = null;
-    return;
-  }
+        if (propKey === "onScroll") {
+          listenToNonDelegatedEvent("scroll", domElement);
+        }
+      }
+    } else if (
+      shouldWarnDev &&
+      true && // Convince Flow we've calculated it (it's DEV-only in this method.)
+      typeof isCustomComponentTag === "boolean"
+    ) {
+      // Validate that the properties correspond to their expected values.
+      var serverValue = void 0;
+      var propertyInfo =
+        isCustomComponentTag && enableCustomElementPropertySupport
+          ? null
+          : getPropertyInfo(propKey);
 
-  try {
-    // Find and mark the nearest Suspense or error boundary that can handle
-    // this "exception".
-    throwException(
-      workInProgressRoot,
-      returnFiber,
-      unitOfWork,
-      thrownValue,
-      workInProgressRootRenderLanes
-    );
-  } catch (error) {
-    // We had trouble processing the error. An example of this happening is
-    // when accessing the `componentDidCatch` property of an error boundary
-    // throws an error. A weird edge case. There's a regression test for this.
-    // To prevent an infinite loop, bubble the error up to the next parent.
-    workInProgress = returnFiber;
-    throw error;
-  } // Return to the normal work loop.
+      if (rawProps[SUPPRESS_HYDRATION_WARNING$1] === true);
+      else if (
+        propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
+        propKey === SUPPRESS_HYDRATION_WARNING$1 || // Controlled attributes are not validated
+        // TODO: Only ignore them on controlled tags.
+        propKey === "value" ||
+        propKey === "checked" ||
+        propKey === "selected"
+      );
+      else if (propKey === DANGEROUSLY_SET_INNER_HTML) {
+        var serverHTML = domElement.innerHTML;
+        var nextHtml = nextProp ? nextProp[HTML] : undefined;
 
-  completeUnitOfWork(unitOfWork);
-}
+        if (nextHtml != null) {
+          var expectedHTML = normalizeHTML(domElement, nextHtml);
 
-function completeUnitOfWork(unitOfWork) {
-  // Attempt to complete the current unit of work, then move to the next
-  // sibling. If there are no more siblings, return to the parent fiber.
-  var completedWork = unitOfWork;
+          if (expectedHTML !== serverHTML) {
+            warnForPropDifference(propKey, serverHTML, expectedHTML);
+          }
+        }
+      } else if (propKey === STYLE$1) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.delete(propKey);
 
-  do {
-    // The current, flushed, state of this fiber is the alternate. 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 = completedWork.alternate;
-    var returnFiber = completedWork.return; // Check if the work completed or if something threw.
+        if (canDiffStyleForHydrationWarning) {
+          var expectedStyle = createDangerousStringForStyles(nextProp);
+          serverValue = domElement.getAttribute("style");
 
-    if ((completedWork.flags & Incomplete) === NoFlags$1) {
-      setCurrentFiber(completedWork);
-      var next = void 0;
+          if (expectedStyle !== serverValue) {
+            warnForPropDifference(propKey, serverValue, expectedStyle);
+          }
+        }
+      } else if (
+        enableCustomElementPropertySupport &&
+        isCustomComponentTag &&
+        (propKey === "offsetParent" ||
+          propKey === "offsetTop" ||
+          propKey === "offsetLeft" ||
+          propKey === "offsetWidth" ||
+          propKey === "offsetHeight" ||
+          propKey === "isContentEditable" ||
+          propKey === "outerText" ||
+          propKey === "outerHTML")
+      ) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.delete(propKey.toLowerCase());
 
-      if ((completedWork.mode & ProfileMode) === NoMode) {
-        next = completeWork(current, completedWork, renderLanes);
-      } else {
-        startProfilerTimer(completedWork);
-        next = completeWork(current, completedWork, renderLanes); // Update render duration assuming we didn't error.
+        {
+          error(
+            "Assignment to read-only property will result in a no-op: `%s`",
+            propKey
+          );
+        }
+      } else if (isCustomComponentTag && !enableCustomElementPropertySupport) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.delete(propKey.toLowerCase());
+        serverValue = getValueForAttribute(
+          domElement,
+          propKey,
+          nextProp,
+          isCustomComponentTag
+        );
 
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
-      }
+        if (nextProp !== serverValue) {
+          warnForPropDifference(propKey, serverValue, nextProp);
+        }
+      } else if (
+        !shouldIgnoreAttribute(propKey, propertyInfo, isCustomComponentTag) &&
+        !shouldRemoveAttribute(
+          propKey,
+          nextProp,
+          propertyInfo,
+          isCustomComponentTag
+        )
+      ) {
+        var isMismatchDueToBadCasing = false;
 
-      resetCurrentFiber();
+        if (propertyInfo !== null) {
+          // $FlowFixMe - Should be inferred as not undefined.
+          extraAttributeNames.delete(propertyInfo.attributeName);
+          serverValue = getValueForProperty(
+            domElement,
+            propKey,
+            nextProp,
+            propertyInfo
+          );
+        } else {
+          var ownNamespaceDev = parentNamespaceDev;
 
-      if (next !== null) {
-        // Completing this fiber spawned new work. Work on that next.
-        workInProgress = next;
-        return;
-      }
-    } else {
-      // This fiber did not complete because something threw. Pop values off
-      // the stack without entering the complete phase. If this is a boundary,
-      // capture values if possible.
-      var _next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.
+          if (ownNamespaceDev === HTML_NAMESPACE) {
+            ownNamespaceDev = getIntrinsicNamespace(tag);
+          }
 
-      if (_next !== null) {
-        // 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
-        // from the effect tag.
-        _next.flags &= HostEffectMask;
-        workInProgress = _next;
-        return;
-      }
+          if (ownNamespaceDev === HTML_NAMESPACE) {
+            // $FlowFixMe - Should be inferred as not undefined.
+            extraAttributeNames.delete(propKey.toLowerCase());
+          } else {
+            var standardName = getPossibleStandardName(propKey);
 
-      if ((completedWork.mode & ProfileMode) !== NoMode) {
-        // Record the render duration for the fiber that errored.
-        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
+            if (standardName !== null && standardName !== propKey) {
+              // If an SVG prop is supplied with bad casing, it will
+              // be successfully parsed from HTML, but will produce a mismatch
+              // (and would be incorrectly rendered on the client).
+              // However, we already warn about bad casing elsewhere.
+              // So we'll skip the misleading extra mismatch warning in this case.
+              isMismatchDueToBadCasing = true; // $FlowFixMe - Should be inferred as not undefined.
 
-        var actualDuration = completedWork.actualDuration;
-        var child = completedWork.child;
+              extraAttributeNames.delete(standardName);
+            } // $FlowFixMe - Should be inferred as not undefined.
 
-        while (child !== null) {
-          // $FlowFixMe[unsafe-addition] addition with possible null/undefined value
-          actualDuration += child.actualDuration;
-          child = child.sibling;
+            extraAttributeNames.delete(propKey);
+          }
+
+          serverValue = getValueForAttribute(
+            domElement,
+            propKey,
+            nextProp,
+            isCustomComponentTag
+          );
         }
 
-        completedWork.actualDuration = actualDuration;
+        var dontWarnCustomElement =
+          enableCustomElementPropertySupport &&
+          isCustomComponentTag &&
+          (typeof nextProp === "function" || typeof nextProp === "object");
+
+        if (
+          !dontWarnCustomElement &&
+          nextProp !== serverValue &&
+          !isMismatchDueToBadCasing
+        ) {
+          warnForPropDifference(propKey, serverValue, nextProp);
+        }
       }
+    }
+  }
 
-      if (returnFiber !== null) {
-        // Mark the parent fiber as incomplete and clear its subtree flags.
-        returnFiber.flags |= Incomplete;
-        returnFiber.subtreeFlags = NoFlags$1;
-        returnFiber.deletions = null;
-      } else {
-        // We've unwound all the way to the root.
-        workInProgressRootExitStatus = RootDidNotComplete;
-        workInProgress = null;
-        return;
+  {
+    if (shouldWarnDev) {
+      if (
+        // $FlowFixMe - Should be inferred as not undefined.
+        extraAttributeNames.size > 0 &&
+        rawProps[SUPPRESS_HYDRATION_WARNING$1] !== true
+      ) {
+        // $FlowFixMe - Should be inferred as not undefined.
+        warnForExtraAttributes(extraAttributeNames);
       }
     }
+  }
 
-    var siblingFiber = completedWork.sibling;
+  switch (tag) {
+    case "input":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper$3(domElement, rawProps, true);
+      break;
 
-    if (siblingFiber !== null) {
-      // If there is more work to do in this returnFiber, do that next.
-      workInProgress = siblingFiber;
-      return;
-    } // Otherwise, return to the parent
-    // $FlowFixMe[incompatible-type] we bail out when we get a null
+    case "textarea":
+      // TODO: Make sure we check if this is still unmounted or do any clean
+      // up necessary since we never stop tracking anymore.
+      track(domElement);
+      postMountWrapper(domElement);
+      break;
 
-    completedWork = returnFiber; // Update the next thing we're working on in case something throws.
+    case "select":
+    case "option":
+      // For input and textarea we current always set the value property at
+      // post mount to force it to diverge from attributes. However, for
+      // option and select we don't quite do the same thing and select
+      // is not resilient to the DOM state changing so we don't do that here.
+      // TODO: Consider not doing this for input and textarea.
+      break;
 
-    workInProgress = completedWork;
-  } while (completedWork !== null); // We've reached the root.
+    default:
+      if (typeof rawProps.onClick === "function") {
+        // TODO: This cast may not be sound for SVG, MathML or custom elements.
+        trapClickOnNonInteractiveElement(domElement);
+      }
 
-  if (workInProgressRootExitStatus === RootInProgress) {
-    workInProgressRootExitStatus = RootCompleted;
+      break;
   }
+
+  return updatePayload;
+}
+function diffHydratedText(textNode, text, isConcurrentMode) {
+  var isDifferent = textNode.nodeValue !== text;
+  return isDifferent;
 }
+function warnForDeletedHydratableElement(parentNode, child) {
+  {
+    if (didWarnInvalidHydration) {
+      return;
+    }
 
-function commitRoot(root, recoverableErrors, transitions) {
-  // TODO: This no longer makes any sense. We already wrap the mutation and
-  // layout phases. Should be able to remove.
-  var previousUpdateLanePriority = getCurrentUpdatePriority$1();
-  var prevTransition = ReactCurrentBatchConfig.transition;
+    didWarnInvalidHydration = true;
 
-  try {
-    ReactCurrentBatchConfig.transition = null;
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    commitRootImpl(
-      root,
-      recoverableErrors,
-      transitions,
-      previousUpdateLanePriority
+    error(
+      "Did not expect server HTML to contain a <%s> in <%s>.",
+      child.nodeName.toLowerCase(),
+      parentNode.nodeName.toLowerCase()
     );
-  } finally {
-    ReactCurrentBatchConfig.transition = prevTransition;
-    setCurrentUpdatePriority(previousUpdateLanePriority);
   }
-
-  return null;
 }
+function warnForDeletedHydratableText(parentNode, child) {
+  {
+    if (didWarnInvalidHydration) {
+      return;
+    }
 
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
-) {
-  do {
-    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
-    // means `flushPassiveEffects` will sometimes result in additional
-    // passive effects. So we need to keep flushing in a loop until there are
-    // no more pending effects.
-    // TODO: Might be better if `flushPassiveEffects` did not automatically
-    // flush synchronous work at the end, to avoid factoring hazards like this.
-    flushPassiveEffects();
-  } while (rootWithPendingPassiveEffects !== null);
-
-  flushRenderPhaseStrictModeWarningsInDEV();
+    didWarnInvalidHydration = true;
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Should not already be working.");
+    error(
+      'Did not expect server HTML to contain the text node "%s" in <%s>.',
+      child.nodeValue,
+      parentNode.nodeName.toLowerCase()
+    );
   }
-
-  var finishedWork = root.finishedWork;
-  var lanes = root.finishedLanes;
-
+}
+function warnForInsertedHydratedElement(parentNode, tag, props) {
   {
-    if (enableDebugTracing) {
-      logCommitStarted(lanes);
+    if (didWarnInvalidHydration) {
+      return;
     }
-  }
-
-  if (enableSchedulingProfiler) {
-    markCommitStarted(lanes);
-  }
 
-  if (finishedWork === null) {
-    {
-      if (enableDebugTracing) {
-        logCommitStopped();
-      }
-    }
+    didWarnInvalidHydration = true;
 
-    if (enableSchedulingProfiler) {
-      markCommitStopped();
+    error(
+      "Expected server HTML to contain a matching <%s> in <%s>.",
+      tag,
+      parentNode.nodeName.toLowerCase()
+    );
+  }
+}
+function warnForInsertedHydratedText(parentNode, text) {
+  {
+    if (text === "") {
+      // We expect to insert empty text nodes since they're not represented in
+      // the HTML.
+      // TODO: Remove this special case if we can just avoid inserting empty
+      // text nodes.
+      return;
     }
 
-    return null;
-  } else {
-    {
-      if (lanes === NoLanes) {
-        error(
-          "root.finishedLanes should not be empty during a commit. This is a " +
-            "bug in React."
-        );
-      }
+    if (didWarnInvalidHydration) {
+      return;
     }
-  }
 
-  root.finishedWork = null;
-  root.finishedLanes = NoLanes;
+    didWarnInvalidHydration = true;
 
-  if (finishedWork === root.current) {
-    throw new Error(
-      "Cannot commit the same tree as before. This error is likely caused by " +
-        "a bug in React. Please file an issue."
+    error(
+      'Expected server HTML to contain a matching text node for "%s" in <%s>.',
+      text,
+      parentNode.nodeName.toLowerCase()
     );
-  } // commitRoot never returns a continuation; it always finishes synchronously.
-  // So we can clear these now to allow a new callback to be scheduled.
-
-  root.callbackNode = null;
-  root.callbackPriority = NoLane; // Check which lanes no longer have any work scheduled on them, and mark
-  // those as finished.
-
-  var remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes); // Make sure to account for lanes that were updated by a concurrent event
-  // during the render phase; don't mark them as finished.
-
-  var concurrentlyUpdatedLanes = getConcurrentlyUpdatedLanes();
-  remainingLanes = mergeLanes(remainingLanes, concurrentlyUpdatedLanes);
-  markRootFinished(root, remainingLanes);
+  }
+}
+function restoreControlledState(domElement, tag, props) {
+  switch (tag) {
+    case "input":
+      restoreControlledState$3(domElement, props);
+      return;
 
-  if (root === workInProgressRoot) {
-    // We can reset these now that they are finished.
-    workInProgressRoot = null;
-    workInProgress = null;
-    workInProgressRootRenderLanes = NoLanes;
-  } // If there are pending passive effects, schedule a callback to process them.
-  // Do this as early as possible, so it is queued before anything else that
-  // might get scheduled in the commit phase. (See #16714.)
-  // TODO: Delete all other places that schedule the passive effect callback
-  // They're redundant.
+    case "textarea":
+      restoreControlledState$1(domElement, props);
+      return;
 
-  if (
-    (finishedWork.subtreeFlags & PassiveMask) !== NoFlags$1 ||
-    (finishedWork.flags & PassiveMask) !== NoFlags$1
-  ) {
-    if (!rootDoesHavePassiveEffects) {
-      rootDoesHavePassiveEffects = true;
-      pendingPassiveEffectsRemainingLanes = remainingLanes; // workInProgressTransitions might be overwritten, so we want
-      // to store it in pendingPassiveTransitions until they get processed
-      // We need to pass this through as an argument to commitRoot
-      // because workInProgressTransitions might have changed between
-      // the previous render and commit if we throttle the commit
-      // with setTimeout
+    case "select":
+      restoreControlledState$2(domElement, props);
+      return;
+  }
+}
 
-      pendingPassiveTransitions = transitions;
-      scheduleCallback(NormalPriority$1, function () {
-        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
-        // *after* passive effects fire to avoid freeing a cache pool that may
-        // be referenced by a node in the tree (HostRoot, Cache boundary etc)
+// This validation code was written based on the HTML5 parsing spec:
+// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
+//
+// Note: this does not catch all invalid nesting, nor does it try to (as it's
+// not clear what practical benefit doing so provides); instead, we warn only
+// for cases where the parser will give a parse tree differing from what React
+// intended. For example, <b><div></div></b> is invalid but we don't warn
+// because it still parses correctly; we do warn for other cases like nested
+// <p> tags where the beginning of the second element implicitly closes the
+// first, causing a confusing mess.
+// https://html.spec.whatwg.org/multipage/syntax.html#special
+var specialTags = [
+  "address",
+  "applet",
+  "area",
+  "article",
+  "aside",
+  "base",
+  "basefont",
+  "bgsound",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "caption",
+  "center",
+  "col",
+  "colgroup",
+  "dd",
+  "details",
+  "dir",
+  "div",
+  "dl",
+  "dt",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "frame",
+  "frameset",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "iframe",
+  "img",
+  "input",
+  "isindex",
+  "li",
+  "link",
+  "listing",
+  "main",
+  "marquee",
+  "menu",
+  "menuitem",
+  "meta",
+  "nav",
+  "noembed",
+  "noframes",
+  "noscript",
+  "object",
+  "ol",
+  "p",
+  "param",
+  "plaintext",
+  "pre",
+  "script",
+  "section",
+  "select",
+  "source",
+  "style",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr",
+  "track",
+  "ul",
+  "wbr",
+  "xmp"
+]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
 
-        return null;
-      });
-    }
-  } // Check if there are any effects in the whole tree.
-  // TODO: This is left over from the effect list implementation, where we had
-  // to check for the existence of `firstEffect` to satisfy Flow. I think the
-  // only other reason this optimization exists is because it affects profiling.
-  // Reconsider whether this is necessary.
+var inScopeTags = [
+  "applet",
+  "caption",
+  "html",
+  "table",
+  "td",
+  "th",
+  "marquee",
+  "object",
+  "template", // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
+  // TODO: Distinguish by namespace here -- for <title>, including it here
+  // errs on the side of fewer warnings
+  "foreignObject",
+  "desc",
+  "title"
+]; // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
 
-  var subtreeHasEffects =
-    (finishedWork.subtreeFlags &
-      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
-    NoFlags$1;
-  var rootHasEffect =
-    (finishedWork.flags &
-      (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !==
-    NoFlags$1;
+var buttonScopeTags = inScopeTags.concat(["button"]); // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
 
-  if (subtreeHasEffects || rootHasEffect) {
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = getCurrentUpdatePriority$1();
-    setCurrentUpdatePriority(DiscreteEventPriority);
-    var prevExecutionContext = executionContext;
-    executionContext |= CommitContext; // Reset this to null before calling lifecycles
+var impliedEndTags = ["dd", "dt", "li", "option", "optgroup", "p", "rp", "rt"];
+var emptyAncestorInfoDev = {
+  current: null,
+  formTag: null,
+  aTagInScope: null,
+  buttonTagInScope: null,
+  nobrTagInScope: null,
+  pTagInButtonScope: null,
+  listItemTagAutoclosing: null,
+  dlItemTagAutoclosing: null,
+  containerTagInScope: null
+};
 
-    ReactCurrentOwner.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
-    // of the effect list for each phase: all mutation effects come before all
-    // layout effects, and so on.
-    // The first phase a "before mutation" phase. We use this phase to read the
-    // state of the host tree right before we mutate it. This is where
-    // getSnapshotBeforeUpdate is called.
+function updatedAncestorInfoDev(oldInfo, tag) {
+  {
+    var ancestorInfo = assign({}, oldInfo || emptyAncestorInfoDev);
 
-    var shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
+    var info = {
+      tag: tag
+    };
 
-    {
-      // Mark the current commit time to be shared by all Profilers in this
-      // batch. This enables them to be grouped later.
-      recordCommitTime();
+    if (inScopeTags.indexOf(tag) !== -1) {
+      ancestorInfo.aTagInScope = null;
+      ancestorInfo.buttonTagInScope = null;
+      ancestorInfo.nobrTagInScope = null;
     }
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      // Track the root here, rather than in commitLayoutEffects(), because of ref setters.
-      // Updates scheduled during ref detachment should also be flagged.
-      rootCommittingMutationOrLayoutEffects = root;
-    } // The next phase is the mutation phase, where we mutate the host tree.
-
-    commitMutationEffects(root, finishedWork, lanes);
+    if (buttonScopeTags.indexOf(tag) !== -1) {
+      ancestorInfo.pTagInButtonScope = null;
+    } // See rules for 'li', 'dd', 'dt' start tags in
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
 
-    {
-      if (shouldFireAfterActiveInstanceBlur) {
-        afterActiveInstanceBlur();
-      }
+    if (
+      specialTags.indexOf(tag) !== -1 &&
+      tag !== "address" &&
+      tag !== "div" &&
+      tag !== "p"
+    ) {
+      ancestorInfo.listItemTagAutoclosing = null;
+      ancestorInfo.dlItemTagAutoclosing = null;
     }
 
-    resetAfterCommit(); // The work-in-progress tree is now the current tree. This must come after
-    // the mutation phase, so that the previous tree is still current during
-    // componentWillUnmount, but before the layout phase, so that the finished
-    // work is current during componentDidMount/Update.
-
-    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
-    // the host tree after it's been mutated. The idiomatic use case for this is
-    // layout, but class component lifecycles also fire here for legacy reasons.
+    ancestorInfo.current = info;
 
-    {
-      if (enableDebugTracing) {
-        logLayoutEffectsStarted(lanes);
-      }
+    if (tag === "form") {
+      ancestorInfo.formTag = info;
     }
 
-    if (enableSchedulingProfiler) {
-      markLayoutEffectsStarted(lanes);
+    if (tag === "a") {
+      ancestorInfo.aTagInScope = info;
     }
 
-    commitLayoutEffects(finishedWork, root, lanes);
-
-    {
-      if (enableDebugTracing) {
-        logLayoutEffectsStopped();
-      }
+    if (tag === "button") {
+      ancestorInfo.buttonTagInScope = info;
     }
 
-    if (enableSchedulingProfiler) {
-      markLayoutEffectsStopped();
+    if (tag === "nobr") {
+      ancestorInfo.nobrTagInScope = info;
     }
 
-    if (enableProfilerNestedUpdateScheduledHook) {
-      rootCommittingMutationOrLayoutEffects = null;
-    } // Tell Scheduler to yield at the end of the frame, so the browser has an
-    // opportunity to paint.
-
-    requestPaint();
-    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
-
-    setCurrentUpdatePriority(previousPriority);
-    ReactCurrentBatchConfig.transition = prevTransition;
-  } else {
-    // No effects.
-    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
-    // no effects.
-    // TODO: Maybe there's a better way to report this.
-
-    {
-      recordCommitTime();
+    if (tag === "p") {
+      ancestorInfo.pTagInButtonScope = info;
     }
-  }
-
-  var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
-
-  if (rootDoesHavePassiveEffects) {
-    // This commit has passive effects. Stash a reference to them. But don't
-    // schedule a callback until after flushing layout work.
-    rootDoesHavePassiveEffects = false;
-    rootWithPendingPassiveEffects = root;
-    pendingPassiveEffectsLanes = lanes;
-  } else {
-    // There were no passive effects, so we can immediately release the cache
-    // pool for this render.
-    releaseRootPooledCache(root, remainingLanes);
 
-    {
-      nestedPassiveUpdateCount = 0;
-      rootWithPassiveNestedUpdates = null;
+    if (tag === "li") {
+      ancestorInfo.listItemTagAutoclosing = info;
     }
-  } // Read this again, since an effect might have updated it
-
-  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
-  // TODO: This is part of the `componentDidCatch` implementation. Its purpose
-  // is to detect whether something might have called setState inside
-  // `componentDidCatch`. The mechanism is known to be flawed because `setState`
-  // inside `componentDidCatch` is itself flawed — that's why we recommend
-  // `getDerivedStateFromError` instead. However, it could be improved by
-  // checking if remainingLanes includes Sync work, instead of whether there's
-  // any work remaining at all (which would also include stuff like Suspense
-  // retries or transitions). It's been like this for a while, though, so fixing
-  // it probably isn't that urgent.
 
-  if (remainingLanes === NoLanes) {
-    // If there's no remaining work, we can clear the set of already failed
-    // error boundaries.
-    legacyErrorBoundariesThatAlreadyFailed = null;
-  }
-
-  {
-    if (!rootDidHavePassiveEffects) {
-      commitDoubleInvokeEffectsInDEV(root, false);
+    if (tag === "dd" || tag === "dt") {
+      ancestorInfo.dlItemTagAutoclosing = info;
     }
-  }
 
-  onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
-
-  {
-    if (isDevToolsPresent) {
-      root.memoizedUpdaters.clear();
+    if (tag === "#document" || tag === "html") {
+      ancestorInfo.containerTagInScope = null;
+    } else if (!ancestorInfo.containerTagInScope) {
+      ancestorInfo.containerTagInScope = info;
     }
+
+    return ancestorInfo;
   }
+}
+/**
+ * Returns whether
+ */
 
-  {
-    onCommitRoot();
-  } // Always call this before exiting `commitRoot`, to ensure that any
-  // additional work on this root is scheduled.
+function isTagValidWithParent(tag, parentTag) {
+  // First, let's check if we're in an unusual parsing mode...
+  switch (parentTag) {
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
+    case "select":
+      return tag === "option" || tag === "optgroup" || tag === "#text";
 
-  ensureRootIsScheduled(root, now$1());
+    case "optgroup":
+      return tag === "option" || tag === "#text";
+    // Strictly speaking, seeing an <option> doesn't mean we're in a <select>
+    // but
 
-  if (recoverableErrors !== null) {
-    // There were errors during this render, but recovered from them without
-    // needing to surface it to the UI. We log them here.
-    var onRecoverableError = root.onRecoverableError;
+    case "option":
+      return tag === "#text";
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
+    // No special behavior since these rules fall back to "in body" mode for
+    // all except special table nodes which cause bad parsing behavior anyway.
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
 
-    for (var i = 0; i < recoverableErrors.length; i++) {
-      var recoverableError = recoverableErrors[i];
-      var errorInfo = makeErrorInfo(
-        recoverableError.digest,
-        recoverableError.stack
+    case "tr":
+      return (
+        tag === "th" ||
+        tag === "td" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
       );
-      onRecoverableError(recoverableError.value, errorInfo);
-    }
-  }
-
-  if (hasUncaughtError) {
-    hasUncaughtError = false;
-    var error$1 = firstUncaughtError;
-    firstUncaughtError = null;
-    throw error$1;
-  } // If the passive effects are the result of a discrete render, flush them
-  // synchronously at the end of the current task so that the result is
-  // immediately observable. Otherwise, we assume that they are not
-  // order-dependent and do not need to be observed by external systems, so we
-  // can wait until after paint.
-  // TODO: We can optimize this by not scheduling the callback earlier. Since we
-  // currently schedule the callback in multiple places, will wait until those
-  // are consolidated.
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
 
-  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
-    flushPassiveEffects();
-  } // Read this again, since a passive effect might have updated it
+    case "tbody":
+    case "thead":
+    case "tfoot":
+      return (
+        tag === "tr" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
+      );
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
 
-  remainingLanes = root.pendingLanes;
+    case "colgroup":
+      return tag === "col" || tag === "template";
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
 
-  if (includesSyncLane(remainingLanes)) {
-    {
-      markNestedUpdateScheduled();
-    } // Count the number of times the root synchronously re-renders without
-    // finishing. If there are too many, it indicates an infinite update loop.
+    case "table":
+      return (
+        tag === "caption" ||
+        tag === "colgroup" ||
+        tag === "tbody" ||
+        tag === "tfoot" ||
+        tag === "thead" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
+      );
+    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
 
-    if (root === rootWithNestedUpdates) {
-      nestedUpdateCount++;
-    } else {
-      nestedUpdateCount = 0;
-      rootWithNestedUpdates = root;
-    }
-  } else {
-    nestedUpdateCount = 0;
-  } // If layout work was scheduled, flush it now.
+    case "head":
+      return (
+        tag === "base" ||
+        tag === "basefont" ||
+        tag === "bgsound" ||
+        tag === "link" ||
+        tag === "meta" ||
+        tag === "title" ||
+        tag === "noscript" ||
+        tag === "noframes" ||
+        tag === "style" ||
+        tag === "script" ||
+        tag === "template"
+      );
+    // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
 
-  flushSyncCallbacks();
+    case "html":
+      return tag === "head" || tag === "body" || tag === "frameset";
 
-  {
-    if (enableDebugTracing) {
-      logCommitStopped();
-    }
-  }
+    case "frameset":
+      return tag === "frame";
 
-  if (enableSchedulingProfiler) {
-    markCommitStopped();
-  }
+    case "#document":
+      return tag === "html";
+  } // Probably in the "in body" parsing mode, so we outlaw only tag combos
+  // where the parsing rules cause implicit opens or closes to be added.
+  // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
 
-  if (enableTransitionTracing) {
-    // We process transitions during passive effects. However, passive effects can be
-    // processed synchronously during the commit phase as well as asynchronously after
-    // paint. At the end of the commit phase, we schedule a callback that will be called
-    // after the next paint. If the transitions have already been processed (passive
-    // effect phase happened synchronously), we will schedule a callback to process
-    // the transitions. However, if we don't have any pending transition callbacks, this
-    // means that the transitions have yet to be processed (passive effects processed after paint)
-    // so we will store the end time of paint so that we can process the transitions
-    // and then call the callback via the correct end time.
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
+  switch (tag) {
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return (
+        parentTag !== "h1" &&
+        parentTag !== "h2" &&
+        parentTag !== "h3" &&
+        parentTag !== "h4" &&
+        parentTag !== "h5" &&
+        parentTag !== "h6"
+      );
 
-    if (prevRootTransitionCallbacks !== null) {
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+    case "rp":
+    case "rt":
+      return impliedEndTags.indexOf(parentTag) === -1;
 
-        if (prevPendingTransitionCallbacks !== null) {
-          currentPendingTransitionCallbacks = null;
-          scheduleCallback(IdlePriority, function () {
-            processTransitionCallbacks(
-              prevPendingTransitionCallbacks,
-              endTime,
-              prevRootTransitionCallbacks
-            );
-          });
-        } else {
-          currentEndTime = endTime;
-        }
-      });
-    }
+    case "body":
+    case "caption":
+    case "col":
+    case "colgroup":
+    case "frameset":
+    case "frame":
+    case "head":
+    case "html":
+    case "tbody":
+    case "td":
+    case "tfoot":
+    case "th":
+    case "thead":
+    case "tr":
+      // These tags are only valid with a few parents that have special child
+      // parsing rules -- if we're down here, then none of those matched and
+      // so we allow it only if we don't know what the parent is, as all other
+      // cases are invalid.
+      return parentTag == null;
   }
 
-  return null;
-}
-
-function makeErrorInfo(digest, componentStack) {
-  {
-    var errorInfo = {
-      componentStack: componentStack,
-      digest: digest
-    };
-    Object.defineProperty(errorInfo, "digest", {
-      configurable: false,
-      enumerable: true,
-      get: function () {
-        error(
-          'You are accessing "digest" from the errorInfo object passed to onRecoverableError.' +
-            " This property is deprecated and will be removed in a future version of React." +
-            " To access the digest of an Error look for this property on the Error instance itself."
-        );
-
-        return digest;
-      }
-    });
-    return errorInfo;
-  }
+  return true;
 }
+/**
+ * Returns whether
+ */
 
-function releaseRootPooledCache(root, remainingLanes) {
-  {
-    var pooledCacheLanes = (root.pooledCacheLanes &= remainingLanes);
-
-    if (pooledCacheLanes === NoLanes) {
-      // None of the remaining work relies on the cache pool. Clear it so
-      // subsequent requests get a new cache
-      var pooledCache = root.pooledCache;
-
-      if (pooledCache != null) {
-        root.pooledCache = null;
-        releaseCache(pooledCache);
-      }
-    }
-  }
-}
+function findInvalidAncestorForTag(tag, ancestorInfo) {
+  switch (tag) {
+    case "address":
+    case "article":
+    case "aside":
+    case "blockquote":
+    case "center":
+    case "details":
+    case "dialog":
+    case "dir":
+    case "div":
+    case "dl":
+    case "fieldset":
+    case "figcaption":
+    case "figure":
+    case "footer":
+    case "header":
+    case "hgroup":
+    case "main":
+    case "menu":
+    case "nav":
+    case "ol":
+    case "p":
+    case "section":
+    case "summary":
+    case "ul":
+    case "pre":
+    case "listing":
+    case "table":
+    case "hr":
+    case "xmp":
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return ancestorInfo.pTagInButtonScope;
 
-function flushPassiveEffects() {
-  // Returns whether passive effects were flushed.
-  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
-  // probably just combine the two functions. I believe they were only separate
-  // in the first place because we used to wrap it with
-  // `Scheduler.runWithPriority`, which accepts a function. But now we track the
-  // priority within React itself, so we can mutate the variable directly.
-  if (rootWithPendingPassiveEffects !== null) {
-    // Cache the root since rootWithPendingPassiveEffects is cleared in
-    // flushPassiveEffectsImpl
-    var root = rootWithPendingPassiveEffects; // Cache and clear the remaining lanes flag; it must be reset since this
-    // method can be called from various places, not always from commitRoot
-    // where the remaining lanes are known
+    case "form":
+      return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
 
-    var remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = NoLanes;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    var previousPriority = getCurrentUpdatePriority$1();
+    case "li":
+      return ancestorInfo.listItemTagAutoclosing;
 
-    try {
-      ReactCurrentBatchConfig.transition = null;
-      setCurrentUpdatePriority(priority);
-      return flushPassiveEffectsImpl();
-    } finally {
-      setCurrentUpdatePriority(previousPriority);
-      ReactCurrentBatchConfig.transition = prevTransition; // Once passive effects have run for the tree - giving components a
-      // chance to retain cache instances they use - release the pooled
-      // cache at the root (if there is one)
+    case "dd":
+    case "dt":
+      return ancestorInfo.dlItemTagAutoclosing;
 
-      releaseRootPooledCache(root, remainingLanes);
-    }
-  }
+    case "button":
+      return ancestorInfo.buttonTagInScope;
 
-  return false;
-}
-function enqueuePendingPassiveProfilerEffect(fiber) {
-  {
-    pendingPassiveProfilerEffects.push(fiber);
+    case "a":
+      // Spec says something about storing a list of markers, but it sounds
+      // equivalent to this check.
+      return ancestorInfo.aTagInScope;
 
-    if (!rootDoesHavePassiveEffects) {
-      rootDoesHavePassiveEffects = true;
-      scheduleCallback(NormalPriority$1, function () {
-        flushPassiveEffects();
-        return null;
-      });
-    }
+    case "nobr":
+      return ancestorInfo.nobrTagInScope;
   }
+
+  return null;
 }
 
-function flushPassiveEffectsImpl() {
-  if (rootWithPendingPassiveEffects === null) {
-    return false;
-  } // Cache and clear the transitions flag
+var didWarn = {};
 
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects;
-  var lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
-  // Figure out why and fix it. It's not causing any known issues (probably
-  // because it's only used for profiling), but it's a refactor hazard.
+function validateDOMNesting(childTag, childText, ancestorInfo) {
+  {
+    ancestorInfo = ancestorInfo || emptyAncestorInfoDev;
+    var parentInfo = ancestorInfo.current;
+    var parentTag = parentInfo && parentInfo.tag;
 
-  pendingPassiveEffectsLanes = NoLanes;
+    if (childText != null) {
+      if (childTag != null) {
+        error(
+          "validateDOMNesting: when childText is passed, childTag should be null"
+        );
+      }
 
-  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
-    throw new Error("Cannot flush passive effects while already rendering.");
-  }
+      childTag = "#text";
+    } else if (childTag == null) {
+      error("validateDOMNesting: when childText or childTag must be provided");
 
-  {
-    isFlushingPassiveEffects = true;
-    didScheduleUpdateDuringPassiveEffects = false;
+      return;
+    }
 
-    if (enableDebugTracing) {
-      logPassiveEffectsStarted(lanes);
+    var invalidParent = isTagValidWithParent(childTag, parentTag)
+      ? null
+      : parentInfo;
+    var invalidAncestor = invalidParent
+      ? null
+      : findInvalidAncestorForTag(childTag, ancestorInfo);
+    var invalidParentOrAncestor = invalidParent || invalidAncestor;
+
+    if (!invalidParentOrAncestor) {
+      return;
     }
-  }
 
-  if (enableSchedulingProfiler) {
-    markPassiveEffectsStarted(lanes);
-  }
+    var ancestorTag = invalidParentOrAncestor.tag;
+    var warnKey = String(!!invalidParent) + "|" + childTag + "|" + ancestorTag; // eslint-disable-next-line react-internal/safe-string-coercion
 
-  var prevExecutionContext = executionContext;
-  executionContext |= CommitContext;
-  commitPassiveUnmountEffects(root.current);
-  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
+    if (didWarn[warnKey]) {
+      return;
+    }
 
-  {
-    var profilerEffects = pendingPassiveProfilerEffects;
-    pendingPassiveProfilerEffects = [];
+    didWarn[warnKey] = true;
+    var tagDisplayName = childTag;
+    var whitespaceInfo = "";
 
-    for (var i = 0; i < profilerEffects.length; i++) {
-      var fiber = profilerEffects[i];
-      commitPassiveEffectDurations(root, fiber);
+    if (childTag === "#text") {
+      if (childText != null && /\S/.test(childText)) {
+        tagDisplayName = "Text nodes";
+      } else {
+        tagDisplayName = "Whitespace text nodes";
+        whitespaceInfo =
+          " Make sure you don't have any extra whitespace between tags on " +
+          "each line of your source code.";
+      }
+    } else {
+      tagDisplayName = "<" + childTag + ">";
     }
-  }
 
-  {
-    if (enableDebugTracing) {
-      logPassiveEffectsStopped();
+    if (invalidParent) {
+      var info = "";
+
+      if (ancestorTag === "table" && childTag === "tr") {
+        info +=
+          " Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by " +
+          "the browser.";
+      }
+
+      error(
+        "validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s",
+        tagDisplayName,
+        ancestorTag,
+        whitespaceInfo,
+        info
+      );
+    } else {
+      error(
+        "validateDOMNesting(...): %s cannot appear as a descendant of " +
+          "<%s>.",
+        tagDisplayName,
+        ancestorTag
+      );
     }
   }
+}
 
-  if (enableSchedulingProfiler) {
-    markPassiveEffectsStopped();
-  }
+var ReactDOMSharedInternals = Internals;
 
+function validateLinkPropsForStyleResource(props) {
   {
-    commitDoubleInvokeEffectsInDEV(root, true);
-  }
-
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
+    // This should only be called when we know we are opting into Resource semantics (i.e. precedence is not null)
+    var href = props.href,
+      onLoad = props.onLoad,
+      onError = props.onError,
+      disabled = props.disabled;
+    var includedProps = [];
+    if (onLoad) includedProps.push("`onLoad`");
+    if (onError) includedProps.push("`onError`");
+    if (disabled != null) includedProps.push("`disabled`");
+    var includedPropsPhrase = propNamesListJoin(includedProps, "and");
+    includedPropsPhrase += includedProps.length === 1 ? " prop" : " props";
+    var withArticlePhrase =
+      includedProps.length === 1
+        ? "an " + includedPropsPhrase
+        : "the " + includedPropsPhrase;
 
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    var prevEndTime = currentEndTime;
+    if (includedProps.length) {
+      error(
+        'React encountered a <link rel="stylesheet" href="%s" ... /> with a `precedence` prop that' +
+          " also included %s. The presence of loading and error handlers indicates an intent to manage" +
+          " the stylesheet loading state from your from your Component code and React will not hoist or" +
+          " deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet" +
+          " using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.",
+        href,
+        withArticlePhrase,
+        includedPropsPhrase
+      );
 
-    if (
-      prevPendingTransitionCallbacks !== null &&
-      prevRootTransitionCallbacks !== null &&
-      prevEndTime !== null
-    ) {
-      currentPendingTransitionCallbacks = null;
-      currentEndTime = null;
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
-        );
-      });
+      return true;
     }
   }
 
-  {
-    // If additional passive effects were scheduled, increment a counter. If this
-    // exceeds the limit, we'll fire a warning.
-    if (didScheduleUpdateDuringPassiveEffects) {
-      if (root === rootWithPassiveNestedUpdates) {
-        nestedPassiveUpdateCount++;
-      } else {
-        nestedPassiveUpdateCount = 0;
-        rootWithPassiveNestedUpdates = root;
-      }
-    } else {
-      nestedPassiveUpdateCount = 0;
-    }
-
-    isFlushingPassiveEffects = false;
-    didScheduleUpdateDuringPassiveEffects = false;
-  } // TODO: Move to commitPassiveMountEffects
+  return false;
+}
 
-  onPostCommitRoot(root);
+function propNamesListJoin(list, combinator) {
+  switch (list.length) {
+    case 0:
+      return "";
 
-  {
-    var stateNode = root.current.stateNode;
-    stateNode.effectDuration = 0;
-    stateNode.passiveEffectDuration = 0;
-  }
+    case 1:
+      return list[0];
 
-  return true;
-}
+    case 2:
+      return list[0] + " " + combinator + " " + list[1];
 
-function isAlreadyFailedLegacyErrorBoundary(instance) {
-  return (
-    legacyErrorBoundariesThatAlreadyFailed !== null &&
-    legacyErrorBoundariesThatAlreadyFailed.has(instance)
-  );
-}
-function markLegacyErrorBoundaryAsFailed(instance) {
-  if (legacyErrorBoundariesThatAlreadyFailed === null) {
-    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
-  } else {
-    legacyErrorBoundariesThatAlreadyFailed.add(instance);
+    default:
+      return (
+        list.slice(0, -1).join(", ") +
+        ", " +
+        combinator +
+        " " +
+        list[list.length - 1]
+      );
   }
 }
 
-function prepareToThrowUncaughtError(error) {
-  if (!hasUncaughtError) {
-    hasUncaughtError = true;
-    firstUncaughtError = error;
-  }
-}
+function validatePreloadArguments(href, options) {
+  {
+    if (!href || typeof href !== "string") {
+      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
 
-var onUncaughtError = prepareToThrowUncaughtError;
+      error(
+        "ReactDOM.preload() expected the first argument to be a string representing an href but found %s instead.",
+        typeOfArg
+      );
+    } else if (typeof options !== "object" || options === null) {
+      var _typeOfArg = getValueDescriptorExpectingObjectForWarning(options);
 
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  var errorInfo = createCapturedValueAtFiber(error, sourceFiber);
-  var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
-  var root = enqueueUpdate(rootFiber, update, SyncLane);
-  var eventTime = requestEventTime();
+      error(
+        'ReactDOM.preload() expected the second argument to be an options argument containing at least an "as" property' +
+          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
+        _typeOfArg,
+        href
+      );
+    } else {
+      var as = options.as;
 
-  if (root !== null) {
-    markRootUpdated(root, SyncLane, eventTime);
-    ensureRootIsScheduled(root, eventTime);
-  }
-}
+      switch (as) {
+        // Font specific validation of options
+        case "font": {
+          if (options.crossOrigin === "use-credentials") {
+            error(
+              'ReactDOM.preload() was called with an "as" type of "font" and with a "crossOrigin" option of "use-credentials".' +
+                ' Fonts preloading must use crossOrigin "anonymous" to be functional. Please update your font preload to omit' +
+                ' the crossOrigin option or change it to any other value than "use-credentials" (Browsers default all other values' +
+                ' to anonymous mode). The href for the preload call where this warning originated is "%s"',
+              href
+            );
+          }
 
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
-  {
-    reportUncaughtErrorInDEV(error$1);
-    setIsRunningInsertionEffect(false);
-  }
+          break;
+        }
 
-  if (sourceFiber.tag === HostRoot) {
-    // Error was thrown at the root. There is no parent, so the root
-    // itself should capture it.
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error$1);
-    return;
-  }
+        case "script":
+        case "style": {
+          break;
+        }
+        // We have an invalid as type and need to warn
 
-  var fiber = null;
+        default: {
+          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
 
-  if (skipUnmountedBoundaries) {
-    fiber = nearestMountedAncestor;
-  } else {
-    fiber = sourceFiber.return;
+          error(
+            'ReactDOM.preload() expected a valid "as" type in the options (second) argument but found %s instead.' +
+              " Please use one of the following valid values instead: %s. The href for the preload call where this" +
+              ' warning originated is "%s".',
+            typeOfAs,
+            '"style", "font", or "script"',
+            href
+          );
+        }
+      }
+    }
   }
+}
+function validatePreinitArguments(href, options) {
+  {
+    if (!href || typeof href !== "string") {
+      var typeOfArg = getValueDescriptorExpectingObjectForWarning(href);
 
-  while (fiber !== null) {
-    if (fiber.tag === HostRoot) {
-      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error$1);
-      return;
-    } else if (fiber.tag === ClassComponent) {
-      var ctor = fiber.type;
-      var instance = fiber.stateNode;
+      error(
+        "ReactDOM.preinit() expected the first argument to be a string representing an href but found %s instead.",
+        typeOfArg
+      );
+    } else if (typeof options !== "object" || options === null) {
+      var _typeOfArg2 = getValueDescriptorExpectingObjectForWarning(options);
 
-      if (
-        typeof ctor.getDerivedStateFromError === "function" ||
-        (typeof instance.componentDidCatch === "function" &&
-          !isAlreadyFailedLegacyErrorBoundary(instance))
-      ) {
-        var errorInfo = createCapturedValueAtFiber(error$1, sourceFiber);
-        var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
-        var root = enqueueUpdate(fiber, update, SyncLane);
-        var eventTime = requestEventTime();
+      error(
+        'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
+          ' specifying the Resource type. It found %s instead. The href for the preload call where this warning originated is "%s".',
+        _typeOfArg2,
+        href
+      );
+    } else {
+      var as = options.as;
 
-        if (root !== null) {
-          markRootUpdated(root, SyncLane, eventTime);
-          ensureRootIsScheduled(root, eventTime);
+      switch (as) {
+        case "style":
+        case "script": {
+          break;
         }
+        // We have an invalid as type and need to warn
 
-        return;
+        default: {
+          var typeOfAs = getValueDescriptorExpectingEnumForWarning(as);
+
+          error(
+            'ReactDOM.preinit() expected the second argument to be an options argument containing at least an "as" property' +
+              ' specifying the Resource type. It found %s instead. Currently, valid resource types for for preinit are "style"' +
+              ' and "script". The href for the preinit call where this warning originated is "%s".',
+            typeOfAs,
+            href
+          );
+        }
       }
     }
-
-    fiber = fiber.return;
   }
+}
+function getValueDescriptorExpectingObjectForWarning(thing) {
+  return thing === null
+    ? "`null`"
+    : thing === undefined
+    ? "`undefined`"
+    : thing === ""
+    ? "an empty string"
+    : 'something with type "' + typeof thing + '"';
+}
+function getValueDescriptorExpectingEnumForWarning(thing) {
+  return thing === null
+    ? "`null`"
+    : thing === undefined
+    ? "`undefined`"
+    : thing === ""
+    ? "an empty string"
+    : typeof thing === "string"
+    ? JSON.stringify(thing)
+    : 'something with type "' + typeof thing + '"';
+}
 
-  {
-    // TODO: Until we re-land skipUnmountedBoundaries (see #20147), this warning
-    // will fire for errors that are thrown by destroy functions inside deleted
-    // trees. What it should instead do is propagate the error to the parent of
-    // the deleted tree. In the meantime, do not add this warning to the
-    // allowlist; this is only for our internal use.
-    error(
-      "Internal React error: Attempted to capture a commit phase error " +
-        "inside a detached tree. This indicates a bug in React. Likely " +
-        "causes include deleting the same fiber more than once, committing an " +
-        "already-finished tree, or an inconsistent return pointer.\n\n" +
-        "Error message:\n\n%s",
-      error$1
-    );
-  }
+var Dispatcher$1 = ReactDOMSharedInternals.Dispatcher;
+// In the future this may need to change, especially when modules / scripts are supported
+// It is valid to preload even when we aren't actively rendering. For cases where Float functions are
+// called when there is no rendering we track the last used document. It is not safe to insert
+// arbitrary resources into the lastCurrentDocument b/c it may not actually be the document
+// that the resource is meant to apply too (for example stylesheets or scripts). This is only
+// appropriate for resources that don't really have a strict tie to the document itself for example
+// preloads
+
+var lastCurrentDocument = null;
+var previousDispatcher = null;
+function prepareToRenderResources(rootContainer) {
+  var rootNode = getHoistableRoot(rootContainer);
+  lastCurrentDocument = getDocumentFromRoot(rootNode);
+  previousDispatcher = Dispatcher$1.current;
+  Dispatcher$1.current = ReactDOMClientDispatcher;
 }
-function attachPingListener(root, wakeable, lanes) {
-  // Attach a ping listener
-  //
-  // The data might resolve before we have a chance to commit the fallback. Or,
-  // in the case of a refresh, we'll never commit a fallback. So we need to
-  // attach a listener now. When it resolves ("pings"), we can decide whether to
-  // try rendering the tree again.
-  //
-  // Only attach a listener if one does not already exist for the lanes
-  // we're currently rendering (which acts like a "thread ID" here).
-  //
-  // We only need to do this in concurrent mode. Legacy Suspense always
-  // commits fallbacks synchronously, so there are no pings.
-  var pingCache = root.pingCache;
-  var threadIDs;
+function cleanupAfterRenderResources() {
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+}
+function prepareToCommitHoistables() {
+  tagCaches = null;
+} // We want this to be the default dispatcher on ReactDOMSharedInternals but we don't want to mutate
+// internals in Module scope. Instead we export it and Internals will import it. There is already a cycle
+// from Internals -> ReactDOM -> FloatClient -> Internals so this doesn't introduce a new one.
 
-  if (pingCache === null) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else {
-    threadIDs = pingCache.get(wakeable);
+var ReactDOMClientDispatcher = {
+  prefetchDNS: prefetchDNS$1,
+  preconnect: preconnect$1,
+  preload: preload$1,
+  preinit: preinit$1
+}; // global collections of Resources
+
+var preloadPropsMap = new Map();
+var preconnectsSet = new Set(); // getRootNode is missing from IE and old jsdom versions
+
+function getHoistableRoot(container) {
+  // $FlowFixMe[method-unbinding]
+  return typeof container.getRootNode === "function"
+    ? /* $FlowFixMe[incompatible-return] Flow types this as returning a `Node`,
+       * but it's either a `Document` or `ShadowRoot`. */
+      container.getRootNode()
+    : container.ownerDocument;
+}
+
+function getCurrentResourceRoot() {
+  var currentContainer = getCurrentRootHostContainer();
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+} // Preloads are somewhat special. Even if we don't have the Document
+// used by the root that is rendering a component trying to insert a preload
+// we can still seed the file cache by doing the preload on any document we have
+// access to. We prefer the currentDocument if it exists, we also prefer the
+// lastCurrentDocument if that exists. As a fallback we will use the window.document
+// if available.
+
+function getDocumentForPreloads() {
+  var root = getCurrentResourceRoot();
 
-    if (threadIDs === undefined) {
-      threadIDs = new Set();
-      pingCache.set(wakeable, threadIDs);
+  if (root) {
+    return root.ownerDocument || root;
+  } else {
+    try {
+      return lastCurrentDocument || window.document;
+    } catch (error) {
+      return null;
     }
   }
+}
 
-  if (!threadIDs.has(lanes)) {
-    workInProgressRootDidAttachPingListener = true; // Memoize using the thread ID to prevent redundant listeners.
+function getDocumentFromRoot(root) {
+  return root.ownerDocument || root;
+}
 
-    threadIDs.add(lanes);
-    var ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);
+function preconnectAs(rel, crossOrigin, href) {
+  var ownerDocument = getDocumentForPreloads();
 
-    {
-      if (isDevToolsPresent) {
-        // If we have pending work still, restore the original updaters
-        restorePendingUpdaters(root, lanes);
-      }
-    }
+  if (typeof href === "string" && href && ownerDocument) {
+    var limitedEscapedHref =
+      escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    var key = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
 
-    wakeable.then(ping, ping);
-  }
-}
+    if (typeof crossOrigin === "string") {
+      key += '[crossorigin="' + crossOrigin + '"]';
+    }
 
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
+    if (!preconnectsSet.has(key)) {
+      preconnectsSet.add(key);
+      var preconnectProps = {
+        rel: rel,
+        crossOrigin: crossOrigin,
+        href: href
+      };
 
-  if (pingCache !== null) {
-    // The wakeable resolved, so we no longer need to memoize, because it will
-    // never be thrown again.
-    pingCache.delete(wakeable);
+      if (null === ownerDocument.querySelector(key)) {
+        var preloadInstance = ownerDocument.createElement("link");
+        setInitialProperties(preloadInstance, "link", preconnectProps);
+        markNodeAsHoistable(preloadInstance);
+        ownerDocument.head.appendChild(preloadInstance);
+      }
+    }
   }
+} // --------------------------------------
+//      ReactDOM.prefetchDNS
+// --------------------------------------
 
-  var eventTime = requestEventTime();
-  markRootPinged(root, pingedLanes);
-  warnIfSuspenseResolutionNotWrappedWithActDEV(root);
-
-  if (
-    workInProgressRoot === root &&
-    isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)
-  ) {
-    // Received a ping at the same priority level at which we're currently
-    // rendering. We might want to restart this render. This should mirror
-    // the logic of whether or not a root suspends once it completes.
-    // TODO: If we're rendering sync either due to Sync, Batched or expired,
-    // we should probably never restart.
-    // If we're suspended with delay, or if it's a retry, we'll always suspend
-    // so we can always restart.
-    if (
-      workInProgressRootExitStatus === RootSuspendedWithDelay ||
-      (workInProgressRootExitStatus === RootSuspended &&
-        includesOnlyRetries(workInProgressRootRenderLanes) &&
-        now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
-    ) {
-      // Force a restart from the root by unwinding the stack. Unless this is
-      // being called from the render phase, because that would cause a crash.
-      if ((executionContext & RenderContext) === NoContext) {
-        prepareFreshStack(root, NoLanes);
-      }
-    } else {
-      // Even though we can't restart right now, we might get an
-      // opportunity later. So we mark this render as having a ping.
-      workInProgressRootPingedLanes = mergeLanes(
-        workInProgressRootPingedLanes,
-        pingedLanes
+function prefetchDNS$1(href, options) {
+  {
+    if (typeof href !== "string" || !href) {
+      error(
+        "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        getValueDescriptorExpectingObjectForWarning(href)
       );
+    } else if (options != null) {
+      if (
+        typeof options === "object" &&
+        hasOwnProperty.call(options, "crossOrigin")
+      ) {
+        error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        );
+      } else {
+        error(
+          "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        );
+      }
     }
   }
 
-  ensureRootIsScheduled(root, eventTime);
-}
+  preconnectAs("dns-prefetch", null, href);
+} // --------------------------------------
+//      ReactDOM.preconnect
+// --------------------------------------
 
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  // The boundary fiber (a Suspense component or SuspenseList component)
-  // previously was rendered in its fallback state. One of the promises that
-  // suspended it has resolved, which means at least part of the tree was
-  // likely unblocked. Try rendering again, at a new lanes.
-  if (retryLane === NoLane) {
-    // TODO: Assign this to `suspenseState.retryLane`? to avoid
-    // unnecessary entanglement?
-    retryLane = requestRetryLane(boundaryFiber);
-  } // TODO: Special case idle priority?
+function preconnect$1(href, options) {
+  {
+    if (typeof href !== "string" || !href) {
+      error(
+        "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+        getValueDescriptorExpectingObjectForWarning(href)
+      );
+    } else if (options != null && typeof options !== "object") {
+      error(
+        "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
+        getValueDescriptorExpectingEnumForWarning(options)
+      );
+    } else if (options != null && typeof options.crossOrigin !== "string") {
+      error(
+        "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
+        getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
+      );
+    }
+  }
 
-  var eventTime = requestEventTime();
-  var root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+  var crossOrigin =
+    options == null || typeof options.crossOrigin !== "string"
+      ? null
+      : options.crossOrigin === "use-credentials"
+      ? "use-credentials"
+      : "";
+  preconnectAs("preconnect", crossOrigin, href);
+} // --------------------------------------
+//      ReactDOM.preload
+// --------------------------------------
 
-  if (root !== null) {
-    markRootUpdated(root, retryLane, eventTime);
-    ensureRootIsScheduled(root, eventTime);
+function preload$1(href, options) {
+  {
+    validatePreloadArguments(href, options);
   }
-}
 
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState;
-  var retryLane = NoLane;
+  var ownerDocument = getDocumentForPreloads();
 
-  if (suspenseState !== null) {
-    retryLane = suspenseState.retryLane;
-  }
+  if (
+    typeof href === "string" &&
+    href &&
+    typeof options === "object" &&
+    options !== null &&
+    ownerDocument
+  ) {
+    var as = options.as;
+    var limitedEscapedHref =
+      escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    var preloadKey =
+      'link[rel="preload"][as="' + as + '"][href="' + limitedEscapedHref + '"]';
+    var key = preloadKey;
 
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-}
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = NoLane; // Default
+    switch (as) {
+      case "style":
+        key = getStyleKey(href);
+        break;
 
-  var retryCache;
+      case "script":
+        key = getScriptKey(href);
+        break;
+    }
 
-  switch (boundaryFiber.tag) {
-    case SuspenseComponent:
-      retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
+    if (!preloadPropsMap.has(key)) {
+      var preloadProps = preloadPropsFromPreloadOptions(href, as, options);
+      preloadPropsMap.set(key, preloadProps);
 
-      if (suspenseState !== null) {
-        retryLane = suspenseState.retryLane;
+      if (null === ownerDocument.querySelector(preloadKey)) {
+        var preloadInstance = ownerDocument.createElement("link");
+        setInitialProperties(preloadInstance, "link", preloadProps);
+        markNodeAsHoistable(preloadInstance);
+        ownerDocument.head.appendChild(preloadInstance);
       }
+    }
+  }
+}
 
-      break;
+function preloadPropsFromPreloadOptions(href, as, options) {
+  return {
+    href: href,
+    rel: "preload",
+    as: as,
+    crossOrigin: as === "font" ? "" : options.crossOrigin,
+    integrity: options.integrity,
+    type: options.type
+  };
+} // --------------------------------------
+//      ReactDOM.preinit
+// --------------------------------------
 
-    case SuspenseListComponent:
-      retryCache = boundaryFiber.stateNode;
-      break;
+function preinit$1(href, options) {
+  {
+    validatePreinitArguments(href, options);
+  }
 
-    case OffscreenComponent: {
-      var instance = boundaryFiber.stateNode;
-      retryCache = instance._retryCache;
-      break;
-    }
+  if (
+    typeof href === "string" &&
+    href &&
+    typeof options === "object" &&
+    options !== null
+  ) {
+    var resourceRoot = getCurrentResourceRoot();
+    var as = options.as;
 
-    default:
-      throw new Error(
-        "Pinged unknown suspense boundary type. " +
-          "This is probably a bug in React."
-      );
-  }
+    if (!resourceRoot) {
+      if (as === "style" || as === "script") {
+        // We are going to emit a preload as a best effort fallback since this preinit
+        // was called outside of a render. Given the passive nature of this fallback
+        // we do not warn in dev when props disagree if there happens to already be a
+        // matching preload with this href
+        var preloadDocument = getDocumentForPreloads();
 
-  if (retryCache !== null) {
-    // The wakeable resolved, so we no longer need to memoize, because it will
-    // never be thrown again.
-    retryCache.delete(wakeable);
-  }
+        if (preloadDocument) {
+          var limitedEscapedHref =
+            escapeSelectorAttributeValueInsideDoubleQuotes(href);
+          var preloadKey =
+            'link[rel="preload"][as="' +
+            as +
+            '"][href="' +
+            limitedEscapedHref +
+            '"]';
+          var key = preloadKey;
 
-  retryTimedOutBoundary(boundaryFiber, retryLane);
-} // Computes the next Just Noticeable Difference (JND) boundary.
-// The theory is that a person can't tell the difference between small differences in time.
-// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
-// difference in the experience. However, waiting for longer might mean that we can avoid
-// showing an intermediate loading state. The longer we have already waited, the harder it
-// is to tell small differences in time. Therefore, the longer we've already waited,
-// the longer we can wait additionally. At some point we have to give up though.
-// We pick a train model where the next boundary commits at a consistent schedule.
-// These particular numbers are vague estimates. We expect to adjust them based on research.
+          switch (as) {
+            case "style":
+              key = getStyleKey(href);
+              break;
 
-function jnd(timeElapsed) {
-  return timeElapsed < 120
-    ? 120
-    : timeElapsed < 480
-    ? 480
-    : timeElapsed < 1080
-    ? 1080
-    : timeElapsed < 1920
-    ? 1920
-    : timeElapsed < 3000
-    ? 3000
-    : timeElapsed < 4320
-    ? 4320
-    : ceil(timeElapsed / 1960) * 1960;
-}
+            case "script":
+              key = getScriptKey(href);
+              break;
+          }
 
-function throwIfInfiniteUpdateLoopDetected() {
-  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
-    nestedUpdateCount = 0;
-    nestedPassiveUpdateCount = 0;
-    rootWithNestedUpdates = null;
-    rootWithPassiveNestedUpdates = null;
-    throw new Error(
-      "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."
-    );
-  }
+          if (!preloadPropsMap.has(key)) {
+            var preloadProps = preloadPropsFromPreinitOptions(
+              href,
+              as,
+              options
+            );
+            preloadPropsMap.set(key, preloadProps);
 
-  {
-    if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
-      nestedPassiveUpdateCount = 0;
-      rootWithPassiveNestedUpdates = null;
+            if (null === preloadDocument.querySelector(preloadKey)) {
+              var preloadInstance = preloadDocument.createElement("link");
+              setInitialProperties(preloadInstance, "link", preloadProps);
+              markNodeAsHoistable(preloadInstance);
+              preloadDocument.head.appendChild(preloadInstance);
+            }
+          }
+        }
+      }
 
-      error(
-        "Maximum update depth exceeded. This can happen when a component " +
-          "calls setState inside useEffect, but useEffect either doesn't " +
-          "have a dependency array, or one of the dependencies changes on " +
-          "every render."
-      );
+      return;
     }
-  }
-}
 
-function flushRenderPhaseStrictModeWarningsInDEV() {
-  {
-    ReactStrictModeWarnings.flushLegacyContextWarning();
-    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
-  }
-}
+    switch (as) {
+      case "style": {
+        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
 
-function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
-  {
-    {
-      legacyCommitDoubleInvokeEffectsInDEV(root.current, hasPassiveEffects);
-    }
-  }
-}
+        var _key = getStyleKey(href);
 
-function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
-  // TODO (StrictEffects) Should we set a marker on the root if it contains strict effects
-  // so we don't traverse unnecessarily? similar to subtreeFlags but just at the root level.
-  // Maybe not a big deal since this is DEV only behavior.
-  setCurrentFiber(fiber);
-  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectUnmountInDEV);
+        var precedence = options.precedence || "default"; // Check if this resource already exists
 
-  if (hasPassiveEffects) {
-    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectUnmountInDEV);
-  }
+        var resource = styles.get(_key);
 
-  invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectMountInDEV);
+        if (resource) {
+          // We can early return. The resource exists and there is nothing
+          // more to do
+          return;
+        } // Attempt to hydrate instance from DOM
 
-  if (hasPassiveEffects) {
-    invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectMountInDEV);
-  }
+        var instance = resourceRoot.querySelector(
+          getStylesheetSelectorFromKey(_key)
+        );
 
-  resetCurrentFiber();
-}
+        if (!instance) {
+          // Construct a new instance and insert it
+          var stylesheetProps = stylesheetPropsFromPreinitOptions(
+            href,
+            precedence,
+            options
+          );
 
-function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
-  var current = firstChild;
-  var subtreeRoot = null;
+          var _preloadProps = preloadPropsMap.get(_key);
 
-  while (current != null) {
-    var primarySubtreeFlag = current.subtreeFlags & fiberFlags;
+          if (_preloadProps) {
+            adoptPreloadPropsForStylesheet(stylesheetProps, _preloadProps);
+          }
 
-    if (
-      current !== subtreeRoot &&
-      current.child != null &&
-      primarySubtreeFlag !== NoFlags$1
-    ) {
-      current = current.child;
-    } else {
-      if ((current.flags & fiberFlags) !== NoFlags$1) {
-        invokeEffectFn(current);
-      }
+          var ownerDocument = getDocumentFromRoot(resourceRoot);
+          instance = ownerDocument.createElement("link");
+          markNodeAsHoistable(instance);
+          setInitialProperties(instance, "link", stylesheetProps);
+          insertStylesheet(instance, precedence, resourceRoot);
+        } // Construct a Resource and cache it
 
-      if (current.sibling !== null) {
-        current = current.sibling;
-      } else {
-        current = subtreeRoot = current.return;
+        resource = {
+          type: "stylesheet",
+          instance: instance,
+          count: 1
+        };
+        styles.set(_key, resource);
+        return;
       }
-    }
-  }
-}
 
-var didWarnStateUpdateForNotYetMountedComponent = null;
-function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
-  {
-    if ((executionContext & RenderContext) !== NoContext) {
-      // We let the other warning about render phase updates deal with this one.
-      return;
-    }
+      case "script": {
+        var src = href;
+        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
 
-    if (!(fiber.mode & ConcurrentMode)) {
-      return;
-    }
+        var _key2 = getScriptKey(src); // Check if this resource already exists
 
-    var tag = fiber.tag;
+        var _resource = scripts.get(_key2);
 
-    if (
-      tag !== IndeterminateComponent &&
-      tag !== HostRoot &&
-      tag !== ClassComponent &&
-      tag !== FunctionComponent &&
-      tag !== ForwardRef &&
-      tag !== MemoComponent &&
-      tag !== SimpleMemoComponent
-    ) {
-      // Only warn for user-defined components, not internal ones like Suspense.
-      return;
-    } // We show the whole stack but dedupe on the top component's name because
-    // the problematic code almost always lies inside that component.
+        if (_resource) {
+          // We can early return. The resource exists and there is nothing
+          // more to do
+          return;
+        } // Attempt to hydrate instance from DOM
 
-    var componentName = getComponentNameFromFiber(fiber) || "ReactComponent";
+        var _instance = resourceRoot.querySelector(
+          getScriptSelectorFromKey(_key2)
+        );
 
-    if (didWarnStateUpdateForNotYetMountedComponent !== null) {
-      if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
-        return;
-      } // $FlowFixMe[incompatible-use] found when upgrading Flow
+        if (!_instance) {
+          // Construct a new instance and insert it
+          var scriptProps = scriptPropsFromPreinitOptions(src, options); // Adopt certain preload props
 
-      didWarnStateUpdateForNotYetMountedComponent.add(componentName);
-    } else {
-      didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
-    }
+          var _preloadProps2 = preloadPropsMap.get(_key2);
 
-    var previousFiber = current;
+          if (_preloadProps2) {
+            adoptPreloadPropsForScript(scriptProps, _preloadProps2);
+          }
 
-    try {
-      setCurrentFiber(fiber);
+          var _ownerDocument = getDocumentFromRoot(resourceRoot);
 
-      error(
-        "Can't perform a React state update on a component that hasn't mounted yet. " +
-          "This indicates that you have a side-effect in your render function that " +
-          "asynchronously later calls tries to update the component. Move this work to " +
-          "useEffect instead."
-      );
-    } finally {
-      if (previousFiber) {
-        setCurrentFiber(fiber);
-      } else {
-        resetCurrentFiber();
+          _instance = _ownerDocument.createElement("script");
+          markNodeAsHoistable(_instance);
+          setInitialProperties(_instance, "link", scriptProps);
+
+          _ownerDocument.head.appendChild(_instance);
+        } // Construct a Resource and cache it
+
+        _resource = {
+          type: "script",
+          instance: _instance,
+          count: 1
+        };
+        scripts.set(_key2, _resource);
+        return;
       }
     }
   }
 }
-var beginWork;
-
-if (replayFailedUnitOfWorkWithInvokeGuardedCallback) {
-  var dummyFiber = null;
 
-  beginWork = function (current, unitOfWork, lanes) {
-    // If a component throws an error, we replay it again in a synchronously
-    // dispatched event, so that the debugger will treat it as an uncaught
-    // error See ReactErrorUtils for more information.
-    // Before entering the begin phase, copy the work-in-progress onto a dummy
-    // fiber. If beginWork throws, we'll use this to reset the state.
-    var originalWorkInProgressCopy = assignFiberPropertiesInDEV(
-      dummyFiber,
-      unitOfWork
-    );
+function preloadPropsFromPreinitOptions(href, as, options) {
+  return {
+    href: href,
+    rel: "preload",
+    as: as,
+    crossOrigin: as === "font" ? "" : options.crossOrigin,
+    integrity: options.integrity
+  };
+}
 
-    try {
-      return beginWork$1(current, unitOfWork, lanes);
-    } catch (originalError) {
-      if (
-        didSuspendOrErrorWhileHydratingDEV() ||
-        originalError === SuspenseException ||
-        originalError === SelectiveHydrationException ||
-        (originalError !== null &&
-          typeof originalError === "object" &&
-          typeof originalError.then === "function")
-      ) {
-        // Don't replay promises.
-        // Don't replay errors if we are hydrating and have already suspended or handled an error
-        throw originalError;
-      } // Don't reset current debug fiber, since we're about to work on the
-      // same fiber again.
-      // Unwind the failed stack frame
+function stylesheetPropsFromPreinitOptions(href, precedence, options) {
+  return {
+    rel: "stylesheet",
+    href: href,
+    "data-precedence": precedence,
+    crossOrigin: options.crossOrigin
+  };
+}
 
-      resetSuspendedWorkLoopOnUnwind();
-      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
+function scriptPropsFromPreinitOptions(src, options) {
+  return {
+    src: src,
+    async: true,
+    crossOrigin: options.crossOrigin,
+    integrity: options.integrity
+  };
+} // --------------------------------------
+//      Resources from render
+// --------------------------------------
+// This function is called in begin work and we should always have a currentDocument set
 
-      assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
+function getResource(type, currentProps, pendingProps) {
+  var resourceRoot = getCurrentResourceRoot();
 
-      if (unitOfWork.mode & ProfileMode) {
-        // Reset the profiler timer.
-        startProfilerTimer(unitOfWork);
-      } // Run beginWork again.
+  if (!resourceRoot) {
+    throw new Error(
+      '"resourceRoot" was expected to exist. This is a bug in React.'
+    );
+  }
 
-      invokeGuardedCallback(
-        null,
-        beginWork$1,
-        null,
-        current,
-        unitOfWork,
-        lanes
-      );
+  switch (type) {
+    case "meta":
+    case "title": {
+      return null;
+    }
 
-      if (hasCaughtError()) {
-        var replayError = clearCaughtError();
+    case "style": {
+      if (
+        typeof pendingProps.precedence === "string" &&
+        typeof pendingProps.href === "string"
+      ) {
+        var key = getStyleKey(pendingProps.href);
+        var styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
+        var resource = styles.get(key);
 
-        if (
-          typeof replayError === "object" &&
-          replayError !== null &&
-          replayError._suppressLogging &&
-          typeof originalError === "object" &&
-          originalError !== null &&
-          !originalError._suppressLogging
-        ) {
-          // If suppressed, let the flag carry over to the original error which is the one we'll rethrow.
-          originalError._suppressLogging = true;
+        if (!resource) {
+          resource = {
+            type: "style",
+            instance: null,
+            count: 0
+          };
+          styles.set(key, resource);
         }
-      } // We always throw the original error in case the second render pass is not idempotent.
-      // This can happen if a memoized function or CommonJS module doesn't throw after first invocation.
 
-      throw originalError;
+        return resource;
+      }
+
+      return {
+        type: "void",
+        instance: null,
+        count: 0
+      };
     }
-  };
-} else {
-  beginWork = beginWork$1;
-}
 
-var didWarnAboutUpdateInRender = false;
-var didWarnAboutUpdateInRenderForAnotherComponent;
+    case "link": {
+      if (
+        pendingProps.rel === "stylesheet" &&
+        typeof pendingProps.href === "string" &&
+        typeof pendingProps.precedence === "string"
+      ) {
+        var qualifiedProps = pendingProps;
 
-{
-  didWarnAboutUpdateInRenderForAnotherComponent = new Set();
-}
+        var _key3 = getStyleKey(qualifiedProps.href);
 
-function warnAboutRenderPhaseUpdatesInDEV(fiber) {
-  {
-    if (isRendering) {
-      switch (fiber.tag) {
-        case FunctionComponent:
-        case ForwardRef:
-        case SimpleMemoComponent: {
-          var renderingComponentName =
-            (workInProgress && getComponentNameFromFiber(workInProgress)) ||
-            "Unknown"; // Dedupe by the rendering component because it's the one that needs to be fixed.
+        var _styles = getResourcesFromRoot(resourceRoot).hoistableStyles;
 
-          var dedupeKey = renderingComponentName;
+        var _resource2 = _styles.get(_key3);
 
-          if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
-            didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
-            var setStateComponentName =
-              getComponentNameFromFiber(fiber) || "Unknown";
+        if (!_resource2) {
+          // We asserted this above but Flow can't figure out that the type satisfies
+          var ownerDocument = getDocumentFromRoot(resourceRoot);
+          _resource2 = {
+            type: "stylesheet",
+            instance: null,
+            count: 0
+          };
 
-            error(
-              "Cannot update a component (`%s`) while rendering a " +
-                "different component (`%s`). To locate the bad setState() call inside `%s`, " +
-                "follow the stack trace as described in https://reactjs.org/link/setstate-in-render",
-              setStateComponentName,
-              renderingComponentName,
-              renderingComponentName
+          _styles.set(_key3, _resource2);
+
+          if (!preloadPropsMap.has(_key3)) {
+            preloadStylesheet(
+              ownerDocument,
+              _key3,
+              preloadPropsFromStylesheet(qualifiedProps)
             );
           }
-
-          break;
         }
 
-        case ClassComponent: {
-          if (!didWarnAboutUpdateInRender) {
-            error(
-              "Cannot update during an existing state transition (such as " +
-                "within `render`). Render methods should be a pure " +
-                "function of props and state."
-            );
+        return _resource2;
+      }
 
-            didWarnAboutUpdateInRender = true;
-          }
+      return null;
+    }
 
-          break;
+    case "script": {
+      if (typeof pendingProps.src === "string" && pendingProps.async === true) {
+        var scriptProps = pendingProps;
+
+        var _key4 = getScriptKey(scriptProps.src);
+
+        var scripts = getResourcesFromRoot(resourceRoot).hoistableScripts;
+
+        var _resource3 = scripts.get(_key4);
+
+        if (!_resource3) {
+          _resource3 = {
+            type: "script",
+            instance: null,
+            count: 0
+          };
+          scripts.set(_key4, _resource3);
         }
+
+        return _resource3;
       }
-    }
-  }
-}
 
-function restorePendingUpdaters(root, lanes) {
-  {
-    if (isDevToolsPresent) {
-      var memoizedUpdaters = root.memoizedUpdaters;
-      memoizedUpdaters.forEach(function (schedulingFiber) {
-        addFiberToLanesMap(root, schedulingFiber, lanes);
-      }); // This function intentionally does not clear memoized updaters.
-      // Those may still be relevant to the current commit
-      // and a future one (e.g. Suspense).
+      return {
+        type: "void",
+        instance: null,
+        count: 0
+      };
     }
-  }
-}
-var fakeActCallbackNode = {}; // $FlowFixMe[missing-local-annot]
-
-function scheduleCallback(priorityLevel, callback) {
-  {
-    // If we're currently inside an `act` scope, bypass Scheduler and push to
-    // the `act` queue instead.
-    var actQueue = ReactCurrentActQueue.current;
 
-    if (actQueue !== null) {
-      actQueue.push(callback);
-      return fakeActCallbackNode;
-    } else {
-      return scheduleCallback$2(priorityLevel, callback);
+    default: {
+      throw new Error(
+        'getResource encountered a type it did not expect: "' +
+          type +
+          '". this is a bug in React.'
+      );
     }
   }
 }
 
-function cancelCallback(callbackNode) {
-  if (callbackNode === fakeActCallbackNode) {
-    return;
-  } // In production, always call Scheduler. This function will be stripped out.
-
-  return cancelCallback$1(callbackNode);
+function styleTagPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    "data-href": rawProps.href,
+    "data-precedence": rawProps.precedence,
+    href: null,
+    precedence: null
+  });
 }
 
-function shouldForceFlushFallbacksInDEV() {
-  // Never force flush in production. This function should get stripped out.
-  return ReactCurrentActQueue.current !== null;
+function getStyleKey(href) {
+  var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+  return 'href~="' + limitedEscapedHref + '"';
 }
 
-function warnIfUpdatesNotWrappedWithActDEV(fiber) {
-  {
-    if (fiber.mode & ConcurrentMode) {
-      if (!isConcurrentActEnvironment()) {
-        // Not in an act environment. No need to warn.
-        return;
-      }
-    } else {
-      // Legacy mode has additional cases where we suppress a warning.
-      if (!isLegacyActEnvironment()) {
-        // Not in an act environment. No need to warn.
-        return;
-      }
-
-      if (executionContext !== NoContext) {
-        // Legacy mode doesn't warn if the update is batched, i.e.
-        // batchedUpdates or flushSync.
-        return;
-      }
-
-      if (
-        fiber.tag !== FunctionComponent &&
-        fiber.tag !== ForwardRef &&
-        fiber.tag !== SimpleMemoComponent
-      ) {
-        // For backwards compatibility with pre-hooks code, legacy mode only
-        // warns for updates that originate from a hook.
-        return;
-      }
-    }
+function getStyleTagSelectorFromKey(key) {
+  return "style[data-" + key + "]";
+}
 
-    if (ReactCurrentActQueue.current === null) {
-      var previousFiber = current;
+function getStylesheetSelectorFromKey(key) {
+  return 'link[rel="stylesheet"][' + key + "]";
+}
 
-      try {
-        setCurrentFiber(fiber);
+function getPreloadStylesheetSelectorFromKey(key) {
+  return 'link[rel="preload"][as="style"][' + key + "]";
+}
 
-        error(
-          "An update to %s inside a test was not wrapped in act(...).\n\n" +
-            "When testing, code that causes React state updates should be " +
-            "wrapped into act(...):\n\n" +
-            "act(() => {\n" +
-            "  /* fire events that update state */\n" +
-            "});\n" +
-            "/* assert on the output */\n\n" +
-            "This ensures that you're testing the behavior the user would see " +
-            "in the browser." +
-            " Learn more at https://reactjs.org/link/wrap-tests-with-act",
-          getComponentNameFromFiber(fiber)
-        );
-      } finally {
-        if (previousFiber) {
-          setCurrentFiber(fiber);
-        } else {
-          resetCurrentFiber();
-        }
-      }
-    }
-  }
+function stylesheetPropsFromRawProps(rawProps) {
+  return assign({}, rawProps, {
+    "data-precedence": rawProps.precedence,
+    precedence: null
+  });
 }
 
-function warnIfSuspenseResolutionNotWrappedWithActDEV(root) {
-  {
+function preloadStylesheet(ownerDocument, key, preloadProps) {
+  preloadPropsMap.set(key, preloadProps);
+
+  if (!ownerDocument.querySelector(getStylesheetSelectorFromKey(key))) {
+    // There is no matching stylesheet instance in the Document.
+    // We will insert a preload now to kick off loading because
+    // we expect this stylesheet to commit
     if (
-      root.tag !== LegacyRoot &&
-      isConcurrentActEnvironment() &&
-      ReactCurrentActQueue.current === null
+      null ===
+      ownerDocument.querySelector(getPreloadStylesheetSelectorFromKey(key))
     ) {
-      error(
-        "A suspended resource finished loading inside a test, but the event " +
-          "was not wrapped in act(...).\n\n" +
-          "When testing, code that resolves suspended data should be wrapped " +
-          "into act(...):\n\n" +
-          "act(() => {\n" +
-          "  /* finish loading suspended data */\n" +
-          "});\n" +
-          "/* assert on the output */\n\n" +
-          "This ensures that you're testing the behavior the user would see " +
-          "in the browser." +
-          " Learn more at https://reactjs.org/link/wrap-tests-with-act"
-      );
+      var preloadInstance = ownerDocument.createElement("link");
+      setInitialProperties(preloadInstance, "link", preloadProps);
+      markNodeAsHoistable(preloadInstance);
+      ownerDocument.head.appendChild(preloadInstance);
     }
   }
 }
 
-function setIsRunningInsertionEffect(isRunning) {
-  {
-    isRunningInsertionEffect = isRunning;
-  }
+function preloadPropsFromStylesheet(props) {
+  return {
+    rel: "preload",
+    as: "style",
+    href: props.href,
+    crossOrigin: props.crossOrigin,
+    integrity: props.integrity,
+    media: props.media,
+    hrefLang: props.hrefLang,
+    referrerPolicy: props.referrerPolicy
+  };
 }
 
-/* eslint-disable react-internal/prod-error-codes */
-// Used by React Refresh runtime through DevTools Global Hook.
+function getScriptKey(src) {
+  var limitedEscapedSrc = escapeSelectorAttributeValueInsideDoubleQuotes(src);
+  return '[src="' + limitedEscapedSrc + '"]';
+}
 
-var resolveFamily = null;
-var failedBoundaries = null;
-var setRefreshHandler = function (handler) {
-  {
-    resolveFamily = handler;
-  }
-};
-function resolveFunctionForHotReloading(type) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return type;
-    }
+function getScriptSelectorFromKey(key) {
+  return "script[async]" + key;
+} // --------------------------------------
+//      Hoistable Resource Reconciliation
+// --------------------------------------
 
-    var family = resolveFamily(type);
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
 
-    if (family === undefined) {
-      return type;
-    } // Use the latest known implementation.
+  if (resource.instance === null) {
+    switch (resource.type) {
+      case "style": {
+        var qualifiedProps = props;
+        var key = getStyleKey(qualifiedProps.href); // Attempt to hydrate instance from DOM
 
-    return family.current;
-  }
-}
-function resolveClassForHotReloading(type) {
-  // No implementation differences.
-  return resolveFunctionForHotReloading(type);
-}
-function resolveForwardRefForHotReloading(type) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return type;
-    }
+        var instance = hoistableRoot.querySelector(
+          getStyleTagSelectorFromKey(key)
+        );
 
-    var family = resolveFamily(type);
+        if (instance) {
+          resource.instance = instance;
+          markNodeAsHoistable(instance);
+          return instance;
+        }
 
-    if (family === undefined) {
-      // Check if we're dealing with a real forwardRef. Don't want to crash early.
-      if (
-        type !== null &&
-        type !== undefined &&
-        typeof type.render === "function"
-      ) {
-        // ForwardRef is special because its resolved .type is an object,
-        // but it's possible that we only have its inner render function in the map.
-        // If that inner render function is different, we'll build a new forwardRef type.
-        var currentRender = resolveFunctionForHotReloading(type.render);
+        var styleProps = styleTagPropsFromRawProps(props);
+        var ownerDocument = getDocumentFromRoot(hoistableRoot);
+        instance = ownerDocument.createElement("style");
+        markNodeAsHoistable(instance);
+        setInitialProperties(instance, "style", styleProps);
+        insertStylesheet(instance, qualifiedProps.precedence, hoistableRoot);
+        resource.instance = instance;
+        return instance;
+      }
 
-        if (type.render !== currentRender) {
-          var syntheticType = {
-            $$typeof: REACT_FORWARD_REF_TYPE,
-            render: currentRender
-          };
+      case "stylesheet": {
+        // This typing is enforce by `getResource`. If we change the logic
+        // there for what qualifies as a stylesheet resource we need to ensure
+        // this cast still makes sense;
+        var _qualifiedProps = props;
 
-          if (type.displayName !== undefined) {
-            syntheticType.displayName = type.displayName;
+        var _key5 = getStyleKey(_qualifiedProps.href); // Attempt to hydrate instance from DOM
+
+        var _instance2 = hoistableRoot.querySelector(
+          getStylesheetSelectorFromKey(_key5)
+        );
+
+        if (_instance2) {
+          resource.instance = _instance2;
+          markNodeAsHoistable(_instance2);
+          return _instance2;
+        }
+
+        var stylesheetProps = stylesheetPropsFromRawProps(props);
+        var preloadProps = preloadPropsMap.get(_key5);
+
+        if (preloadProps) {
+          adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps);
+        } // Construct and insert a new instance
+
+        var _ownerDocument2 = getDocumentFromRoot(hoistableRoot);
+
+        _instance2 = _ownerDocument2.createElement("link");
+        markNodeAsHoistable(_instance2);
+        var linkInstance = _instance2;
+        linkInstance._p = new Promise(function (resolve, reject) {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        }).then(
+          function () {
+            return (linkInstance._p.s = "l");
+          },
+          function () {
+            return (linkInstance._p.s = "e");
           }
-
-          return syntheticType;
-        }
+        );
+        setInitialProperties(_instance2, "link", stylesheetProps);
+        insertStylesheet(_instance2, _qualifiedProps.precedence, hoistableRoot);
+        resource.instance = _instance2;
+        return _instance2;
       }
 
-      return type;
-    } // Use the latest known implementation.
-
-    return family.current;
-  }
-}
-function isCompatibleFamilyForHotReloading(fiber, element) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return false;
-    }
+      case "script": {
+        // This typing is enforce by `getResource`. If we change the logic
+        // there for what qualifies as a stylesheet resource we need to ensure
+        // this cast still makes sense;
+        var borrowedScriptProps = props;
 
-    var prevType = fiber.elementType;
-    var nextType = element.type; // If we got here, we know types aren't === equal.
+        var _key6 = getScriptKey(borrowedScriptProps.src); // Attempt to hydrate instance from DOM
 
-    var needsCompareFamilies = false;
-    var $$typeofNextType =
-      typeof nextType === "object" && nextType !== null
-        ? nextType.$$typeof
-        : null;
+        var _instance3 = hoistableRoot.querySelector(
+          getScriptSelectorFromKey(_key6)
+        );
 
-    switch (fiber.tag) {
-      case ClassComponent: {
-        if (typeof nextType === "function") {
-          needsCompareFamilies = true;
+        if (_instance3) {
+          resource.instance = _instance3;
+          markNodeAsHoistable(_instance3);
+          return _instance3;
         }
 
-        break;
-      }
+        var scriptProps = borrowedScriptProps;
 
-      case FunctionComponent: {
-        if (typeof nextType === "function") {
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          // We don't know the inner type yet.
-          // We're going to assume that the lazy inner type is stable,
-          // and so it is sufficient to avoid reconciling it away.
-          // We're not going to unwrap or actually use the new lazy type.
-          needsCompareFamilies = true;
-        }
+        var _preloadProps3 = preloadPropsMap.get(_key6);
 
-        break;
-      }
+        if (_preloadProps3) {
+          scriptProps = assign({}, borrowedScriptProps);
+          adoptPreloadPropsForScript(scriptProps, _preloadProps3);
+        } // Construct and insert a new instance
 
-      case ForwardRef: {
-        if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          needsCompareFamilies = true;
-        }
+        var _ownerDocument3 = getDocumentFromRoot(hoistableRoot);
 
-        break;
-      }
+        _instance3 = _ownerDocument3.createElement("script");
+        markNodeAsHoistable(_instance3);
+        setInitialProperties(_instance3, "link", scriptProps);
 
-      case MemoComponent:
-      case SimpleMemoComponent: {
-        if ($$typeofNextType === REACT_MEMO_TYPE) {
-          // TODO: if it was but can no longer be simple,
-          // we shouldn't set this.
-          needsCompareFamilies = true;
-        } else if ($$typeofNextType === REACT_LAZY_TYPE) {
-          needsCompareFamilies = true;
-        }
+        _ownerDocument3.head.appendChild(_instance3);
 
-        break;
+        resource.instance = _instance3;
+        return _instance3;
       }
 
-      default:
-        return false;
-    } // Check if both types have a family and it's the same one.
-
-    if (needsCompareFamilies) {
-      // Note: memo() and forwardRef() we'll compare outer rather than inner type.
-      // This means both of them need to be registered to preserve state.
-      // If we unwrapped and compared the inner types for wrappers instead,
-      // then we would risk falsely saying two separate memo(Foo)
-      // calls are equivalent because they wrap the same Foo function.
-      var prevFamily = resolveFamily(prevType); // $FlowFixMe[not-a-function] found when upgrading Flow
+      case "void": {
+        return null;
+      }
 
-      if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
-        return true;
+      default: {
+        throw new Error(
+          'acquireResource encountered a resource type it did not expect: "' +
+            resource.type +
+            '". this is a bug in React.'
+        );
       }
     }
-
-    return false;
   }
+
+  return resource.instance;
+}
+function releaseResource(resource) {
+  resource.count--;
 }
-function markFailedErrorBoundaryForHotReloading(fiber) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return;
-    }
 
-    if (typeof WeakSet !== "function") {
-      return;
-    }
+function insertStylesheet(instance, precedence, root) {
+  var nodes = root.querySelectorAll(
+    'link[rel="stylesheet"][data-precedence],style[data-precedence]'
+  );
+  var last = nodes.length ? nodes[nodes.length - 1] : null;
+  var prior = last;
 
-    if (failedBoundaries === null) {
-      failedBoundaries = new WeakSet();
+  for (var i = 0; i < nodes.length; i++) {
+    var node = nodes[i];
+    var nodePrecedence = node.dataset.precedence;
+
+    if (nodePrecedence === precedence) {
+      prior = node;
+    } else if (prior !== last) {
+      break;
     }
+  }
 
-    failedBoundaries.add(fiber);
+  if (prior) {
+    // We get the prior from the document so we know it is in the tree.
+    // We also know that links can't be the topmost Node so the parentNode
+    // must exist.
+    prior.parentNode.insertBefore(instance, prior.nextSibling);
+  } else {
+    var parent = root.nodeType === DOCUMENT_NODE ? root.head : root;
+    parent.insertBefore(instance, parent.firstChild);
   }
 }
-var scheduleRefresh = function (root, update) {
-  {
-    if (resolveFamily === null) {
-      // Hot reloading is disabled.
-      return;
-    }
 
-    var staleFamilies = update.staleFamilies,
-      updatedFamilies = update.updatedFamilies;
-    flushPassiveEffects();
-    flushSync$1(function () {
-      scheduleFibersWithFamiliesRecursively(
-        root.current,
-        updatedFamilies,
-        staleFamilies
-      );
-    });
-  }
-};
-var scheduleRoot = function (root, element) {
-  {
-    if (root.context !== emptyContextObject) {
-      // Super edge case: root has a legacy _renderSubtree context
-      // but we don't know the parentComponent so we can't pass it.
-      // Just ignore. We'll delete this with _renderSubtree code path later.
-      return;
-    }
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  if (stylesheetProps.crossOrigin == null)
+    stylesheetProps.crossOrigin = preloadProps.crossOrigin;
+  if (stylesheetProps.referrerPolicy == null)
+    stylesheetProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (stylesheetProps.title == null) stylesheetProps.title = preloadProps.title;
+}
 
-    flushPassiveEffects();
-    flushSync$1(function () {
-      updateContainer(element, root, null, null);
-    });
-  }
-};
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  if (scriptProps.crossOrigin == null)
+    scriptProps.crossOrigin = preloadProps.crossOrigin;
+  if (scriptProps.referrerPolicy == null)
+    scriptProps.referrerPolicy = preloadProps.referrerPolicy;
+  if (scriptProps.integrity == null)
+    scriptProps.referrerPolicy = preloadProps.integrity;
+} // --------------------------------------
+//      Hoistable Element Reconciliation
+// --------------------------------------
 
-function scheduleFibersWithFamiliesRecursively(
-  fiber,
-  updatedFamilies,
-  staleFamilies
-) {
-  {
-    var alternate = fiber.alternate,
-      child = fiber.child,
-      sibling = fiber.sibling,
-      tag = fiber.tag,
-      type = fiber.type;
-    var candidateType = null;
+var tagCaches = null;
+function hydrateHoistable(hoistableRoot, type, props, internalInstanceHandle) {
+  var ownerDocument = getDocumentFromRoot(hoistableRoot);
+  var instance = null;
 
-    switch (tag) {
-      case FunctionComponent:
-      case SimpleMemoComponent:
-      case ClassComponent:
-        candidateType = type;
-        break;
+  getInstance: switch (type) {
+    case "title": {
+      instance = ownerDocument.getElementsByTagName("title")[0];
 
-      case ForwardRef:
-        candidateType = type.render;
-        break;
-    }
+      if (
+        !instance ||
+        isOwnedInstance(instance) ||
+        instance.namespaceURI === SVG_NAMESPACE ||
+        instance.hasAttribute("itemprop")
+      ) {
+        instance = ownerDocument.createElement(type);
+        ownerDocument.head.insertBefore(
+          instance,
+          ownerDocument.querySelector("head > title")
+        );
+      }
 
-    if (resolveFamily === null) {
-      throw new Error("Expected resolveFamily to be set during hot reload.");
+      setInitialProperties(instance, type, props);
+      precacheFiberNode(internalInstanceHandle, instance);
+      markNodeAsHoistable(instance);
+      return instance;
     }
 
-    var needsRender = false;
-    var needsRemount = false;
+    case "link": {
+      var cache = getHydratableHoistableCache("link", "href", ownerDocument);
+      var key = type + (props.href || "");
+      var maybeNodes = cache.get(key);
 
-    if (candidateType !== null) {
-      var family = resolveFamily(candidateType);
+      if (maybeNodes) {
+        var nodes = maybeNodes;
 
-      if (family !== undefined) {
-        if (staleFamilies.has(family)) {
-          needsRemount = true;
-        } else if (updatedFamilies.has(family)) {
-          if (tag === ClassComponent) {
-            needsRemount = true;
-          } else {
-            needsRender = true;
+        for (var i = 0; i < nodes.length; i++) {
+          var node = nodes[i];
+
+          if (
+            node.getAttribute("href") !==
+              (props.href == null ? null : props.href) ||
+            node.getAttribute("rel") !==
+              (props.rel == null ? null : props.rel) ||
+            node.getAttribute("title") !==
+              (props.title == null ? null : props.title) ||
+            node.getAttribute("crossorigin") !==
+              (props.crossOrigin == null ? null : props.crossOrigin)
+          ) {
+            // mismatch, try the next node;
+            continue;
           }
-        }
-      }
-    }
 
-    if (failedBoundaries !== null) {
-      if (
-        failedBoundaries.has(fiber) || // $FlowFixMe[incompatible-use] found when upgrading Flow
-        (alternate !== null && failedBoundaries.has(alternate))
-      ) {
-        needsRemount = true;
+          instance = node;
+          nodes.splice(i, 1);
+          break getInstance;
+        }
       }
-    }
 
-    if (needsRemount) {
-      fiber._debugNeedsRemount = true;
+      instance = ownerDocument.createElement(type);
+      setInitialProperties(instance, type, props);
+      ownerDocument.head.appendChild(instance);
+      break;
     }
 
-    if (needsRemount || needsRender) {
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    case "meta": {
+      var _cache = getHydratableHoistableCache(
+        "meta",
+        "content",
+        ownerDocument
+      );
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-      }
-    }
+      var _key7 = type + (props.content || "");
 
-    if (child !== null && !needsRemount) {
-      scheduleFibersWithFamiliesRecursively(
-        child,
-        updatedFamilies,
-        staleFamilies
-      );
-    }
+      var _maybeNodes = _cache.get(_key7);
 
-    if (sibling !== null) {
-      scheduleFibersWithFamiliesRecursively(
-        sibling,
-        updatedFamilies,
-        staleFamilies
-      );
-    }
-  }
-}
+      if (_maybeNodes) {
+        var _nodes = _maybeNodes;
 
-var findHostInstancesForRefresh = function (root, families) {
-  {
-    var hostInstances = new Set();
-    var types = new Set(
-      families.map(function (family) {
-        return family.current;
-      })
-    );
-    findHostInstancesForMatchingFibersRecursively(
-      root.current,
-      types,
-      hostInstances
-    );
-    return hostInstances;
-  }
-};
+        for (var _i = 0; _i < _nodes.length; _i++) {
+          var _node = _nodes[_i]; // We coerce content to string because it is the most likely one to
+          // use a `toString` capable value. For the rest we just do identity match
+          // passing non-strings here is not really valid anyway.
 
-function findHostInstancesForMatchingFibersRecursively(
-  fiber,
-  types,
-  hostInstances
-) {
-  {
-    var child = fiber.child,
-      sibling = fiber.sibling,
-      tag = fiber.tag,
-      type = fiber.type;
-    var candidateType = null;
+          {
+            checkAttributeStringCoercion(props.content, "content");
+          }
 
-    switch (tag) {
-      case FunctionComponent:
-      case SimpleMemoComponent:
-      case ClassComponent:
-        candidateType = type;
-        break;
+          if (
+            _node.getAttribute("content") !==
+              (props.content == null ? null : "" + props.content) ||
+            _node.getAttribute("name") !==
+              (props.name == null ? null : props.name) ||
+            _node.getAttribute("property") !==
+              (props.property == null ? null : props.property) ||
+            _node.getAttribute("http-equiv") !==
+              (props.httpEquiv == null ? null : props.httpEquiv) ||
+            _node.getAttribute("charset") !==
+              (props.charSet == null ? null : props.charSet)
+          ) {
+            // mismatch, try the next node;
+            continue;
+          }
 
-      case ForwardRef:
-        candidateType = type.render;
-        break;
-    }
+          instance = _node;
 
-    var didMatch = false;
+          _nodes.splice(_i, 1);
 
-    if (candidateType !== null) {
-      if (types.has(candidateType)) {
-        didMatch = true;
+          break getInstance;
+        }
       }
-    }
 
-    if (didMatch) {
-      // We have a match. This only drills down to the closest host components.
-      // There's no need to search deeper because for the purpose of giving
-      // visual feedback, "flashing" outermost parent rectangles is sufficient.
-      findHostInstancesForFiberShallowly(fiber, hostInstances);
-    } else {
-      // If there's no match, maybe there will be one further down in the child tree.
-      if (child !== null) {
-        findHostInstancesForMatchingFibersRecursively(
-          child,
-          types,
-          hostInstances
-        );
-      }
+      instance = ownerDocument.createElement(type);
+      setInitialProperties(instance, type, props);
+      ownerDocument.head.appendChild(instance);
+      break;
     }
 
-    if (sibling !== null) {
-      findHostInstancesForMatchingFibersRecursively(
-        sibling,
-        types,
-        hostInstances
+    default:
+      throw new Error(
+        'getNodesForType encountered a type it did not expect: "' +
+          type +
+          '". This is a bug in React.'
       );
-    }
-  }
-}
-
-function findHostInstancesForFiberShallowly(fiber, hostInstances) {
-  {
-    var foundHostInstances = findChildHostInstancesForFiberShallowly(
-      fiber,
-      hostInstances
-    );
-
-    if (foundHostInstances) {
-      return;
-    } // If we didn't find any host children, fallback to closest host parent.
-
-    var node = fiber;
-
-    while (true) {
-      switch (node.tag) {
-        case HostSingleton:
-        case HostComponent:
-          hostInstances.add(node.stateNode);
-          return;
+  } // This node is a match
 
-        case HostPortal:
-          hostInstances.add(node.stateNode.containerInfo);
-          return;
+  precacheFiberNode(internalInstanceHandle, instance);
+  markNodeAsHoistable(instance);
+  return instance;
+}
 
-        case HostRoot:
-          hostInstances.add(node.stateNode.containerInfo);
-          return;
-      }
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  var cache;
+  var caches;
 
-      if (node.return === null) {
-        throw new Error("Expected to reach root first.");
-      }
+  if (tagCaches === null) {
+    cache = new Map();
+    caches = tagCaches = new Map();
+    caches.set(ownerDocument, cache);
+  } else {
+    caches = tagCaches;
+    var maybeCache = caches.get(ownerDocument);
 
-      node = node.return;
+    if (!maybeCache) {
+      cache = new Map();
+      caches.set(ownerDocument, cache);
+    } else {
+      cache = maybeCache;
     }
   }
-}
-
-function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
-  {
-    var node = fiber;
-    var foundHostInstances = false;
 
-    while (true) {
-      if (
-        node.tag === HostComponent ||
-        node.tag === HostHoistable ||
-        node.tag === HostSingleton
-      ) {
-        // We got a match.
-        foundHostInstances = true;
-        hostInstances.add(node.stateNode); // There may still be more, so keep searching.
-      } else if (node.child !== null) {
-        node.child.return = node;
-        node = node.child;
-        continue;
-      }
+  if (cache.has(type)) {
+    // We use type as a special key that signals that this cache has been seeded for this type
+    return cache;
+  } // Mark this cache as seeded for this type
 
-      if (node === fiber) {
-        return foundHostInstances;
-      }
+  cache.set(type, null);
+  var nodes = ownerDocument.getElementsByTagName(type);
 
-      while (node.sibling === null) {
-        if (node.return === null || node.return === fiber) {
-          return foundHostInstances;
-        }
+  for (var i = 0; i < nodes.length; i++) {
+    var node = nodes[i];
 
-        node = node.return;
-      }
+    if (
+      !isOwnedInstance(node) &&
+      (type !== "link" || node.getAttribute("rel") !== "stylesheet") &&
+      node.namespaceURI !== SVG_NAMESPACE
+    ) {
+      var nodeKey = node.getAttribute(keyAttribute) || "";
+      var key = type + nodeKey;
+      var existing = cache.get(key);
 
-      node.sibling.return = node.return;
-      node = node.sibling;
+      if (existing) {
+        existing.push(node);
+      } else {
+        cache.set(key, [node]);
+      }
     }
   }
 
-  return false;
+  return cache;
 }
 
-var hasBadMapPolyfill;
-
-{
-  hasBadMapPolyfill = false;
+function mountHoistable(hoistableRoot, type, instance) {
+  var ownerDocument = getDocumentFromRoot(hoistableRoot);
+  ownerDocument.head.insertBefore(
+    instance,
+    type === "title" ? ownerDocument.querySelector("head > title") : null
+  );
+}
+function unmountHoistable(instance) {
+  instance.parentNode.removeChild(instance);
+} // When passing user input into querySelector(All) the embedded string must not alter
+// the semantics of the query. This escape function is safe to use when we know the
+// provided value is going to be wrapped in double quotes as part of an attribute selector
+// Do not use it anywhere else
+// we escape double quotes and backslashes
 
-  try {
-    var nonExtensibleObject = Object.preventExtensions({});
-    /* eslint-disable no-new */
+var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n\"\\]/g;
 
-    new Map([[nonExtensibleObject, null]]);
-    new Set([nonExtensibleObject]);
-    /* eslint-enable no-new */
-  } catch (e) {
-    // TODO: Consider warning about bad polyfills
-    hasBadMapPolyfill = true;
-  }
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(
+    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
+    function (ch) {
+      return "\\" + ch.charCodeAt(0).toString(16);
+    }
+  );
 }
 
-function FiberNode(tag, pendingProps, key, mode) {
-  // Instance
-  this.tag = tag;
-  this.key = key;
-  this.elementType = null;
-  this.type = null;
-  this.stateNode = null; // Fiber
+var SUPPRESS_HYDRATION_WARNING = "suppressHydrationWarning";
+var SUSPENSE_START_DATA = "$";
+var SUSPENSE_END_DATA = "/$";
+var SUSPENSE_PENDING_START_DATA = "$?";
+var SUSPENSE_FALLBACK_START_DATA = "$!";
+var STYLE = "style";
+var eventsEnabled = null;
+var selectionInformation = null;
+function getRootHostContext(rootContainerInstance) {
+  var type;
+  var namespace;
+  var nodeType = rootContainerInstance.nodeType;
 
-  this.return = null;
-  this.child = null;
-  this.sibling = null;
-  this.index = 0;
-  this.ref = null;
-  this.refCleanup = null;
-  this.pendingProps = pendingProps;
-  this.memoizedProps = null;
-  this.updateQueue = null;
-  this.memoizedState = null;
-  this.dependencies = null;
-  this.mode = mode; // Effects
+  switch (nodeType) {
+    case DOCUMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE: {
+      type = nodeType === DOCUMENT_NODE ? "#document" : "#fragment";
+      var root = rootContainerInstance.documentElement;
+      namespace = root ? root.namespaceURI : getChildNamespace(null, "");
+      break;
+    }
 
-  this.flags = NoFlags$1;
-  this.subtreeFlags = NoFlags$1;
-  this.deletions = null;
-  this.lanes = NoLanes;
-  this.childLanes = NoLanes;
-  this.alternate = null;
+    default: {
+      var container =
+        nodeType === COMMENT_NODE
+          ? rootContainerInstance.parentNode
+          : rootContainerInstance;
+      var ownNamespace = container.namespaceURI || null;
+      type = container.tagName;
+      namespace = getChildNamespace(ownNamespace, type);
+      break;
+    }
+  }
 
   {
-    // Note: The following is done to avoid a v8 performance cliff.
-    //
-    // Initializing the fields below to smis and later updating them with
-    // double values will cause Fibers to end up having separate shapes.
-    // This behavior/bug has something to do with Object.preventExtension().
-    // Fortunately this only impacts DEV builds.
-    // Unfortunately it makes React unusably slow for some applications.
-    // To work around this, initialize the fields below with doubles.
-    //
-    // Learn more about this here:
-    // https://github.com/facebook/react/issues/14365
-    // https://bugs.chromium.org/p/v8/issues/detail?id=8538
-    this.actualDuration = Number.NaN;
-    this.actualStartTime = Number.NaN;
-    this.selfBaseDuration = Number.NaN;
-    this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
-    // This won't trigger the performance cliff mentioned above,
-    // and it simplifies other profiler code (including DevTools).
-
-    this.actualDuration = 0;
-    this.actualStartTime = -1;
-    this.selfBaseDuration = 0;
-    this.treeBaseDuration = 0;
+    var validatedTag = type.toLowerCase();
+    var ancestorInfo = updatedAncestorInfoDev(null, validatedTag);
+    return {
+      namespace: namespace,
+      ancestorInfo: ancestorInfo
+    };
+  }
+}
+function getChildHostContext(parentHostContext, type) {
+  {
+    var parentHostContextDev = parentHostContext;
+    var namespace = getChildNamespace(parentHostContextDev.namespace, type);
+    var ancestorInfo = updatedAncestorInfoDev(
+      parentHostContextDev.ancestorInfo,
+      type
+    );
+    return {
+      namespace: namespace,
+      ancestorInfo: ancestorInfo
+    };
   }
+}
+function getPublicInstance(instance) {
+  return instance;
+}
+function prepareForCommit(containerInfo) {
+  eventsEnabled = isEnabled();
+  selectionInformation = getSelectionInformation();
+  var activeInstance = null;
 
   {
-    // This isn't directly used but is handy for debugging internals:
-    this._debugSource = null;
-    this._debugOwner = null;
-    this._debugNeedsRemount = false;
-    this._debugHookTypes = null;
+    var focusedElem = selectionInformation.focusedElem;
 
-    if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
-      Object.preventExtensions(this);
+    if (focusedElem !== null) {
+      activeInstance = getClosestInstanceFromNode(focusedElem);
     }
   }
-} // This is a constructor function, rather than a POJO constructor, still
-// please ensure we do the following:
-// 1) Nobody should add any instance methods on this. Instance methods can be
-//    more difficult to predict when they get optimized and they are almost
-//    never inlined properly in static compilers.
-// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
-//    always know when it is a fiber.
-// 3) We might want to experiment with using numeric keys since they are easier
-//    to optimize in a non-JIT environment.
-// 4) We can easily go from a constructor to a createFiber object literal if that
-//    is faster.
-// 5) It should be easy to port this to a C struct and keep a C implementation
-//    compatible.
 
-function createFiber(tag, pendingProps, key, mode) {
-  // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
-  return new FiberNode(tag, pendingProps, key, mode);
+  setEnabled(false);
+  return activeInstance;
 }
-
-function shouldConstruct(Component) {
-  var prototype = Component.prototype;
-  return !!(prototype && prototype.isReactComponent);
+function beforeActiveInstanceBlur(internalInstanceHandle) {
+  {
+    setEnabled(true);
+    dispatchBeforeDetachedBlur(
+      selectionInformation.focusedElem,
+      internalInstanceHandle
+    );
+    setEnabled(false);
+  }
 }
-
-function isSimpleFunctionComponent(type) {
-  return (
-    typeof type === "function" &&
-    !shouldConstruct(type) &&
-    type.defaultProps === undefined
-  );
+function afterActiveInstanceBlur() {
+  {
+    setEnabled(true);
+    dispatchAfterDetachedBlur(selectionInformation.focusedElem);
+    setEnabled(false);
+  }
 }
-function resolveLazyComponentTag(Component) {
-  if (typeof Component === "function") {
-    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
-  } else if (Component !== undefined && Component !== null) {
-    var $$typeof = Component.$$typeof;
+function resetAfterCommit(containerInfo) {
+  restoreSelection(selectionInformation);
+  setEnabled(eventsEnabled);
+  eventsEnabled = null;
+  selectionInformation = null;
+}
+function createHoistableInstance(
+  type,
+  props,
+  rootContainerInstance,
+  internalInstanceHandle
+) {
+  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  var domElement = createHTMLElement(type, props, ownerDocument);
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  setInitialProperties(domElement, type, props);
+  markNodeAsHoistable(domElement);
+  return domElement;
+}
+function createInstance(
+  type,
+  props,
+  rootContainerInstance,
+  hostContext,
+  internalInstanceHandle
+) {
+  var namespace;
 
-    if ($$typeof === REACT_FORWARD_REF_TYPE) {
-      return ForwardRef;
-    }
+  {
+    // TODO: take namespace into account when validating.
+    var hostContextDev = hostContext;
+    validateDOMNesting(type, null, hostContextDev.ancestorInfo);
 
-    if ($$typeof === REACT_MEMO_TYPE) {
-      return MemoComponent;
+    if (
+      typeof props.children === "string" ||
+      typeof props.children === "number"
+    ) {
+      var string = "" + props.children;
+      var ownAncestorInfo = updatedAncestorInfoDev(
+        hostContextDev.ancestorInfo,
+        type
+      );
+      validateDOMNesting(null, string, ownAncestorInfo);
     }
-  }
-
-  return IndeterminateComponent;
-} // This is used to create an alternate fiber to do work on.
 
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
+    namespace = hostContextDev.namespace;
+  }
 
-  if (workInProgress === null) {
-    // We use a double buffering pooling technique because we know that we'll
-    // only ever need at most two versions of a tree. We pool the "other" unused
-    // node that we're free to reuse. This is lazily created to avoid allocating
-    // extra objects for things that are never updated. It also allow us to
-    // reclaim the extra memory if needed.
-    workInProgress = createFiber(
-      current.tag,
-      pendingProps,
-      current.key,
-      current.mode
-    );
-    workInProgress.elementType = current.elementType;
-    workInProgress.type = current.type;
-    workInProgress.stateNode = current.stateNode;
+  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  var domElement;
 
-    {
-      // DEV-only fields
-      workInProgress._debugSource = current._debugSource;
-      workInProgress._debugOwner = current._debugOwner;
-      workInProgress._debugHookTypes = current._debugHookTypes;
-    }
+  switch (namespace) {
+    case SVG_NAMESPACE:
+    case MATH_NAMESPACE:
+      domElement = ownerDocument.createElementNS(namespace, type);
+      break;
 
-    workInProgress.alternate = current;
-    current.alternate = workInProgress;
-  } else {
-    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
+    default:
+      switch (type) {
+        case "svg":
+          domElement = ownerDocument.createElementNS(SVG_NAMESPACE, type);
+          break;
 
-    workInProgress.type = current.type; // We already have an alternate.
-    // Reset the effect tag.
+        case "math":
+          domElement = ownerDocument.createElementNS(MATH_NAMESPACE, type);
+          break;
 
-    workInProgress.flags = NoFlags$1; // The effects are no longer valid.
+        case "script":
+          domElement = createPotentiallyInlineScriptElement(ownerDocument);
+          break;
 
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.deletions = null;
+        case "select":
+          domElement = createSelectElement(props, ownerDocument);
+          break;
 
-    {
-      // We intentionally reset, rather than copy, actualDuration & actualStartTime.
-      // This prevents time from endlessly accumulating in new commits.
-      // This has the downside of resetting values for different priority renders,
-      // But works for yielding (the common case) and should support resuming.
-      workInProgress.actualDuration = 0;
-      workInProgress.actualStartTime = -1;
-    }
-  } // Reset all effects except static ones.
-  // Static effects are not specific to a render.
+        default:
+          domElement = createHTMLElement(type, props, ownerDocument);
+      }
+  }
 
-  workInProgress.flags = current.flags & StaticMask;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
-  // it cannot be shared with the current fiber.
+  precacheFiberNode(internalInstanceHandle, domElement);
+  updateFiberProps(domElement, props);
+  return domElement;
+}
+function appendInitialChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function finalizeInitialChildren(domElement, type, props, hostContext) {
+  setInitialProperties(domElement, type, props);
 
-  var currentDependencies = current.dependencies;
-  workInProgress.dependencies =
-    currentDependencies === null
-      ? null
-      : {
-          lanes: currentDependencies.lanes,
-          firstContext: currentDependencies.firstContext
-        }; // These will be overridden during the parent's reconciliation
+  switch (type) {
+    case "button":
+    case "input":
+    case "select":
+    case "textarea":
+      return !!props.autoFocus;
 
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
+    case "img":
+      return true;
 
-  {
-    workInProgress.selfBaseDuration = current.selfBaseDuration;
-    workInProgress.treeBaseDuration = current.treeBaseDuration;
+    default:
+      return false;
   }
-
+}
+function prepareUpdate(domElement, type, oldProps, newProps, hostContext) {
   {
-    workInProgress._debugNeedsRemount = current._debugNeedsRemount;
-
-    switch (workInProgress.tag) {
-      case IndeterminateComponent:
-      case FunctionComponent:
-      case SimpleMemoComponent:
-        workInProgress.type = resolveFunctionForHotReloading(current.type);
-        break;
-
-      case ClassComponent:
-        workInProgress.type = resolveClassForHotReloading(current.type);
-        break;
+    var hostContextDev = hostContext;
 
-      case ForwardRef:
-        workInProgress.type = resolveForwardRefForHotReloading(current.type);
-        break;
+    if (
+      typeof newProps.children !== typeof oldProps.children &&
+      (typeof newProps.children === "string" ||
+        typeof newProps.children === "number")
+    ) {
+      var string = "" + newProps.children;
+      var ownAncestorInfo = updatedAncestorInfoDev(
+        hostContextDev.ancestorInfo,
+        type
+      );
+      validateDOMNesting(null, string, ownAncestorInfo);
     }
   }
 
-  return workInProgress;
-} // Used to reuse a Fiber for a second pass.
-
-function resetWorkInProgress(workInProgress, renderLanes) {
-  // This resets the Fiber to what createFiber or createWorkInProgress would
-  // have set the values to before during the first pass. Ideally this wouldn't
-  // be necessary but unfortunately many code paths reads from the workInProgress
-  // when they should be reading from current and writing to workInProgress.
-  // We assume pendingProps, index, key, ref, return are still untouched to
-  // avoid doing another reconciliation.
-  // Reset the effect flags but keep any Placement tags, since that's something
-  // that child fiber is setting, not the reconciliation.
-  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
-
-  var current = workInProgress.alternate;
-
-  if (current === null) {
-    // Reset to createFiber's initial values.
-    workInProgress.childLanes = NoLanes;
-    workInProgress.lanes = renderLanes;
-    workInProgress.child = null;
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.memoizedProps = null;
-    workInProgress.memoizedState = null;
-    workInProgress.updateQueue = null;
-    workInProgress.dependencies = null;
-    workInProgress.stateNode = null;
-
-    {
-      // Note: We don't reset the actualTime counts. It's useful to accumulate
-      // actual time across multiple render passes.
-      workInProgress.selfBaseDuration = 0;
-      workInProgress.treeBaseDuration = 0;
-    }
-  } else {
-    // Reset to the cloned values that createWorkInProgress would've.
-    workInProgress.childLanes = current.childLanes;
-    workInProgress.lanes = current.lanes;
-    workInProgress.child = current.child;
-    workInProgress.subtreeFlags = NoFlags$1;
-    workInProgress.deletions = null;
-    workInProgress.memoizedProps = current.memoizedProps;
-    workInProgress.memoizedState = current.memoizedState;
-    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
-
-    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
-    // it cannot be shared with the current fiber.
-
-    var currentDependencies = current.dependencies;
-    workInProgress.dependencies =
-      currentDependencies === null
-        ? null
-        : {
-            lanes: currentDependencies.lanes,
-            firstContext: currentDependencies.firstContext
-          };
-
-    {
-      // Note: We don't reset the actualTime counts. It's useful to accumulate
-      // actual time across multiple render passes.
-      workInProgress.selfBaseDuration = current.selfBaseDuration;
-      workInProgress.treeBaseDuration = current.treeBaseDuration;
-    }
+  return diffProperties(domElement, type, oldProps, newProps);
+}
+function shouldSetTextContent(type, props) {
+  return (
+    type === "textarea" ||
+    type === "noscript" ||
+    typeof props.children === "string" ||
+    typeof props.children === "number" ||
+    (typeof props.dangerouslySetInnerHTML === "object" &&
+      props.dangerouslySetInnerHTML !== null &&
+      props.dangerouslySetInnerHTML.__html != null)
+  );
+}
+function createTextInstance(
+  text,
+  rootContainerInstance,
+  hostContext,
+  internalInstanceHandle
+) {
+  {
+    var hostContextDev = hostContext;
+    validateDOMNesting(null, text, hostContextDev.ancestorInfo);
   }
 
-  return workInProgress;
+  var textNode = createTextNode(text, rootContainerInstance);
+  precacheFiberNode(internalInstanceHandle, textNode);
+  return textNode;
 }
-function createHostRootFiber(
-  tag,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride
-) {
-  var mode;
-
-  if (tag === ConcurrentRoot) {
-    mode = ConcurrentMode;
-
-    if (isStrictMode === true || createRootStrictEffectsByDefault) {
-      mode |= StrictLegacyMode | StrictEffectsMode;
-    }
+function getCurrentEventPriority() {
+  var currentEvent = window.event;
 
-    if (
-      // Only for internal experiments.
-      concurrentUpdatesByDefaultOverride
-    ) {
-      mode |= ConcurrentUpdatesByDefaultMode;
-    }
-  } else {
-    mode = NoMode;
+  if (currentEvent === undefined) {
+    return DefaultEventPriority;
   }
 
-  if (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 getEventPriority(currentEvent.type);
+}
+var isPrimaryRenderer = true;
+// if a component just imports ReactDOM (e.g. for findDOMNode).
+// Some environments might not have setTimeout or clearTimeout.
 
-  return createFiber(HostRoot, null, null, mode);
+var scheduleTimeout = typeof setTimeout === "function" ? setTimeout : undefined;
+var cancelTimeout =
+  typeof clearTimeout === "function" ? clearTimeout : undefined;
+var noTimeout = -1;
+var localPromise = typeof Promise === "function" ? Promise : undefined;
+var localRequestAnimationFrame =
+  typeof requestAnimationFrame === "function"
+    ? requestAnimationFrame
+    : scheduleTimeout;
+function getInstanceFromNode(node) {
+  return getClosestInstanceFromNode(node) || null;
 }
-function createFiberFromTypeAndProps(
-  type, // React$ElementType
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
+function preparePortalMount(portalInstance) {
+  listenToAllSupportedEvents(portalInstance);
+}
+function prepareScopeUpdate(scopeInstance, internalInstanceHandle) {
+  {
+    precacheFiberNode(internalInstanceHandle, scopeInstance);
+  }
+}
+function getInstanceFromScope(scopeInstance) {
+  {
+    return getFiberFromScopeInstance(scopeInstance);
+  }
+} // -------------------
+var scheduleMicrotask =
+  typeof queueMicrotask === "function"
+    ? queueMicrotask
+    : typeof localPromise !== "undefined"
+    ? function (callback) {
+        return localPromise
+          .resolve(null)
+          .then(callback)
+          .catch(handleErrorInNextTick);
+      }
+    : scheduleTimeout; // TODO: Determine the best fallback here.
 
-  var resolvedType = type;
+function handleErrorInNextTick(error) {
+  setTimeout(function () {
+    throw error;
+  });
+} // -------------------
+function commitMount(domElement, type, newProps, internalInstanceHandle) {
+  // Despite the naming that might imply otherwise, this method only
+  // fires if there is an `Update` effect scheduled during mounting.
+  // This happens if `finalizeInitialChildren` returns `true` (which it
+  // does to implement the `autoFocus` attribute on the client). But
+  // there are also other cases when this might happen (such as patching
+  // up text content during hydration mismatch). So we'll check this again.
+  switch (type) {
+    case "button":
+    case "input":
+    case "select":
+    case "textarea":
+      if (newProps.autoFocus) {
+        domElement.focus();
+      }
 
-  if (typeof type === "function") {
-    if (shouldConstruct(type)) {
-      fiberTag = ClassComponent;
+      return;
 
-      {
-        resolvedType = resolveClassForHotReloading(resolvedType);
-      }
-    } else {
-      {
-        resolvedType = resolveFunctionForHotReloading(resolvedType);
+    case "img": {
+      if (newProps.src) {
+        domElement.src = newProps.src;
       }
+
+      return;
     }
-  } else if (typeof type === "string") {
-    {
-      var hostContext = getHostContext();
-      fiberTag = isHostHoistableType(type, pendingProps, hostContext)
-        ? HostHoistable
-        : isHostSingletonType(type)
-        ? HostSingleton
-        : HostComponent;
-    }
-  } else {
-    getTag: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+  }
+}
+function commitUpdate(
+  domElement,
+  updatePayload,
+  type,
+  oldProps,
+  newProps,
+  internalInstanceHandle
+) {
+  // Apply the diff to the DOM node.
+  updateProperties(domElement, updatePayload, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with
+  // with current event handlers.
 
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = Mode;
-        mode |= StrictLegacyMode;
+  updateFiberProps(domElement, newProps);
+}
+function resetTextContent(domElement) {
+  setTextContent(domElement, "");
+}
+function commitTextUpdate(textInstance, oldText, newText) {
+  textInstance.nodeValue = newText;
+}
+function appendChild(parentInstance, child) {
+  parentInstance.appendChild(child);
+}
+function appendChildToContainer(container, child) {
+  var parentNode;
 
-        if ((mode & ConcurrentMode) !== NoMode) {
-          // Strict effects should never run on legacy roots
-          mode |= StrictEffectsMode;
-        }
+  if (container.nodeType === COMMENT_NODE) {
+    parentNode = container.parentNode;
+    parentNode.insertBefore(child, container);
+  } else {
+    parentNode = container;
+    parentNode.appendChild(child);
+  } // This container might be used for a portal.
+  // If something inside a portal is clicked, that click should bubble
+  // through the React tree. However, on Mobile Safari the click would
+  // never bubble through the *DOM* tree unless an ancestor with onclick
+  // event exists. So we wouldn't see it and dispatch it.
+  // This is why we ensure that non React root containers have inline onclick
+  // defined.
+  // https://github.com/facebook/react/issues/11918
 
-        break;
+  var reactRootContainer = container._reactRootContainer;
 
-      case REACT_PROFILER_TYPE:
-        return createFiberFromProfiler(pendingProps, mode, lanes, key);
+  if (
+    (reactRootContainer === null || reactRootContainer === undefined) &&
+    parentNode.onclick === null
+  ) {
+    // TODO: This cast may not be sound for SVG, MathML or custom elements.
+    trapClickOnNonInteractiveElement(parentNode);
+  }
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  parentInstance.insertBefore(child, beforeChild);
+}
+function insertInContainerBefore(container, child, beforeChild) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.insertBefore(child, beforeChild);
+  } else {
+    container.insertBefore(child, beforeChild);
+  }
+}
 
-      case REACT_SUSPENSE_TYPE:
-        return createFiberFromSuspense(pendingProps, mode, lanes, key);
+function createEvent(type, bubbles) {
+  var event = document.createEvent("Event");
+  event.initEvent(type, bubbles, false);
+  return event;
+}
 
-      case REACT_SUSPENSE_LIST_TYPE:
-        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
+function dispatchBeforeDetachedBlur(target, internalInstanceHandle) {
+  {
+    var event = createEvent("beforeblur", true); // Dispatch "beforeblur" directly on the target,
+    // so it gets picked up by the event system and
+    // can propagate through the React internal tree.
+    // $FlowFixMe: internal field
 
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+    event._detachedInterceptFiber = internalInstanceHandle;
+    target.dispatchEvent(event);
+  }
+}
 
-      case REACT_LEGACY_HIDDEN_TYPE: {
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      }
+function dispatchAfterDetachedBlur(target) {
+  {
+    var event = createEvent("afterblur", false); // So we know what was detached, make the relatedTarget the
+    // detached target on the "afterblur" event.
 
-      // eslint-disable-next-line no-fallthrough
+    event.relatedTarget = target; // Dispatch the event on the document.
 
-      case REACT_SCOPE_TYPE: {
-        return createFiberFromScope(type, pendingProps, mode, lanes, key);
-      }
+    document.dispatchEvent(event);
+  }
+}
 
-      // eslint-disable-next-line no-fallthrough
+function removeChild(parentInstance, child) {
+  parentInstance.removeChild(child);
+}
+function removeChildFromContainer(container, child) {
+  if (container.nodeType === COMMENT_NODE) {
+    container.parentNode.removeChild(child);
+  } else {
+    container.removeChild(child);
+  }
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  var node = suspenseInstance; // Delete all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
 
-      case REACT_CACHE_TYPE: {
-        return createFiberFromCache(pendingProps, mode, lanes, key);
-      }
+  var depth = 0;
 
-      // eslint-disable-next-line no-fallthrough
+  do {
+    var nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
 
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing) {
-          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
-        }
+    if (nextNode && nextNode.nodeType === COMMENT_NODE) {
+      var data = nextNode.data;
 
-      // eslint-disable-next-line no-fallthrough
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.
 
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = Mode;
-          mode |= DebugTracingMode;
-          break;
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        } else {
+          depth--;
         }
+      } else if (
+        data === SUSPENSE_START_DATA ||
+        data === SUSPENSE_PENDING_START_DATA ||
+        data === SUSPENSE_FALLBACK_START_DATA
+      ) {
+        depth++;
+      }
+    } // $FlowFixMe[incompatible-type] we bail out when we get a null
 
-      // eslint-disable-next-line no-fallthrough
+    node = nextNode;
+  } while (node); // TODO: Warn, we didn't find the end comment boundary.
+  // Retry if any event replaying was blocked on this.
 
-      default: {
-        if (typeof type === "object" && type !== null) {
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = ContextProvider;
-              break getTag;
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearSuspenseBoundaryFromContainer(container, suspenseInstance) {
+  if (container.nodeType === COMMENT_NODE) {
+    clearSuspenseBoundary(container.parentNode, suspenseInstance);
+  } else if (container.nodeType === ELEMENT_NODE) {
+    clearSuspenseBoundary(container, suspenseInstance);
+  } else; // Retry if any event replaying was blocked on this.
 
-            case REACT_CONTEXT_TYPE:
-              // This is a consumer
-              fiberTag = ContextConsumer;
-              break getTag;
+  retryIfBlockedOn(container);
+}
+function hideInstance(instance) {
+  // TODO: Does this work for all element types? What about MathML? Should we
+  // pass host context to this method?
+  instance = instance;
+  var style = instance.style; // $FlowFixMe[method-unbinding]
 
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = ForwardRef;
+  if (typeof style.setProperty === "function") {
+    style.setProperty("display", "none", "important");
+  } else {
+    style.display = "none";
+  }
+}
+function hideTextInstance(textInstance) {
+  textInstance.nodeValue = "";
+}
+function unhideInstance(instance, props) {
+  instance = instance;
+  var styleProp = props[STYLE];
+  var display =
+    styleProp !== undefined &&
+    styleProp !== null &&
+    styleProp.hasOwnProperty("display")
+      ? styleProp.display
+      : null;
+  instance.style.display = dangerousStyleValue("display", display);
+}
+function unhideTextInstance(textInstance, text) {
+  textInstance.nodeValue = text;
+}
+function clearContainer(container) {
+  {
+    var nodeType = container.nodeType;
 
-              {
-                resolvedType = resolveForwardRefForHotReloading(resolvedType);
-              }
+    if (nodeType === DOCUMENT_NODE) {
+      clearContainerSparingly(container);
+    } else if (nodeType === ELEMENT_NODE) {
+      switch (container.nodeName) {
+        case "HEAD":
+        case "HTML":
+        case "BODY":
+          clearContainerSparingly(container);
+          return;
 
-              break getTag;
+        default: {
+          container.textContent = "";
+        }
+      }
+    }
+  }
+}
 
-            case REACT_MEMO_TYPE:
-              fiberTag = MemoComponent;
-              break getTag;
+function clearContainerSparingly(container) {
+  var node;
+  var nextNode = container.firstChild;
 
-            case REACT_LAZY_TYPE:
-              fiberTag = LazyComponent;
-              resolvedType = null;
-              break getTag;
-          }
-        }
+  if (nextNode && nextNode.nodeType === DOCUMENT_TYPE_NODE) {
+    nextNode = nextNode.nextSibling;
+  }
 
-        var info = "";
+  while (nextNode) {
+    node = nextNode;
+    nextNode = nextNode.nextSibling;
 
-        {
-          if (
-            type === undefined ||
-            (typeof type === "object" &&
-              type !== null &&
-              Object.keys(type).length === 0)
-          ) {
-            info +=
-              " You likely forgot to export your component from the file " +
-              "it's defined in, or you might have mixed up default and " +
-              "named imports.";
-          }
+    switch (node.nodeName) {
+      case "HTML":
+      case "HEAD":
+      case "BODY": {
+        var element = node;
+        clearContainerSparingly(element); // If these singleton instances had previously been rendered with React they
+        // may still hold on to references to the previous fiber tree. We detatch them
+        // prospectively to reset them to a baseline starting state since we cannot create
+        // new instances.
 
-          var ownerName = owner ? getComponentNameFromFiber(owner) : null;
+        detachDeletedInstance(element);
+        continue;
+      }
 
-          if (ownerName) {
-            info += "\n\nCheck the render method of `" + ownerName + "`.";
-          }
-        }
+      case "STYLE": {
+        continue;
+      }
 
-        throw new Error(
-          "Element type is invalid: expected a string (for built-in " +
-            "components) or a class/function (for composite components) " +
-            ("but got: " + (type == null ? type : typeof type) + "." + info)
-        );
+      case "LINK": {
+        if (node.rel.toLowerCase() === "stylesheet") {
+          continue;
+        }
       }
     }
+
+    container.removeChild(node);
   }
 
-  var fiber = createFiber(fiberTag, pendingProps, key, mode);
-  fiber.elementType = type;
-  fiber.type = resolvedType;
-  fiber.lanes = lanes;
+  return;
+} // Making this so we can eventually move all of the instance caching to the commit phase.
+// inserted without breaking hydration
 
+function isHydratableType(type, props) {
   {
-    fiber._debugOwner = owner;
-  }
+    if (type === "script") {
+      var async = props.async,
+        onLoad = props.onLoad,
+        onError = props.onError;
+      return !(async && (onLoad || onError));
+    }
 
-  return fiber;
+    return true;
+  }
 }
-function createFiberFromElement(element, mode, lanes) {
-  var owner = null;
+function isHydratableText(text) {
+  return text !== "";
+}
+function shouldSkipHydratableForInstance(instance, type, props) {
+  if (instance.nodeType !== ELEMENT_NODE) {
+    // This is a suspense boundary or Text node.
+    // Suspense Boundaries are never expected to be injected by 3rd parties. If we see one it should be matched
+    // and this is a hydration error.
+    // Text Nodes are also not expected to be injected by 3rd parties. This is less of a guarantee for <body>
+    // but it seems reasonable and conservative to reject this as a hydration error as well
+    return false;
+  } else if (
+    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
+    isMarkedHoistable(instance)
+  ) {
+    // We are either about to
+    return true;
+  } else {
+    // We have an Element with the right type.
+    var element = instance;
+    var anyProps = props; // We are going to try to exclude it if we can definitely identify it as a hoisted Node or if
+    // we can guess that the node is likely hoisted or was inserted by a 3rd party script or browser extension
+    // using high entropy attributes for certain types. This technique will fail for strange insertions like
+    // extension prepending <div> in the <body> but that already breaks before and that is an edge case.
 
-  {
-    owner = element._owner;
-  }
+    switch (type) {
+      // case 'title':
+      //We assume all titles are matchable. You should only have one in the Document, at least in a hoistable scope
+      // and if you are a HostComponent with type title we must either be in an <svg> context or this title must have an `itemProp` prop.
+      case "meta": {
+        // The only way to opt out of hoisting meta tags is to give it an itemprop attribute. We assume there will be
+        // not 3rd party meta tags that are prepended, accepting the cases where this isn't true because meta tags
+        // are usually only functional for SSR so even in a rare case where we did bind to an injected tag the runtime
+        // implications are minimal
+        if (!element.hasAttribute("itemprop")) {
+          // This is a Hoistable
+          return true;
+        }
+
+        break;
+      }
+
+      case "link": {
+        // Links come in many forms and we do expect 3rd parties to inject them into <head> / <body>. We exclude known resources
+        // and then use high-entroy attributes like href which are almost always used and almost always unique to filter out unlikely
+        // matches.
+        var rel = element.getAttribute("rel");
+
+        if (rel === "stylesheet" && element.hasAttribute("data-precedence")) {
+          // This is a stylesheet resource
+          return true;
+        } else if (
+          rel !== anyProps.rel ||
+          element.getAttribute("href") !==
+            (anyProps.href == null ? null : anyProps.href) ||
+          element.getAttribute("crossorigin") !==
+            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin) ||
+          element.getAttribute("title") !==
+            (anyProps.title == null ? null : anyProps.title)
+        ) {
+          // rel + href should usually be enough to uniquely identify a link however crossOrigin can vary for rel preconnect
+          // and title could vary for rel alternate
+          return true;
+        }
 
-  var type = element.type;
-  var key = element.key;
-  var pendingProps = element.props;
-  var fiber = createFiberFromTypeAndProps(
-    type,
-    key,
-    pendingProps,
-    owner,
-    mode,
-    lanes
-  );
+        break;
+      }
 
-  {
-    fiber._debugSource = element._source;
-    fiber._debugOwner = element._owner;
-  }
+      case "style": {
+        // Styles are hard to match correctly. We can exclude known resources but otherwise we accept the fact that a non-hoisted style tags
+        // in <head> or <body> are likely never going to be unmounted given their position in the document and the fact they likely hold global styles
+        if (element.hasAttribute("data-precedence")) {
+          // This is a style resource
+          return true;
+        }
 
-  return fiber;
-}
-function createFiberFromFragment(elements, mode, lanes, key) {
-  var fiber = createFiber(Fragment, elements, key, mode);
-  fiber.lanes = lanes;
-  return fiber;
-}
+        break;
+      }
 
-function createFiberFromScope(scope, pendingProps, mode, lanes, key) {
-  var fiber = createFiber(ScopeComponent, pendingProps, key, mode);
-  fiber.type = scope;
-  fiber.elementType = scope;
-  fiber.lanes = lanes;
-  return fiber;
-}
+      case "script": {
+        // Scripts are a little tricky, we exclude known resources and then similar to links try to use high-entropy attributes
+        // to reject poor matches. One challenge with scripts are inline scripts. We don't attempt to check text content which could
+        // in theory lead to a hydration error later if a 3rd party injected an inline script before the React rendered nodes.
+        // Falling back to client rendering if this happens should be seemless though so we will try this hueristic and revisit later
+        // if we learn it is problematic
+        var srcAttr = element.getAttribute("src");
 
-function createFiberFromProfiler(pendingProps, mode, lanes, key) {
-  {
-    if (typeof pendingProps.id !== "string") {
-      error(
-        'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
-        typeof pendingProps.id
-      );
-    }
-  }
+        if (
+          srcAttr &&
+          element.hasAttribute("async") &&
+          !element.hasAttribute("itemprop")
+        ) {
+          // This is an async script resource
+          return true;
+        } else if (
+          srcAttr !== (anyProps.src == null ? null : anyProps.src) ||
+          element.getAttribute("type") !==
+            (anyProps.type == null ? null : anyProps.type) ||
+          element.getAttribute("crossorigin") !==
+            (anyProps.crossOrigin == null ? null : anyProps.crossOrigin)
+        ) {
+          // This script is for a different src
+          return true;
+        }
 
-  var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
-  fiber.elementType = REACT_PROFILER_TYPE;
-  fiber.lanes = lanes;
+        break;
+      }
+    } // We have excluded the most likely cases of mismatch between hoistable tags, 3rd party script inserted tags,
+    // and browser extension inserted tags. While it is possible this is not the right match it is a decent hueristic
+    // that should work in the vast majority of cases.
 
-  {
-    fiber.stateNode = {
-      effectDuration: 0,
-      passiveEffectDuration: 0
-    };
+    return false;
   }
-
-  return fiber;
 }
-
-function createFiberFromSuspense(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_SUSPENSE_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
+function shouldSkipHydratableForTextInstance(instance) {
+  return instance.nodeType === ELEMENT_NODE;
 }
-function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
+function shouldSkipHydratableForSuspenseInstance(instance) {
+  return instance.nodeType === ELEMENT_NODE;
 }
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_OFFSCREEN_TYPE;
-  fiber.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: OffscreenVisible,
-    _pendingVisibility: OffscreenVisible,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
-    }
-  };
-  fiber.stateNode = primaryChildInstance;
-  return fiber;
+function canHydrateInstance(instance, type, props) {
+  if (
+    instance.nodeType !== ELEMENT_NODE ||
+    instance.nodeName.toLowerCase() !== type.toLowerCase()
+  ) {
+    return null;
+  } else {
+    return instance;
+  }
 }
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(LegacyHiddenComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  fiber.lanes = lanes; // Adding a stateNode for legacy hidden because it's currently using
-  // the offscreen implementation, which depends on a state node
+function canHydrateTextInstance(instance, text) {
+  if (text === "") return null;
 
-  var instance = {
-    _visibility: OffscreenVisible,
-    _pendingVisibility: OffscreenVisible,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
-    }
-  };
-  fiber.stateNode = instance;
-  return fiber;
-}
-function createFiberFromCache(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(CacheComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_CACHE_TYPE;
-  fiber.lanes = lanes;
-  return fiber;
-}
-function createFiberFromTracingMarker(pendingProps, mode, lanes, key) {
-  var fiber = createFiber(TracingMarkerComponent, pendingProps, key, mode);
-  fiber.elementType = REACT_TRACING_MARKER_TYPE;
-  fiber.lanes = lanes;
-  var tracingMarkerInstance = {
-    tag: TransitionTracingMarker,
-    transitions: null,
-    pendingBoundaries: null,
-    aborts: null,
-    name: pendingProps.name
-  };
-  fiber.stateNode = tracingMarkerInstance;
-  return fiber;
-}
-function createFiberFromText(content, mode, lanes) {
-  var fiber = createFiber(HostText, content, null, mode);
-  fiber.lanes = lanes;
-  return fiber;
+  if (instance.nodeType !== TEXT_NODE) {
+    // Empty strings are not parsed by HTML so there won't be a correct match here.
+    return null;
+  } // This has now been refined to a text node.
+
+  return instance;
 }
-function createFiberFromHostInstanceForDeletion() {
-  var fiber = createFiber(HostComponent, null, null, NoMode);
-  fiber.elementType = "DELETED";
-  return fiber;
+function canHydrateSuspenseInstance(instance) {
+  if (instance.nodeType !== COMMENT_NODE) {
+    return null;
+  } // This has now been refined to a suspense node.
+
+  return instance;
 }
-function createFiberFromDehydratedFragment(dehydratedNode) {
-  var fiber = createFiber(DehydratedFragment, null, null, NoMode);
-  fiber.stateNode = dehydratedNode;
-  return fiber;
+function isSuspenseInstancePending(instance) {
+  return instance.data === SUSPENSE_PENDING_START_DATA;
 }
-function createFiberFromPortal(portal, mode, lanes) {
-  var pendingProps = portal.children !== null ? portal.children : [];
-  var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
-  fiber.lanes = lanes;
-  fiber.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    // Used by persistent updates
-    implementation: portal.implementation
-  };
-  return fiber;
-} // Used for stashing WIP properties to replay failed work in DEV.
-
-function assignFiberPropertiesInDEV(target, source) {
-  if (target === null) {
-    // This Fiber's initial properties will always be overwritten.
-    // We only use a Fiber to ensure the same hidden class so DEV isn't slow.
-    target = createFiber(IndeterminateComponent, null, null, NoMode);
-  } // This is intentionally written as a list of all properties.
-  // We tried to use Object.assign() instead but this is called in
-  // the hottest path, and Object.assign() was too slow:
-  // https://github.com/facebook/react/issues/12502
-  // This code is DEV-only so size is not a concern.
-
-  target.tag = source.tag;
-  target.key = source.key;
-  target.elementType = source.elementType;
-  target.type = source.type;
-  target.stateNode = source.stateNode;
-  target.return = source.return;
-  target.child = source.child;
-  target.sibling = source.sibling;
-  target.index = source.index;
-  target.ref = source.ref;
-  target.refCleanup = source.refCleanup;
-  target.pendingProps = source.pendingProps;
-  target.memoizedProps = source.memoizedProps;
-  target.updateQueue = source.updateQueue;
-  target.memoizedState = source.memoizedState;
-  target.dependencies = source.dependencies;
-  target.mode = source.mode;
-  target.flags = source.flags;
-  target.subtreeFlags = source.subtreeFlags;
-  target.deletions = source.deletions;
-  target.lanes = source.lanes;
-  target.childLanes = source.childLanes;
-  target.alternate = source.alternate;
-
-  {
-    target.actualDuration = source.actualDuration;
-    target.actualStartTime = source.actualStartTime;
-    target.selfBaseDuration = source.selfBaseDuration;
-    target.treeBaseDuration = source.treeBaseDuration;
-  }
-
-  target._debugSource = source._debugSource;
-  target._debugOwner = source._debugOwner;
-  target._debugNeedsRemount = source._debugNeedsRemount;
-  target._debugHookTypes = source._debugHookTypes;
-  return target;
+function isSuspenseInstanceFallback(instance) {
+  return instance.data === SUSPENSE_FALLBACK_START_DATA;
 }
+function getSuspenseInstanceFallbackErrorDetails(instance) {
+  var dataset = instance.nextSibling && instance.nextSibling.dataset;
+  var digest, message, stack;
 
-function FiberRootNode(
-  containerInfo, // $FlowFixMe[missing-local-annot]
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
-) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.pendingChildren = null;
-  this.current = null;
-  this.pingCache = null;
-  this.finishedWork = null;
-  this.timeoutHandle = noTimeout;
-  this.context = null;
-  this.pendingContext = null;
-  this.callbackNode = null;
-  this.callbackPriority = NoLane;
-  this.eventTimes = createLaneMap(NoLanes);
-  this.expirationTimes = createLaneMap(NoTimestamp);
-  this.pendingLanes = NoLanes;
-  this.suspendedLanes = NoLanes;
-  this.pingedLanes = NoLanes;
-  this.expiredLanes = NoLanes;
-  this.mutableReadLanes = NoLanes;
-  this.finishedLanes = NoLanes;
-  this.errorRecoveryDisabledLanes = NoLanes;
-  this.entangledLanes = NoLanes;
-  this.entanglements = createLaneMap(NoLanes);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
-
-  {
-    this.pooledCache = null;
-    this.pooledCacheLanes = NoLanes;
-  }
-
-  {
-    this.mutableSourceEagerHydrationData = null;
-  }
-
-  {
-    this.hydrationCallbacks = null;
-  }
-
-  this.incompleteTransitions = new Map();
-
-  if (enableTransitionTracing) {
-    this.transitionCallbacks = null;
-    var transitionLanesMap = (this.transitionLanes = []);
+  if (dataset) {
+    digest = dataset.dgst;
 
-    for (var i = 0; i < TotalLanes; i++) {
-      transitionLanesMap.push(null);
+    {
+      message = dataset.msg;
+      stack = dataset.stck;
     }
   }
 
   {
-    this.effectDuration = 0;
-    this.passiveEffectDuration = 0;
+    return {
+      message: message,
+      digest: digest,
+      stack: stack
+    };
   }
+}
+function registerSuspenseInstanceRetry(instance, callback) {
+  instance._reactRetry = callback;
+}
 
-  {
-    this.memoizedUpdaters = new Set();
-    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
+function getNextHydratable(node) {
+  // Skip non-hydratable nodes.
+  for (; node != null; node = node.nextSibling) {
+    var nodeType = node.nodeType;
 
-    for (var _i = 0; _i < TotalLanes; _i++) {
-      pendingUpdatersLaneMap.push(new Set());
+    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {
+      break;
     }
-  }
 
-  {
-    switch (tag) {
-      case ConcurrentRoot:
-        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
-        break;
+    if (nodeType === COMMENT_NODE) {
+      var nodeData = node.data;
 
-      case LegacyRoot:
-        this._debugRootType = hydrate ? "hydrate()" : "render()";
+      if (
+        nodeData === SUSPENSE_START_DATA ||
+        nodeData === SUSPENSE_FALLBACK_START_DATA ||
+        nodeData === SUSPENSE_PENDING_START_DATA
+      ) {
         break;
+      }
+
+      if (nodeData === SUSPENSE_END_DATA) {
+        return null;
+      }
     }
   }
+
+  return node;
 }
 
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
-  // host config, but because they are passed in at runtime, we have to thread
-  // them through the root constructor. Perhaps we should put them all into a
-  // single type, like a DynamicHostConfig that is defined by the renderer.
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+function getNextHydratableSibling(instance) {
+  return getNextHydratable(instance.nextSibling);
+}
+function getFirstHydratableChild(parentInstance) {
+  return getNextHydratable(parentInstance.firstChild);
+}
+function getFirstHydratableChildWithinContainer(parentContainer) {
+  return getNextHydratable(parentContainer.firstChild);
+}
+function getFirstHydratableChildWithinSuspenseInstance(parentInstance) {
+  return getNextHydratable(parentInstance.nextSibling);
+}
+function hydrateInstance(
+  instance,
+  type,
+  props,
+  hostContext,
+  internalInstanceHandle,
+  shouldWarnDev
 ) {
-  // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
-  var root = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
-  );
-
-  {
-    root.hydrationCallbacks = hydrationCallbacks;
-  }
+  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events
+  // get attached.
 
-  if (enableTransitionTracing) {
-    root.transitionCallbacks = transitionCallbacks;
-  } // Cyclic construction. This cheats the type system right now because
-  // stateNode is any.
+  updateFiberProps(instance, props); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  // when the legacy root API is removed.
 
-  var uninitializedFiber = createHostRootFiber(
-    tag,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride
-  );
-  root.current = uninitializedFiber;
-  uninitializedFiber.stateNode = root;
+  var isConcurrentMode =
+    (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;
+  var parentNamespace;
 
   {
-    var initialCache = createCache();
-    retainCache(initialCache); // The pooledCache is a fresh cache instance that is used temporarily
-    // for newly mounted boundaries during a render. In general, the
-    // pooledCache is always cleared from the root at the end of a render:
-    // it is either released when render commits, or moved to an Offscreen
-    // component if rendering suspends. Because the lifetime of the pooled
-    // cache is distinct from the main memoizedState.cache, it must be
-    // retained separately.
-
-    root.pooledCache = initialCache;
-    retainCache(initialCache);
-    var initialState = {
-      element: initialChildren,
-      isDehydrated: hydrate,
-      cache: initialCache
-    };
-    uninitializedFiber.memoizedState = initialState;
+    var hostContextDev = hostContext;
+    parentNamespace = hostContextDev.namespace;
   }
 
-  initializeUpdateQueue(uninitializedFiber);
-  return root;
+  return diffHydratedProperties(
+    instance,
+    type,
+    props,
+    isConcurrentMode,
+    shouldWarnDev,
+    parentNamespace
+  );
 }
-
-var ReactVersion = "18.3.0-www-modern-499f9087";
-
-function createPortal$1(
-  children,
-  containerInfo, // TODO: figure out the API for cross-renderer implementation.
-  implementation
+function hydrateTextInstance(
+  textInstance,
+  text,
+  internalInstanceHandle,
+  shouldWarnDev
 ) {
-  var key =
-    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete
+  return diffHydratedText(textInstance, text);
+}
+function hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {
+  precacheFiberNode(internalInstanceHandle, suspenseInstance);
+}
+function getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {
+  var node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
 
-  {
-    checkKeyStringCoercion(key);
-  }
+  var depth = 0;
 
-  return {
-    // This tag allow us to uniquely identify this as a React Portal
-    $$typeof: REACT_PORTAL_TYPE,
-    key: key == null ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
-  };
-}
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      var data = node.data;
 
-// Might add PROFILE later.
+      if (data === SUSPENSE_END_DATA) {
+        if (depth === 0) {
+          return getNextHydratableSibling(node);
+        } else {
+          depth--;
+        }
+      } else if (
+        data === SUSPENSE_START_DATA ||
+        data === SUSPENSE_FALLBACK_START_DATA ||
+        data === SUSPENSE_PENDING_START_DATA
+      ) {
+        depth++;
+      }
+    }
 
-var didWarnAboutNestedUpdates;
+    node = node.nextSibling;
+  } // TODO: Warn, we didn't find the end comment boundary.
 
-{
-  didWarnAboutNestedUpdates = false;
-}
+  return null;
+} // Returns the SuspenseInstance if this node is a direct child of a
+// SuspenseInstance. I.e. if its previous sibling is a Comment with
+// SUSPENSE_x_START_DATA. Otherwise, null.
 
-function getContextForSubtree(parentComponent) {
-  if (!parentComponent) {
-    return emptyContextObject;
-  }
+function getParentSuspenseInstance(targetInstance) {
+  var node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.
+  // There might be nested nodes so we need to keep track of how
+  // deep we are and only break out when we're back on top.
 
-  var fiber = get(parentComponent);
-  var parentContext = findCurrentUnmaskedContext();
+  var depth = 0;
 
-  if (fiber.tag === ClassComponent) {
-    var Component = fiber.type;
+  while (node) {
+    if (node.nodeType === COMMENT_NODE) {
+      var data = node.data;
 
-    if (isContextProvider()) {
-      return processChildContext(fiber, Component, parentContext);
+      if (
+        data === SUSPENSE_START_DATA ||
+        data === SUSPENSE_FALLBACK_START_DATA ||
+        data === SUSPENSE_PENDING_START_DATA
+      ) {
+        if (depth === 0) {
+          return node;
+        } else {
+          depth--;
+        }
+      } else if (data === SUSPENSE_END_DATA) {
+        depth++;
+      }
     }
+
+    node = node.previousSibling;
   }
 
-  return parentContext;
+  return null;
 }
-
-function createContainer(
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+function commitHydratedContainer(container) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(container);
+}
+function commitHydratedSuspenseInstance(suspenseInstance) {
+  // Retry if any event replaying was blocked on this.
+  retryIfBlockedOn(suspenseInstance);
+} // @TODO remove this function once float lands and hydrated tail nodes
+function didNotMatchHydratedContainerTextInstance(
+  parentContainer,
+  textInstance,
+  text,
+  isConcurrentMode,
+  shouldWarnDev
 ) {
-  var hydrate = false;
-  var initialChildren = null;
-  return createFiberRoot(
-    containerInfo,
-    tag,
-    hydrate,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
+  checkForUnmatchedText(
+    textInstance.nodeValue,
+    text,
+    isConcurrentMode,
+    shouldWarnDev
   );
 }
-function createHydrationContainer(
-  initialChildren, // TODO: Remove `callback` when we delete legacy mode.
-  callback,
-  containerInfo,
-  tag,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
+function didNotMatchHydratedTextInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  textInstance,
+  text,
+  isConcurrentMode,
+  shouldWarnDev
 ) {
-  var hydrate = true;
-  var root = createFiberRoot(
-    containerInfo,
-    tag,
-    hydrate,
-    initialChildren,
-    hydrationCallbacks,
-    isStrictMode,
-    concurrentUpdatesByDefaultOverride,
-    identifierPrefix,
-    onRecoverableError,
-    transitionCallbacks
-  ); // TODO: Move this to FiberRoot constructor
-
-  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
-  // a regular update because the initial render must match was was rendered
-  // on the server.
-  // NOTE: This update intentionally doesn't have a payload. We're only using
-  // the update to schedule work on the root fiber (and, for legacy roots, to
-  // enqueue the callback if one is provided).
-
-  var current = root.current;
-  var lane = requestUpdateLane(current);
-  var update = createUpdate(lane);
-  update.callback =
-    callback !== undefined && callback !== null ? callback : null;
-  var eventTime = requestEventTime();
-  enqueueUpdate(current, update, lane);
-  scheduleInitialHydrationOnRoot(root, lane, eventTime);
-  return root;
+  if (parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+    checkForUnmatchedText(
+      textInstance.nodeValue,
+      text,
+      isConcurrentMode,
+      shouldWarnDev
+    );
+  }
 }
-function updateContainer(element, container, parentComponent, callback) {
+function didNotHydrateInstanceWithinContainer(parentContainer, instance) {
   {
-    onScheduleRoot(container, element);
-  }
-
-  var current$1 = container.current;
-  var lane = requestUpdateLane(current$1);
-
-  if (enableSchedulingProfiler) {
-    markRenderScheduled(lane);
-  }
-
-  var context = getContextForSubtree(parentComponent);
-
-  if (container.context === null) {
-    container.context = context;
-  } else {
-    container.pendingContext = context;
+    if (instance.nodeType === ELEMENT_NODE) {
+      warnForDeletedHydratableElement(parentContainer, instance);
+    } else if (instance.nodeType === COMMENT_NODE);
+    else {
+      warnForDeletedHydratableText(parentContainer, instance);
+    }
   }
-
+}
+function didNotHydrateInstanceWithinSuspenseInstance(parentInstance, instance) {
   {
-    if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
-      didWarnAboutNestedUpdates = true;
+    // $FlowFixMe: Only Element or Document can be parent nodes.
+    var parentNode = parentInstance.parentNode;
 
-      error(
-        "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.",
-        getComponentNameFromFiber(current) || "Unknown"
-      );
+    if (parentNode !== null) {
+      if (instance.nodeType === ELEMENT_NODE) {
+        warnForDeletedHydratableElement(parentNode, instance);
+      } else if (instance.nodeType === COMMENT_NODE);
+      else {
+        warnForDeletedHydratableText(parentNode, instance);
+      }
     }
   }
-
-  var update = createUpdate(lane); // Caution: React DevTools currently depends on this property
-  // being called "element".
-
-  update.payload = {
-    element: element
-  };
-  callback = callback === undefined ? null : callback;
-
-  if (callback !== null) {
-    {
-      if (typeof callback !== "function") {
-        error(
-          "render(...): Expected the last optional `callback` argument to be a " +
-            "function. Instead received: %s.",
-          callback
-        );
+}
+function didNotHydrateInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  instance,
+  isConcurrentMode
+) {
+  {
+    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+      if (instance.nodeType === ELEMENT_NODE) {
+        warnForDeletedHydratableElement(parentInstance, instance);
+      } else if (instance.nodeType === COMMENT_NODE);
+      else {
+        warnForDeletedHydratableText(parentInstance, instance);
       }
     }
-
-    update.callback = callback;
   }
-
-  var root = enqueueUpdate(current$1, update, lane);
-
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, current$1, lane, eventTime);
-    entangleTransitions(root, current$1, lane);
+}
+function didNotFindHydratableInstanceWithinContainer(
+  parentContainer,
+  type,
+  props
+) {
+  {
+    warnForInsertedHydratedElement(parentContainer, type);
   }
-
-  return lane;
 }
-function attemptSynchronousHydration(fiber) {
-  switch (fiber.tag) {
-    case HostRoot: {
-      var root = fiber.stateNode;
-
-      if (isRootDehydrated(root)) {
-        // Flush the first scheduled "update".
-        var lanes = getHighestPriorityPendingLanes(root);
-        flushRoot(root, lanes);
-      }
-
-      break;
+function didNotFindHydratableTextInstanceWithinContainer(
+  parentContainer,
+  text
+) {
+  {
+    warnForInsertedHydratedText(parentContainer, text);
+  }
+}
+function didNotFindHydratableInstanceWithinSuspenseInstance(
+  parentInstance,
+  type,
+  props
+) {
+  {
+    // $FlowFixMe: Only Element or Document can be parent nodes.
+    var parentNode = parentInstance.parentNode;
+    if (parentNode !== null) warnForInsertedHydratedElement(parentNode, type);
+  }
+}
+function didNotFindHydratableTextInstanceWithinSuspenseInstance(
+  parentInstance,
+  text
+) {
+  {
+    // $FlowFixMe: Only Element or Document can be parent nodes.
+    var parentNode = parentInstance.parentNode;
+    if (parentNode !== null) warnForInsertedHydratedText(parentNode, text);
+  }
+}
+function didNotFindHydratableInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  type,
+  props,
+  isConcurrentMode
+) {
+  {
+    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+      warnForInsertedHydratedElement(parentInstance, type);
     }
-
-    case SuspenseComponent: {
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
-        if (root !== null) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);
-        }
-      }); // If we're still blocked after this, we need to increase
-      // the priority of any promises resolving within this
-      // boundary so that they next attempt also has higher pri.
-
-      var retryLane = SyncLane;
-      markRetryLaneIfNotHydrated(fiber, retryLane);
-      break;
+  }
+}
+function didNotFindHydratableTextInstance(
+  parentType,
+  parentProps,
+  parentInstance,
+  text,
+  isConcurrentMode
+) {
+  {
+    if (isConcurrentMode || parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {
+      warnForInsertedHydratedText(parentInstance, text);
     }
   }
 }
-
-function markRetryLaneImpl(fiber, retryLane) {
-  var suspenseState = fiber.memoizedState;
-
-  if (suspenseState !== null && suspenseState.dehydrated !== null) {
-    suspenseState.retryLane = higherPriorityLane(
-      suspenseState.retryLane,
-      retryLane
+function errorHydratingContainer(parentContainer) {
+  {
+    // TODO: This gets logged by onRecoverableError, too, so we should be
+    // able to remove it.
+    error(
+      "An error occurred during hydration. The server HTML was replaced with client content in <%s>.",
+      parentContainer.nodeName.toLowerCase()
     );
   }
-} // Increases the priority of thenables when they resolve within this boundary.
-
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  var alternate = fiber.alternate;
-
-  if (alternate) {
-    markRetryLaneImpl(alternate, retryLane);
-  }
-}
+} // -------------------
+function findFiberRoot(node) {
+  var stack = [node];
+  var index = 0;
 
-function attemptDiscreteHydration(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority and they should not suspend on I/O,
-    // since you have to wrap anything that might suspend in
-    // Suspense.
-    return;
-  }
+  while (index < stack.length) {
+    var current = stack[index++];
 
-  var lane = SyncLane;
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
+    if (isContainerMarkedAsRoot(current)) {
+      return getInstanceFromNode$1(current);
+    }
 
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+    stack.push.apply(stack, current.children);
   }
 
-  markRetryLaneIfNotHydrated(fiber, lane);
+  return null;
 }
-function attemptContinuousHydration(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority and they should not suspend on I/O,
-    // since you have to wrap anything that might suspend in
-    // Suspense.
-    return;
+function getBoundingRect(node) {
+  var rect = node.getBoundingClientRect();
+  return {
+    x: rect.left,
+    y: rect.top,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function matchAccessibilityRole(node, role) {
+  if (hasRole(node, role)) {
+    return true;
   }
 
-  var lane = SelectiveHydrationLane;
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
+  return false;
+}
+function getTextContent(fiber) {
+  switch (fiber.tag) {
+    case HostHoistable:
+    case HostSingleton:
+    case HostComponent:
+      var textContent = "";
+      var childNodes = fiber.stateNode.childNodes;
 
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-  }
+      for (var i = 0; i < childNodes.length; i++) {
+        var childNode = childNodes[i];
 
-  markRetryLaneIfNotHydrated(fiber, lane);
-}
-function attemptHydrationAtCurrentPriority(fiber) {
-  if (fiber.tag !== SuspenseComponent) {
-    // We ignore HostRoots here because we can't increase
-    // their priority other than synchronously flush it.
-    return;
-  }
+        if (childNode.nodeType === Node.TEXT_NODE) {
+          textContent += childNode.textContent;
+        }
+      }
 
-  var lane = requestUpdateLane(fiber);
-  var root = enqueueConcurrentRenderForLane(fiber, lane);
+      return textContent;
 
-  if (root !== null) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+    case HostText:
+      return fiber.stateNode.textContent;
   }
 
-  markRetryLaneIfNotHydrated(fiber, lane);
-}
-
-var shouldErrorImpl = function (fiber) {
   return null;
-};
-
-function shouldError(fiber) {
-  return shouldErrorImpl(fiber);
 }
-
-var shouldSuspendImpl = function (fiber) {
-  return false;
-};
-
-function shouldSuspend(fiber) {
-  return shouldSuspendImpl(fiber);
+function isHiddenSubtree(fiber) {
+  return fiber.tag === HostComponent && fiber.memoizedProps.hidden === true;
 }
-var overrideHookState = null;
-var overrideHookStateDeletePath = null;
-var overrideHookStateRenamePath = null;
-var overrideProps = null;
-var overridePropsDeletePath = null;
-var overridePropsRenamePath = null;
-var scheduleUpdate = null;
-var setErrorHandler = null;
-var setSuspenseHandler = null;
+function setFocusIfFocusable(node) {
+  // The logic for determining if an element is focusable is kind of complex,
+  // and since we want to actually change focus anyway- we can just skip it.
+  // Instead we'll just listen for a "focus" event to verify that focus was set.
+  //
+  // We could compare the node to document.activeElement after focus,
+  // but this would not handle the case where application code managed focus to automatically blur.
+  var didFocus = false;
 
-{
-  var copyWithDeleteImpl = function (obj, path, index) {
-    var key = path[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
+  var handleFocus = function () {
+    didFocus = true;
+  };
 
-    if (index + 1 === path.length) {
-      if (isArray(updated)) {
-        updated.splice(key, 1);
-      } else {
-        delete updated[key];
-      }
+  var element = node;
 
-      return updated;
-    } // $FlowFixMe number or string is fine here
+  try {
+    element.addEventListener("focus", handleFocus); // $FlowFixMe[method-unbinding]
 
-    updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
-    return updated;
-  };
+    (element.focus || HTMLElement.prototype.focus).call(element);
+  } finally {
+    element.removeEventListener("focus", handleFocus);
+  }
 
-  var copyWithDelete = function (obj, path) {
-    return copyWithDeleteImpl(obj, path, 0);
+  return didFocus;
+}
+function setupIntersectionObserver(targets, callback, options) {
+  var rectRatioCache = new Map();
+  targets.forEach(function (target) {
+    rectRatioCache.set(target, {
+      rect: getBoundingRect(target),
+      ratio: 0
+    });
+  });
+
+  var handleIntersection = function (entries) {
+    entries.forEach(function (entry) {
+      var boundingClientRect = entry.boundingClientRect,
+        intersectionRatio = entry.intersectionRatio,
+        target = entry.target;
+      rectRatioCache.set(target, {
+        rect: {
+          x: boundingClientRect.left,
+          y: boundingClientRect.top,
+          width: boundingClientRect.width,
+          height: boundingClientRect.height
+        },
+        ratio: intersectionRatio
+      });
+    });
+    callback(Array.from(rectRatioCache.values()));
   };
 
-  var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
-    var oldKey = oldPath[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-
-    if (index + 1 === oldPath.length) {
-      var newKey = newPath[index]; // $FlowFixMe number or string is fine here
-
-      updated[newKey] = updated[oldKey];
-
-      if (isArray(updated)) {
-        updated.splice(oldKey, 1);
-      } else {
-        delete updated[oldKey];
-      }
-    } else {
-      // $FlowFixMe number or string is fine here
-      updated[oldKey] = copyWithRenameImpl(
-        // $FlowFixMe number or string is fine here
-        obj[oldKey],
-        oldPath,
-        newPath,
-        index + 1
-      );
+  var observer = new IntersectionObserver(handleIntersection, options);
+  targets.forEach(function (target) {
+    observer.observe(target);
+  });
+  return {
+    disconnect: function () {
+      return observer.disconnect();
+    },
+    observe: function (target) {
+      rectRatioCache.set(target, {
+        rect: getBoundingRect(target),
+        ratio: 0
+      });
+      observer.observe(target);
+    },
+    unobserve: function (target) {
+      rectRatioCache.delete(target);
+      observer.unobserve(target);
     }
-
-    return updated;
   };
+}
+function requestPostPaintCallback(callback) {
+  localRequestAnimationFrame(function () {
+    localRequestAnimationFrame(function (time) {
+      return callback(time);
+    });
+  });
+} // -------------------
+function isHostHoistableType(type, props, hostContext) {
+  var outsideHostContainerContext;
+  var namespace;
 
-  var copyWithRename = function (obj, oldPath, newPath) {
-    if (oldPath.length !== newPath.length) {
-      warn("copyWithRename() expects paths of the same length");
+  {
+    var hostContextDev = hostContext; // We can only render resources when we are not within the host container context
 
-      return;
-    } else {
-      for (var i = 0; i < newPath.length - 1; i++) {
-        if (oldPath[i] !== newPath[i]) {
-          warn(
-            "copyWithRename() expects paths to be the same except for the deepest key"
-          );
+    outsideHostContainerContext =
+      !hostContextDev.ancestorInfo.containerTagInScope;
+    namespace = hostContextDev.namespace;
+  } // Global opt out of hoisting for anything in SVG Namespace or anything with an itemProp inside an itemScope
 
-          return;
-        }
+  if (namespace === SVG_NAMESPACE || props.itemProp != null) {
+    {
+      if (
+        outsideHostContainerContext &&
+        props.itemProp != null &&
+        (type === "meta" ||
+          type === "title" ||
+          type === "style" ||
+          type === "link" ||
+          type === "script")
+      ) {
+        error(
+          "Cannot render a <%s> outside the main document if it has an `itemProp` prop. `itemProp` suggests the tag belongs to an" +
+            " `itemScope` which can appear anywhere in the DOM. If you were intending for React to hoist this <%s> remove the `itemProp` prop." +
+            " Otherwise, try moving this tag into the <head> or <body> of the Document.",
+          type,
+          type
+        );
       }
     }
 
-    return copyWithRenameImpl(obj, oldPath, newPath, 0);
-  };
+    return false;
+  }
 
-  var copyWithSetImpl = function (obj, path, index, value) {
-    if (index >= path.length) {
-      return value;
+  switch (type) {
+    case "meta":
+    case "title": {
+      return true;
     }
 
-    var key = path[index];
-    var updated = isArray(obj) ? obj.slice() : assign({}, obj); // $FlowFixMe number or string is fine here
-
-    updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
-    return updated;
-  };
-
-  var copyWithSet = function (obj, path, value) {
-    return copyWithSetImpl(obj, path, 0, value);
-  };
+    case "style": {
+      if (
+        typeof props.precedence !== "string" ||
+        typeof props.href !== "string" ||
+        props.href === ""
+      ) {
+        {
+          if (outsideHostContainerContext) {
+            error(
+              "Cannot render a <style> outside the main document without knowing its precedence and a unique href key." +
+                " React can hoist and deduplicate <style> tags if you provide a `precedence` prop along with an `href` prop that" +
+                ' does not conflic with the `href` values used in any other hoisted <style> or <link rel="stylesheet" ...> tags. ' +
+                " Note that hoisting <style> tags is considered an advanced feature that most will not use directly." +
+                ' Consider moving the <style> tag to the <head> or consider adding a `precedence="default"` and `href="some unique resource identifier"`, or move the <style>' +
+                " to the <style> tag."
+            );
+          }
+        }
 
-  var findHook = function (fiber, id) {
-    // For now, the "id" of stateful hooks is just the stateful hook index.
-    // This may change in the future with e.g. nested hooks.
-    var currentHook = fiber.memoizedState;
+        return false;
+      }
 
-    while (currentHook !== null && id > 0) {
-      currentHook = currentHook.next;
-      id--;
+      return true;
     }
 
-    return currentHook;
-  }; // Support DevTools editable values for useState and useReducer.
-
-  overrideHookState = function (fiber, id, path, value) {
-    var hook = findHook(fiber, id);
-
-    if (hook !== null) {
-      var newState = copyWithSet(hook.memoizedState, path, value);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+    case "link": {
+      if (
+        typeof props.rel !== "string" ||
+        typeof props.href !== "string" ||
+        props.href === "" ||
+        props.onLoad ||
+        props.onError
+      ) {
+        {
+          if (
+            props.rel === "stylesheet" &&
+            typeof props.precedence === "string"
+          ) {
+            validateLinkPropsForStyleResource(props);
+          }
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+          if (outsideHostContainerContext) {
+            if (
+              typeof props.rel !== "string" ||
+              typeof props.href !== "string" ||
+              props.href === ""
+            ) {
+              error(
+                "Cannot render a <link> outside the main document without a `rel` and `href` prop." +
+                  " Try adding a `rel` and/or `href` prop to this <link> or moving the link into the <head> tag"
+              );
+            } else if (props.onError || props.onLoad) {
+              error(
+                "Cannot render a <link> with onLoad or onError listeners outside the main document." +
+                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
+                  " somewhere in the <body>."
+              );
+            }
+          }
+        }
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+        return false;
       }
-    }
-  };
 
-  overrideHookStateDeletePath = function (fiber, id, path) {
-    var hook = findHook(fiber, id);
+      switch (props.rel) {
+        case "stylesheet": {
+          var precedence = props.precedence,
+            disabled = props.disabled;
 
-    if (hook !== null) {
-      var newState = copyWithDelete(hook.memoizedState, path);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+          {
+            if (typeof precedence !== "string") {
+              if (outsideHostContainerContext) {
+                error(
+                  'Cannot render a <link rel="stylesheet" /> outside the main document without knowing its precedence.' +
+                    ' Consider adding precedence="default" or moving it into the root <head> tag.'
+                );
+              }
+            }
+          }
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+          return typeof precedence === "string" && disabled == null;
+        }
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+        default: {
+          return true;
+        }
       }
     }
-  };
 
-  overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
-    var hook = findHook(fiber, id);
+    case "script": {
+      if (
+        props.async !== true ||
+        props.onLoad ||
+        props.onError ||
+        typeof props.src !== "string" ||
+        !props.src
+      ) {
+        {
+          if (outsideHostContainerContext) {
+            if (props.async !== true) {
+              error(
+                "Cannot render a sync or defer <script> outside the main document without knowing its order." +
+                  ' Try adding async="" or moving it into the root <head> tag.'
+              );
+            } else if (props.onLoad || props.onError) {
+              error(
+                "Cannot render a <script> with onLoad or onError listeners outside the main document." +
+                  " Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or" +
+                  " somewhere in the <body>."
+              );
+            } else {
+              error(
+                "Cannot render a <script> outside the main document without `async={true}` and a non-empty `src` prop." +
+                  " Ensure there is a valid `src` and either make the script async or move it into the root <head> tag or" +
+                  " somewhere in the <body>."
+              );
+            }
+          }
+        }
 
-    if (hook !== null) {
-      var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
-      hook.memoizedState = newState;
-      hook.baseState = newState; // We aren't actually adding an update to the queue,
-      // because there is no update we can add for useReducer hooks that won't trigger an error.
-      // (There's no appropriate action type for DevTools overrides.)
-      // As a result though, React will see the scheduled update as a noop and bailout.
-      // Shallow cloning props works as a workaround for now to bypass the bailout check.
+        return false;
+      }
 
-      fiber.memoizedProps = assign({}, fiber.memoizedProps);
-      var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+      return true;
+    }
 
-      if (root !== null) {
-        scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    case "noscript":
+    case "template": {
+      {
+        if (outsideHostContainerContext) {
+          error(
+            "Cannot render <%s> outside the main document. Try moving it into the root <head> tag.",
+            type
+          );
+        }
       }
+
+      return false;
     }
-  }; // Support DevTools props for function components, forwardRef, memo, host components, etc.
+  }
 
-  overrideProps = function (fiber, path, value) {
-    fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+  return false;
+}
+function prepareRendererToRender(rootContainer) {
+  {
+    prepareToRenderResources(rootContainer);
+  }
+}
+function resetRendererAfterRender() {
+  {
+    cleanupAfterRenderResources();
+  }
+}
+function isHostSingletonType(type) {
+  return type === "html" || type === "head" || type === "body";
+}
+function resolveSingletonInstance(
+  type,
+  props,
+  rootContainerInstance,
+  hostContext,
+  validateDOMNestingDev
+) {
+  {
+    var hostContextDev = hostContext;
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
+    if (validateDOMNestingDev) {
+      validateDOMNesting(type, null, hostContextDev.ancestorInfo);
     }
+  }
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+  var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerInstance);
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
-    }
-  };
+  switch (type) {
+    case "html": {
+      var documentElement = ownerDocument.documentElement;
 
-  overridePropsDeletePath = function (fiber, path) {
-    fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
+      if (!documentElement) {
+        throw new Error(
+          "React expected an <html> element (document.documentElement) to exist in the Document but one was" +
+            " not found. React never removes the documentElement for any Document it renders into so" +
+            " the cause is likely in some other script running on this page."
+        );
+      }
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
+      return documentElement;
     }
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    case "head": {
+      var head = ownerDocument.head;
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      if (!head) {
+        throw new Error(
+          "React expected a <head> element (document.head) to exist in the Document but one was" +
+            " not found. React never removes the head for any Document it renders into so" +
+            " the cause is likely in some other script running on this page."
+        );
+      }
+
+      return head;
     }
-  };
 
-  overridePropsRenamePath = function (fiber, oldPath, newPath) {
-    fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
+    case "body": {
+      var body = ownerDocument.body;
 
-    if (fiber.alternate) {
-      fiber.alternate.pendingProps = fiber.pendingProps;
-    }
+      if (!body) {
+        throw new Error(
+          "React expected a <body> element (document.body) to exist in the Document but one was" +
+            " not found. React never removes the body for any Document it renders into so" +
+            " the cause is likely in some other script running on this page."
+        );
+      }
 
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+      return body;
+    }
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+    default: {
+      throw new Error(
+        "resolveSingletonInstance was called with an element type that is not supported. This is a bug in React."
+      );
     }
-  };
+  }
+}
+function acquireSingletonInstance(
+  type,
+  props,
+  instance,
+  internalInstanceHandle
+) {
+  {
+    var currentInstanceHandle = getInstanceFromNode$1(instance);
 
-  scheduleUpdate = function (fiber) {
-    var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
+    if (currentInstanceHandle) {
+      var tagName = instance.tagName.toLowerCase();
 
-    if (root !== null) {
-      scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
+      error(
+        "You are mounting a new %s component when a previous one has not first unmounted. It is an" +
+          " error to render more than one %s component at a time and attributes and children of these" +
+          " components will likely fail in unpredictable ways. Please only render a single instance of" +
+          " <%s> and if you need to mount a new one, ensure any previous ones have unmounted first.",
+        tagName,
+        tagName,
+        tagName
+      );
     }
-  };
 
-  setErrorHandler = function (newShouldErrorImpl) {
-    shouldErrorImpl = newShouldErrorImpl;
-  };
+    switch (type) {
+      case "html":
+      case "head":
+      case "body": {
+        break;
+      }
 
-  setSuspenseHandler = function (newShouldSuspendImpl) {
-    shouldSuspendImpl = newShouldSuspendImpl;
-  };
-}
+      default: {
+        error(
+          "acquireSingletonInstance was called with an element type that is not supported. This is a bug in React."
+        );
+      }
+    }
+  }
 
-function findHostInstanceByFiber(fiber) {
-  var hostFiber = findCurrentHostFiber(fiber);
+  var attributes = instance.attributes;
 
-  if (hostFiber === null) {
-    return null;
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
   }
 
-  return hostFiber.stateNode;
+  setInitialProperties(instance, type, props);
+  precacheFiberNode(internalInstanceHandle, instance);
+  updateFiberProps(instance, props);
 }
+function releaseSingletonInstance(instance) {
+  var attributes = instance.attributes;
 
-function emptyFindFiberByHostInstance(instance) {
-  return null;
-}
+  while (attributes.length) {
+    instance.removeAttributeNode(attributes[0]);
+  }
 
-function getCurrentFiberForDevTools() {
-  return current;
+  detachDeletedInstance(instance);
 }
+function clearSingleton(instance) {
+  var element = instance;
+  var node = element.firstChild;
 
-function injectIntoDevTools(devToolsConfig) {
-  var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
-  var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
-  return injectInternals({
-    bundleType: devToolsConfig.bundleType,
-    version: devToolsConfig.version,
-    rendererPackageName: devToolsConfig.rendererPackageName,
-    rendererConfig: devToolsConfig.rendererConfig,
-    overrideHookState: overrideHookState,
-    overrideHookStateDeletePath: overrideHookStateDeletePath,
-    overrideHookStateRenamePath: overrideHookStateRenamePath,
-    overrideProps: overrideProps,
-    overridePropsDeletePath: overridePropsDeletePath,
-    overridePropsRenamePath: overridePropsRenamePath,
-    setErrorHandler: setErrorHandler,
-    setSuspenseHandler: setSuspenseHandler,
-    scheduleUpdate: scheduleUpdate,
-    currentDispatcherRef: ReactCurrentDispatcher,
-    findHostInstanceByFiber: findHostInstanceByFiber,
-    findFiberByHostInstance:
-      findFiberByHostInstance || emptyFindFiberByHostInstance,
-    // React Refresh
-    findHostInstancesForRefresh: findHostInstancesForRefresh,
-    scheduleRefresh: scheduleRefresh,
-    scheduleRoot: scheduleRoot,
-    setRefreshHandler: setRefreshHandler,
-    // Enables DevTools to append owner stacks to error messages in DEV mode.
-    getCurrentFiber: getCurrentFiberForDevTools,
-    // Enables DevTools to detect reconciler version rather than renderer version
-    // which may not match for third party renderers.
-    reconcilerVersion: ReactVersion
-  });
+  while (node) {
+    var nextNode = node.nextSibling;
+    var nodeName = node.nodeName;
+
+    if (
+      isMarkedHoistable(node) ||
+      nodeName === "HEAD" ||
+      nodeName === "BODY" ||
+      nodeName === "STYLE" ||
+      (nodeName === "LINK" && node.rel.toLowerCase() === "stylesheet")
+    );
+    else {
+      element.removeChild(node);
+    }
+
+    node = nextNode;
+  }
+
+  return;
 }
 
 var Dispatcher = Internals.Dispatcher;
@@ -43961,13 +43907,6 @@ function preinit() {
   // so we favor silent bailout over warning or erroring.
 }
 
-setAttemptSynchronousHydration(attemptSynchronousHydration);
-setAttemptDiscreteHydration(attemptDiscreteHydration);
-setAttemptContinuousHydration(attemptContinuousHydration);
-setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority);
-setGetCurrentUpdatePriority(getCurrentUpdatePriority$1);
-setAttemptHydrationAtPriority(runWithPriority);
-
 {
   if (
     typeof Map !== "function" || // $FlowFixMe Flow incorrectly thinks Map has no prototype
@@ -43985,9 +43924,6 @@ setAttemptHydrationAtPriority(runWithPriority);
   }
 }
 
-setRestoreImplementation(restoreControlledState);
-setBatchingImplementation(batchedUpdates, discreteUpdates, flushSync$1);
-
 function createPortal(children, container) {
   var key =
     arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
@@ -44050,7 +43986,7 @@ Internals.Events = [
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
 var foundDevTools = injectIntoDevTools({
   findFiberByHostInstance: getClosestInstanceFromNode,
@@ -44105,7 +44041,7 @@ exports.preconnect = preconnect;
 exports.prefetchDNS = prefetchDNS;
 exports.preinit = preinit;
 exports.preload = preload;
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = createEventHandle;
 exports.unstable_flushControlled = flushControlled;
 exports.unstable_runWithPriority = runWithPriority;
diff --git a/compiled/facebook-www/ReactDOMTesting-prod.classic.js b/compiled/facebook-www/ReactDOMTesting-prod.classic.js
index 2749b63621bac..6b28a0af2e684 100644
--- a/compiled/facebook-www/ReactDOMTesting-prod.classic.js
+++ b/compiled/facebook-www/ReactDOMTesting-prod.classic.js
@@ -20,6 +20,7 @@ var Scheduler = require("scheduler"),
   dynamicFeatureFlags = require("ReactFeatureFlags"),
   disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   enableFilterEmptyStringAttributesDOM =
@@ -1440,7 +1441,10 @@ function setInitialProperties(domElement, tag, rawProps) {
         ? setValueForStyles(domElement, nextProp)
         : "dangerouslySetInnerHTML" === propKey
         ? ((nextProp = nextProp ? nextProp.__html : void 0),
-          null != nextProp && setInnerHTML$1(domElement, nextProp))
+          null != nextProp &&
+            (disableIEWorkarounds
+              ? (domElement.innerHTML = nextProp)
+              : setInnerHTML$1(domElement, nextProp)))
         : "children" === propKey
         ? "string" === typeof nextProp
           ? "body" === tag ||
@@ -1513,7 +1517,9 @@ function updateProperties(
     "style" === propKey
       ? setValueForStyles(domElement, propValue)
       : "dangerouslySetInnerHTML" === propKey
-      ? setInnerHTML$1(domElement, propValue)
+      ? disableIEWorkarounds
+        ? (domElement.innerHTML = propValue)
+        : setInnerHTML$1(domElement, propValue)
       : "children" === propKey
       ? setTextContent(domElement, propValue)
       : setValueForProperty(domElement, propKey, propValue, lastRawProps);
@@ -12681,6 +12687,30 @@ function getPublicRootInstance(container) {
       return container.child.stateNode;
   }
 }
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case 3:
+      var root$182 = fiber.stateNode;
+      if (root$182.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$182.pendingLanes);
+        0 !== lanes &&
+          (markRootEntangled(root$182, lanes | 2),
+          ensureRootIsScheduled(root$182, now()),
+          0 === (executionContext & 6) &&
+            (resetRenderTimer(), flushSyncCallbacks()));
+      }
+      break;
+    case 13:
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, 2);
+        if (null !== root) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
+        }
+      }),
+        markRetryLaneIfNotHydrated(fiber, 2);
+  }
+}
 function markRetryLaneImpl(fiber, retryLane) {
   fiber = fiber.memoizedState;
   if (null !== fiber && null !== fiber.dehydrated) {
@@ -12692,6 +12722,16 @@ function markRetryLaneIfNotHydrated(fiber, retryLane) {
   markRetryLaneImpl(fiber, retryLane);
   (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
 }
+function attemptContinuousHydration(fiber) {
+  if (13 === fiber.tag) {
+    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
+    if (null !== root) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
+    }
+    markRetryLaneIfNotHydrated(fiber, 134217728);
+  }
+}
 function emptyFindFiberByHostInstance() {
   return null;
 }
@@ -12728,7 +12768,7 @@ function ReactDOMHydrationRoot(internalRoot) {
 }
 ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
   if (target) {
-    var updatePriority = getCurrentUpdatePriority();
+    var updatePriority = currentUpdatePriority;
     target = { blockedOn: null, target: target, priority: updatePriority };
     for (
       var i = 0;
@@ -12876,17 +12916,46 @@ function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
         listenerSet.add(listenerSetKey));
     } else throw Error(formatProdErrorMessage(369));
 }
-var restoreImpl = null,
-  restoreTarget = null,
+var restoreTarget = null,
   restoreQueue = null;
 function restoreStateOfTarget(target) {
-  if ((target = getInstanceFromNode(target))) {
-    if ("function" !== typeof restoreImpl)
-      throw Error(formatProdErrorMessage(280));
-    var stateNode = target.stateNode;
-    stateNode &&
-      ((stateNode = getFiberCurrentPropsFromNode(stateNode)),
-      restoreImpl(target.stateNode, target.type, stateNode));
+  var internalInstance = getInstanceFromNode(target);
+  if (internalInstance && (target = internalInstance.stateNode)) {
+    var props = getFiberCurrentPropsFromNode(target);
+    a: switch (((target = internalInstance.stateNode), internalInstance.type)) {
+      case "input":
+        updateWrapper$1(target, props);
+        internalInstance = props.name;
+        if ("radio" === props.type && null != internalInstance) {
+          for (props = target; props.parentNode; ) props = props.parentNode;
+          props = props.querySelectorAll(
+            "input[name=" +
+              JSON.stringify("" + internalInstance) +
+              '][type="radio"]'
+          );
+          for (
+            internalInstance = 0;
+            internalInstance < props.length;
+            internalInstance++
+          ) {
+            var otherNode = props[internalInstance];
+            if (otherNode !== target && otherNode.form === target.form) {
+              var otherProps = getFiberCurrentPropsFromNode(otherNode);
+              if (!otherProps) throw Error(formatProdErrorMessage(90));
+              updateValueIfChanged(otherNode);
+              updateWrapper$1(otherNode, otherProps);
+            }
+          }
+        }
+        break a;
+      case "textarea":
+        updateWrapper(target, props);
+        break a;
+      case "select":
+        (internalInstance = props.value),
+          null != internalInstance &&
+            updateOptions(target, !!props.multiple, internalInstance, !1);
+    }
   }
 }
 function enqueueStateRestore(target) {
@@ -12907,114 +12976,6 @@ function restoreStateIfNeeded() {
         restoreStateOfTarget(queuedTargets[target]);
   }
 }
-function batchedUpdatesImpl(fn, bookkeeping) {
-  return fn(bookkeeping);
-}
-function flushSyncImpl() {}
-var isInsideEventHandler = !1;
-function batchedUpdates(fn, a, b) {
-  if (isInsideEventHandler) return fn(a, b);
-  isInsideEventHandler = !0;
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    if (
-      ((isInsideEventHandler = !1),
-      null !== restoreTarget || null !== restoreQueue)
-    )
-      flushSyncImpl(), restoreStateIfNeeded();
-  }
-}
-_attemptSynchronousHydration = function (fiber) {
-  switch (fiber.tag) {
-    case 3:
-      var root$182 = fiber.stateNode;
-      if (root$182.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$182.pendingLanes);
-        0 !== lanes &&
-          (markRootEntangled(root$182, lanes | 2),
-          ensureRootIsScheduled(root$182, now()),
-          0 === (executionContext & 6) &&
-            (resetRenderTimer(), flushSyncCallbacks()));
-      }
-      break;
-    case 13:
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        if (null !== root) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-        }
-      }),
-        markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptDiscreteHydration = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptContinuousHydration = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 134217728);
-  }
-};
-attemptHydrationAtCurrentPriority = function (fiber) {
-  if (13 === fiber.tag) {
-    var lane = requestUpdateLane(fiber),
-      root = enqueueConcurrentRenderForLane(fiber, lane);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, lane);
-  }
-};
-getCurrentUpdatePriority = function () {
-  return currentUpdatePriority;
-};
-attemptHydrationAtPriority = runWithPriority;
-restoreImpl = function (domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, props);
-      tag = props.name;
-      if ("radio" === props.type && null != tag) {
-        for (props = domElement; props.parentNode; ) props = props.parentNode;
-        props = props.querySelectorAll(
-          "input[name=" + JSON.stringify("" + tag) + '][type="radio"]'
-        );
-        for (tag = 0; tag < props.length; tag++) {
-          var otherNode = props[tag];
-          if (otherNode !== domElement && otherNode.form === domElement.form) {
-            var otherProps = getFiberCurrentPropsFromNode(otherNode);
-            if (!otherProps) throw Error(formatProdErrorMessage(90));
-            updateValueIfChanged(otherNode);
-            updateWrapper$1(otherNode, otherProps);
-          }
-        }
-      }
-      break;
-    case "textarea":
-      updateWrapper(domElement, props);
-      break;
-    case "select":
-      (tag = props.value),
-        null != tag && updateOptions(domElement, !!props.multiple, tag, !1);
-  }
-};
-batchedUpdatesImpl = batchedUpdates$1;
-flushSyncImpl = flushSync$1;
 Internals.Events = [
   getInstanceFromNode,
   getNodeFromInstance,
@@ -13023,17 +12984,17 @@ Internals.Events = [
   restoreStateIfNeeded,
   batchedUpdates$1
 ];
-var devToolsConfig$jscomp$inline_1631 = {
+var devToolsConfig$jscomp$inline_1602 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-classic-d10ee72f",
+  version: "18.3.0-www-classic-773bb029",
   rendererPackageName: "react-dom"
 };
-var internals$jscomp$inline_2189 = {
-  bundleType: devToolsConfig$jscomp$inline_1631.bundleType,
-  version: devToolsConfig$jscomp$inline_1631.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1631.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1631.rendererConfig,
+var internals$jscomp$inline_2168 = {
+  bundleType: devToolsConfig$jscomp$inline_1602.bundleType,
+  version: devToolsConfig$jscomp$inline_1602.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1602.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1602.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -13049,26 +13010,26 @@ var internals$jscomp$inline_2189 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1631.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1602.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-classic-d10ee72f"
+  reconcilerVersion: "18.3.0-www-classic-773bb029"
 };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
-  var hook$jscomp$inline_2190 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  var hook$jscomp$inline_2169 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
   if (
-    !hook$jscomp$inline_2190.isDisabled &&
-    hook$jscomp$inline_2190.supportsFiber
+    !hook$jscomp$inline_2169.isDisabled &&
+    hook$jscomp$inline_2169.supportsFiber
   )
     try {
-      (rendererID = hook$jscomp$inline_2190.inject(
-        internals$jscomp$inline_2189
+      (rendererID = hook$jscomp$inline_2169.inject(
+        internals$jscomp$inline_2168
       )),
-        (injectedHook = hook$jscomp$inline_2190);
+        (injectedHook = hook$jscomp$inline_2169);
     } catch (err) {}
 }
 var Dispatcher = Internals.Dispatcher,
@@ -13917,6 +13878,20 @@ function getResourcesFromRoot(root) {
 function markNodeAsHoistable(node) {
   node[internalHoistableMarker] = !0;
 }
+var isInsideEventHandler = !1;
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) return fn(a, b);
+  isInsideEventHandler = !0;
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    if (
+      ((isInsideEventHandler = !1),
+      null !== restoreTarget || null !== restoreQueue)
+    )
+      flushSync$1(), restoreStateIfNeeded();
+  }
+}
 function getListener(inst, registrationName) {
   var stateNode = inst.stateNode;
   if (null === stateNode) return null;
@@ -14436,14 +14411,14 @@ var isInputEventSupported = !1;
 if (canUseDOM) {
   var JSCompiler_inline_result$jscomp$318;
   if (canUseDOM) {
-    var isSupported$jscomp$inline_1706 = "oninput" in document;
-    if (!isSupported$jscomp$inline_1706) {
-      var element$jscomp$inline_1707 = document.createElement("div");
-      element$jscomp$inline_1707.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_1706 =
-        "function" === typeof element$jscomp$inline_1707.oninput;
+    var isSupported$jscomp$inline_1679 = "oninput" in document;
+    if (!isSupported$jscomp$inline_1679) {
+      var element$jscomp$inline_1680 = document.createElement("div");
+      element$jscomp$inline_1680.setAttribute("oninput", "return;");
+      isSupported$jscomp$inline_1679 =
+        "function" === typeof element$jscomp$inline_1680.oninput;
     }
-    JSCompiler_inline_result$jscomp$318 = isSupported$jscomp$inline_1706;
+    JSCompiler_inline_result$jscomp$318 = isSupported$jscomp$inline_1679;
   } else JSCompiler_inline_result$jscomp$318 = !1;
   isInputEventSupported =
     JSCompiler_inline_result$jscomp$318 &&
@@ -14584,20 +14559,20 @@ function registerSimpleEvent(domEventName, reactName) {
   registerTwoPhaseEvent(reactName, [domEventName]);
 }
 for (
-  var i$jscomp$inline_1719 = 0;
-  i$jscomp$inline_1719 < simpleEventPluginEvents.length;
-  i$jscomp$inline_1719++
+  var i$jscomp$inline_1692 = 0;
+  i$jscomp$inline_1692 < simpleEventPluginEvents.length;
+  i$jscomp$inline_1692++
 ) {
-  var eventName$jscomp$inline_1720 =
-      simpleEventPluginEvents[i$jscomp$inline_1719],
-    domEventName$jscomp$inline_1721 =
-      eventName$jscomp$inline_1720.toLowerCase(),
-    capitalizedEvent$jscomp$inline_1722 =
-      eventName$jscomp$inline_1720[0].toUpperCase() +
-      eventName$jscomp$inline_1720.slice(1);
+  var eventName$jscomp$inline_1693 =
+      simpleEventPluginEvents[i$jscomp$inline_1692],
+    domEventName$jscomp$inline_1694 =
+      eventName$jscomp$inline_1693.toLowerCase(),
+    capitalizedEvent$jscomp$inline_1695 =
+      eventName$jscomp$inline_1693[0].toUpperCase() +
+      eventName$jscomp$inline_1693.slice(1);
   registerSimpleEvent(
-    domEventName$jscomp$inline_1721,
-    "on" + capitalizedEvent$jscomp$inline_1722
+    domEventName$jscomp$inline_1694,
+    "on" + capitalizedEvent$jscomp$inline_1695
   );
 }
 registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
@@ -15424,13 +15399,7 @@ function accumulateEventHandleNonManagedNodeListeners(
     });
   return listeners;
 }
-var _attemptSynchronousHydration,
-  attemptDiscreteHydration,
-  attemptContinuousHydration,
-  attemptHydrationAtCurrentPriority,
-  getCurrentUpdatePriority,
-  attemptHydrationAtPriority,
-  hasScheduledReplayAttempt = !1,
+var hasScheduledReplayAttempt = !1,
   queuedDiscreteEvents = [],
   queuedFocus = null,
   queuedDrag = null,
@@ -15479,7 +15448,7 @@ function queueDiscreteEvent(
     for (; null !== blockedOn.blockedOn; ) {
       domEventName = getInstanceFromNode(blockedOn.blockedOn);
       if (null === domEventName) break;
-      _attemptSynchronousHydration(domEventName);
+      attemptSynchronousHydration(domEventName);
       if (null === blockedOn.blockedOn) replayUnblockedEvents();
       else break;
     }
@@ -15627,8 +15596,16 @@ function attemptExplicitHydrationTarget(queuedTarget) {
           null !== targetInst)
         ) {
           queuedTarget.blockedOn = targetInst;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority(nearestMounted);
+          runWithPriority(queuedTarget.priority, function () {
+            if (13 === nearestMounted.tag) {
+              var lane = requestUpdateLane(nearestMounted),
+                root = enqueueConcurrentRenderForLane(nearestMounted, lane);
+              if (null !== root) {
+                var eventTime = requestEventTime();
+                scheduleUpdateOnFiber(root, nearestMounted, lane, eventTime);
+              }
+              markRetryLaneIfNotHydrated(nearestMounted, lane);
+            }
           });
           return;
         }
@@ -15696,22 +15673,24 @@ function replayUnblockedEvents() {
       var nextDiscreteEvent = queuedDiscreteEvents[0];
       if (null !== nextDiscreteEvent.blockedOn) {
         nextDiscreteEvent = getInstanceFromNode(nextDiscreteEvent.blockedOn);
-        null !== nextDiscreteEvent &&
-          attemptDiscreteHydration(nextDiscreteEvent);
+        if (null !== nextDiscreteEvent && 13 === nextDiscreteEvent.tag) {
+          var root = enqueueConcurrentRenderForLane(nextDiscreteEvent, 2);
+          if (null !== root) {
+            var eventTime = requestEventTime();
+            scheduleUpdateOnFiber(root, nextDiscreteEvent, 2, eventTime);
+          }
+          markRetryLaneIfNotHydrated(nextDiscreteEvent, 2);
+        }
         break;
       }
-      for (
-        var targetContainers = nextDiscreteEvent.targetContainers;
-        0 < targetContainers.length;
-
-      ) {
-        var targetContainer = targetContainers[0],
-          nextBlockedOn = findInstanceBlockingEvent(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            targetContainer,
-            nextDiscreteEvent.nativeEvent
-          );
+      for (root = nextDiscreteEvent.targetContainers; 0 < root.length; ) {
+        eventTime = root[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          eventTime,
+          nextDiscreteEvent.nativeEvent
+        );
         if (null === nextBlockedOn)
           (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
             dispatchEventForPluginEventSystem(
@@ -15719,14 +15698,14 @@ function replayUnblockedEvents() {
               nextDiscreteEvent.eventSystemFlags,
               nextDiscreteEvent.nativeEvent,
               return_targetInst,
-              targetContainer
+              eventTime
             ),
             (currentReplayingEvent = null);
         else {
           nextDiscreteEvent.blockedOn = nextBlockedOn;
           break;
         }
-        targetContainers.shift();
+        root.shift();
       }
       null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
     }
@@ -15880,7 +15859,7 @@ function dispatchEvent(
       ) {
         for (; null !== blockedOn; ) {
           var fiber = getInstanceFromNode(blockedOn);
-          null !== fiber && _attemptSynchronousHydration(fiber);
+          null !== fiber && attemptSynchronousHydration(fiber);
           fiber = findInstanceBlockingEvent(
             domEventName,
             eventSystemFlags,
@@ -16486,4 +16465,4 @@ exports.unstable_renderSubtreeIntoContainer = function (
   );
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-classic-d10ee72f";
+exports.version = "18.3.0-www-classic-773bb029";
diff --git a/compiled/facebook-www/ReactDOMTesting-prod.modern.js b/compiled/facebook-www/ReactDOMTesting-prod.modern.js
index 0c0c9617018da..d80a537d38bde 100644
--- a/compiled/facebook-www/ReactDOMTesting-prod.modern.js
+++ b/compiled/facebook-www/ReactDOMTesting-prod.modern.js
@@ -14,8 +14,8 @@
  Modernizr 3.0.0pre (Custom Build) | MIT
 */
 "use strict";
-var Scheduler = require("scheduler"),
-  React = require("react"),
+var React = require("react"),
+  Scheduler = require("scheduler"),
   Internals = {
     usingClientEntryPoint: !1,
     Events: null,
@@ -40,6 +40,7 @@ function formatProdErrorMessage(code) {
 var dynamicFeatureFlags = require("ReactFeatureFlags"),
   disableInputAttributeSyncing =
     dynamicFeatureFlags.disableInputAttributeSyncing,
+  disableIEWorkarounds = dynamicFeatureFlags.disableIEWorkarounds,
   enableTrustedTypesIntegration =
     dynamicFeatureFlags.enableTrustedTypesIntegration,
   enableFilterEmptyStringAttributesDOM =
@@ -1256,17 +1257,46 @@ function getEventTarget(nativeEvent) {
     (nativeEvent = nativeEvent.correspondingUseElement);
   return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;
 }
-var restoreImpl = null,
-  restoreTarget = null,
+var restoreTarget = null,
   restoreQueue = null;
 function restoreStateOfTarget(target) {
-  if ((target = getInstanceFromNode$1(target))) {
-    if ("function" !== typeof restoreImpl)
-      throw Error(formatProdErrorMessage(280));
-    var stateNode = target.stateNode;
-    stateNode &&
-      ((stateNode = getFiberCurrentPropsFromNode(stateNode)),
-      restoreImpl(target.stateNode, target.type, stateNode));
+  var internalInstance = getInstanceFromNode$1(target);
+  if (internalInstance && (target = internalInstance.stateNode)) {
+    var props = getFiberCurrentPropsFromNode(target);
+    a: switch (((target = internalInstance.stateNode), internalInstance.type)) {
+      case "input":
+        updateWrapper$1(target, props);
+        internalInstance = props.name;
+        if ("radio" === props.type && null != internalInstance) {
+          for (props = target; props.parentNode; ) props = props.parentNode;
+          props = props.querySelectorAll(
+            "input[name=" +
+              JSON.stringify("" + internalInstance) +
+              '][type="radio"]'
+          );
+          for (
+            internalInstance = 0;
+            internalInstance < props.length;
+            internalInstance++
+          ) {
+            var otherNode = props[internalInstance];
+            if (otherNode !== target && otherNode.form === target.form) {
+              var otherProps = getFiberCurrentPropsFromNode(otherNode);
+              if (!otherProps) throw Error(formatProdErrorMessage(90));
+              updateValueIfChanged(otherNode);
+              updateWrapper$1(otherNode, otherProps);
+            }
+          }
+        }
+        break a;
+      case "textarea":
+        updateWrapper(target, props);
+        break a;
+      case "select":
+        (internalInstance = props.value),
+          null != internalInstance &&
+            updateOptions(target, !!props.multiple, internalInstance, !1);
+    }
   }
 }
 function enqueueStateRestore(target) {
@@ -1287,118 +1317,6 @@ function restoreStateIfNeeded() {
         restoreStateOfTarget(queuedTargets[target]);
   }
 }
-function batchedUpdatesImpl(fn, bookkeeping) {
-  return fn(bookkeeping);
-}
-function flushSyncImpl() {}
-var isInsideEventHandler = !1;
-function batchedUpdates$1(fn, a, b) {
-  if (isInsideEventHandler) return fn(a, b);
-  isInsideEventHandler = !0;
-  try {
-    return batchedUpdatesImpl(fn, a, b);
-  } finally {
-    if (
-      ((isInsideEventHandler = !1),
-      null !== restoreTarget || null !== restoreQueue)
-    )
-      flushSyncImpl(), restoreStateIfNeeded();
-  }
-}
-function getListener(inst, registrationName) {
-  var stateNode = inst.stateNode;
-  if (null === stateNode) return null;
-  var props = getFiberCurrentPropsFromNode(stateNode);
-  if (null === props) return null;
-  stateNode = props[registrationName];
-  a: switch (registrationName) {
-    case "onClick":
-    case "onClickCapture":
-    case "onDoubleClick":
-    case "onDoubleClickCapture":
-    case "onMouseDown":
-    case "onMouseDownCapture":
-    case "onMouseMove":
-    case "onMouseMoveCapture":
-    case "onMouseUp":
-    case "onMouseUpCapture":
-    case "onMouseEnter":
-      (props = !props.disabled) ||
-        ((inst = inst.type),
-        (props = !(
-          "button" === inst ||
-          "input" === inst ||
-          "select" === inst ||
-          "textarea" === inst
-        )));
-      inst = !props;
-      break a;
-    default:
-      inst = !1;
-  }
-  if (inst) return null;
-  if (stateNode && "function" !== typeof stateNode)
-    throw Error(
-      formatProdErrorMessage(231, registrationName, typeof stateNode)
-    );
-  return stateNode;
-}
-var passiveBrowserEventsSupported = !1;
-if (canUseDOM)
-  try {
-    var options = {};
-    Object.defineProperty(options, "passive", {
-      get: function () {
-        passiveBrowserEventsSupported = !0;
-      }
-    });
-    window.addEventListener("test", options, options);
-    window.removeEventListener("test", options, options);
-  } catch (e) {
-    passiveBrowserEventsSupported = !1;
-  }
-var ReactFbErrorUtils = require("ReactFbErrorUtils");
-if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
-  throw Error(formatProdErrorMessage(255));
-function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
-  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
-}
-var hasError = !1,
-  caughtError = null,
-  hasRethrowError = !1,
-  rethrowError = null,
-  reporter = {
-    onError: function (error) {
-      hasError = !0;
-      caughtError = error;
-    }
-  };
-function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
-  hasError = !1;
-  caughtError = null;
-  invokeGuardedCallbackImpl.apply(reporter, arguments);
-}
-function invokeGuardedCallbackAndCatchFirstError(
-  name,
-  func,
-  context,
-  a,
-  b,
-  c,
-  d,
-  e,
-  f
-) {
-  invokeGuardedCallback.apply(this, arguments);
-  if (hasError) {
-    if (hasError) {
-      var error = caughtError;
-      hasError = !1;
-      caughtError = null;
-    } else throw Error(formatProdErrorMessage(198));
-    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
-  }
-}
 function getNearestMountedFiber(fiber) {
   var node = fiber,
     nearestMounted = fiber;
@@ -1525,31 +1443,22 @@ function doesFiberContain(parentFiber, childFiber) {
   }
   return !1;
 }
-var scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
-  cancelCallback$1 = Scheduler.unstable_cancelCallback,
-  shouldYield = Scheduler.unstable_shouldYield,
-  requestPaint = Scheduler.unstable_requestPaint,
-  now = Scheduler.unstable_now,
-  getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
-  ImmediatePriority = Scheduler.unstable_ImmediatePriority,
-  UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
-  NormalPriority$1 = Scheduler.unstable_NormalPriority,
-  LowPriority = Scheduler.unstable_LowPriority,
-  IdlePriority = Scheduler.unstable_IdlePriority,
-  rendererID = null,
-  injectedHook = null;
-function onCommitRoot(root) {
-  if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
-    try {
-      injectedHook.onCommitFiberRoot(
-        rendererID,
-        root,
-        void 0,
-        128 === (root.current.flags & 128)
-      );
-    } catch (err) {}
+var valueStack = [],
+  index = -1;
+function createCursor(defaultValue) {
+  return { current: defaultValue };
 }
-var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
+function pop(cursor) {
+  0 > index ||
+    ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
+}
+function push(cursor, value) {
+  index++;
+  valueStack[index] = cursor.current;
+  cursor.current = value;
+}
+var emptyContextObject = {},
+  clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
   log = Math.log,
   LN2 = Math.LN2;
 function clz32Fallback(x) {
@@ -1825,1231 +1734,765 @@ function lanesToEventPriority(lanes) {
       : 8
     : 2;
 }
-var _attemptSynchronousHydration,
-  attemptDiscreteHydration$1,
-  attemptContinuousHydration$1,
-  attemptHydrationAtCurrentPriority$1,
-  getCurrentUpdatePriority,
-  attemptHydrationAtPriority,
-  hasScheduledReplayAttempt = !1,
-  queuedDiscreteEvents = [],
-  queuedFocus = null,
-  queuedDrag = null,
-  queuedMouse = null,
-  queuedPointers = new Map(),
-  queuedPointerCaptures = new Map(),
-  queuedExplicitHydrationTargets = [],
-  discreteReplayableEvents =
-    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
-      " "
-    );
-function createQueuedReplayableEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return {
-    blockedOn: blockedOn,
-    domEventName: domEventName,
-    eventSystemFlags: eventSystemFlags,
-    nativeEvent: nativeEvent,
-    targetContainers: [targetContainer]
-  };
+var scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
+  cancelCallback$1 = Scheduler.unstable_cancelCallback,
+  shouldYield = Scheduler.unstable_shouldYield,
+  requestPaint = Scheduler.unstable_requestPaint,
+  now = Scheduler.unstable_now,
+  getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
+  ImmediatePriority = Scheduler.unstable_ImmediatePriority,
+  UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
+  NormalPriority$1 = Scheduler.unstable_NormalPriority,
+  LowPriority = Scheduler.unstable_LowPriority,
+  IdlePriority = Scheduler.unstable_IdlePriority,
+  rendererID = null,
+  injectedHook = null;
+function onCommitRoot(root) {
+  if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
+    try {
+      injectedHook.onCommitFiberRoot(
+        rendererID,
+        root,
+        void 0,
+        128 === (root.current.flags & 128)
+      );
+    } catch (err) {}
 }
-function queueDiscreteEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
-    ((blockedOn = createQueuedReplayableEvent(
-      blockedOn,
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    )),
-    queuedDiscreteEvents.push(blockedOn),
-    1 === queuedDiscreteEvents.length)
-  )
-    for (; null !== blockedOn.blockedOn; ) {
-      domEventName = getInstanceFromNode$1(blockedOn.blockedOn);
-      if (null === domEventName) break;
-      _attemptSynchronousHydration(domEventName);
-      if (null === blockedOn.blockedOn) replayUnblockedEvents();
-      else break;
-    }
+function is(x, y) {
+  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
 }
-function clearIfContinuousEvent(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "focusin":
-    case "focusout":
-      queuedFocus = null;
-      break;
-    case "dragenter":
-    case "dragleave":
-      queuedDrag = null;
-      break;
-    case "mouseover":
-    case "mouseout":
-      queuedMouse = null;
-      break;
-    case "pointerover":
-    case "pointerout":
-      queuedPointers.delete(nativeEvent.pointerId);
-      break;
-    case "gotpointercapture":
-    case "lostpointercapture":
-      queuedPointerCaptures.delete(nativeEvent.pointerId);
-  }
+var objectIs = "function" === typeof Object.is ? Object.is : is,
+  syncQueue = null,
+  includesLegacySyncCallbacks = !1,
+  isFlushingSyncQueue = !1;
+function scheduleSyncCallback(callback) {
+  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
 }
-function accumulateOrCreateContinuousQueuedReplayableEvent(
-  existingQueuedEvent,
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (
-    null === existingQueuedEvent ||
-    existingQueuedEvent.nativeEvent !== nativeEvent
-  )
-    return (
-      (existingQueuedEvent = createQueuedReplayableEvent(
-        blockedOn,
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      )),
-      null !== blockedOn &&
-        ((blockedOn = getInstanceFromNode$1(blockedOn)),
-        null !== blockedOn && attemptContinuousHydration$1(blockedOn)),
-      existingQueuedEvent
-    );
-  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
-  blockedOn = existingQueuedEvent.targetContainers;
-  null !== targetContainer &&
-    -1 === blockedOn.indexOf(targetContainer) &&
-    blockedOn.push(targetContainer);
-  return existingQueuedEvent;
+function scheduleLegacySyncCallback(callback) {
+  includesLegacySyncCallbacks = !0;
+  scheduleSyncCallback(callback);
 }
-function queueIfContinuousEvent(
-  blockedOn,
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  switch (domEventName) {
-    case "focusin":
-      return (
-        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedFocus,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "dragenter":
-      return (
-        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedDrag,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "mouseover":
-      return (
-        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedMouse,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        !0
-      );
-    case "pointerover":
-      var pointerId = nativeEvent.pointerId;
-      queuedPointers.set(
-        pointerId,
-        accumulateOrCreateContinuousQueuedReplayableEvent(
-          queuedPointers.get(pointerId) || null,
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
+function flushSyncCallbacks() {
+  if (!isFlushingSyncQueue && null !== syncQueue) {
+    isFlushingSyncQueue = !0;
+    var previousUpdatePriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
+      var callback = queue[i];
+      try {
+        do callback = callback(!0);
+        while (null !== callback);
+      } catch (error) {
+        null === errors ? (errors = [error]) : errors.push(error);
+      }
+    }
+    syncQueue = null;
+    includesLegacySyncCallbacks = !1;
+    currentUpdatePriority = previousUpdatePriority;
+    isFlushingSyncQueue = !1;
+    if (null !== errors) {
+      if (1 < errors.length) {
+        if ("function" === typeof AggregateError)
+          throw new AggregateError(errors);
+        for (
+          previousUpdatePriority = 1;
+          previousUpdatePriority < errors.length;
+          previousUpdatePriority++
         )
-      );
-      return !0;
-    case "gotpointercapture":
-      return (
-        (pointerId = nativeEvent.pointerId),
-        queuedPointerCaptures.set(
-          pointerId,
-          accumulateOrCreateContinuousQueuedReplayableEvent(
-            queuedPointerCaptures.get(pointerId) || null,
-            blockedOn,
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          )
-        ),
-        !0
-      );
-  }
-  return !1;
-}
-function attemptExplicitHydrationTarget(queuedTarget) {
-  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
-  if (null !== targetInst) {
-    var nearestMounted = getNearestMountedFiber(targetInst);
-    if (null !== nearestMounted)
-      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
-        if (
-          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
-          null !== targetInst)
-        ) {
-          queuedTarget.blockedOn = targetInst;
-          attemptHydrationAtPriority(queuedTarget.priority, function () {
-            attemptHydrationAtCurrentPriority$1(nearestMounted);
-          });
-          return;
-        }
-      } else if (
-        3 === targetInst &&
-        nearestMounted.stateNode.current.memoizedState.isDehydrated
-      ) {
-        queuedTarget.blockedOn =
-          3 === nearestMounted.tag
-            ? nearestMounted.stateNode.containerInfo
-            : null;
-        return;
+          scheduleCallback$2(
+            ImmediatePriority,
+            throwError.bind(null, errors[previousUpdatePriority])
+          );
       }
+      throw errors[0];
+    }
   }
-  queuedTarget.blockedOn = null;
+  return null;
 }
-function attemptReplayContinuousQueuedEvent(queuedEvent) {
-  if (null !== queuedEvent.blockedOn) return !1;
-  for (
-    var targetContainers = queuedEvent.targetContainers;
-    0 < targetContainers.length;
-
-  ) {
-    var targetContainer = targetContainers[0],
-      nextBlockedOn = findInstanceBlockingEvent(
-        queuedEvent.domEventName,
-        queuedEvent.eventSystemFlags,
-        targetContainer,
-        queuedEvent.nativeEvent
-      );
-    if (null === nextBlockedOn)
-      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
-        ? ((nextBlockedOn = queuedEvent.nativeEvent),
-          (currentReplayingEvent = targetContainer =
-            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
-          nextBlockedOn.target.dispatchEvent(targetContainer))
-        : ((currentReplayingEvent = queuedEvent.nativeEvent),
-          dispatchEventForPluginEventSystem(
-            queuedEvent.domEventName,
-            queuedEvent.eventSystemFlags,
-            queuedEvent.nativeEvent,
-            return_targetInst,
-            targetContainer
-          )),
-        (currentReplayingEvent = null);
-    else
-      return (
-        (targetContainers = getInstanceFromNode$1(nextBlockedOn)),
-        null !== targetContainers &&
-          attemptContinuousHydration$1(targetContainers),
-        (queuedEvent.blockedOn = nextBlockedOn),
-        !1
-      );
-    targetContainers.shift();
-  }
-  return !0;
+function throwError(error) {
+  throw error;
 }
-function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
-  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+var forkStack = [],
+  forkStackIndex = 0,
+  treeForkProvider = null,
+  treeForkCount = 0,
+  idStack = [],
+  idStackIndex = 0,
+  treeContextProvider = null,
+  treeContextId = 1,
+  treeContextOverflow = "";
+function pushTreeFork(workInProgress, totalChildren) {
+  forkStack[forkStackIndex++] = treeForkCount;
+  forkStack[forkStackIndex++] = treeForkProvider;
+  treeForkProvider = workInProgress;
+  treeForkCount = totalChildren;
 }
-function replayUnblockedEvents() {
-  hasScheduledReplayAttempt = !1;
-  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
-    for (; 0 < queuedDiscreteEvents.length; ) {
-      var nextDiscreteEvent = queuedDiscreteEvents[0];
-      if (null !== nextDiscreteEvent.blockedOn) {
-        nextDiscreteEvent = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
-        null !== nextDiscreteEvent &&
-          attemptDiscreteHydration$1(nextDiscreteEvent);
-        break;
-      }
-      for (
-        var targetContainers = nextDiscreteEvent.targetContainers;
-        0 < targetContainers.length;
-
-      ) {
-        var targetContainer = targetContainers[0],
-          nextBlockedOn = findInstanceBlockingEvent(
-            nextDiscreteEvent.domEventName,
-            nextDiscreteEvent.eventSystemFlags,
-            targetContainer,
-            nextDiscreteEvent.nativeEvent
-          );
-        if (null === nextBlockedOn)
-          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
-            dispatchEventForPluginEventSystem(
-              nextDiscreteEvent.domEventName,
-              nextDiscreteEvent.eventSystemFlags,
-              nextDiscreteEvent.nativeEvent,
-              return_targetInst,
-              targetContainer
-            ),
-            (currentReplayingEvent = null);
-        else {
-          nextDiscreteEvent.blockedOn = nextBlockedOn;
-          break;
-        }
-        targetContainers.shift();
-      }
-      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
-    }
-  null !== queuedFocus &&
-    attemptReplayContinuousQueuedEvent(queuedFocus) &&
-    (queuedFocus = null);
-  null !== queuedDrag &&
-    attemptReplayContinuousQueuedEvent(queuedDrag) &&
-    (queuedDrag = null);
-  null !== queuedMouse &&
-    attemptReplayContinuousQueuedEvent(queuedMouse) &&
-    (queuedMouse = null);
-  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
-  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+function pushTreeId(workInProgress, totalChildren, index) {
+  idStack[idStackIndex++] = treeContextId;
+  idStack[idStackIndex++] = treeContextOverflow;
+  idStack[idStackIndex++] = treeContextProvider;
+  treeContextProvider = workInProgress;
+  var baseIdWithLeadingBit = treeContextId;
+  workInProgress = treeContextOverflow;
+  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
+  baseIdWithLeadingBit &= ~(1 << baseLength);
+  index += 1;
+  var length = 32 - clz32(totalChildren) + baseLength;
+  if (30 < length) {
+    var numberOfOverflowBits = baseLength - (baseLength % 5);
+    length = (
+      baseIdWithLeadingBit &
+      ((1 << numberOfOverflowBits) - 1)
+    ).toString(32);
+    baseIdWithLeadingBit >>= numberOfOverflowBits;
+    baseLength -= numberOfOverflowBits;
+    treeContextId =
+      (1 << (32 - clz32(totalChildren) + baseLength)) |
+      (index << baseLength) |
+      baseIdWithLeadingBit;
+    treeContextOverflow = length + workInProgress;
+  } else
+    (treeContextId =
+      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
+      (treeContextOverflow = workInProgress);
 }
-function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
-  queuedEvent.blockedOn === unblocked &&
-    ((queuedEvent.blockedOn = null),
-    hasScheduledReplayAttempt ||
-      ((hasScheduledReplayAttempt = !0),
-      Scheduler.unstable_scheduleCallback(
-        Scheduler.unstable_NormalPriority,
-        replayUnblockedEvents
-      )));
+function pushMaterializedTreeId(workInProgress) {
+  null !== workInProgress.return &&
+    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
 }
-function retryIfBlockedOn(unblocked) {
-  function unblock(queuedEvent) {
-    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+function popTreeContext(workInProgress) {
+  for (; workInProgress === treeForkProvider; )
+    (treeForkProvider = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null),
+      (treeForkCount = forkStack[--forkStackIndex]),
+      (forkStack[forkStackIndex] = null);
+  for (; workInProgress === treeContextProvider; )
+    (treeContextProvider = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextOverflow = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null),
+      (treeContextId = idStack[--idStackIndex]),
+      (idStack[idStackIndex] = null);
+}
+var contextStackCursor = createCursor(null),
+  contextFiberStackCursor = createCursor(null),
+  rootInstanceStackCursor = createCursor(null);
+function pushHostContainer(fiber, nextRootInstance) {
+  push(rootInstanceStackCursor, nextRootInstance);
+  push(contextFiberStackCursor, fiber);
+  push(contextStackCursor, null);
+  fiber = nextRootInstance.nodeType;
+  switch (fiber) {
+    case 9:
+    case 11:
+      nextRootInstance = (nextRootInstance = nextRootInstance.documentElement)
+        ? nextRootInstance.namespaceURI
+        : getChildNamespace(null, "");
+      break;
+    default:
+      (fiber = 8 === fiber ? nextRootInstance.parentNode : nextRootInstance),
+        (nextRootInstance = fiber.namespaceURI || null),
+        (fiber = fiber.tagName),
+        (nextRootInstance = getChildNamespace(nextRootInstance, fiber));
   }
-  if (0 < queuedDiscreteEvents.length) {
-    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
-    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
-      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
-    }
+  pop(contextStackCursor);
+  push(contextStackCursor, nextRootInstance);
+}
+function popHostContainer() {
+  pop(contextStackCursor);
+  pop(contextFiberStackCursor);
+  pop(rootInstanceStackCursor);
+}
+function pushHostContext(fiber) {
+  var context = contextStackCursor.current;
+  var JSCompiler_inline_result = getChildNamespace(context, fiber.type);
+  context !== JSCompiler_inline_result &&
+    (push(contextFiberStackCursor, fiber),
+    push(contextStackCursor, JSCompiler_inline_result));
+}
+function popHostContext(fiber) {
+  contextFiberStackCursor.current === fiber &&
+    (pop(contextStackCursor), pop(contextFiberStackCursor));
+}
+var hydrationParentFiber = null,
+  nextHydratableInstance = null,
+  isHydrating = !1,
+  hydrationErrors = null,
+  rootOrSingletonContext = !1;
+function deleteHydratableInstance(returnFiber, instance) {
+  var fiber = createFiber(5, null, null, 0);
+  fiber.elementType = "DELETED";
+  fiber.stateNode = instance;
+  fiber.return = returnFiber;
+  instance = returnFiber.deletions;
+  null === instance
+    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
+    : instance.push(fiber);
+}
+function insertNonHydratedInstance(returnFiber, fiber) {
+  fiber.flags = (fiber.flags & -4097) | 2;
+}
+function tryHydrateInstance(fiber, nextInstance) {
+  var type = fiber.type;
+  nextInstance =
+    1 !== nextInstance.nodeType ||
+    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
+      (rootOrSingletonContext = !1),
+      !0)
+    : !1;
+}
+function tryHydrateText(fiber, nextInstance) {
+  nextInstance =
+    "" === fiber.pendingProps
+      ? null
+      : 3 !== nextInstance.nodeType
+      ? null
+      : nextInstance;
+  return null !== nextInstance
+    ? ((fiber.stateNode = nextInstance),
+      (hydrationParentFiber = fiber),
+      (nextHydratableInstance = null),
+      !0)
+    : !1;
+}
+function tryHydrateSuspense(fiber, nextInstance) {
+  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
+  if (null !== nextInstance) {
+    var JSCompiler_inline_result =
+      null !== treeContextProvider
+        ? { id: treeContextId, overflow: treeContextOverflow }
+        : null;
+    fiber.memoizedState = {
+      dehydrated: nextInstance,
+      treeContext: JSCompiler_inline_result,
+      retryLane: 1073741824
+    };
+    JSCompiler_inline_result = createFiber(18, null, null, 0);
+    JSCompiler_inline_result.stateNode = nextInstance;
+    JSCompiler_inline_result.return = fiber;
+    fiber.child = JSCompiler_inline_result;
+    hydrationParentFiber = fiber;
+    nextHydratableInstance = null;
+    return !0;
   }
-  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
-  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
-  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
-  queuedPointers.forEach(unblock);
-  queuedPointerCaptures.forEach(unblock);
-  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
-    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
-      queuedEvent$jscomp$0.blockedOn === unblocked &&
-        (queuedEvent$jscomp$0.blockedOn = null);
+  return !1;
+}
+function shouldClientRenderOnMismatch(fiber) {
+  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
+}
+function throwOnHydrationMismatch() {
+  throw Error(formatProdErrorMessage(418));
+}
+function advanceToFirstAttemptableInstance(fiber) {
   for (
     ;
-    0 < queuedExplicitHydrationTargets.length &&
-    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
+    nextHydratableInstance &&
+    shouldSkipHydratableForInstance(
+      nextHydratableInstance,
+      fiber.type,
+      fiber.pendingProps
+    );
 
   )
-    attemptExplicitHydrationTarget(i),
-      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-var ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
-  _enabled = !0;
-function createEventListenerWrapperWithPriority(
-  targetContainer,
-  domEventName,
-  eventSystemFlags
-) {
-  switch (getEventPriority(domEventName)) {
-    case 2:
-      var listenerWrapper = dispatchDiscreteEvent;
-      break;
-    case 8:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
-    default:
-      listenerWrapper = dispatchEvent;
-  }
-  return listenerWrapper.bind(
-    null,
-    domEventName,
-    eventSystemFlags,
-    targetContainer
-  );
+function advanceToFirstAttemptableTextInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-function dispatchDiscreteEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 2),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
-  }
+function advanceToFirstAttemptableSuspenseInstance() {
+  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
+    nextHydratableInstance = getNextHydratable(
+      nextHydratableInstance.nextSibling
+    );
 }
-function dispatchContinuousEvent(
-  domEventName,
-  eventSystemFlags,
-  container,
-  nativeEvent
-) {
-  var previousPriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig$3.transition;
-  ReactCurrentBatchConfig$3.transition = null;
-  try {
-    (currentUpdatePriority = 8),
-      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$3.transition = prevTransition);
+function prepareToHydrateHostInstance(fiber) {
+  var instance = fiber.stateNode,
+    type = fiber.type,
+    props = fiber.memoizedProps;
+  instance[internalInstanceKey] = fiber;
+  instance[internalPropsKey] = props;
+  switch (type) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", instance);
+      listenToNonDelegatedEvent("close", instance);
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "video":
+    case "audio":
+      for (var i = 0; i < mediaEventTypes.length; i++)
+        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", instance);
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", instance);
+      listenToNonDelegatedEvent("load", instance);
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", instance);
+      break;
+    case "input":
+      initWrapperState$2(instance, props);
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "select":
+      instance._wrapperState = { wasMultiple: !!props.multiple };
+      listenToNonDelegatedEvent("invalid", instance);
+      break;
+    case "textarea":
+      initWrapperState(instance, props),
+        listenToNonDelegatedEvent("invalid", instance);
+  }
+  assertValidProps(type, props);
+  var updatePayload = null,
+    propKey;
+  for (propKey in props)
+    props.hasOwnProperty(propKey) &&
+      ((i = props[propKey]),
+      "children" === propKey
+        ? "string" === typeof i
+          ? instance.textContent !== i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", i]))
+          : "number" === typeof i &&
+            instance.textContent !== "" + i &&
+            (!0 !== props.suppressHydrationWarning &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", "" + i]))
+        : registrationNameDependencies.hasOwnProperty(propKey) &&
+          null != i &&
+          "onScroll" === propKey &&
+          listenToNonDelegatedEvent("scroll", instance));
+  switch (type) {
+    case "input":
+      track(instance);
+      postMountWrapper$3(instance, props, !0);
+      break;
+    case "textarea":
+      track(instance);
+      postMountWrapper(instance);
+      break;
+    case "select":
+    case "option":
+      break;
+    default:
+      "function" === typeof props.onClick && (instance.onclick = noop);
   }
+  instance = updatePayload;
+  fiber.updateQueue = instance;
+  return null !== instance ? !0 : !1;
 }
-function dispatchEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  if (_enabled)
-    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
-      var blockedOn = findInstanceBlockingEvent(
-        domEventName,
-        eventSystemFlags,
-        targetContainer,
-        nativeEvent
-      );
-      if (null === blockedOn)
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          clearIfContinuousEvent(domEventName, nativeEvent);
-      else if (
-        queueIfContinuousEvent(
-          blockedOn,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )
-      )
-        nativeEvent.stopPropagation();
-      else if (
-        (clearIfContinuousEvent(domEventName, nativeEvent),
-        eventSystemFlags & 4 &&
-          -1 < discreteReplayableEvents.indexOf(domEventName))
-      ) {
-        for (; null !== blockedOn; ) {
-          var fiber = getInstanceFromNode$1(blockedOn);
-          null !== fiber && _attemptSynchronousHydration(fiber);
-          fiber = findInstanceBlockingEvent(
-            domEventName,
-            eventSystemFlags,
-            targetContainer,
-            nativeEvent
-          );
-          null === fiber &&
-            dispatchEventForPluginEventSystem(
-              domEventName,
-              eventSystemFlags,
-              nativeEvent,
-              return_targetInst,
-              targetContainer
-            );
-          if (fiber === blockedOn) break;
-          blockedOn = fiber;
-        }
-        null !== blockedOn && nativeEvent.stopPropagation();
-      } else
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-    } else
-      a: if (
-        (blockedOn = 0 === (eventSystemFlags & 4)) &&
-        0 < queuedDiscreteEvents.length &&
-        -1 < discreteReplayableEvents.indexOf(domEventName)
-      )
-        queueDiscreteEvent(
-          null,
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        );
-      else if (
-        ((fiber = findInstanceBlockingEvent(
-          domEventName,
-          eventSystemFlags,
-          targetContainer,
-          nativeEvent
-        )),
-        null === fiber)
-      )
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          return_targetInst,
-          targetContainer
-        ),
-          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
-      else {
-        if (blockedOn) {
-          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
-            queueDiscreteEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            );
-            break a;
-          }
-          if (
-            queueIfContinuousEvent(
-              fiber,
-              domEventName,
-              eventSystemFlags,
-              targetContainer,
-              nativeEvent
-            )
-          )
-            break a;
-          clearIfContinuousEvent(domEventName, nativeEvent);
-        }
-        dispatchEventForPluginEventSystem(
-          domEventName,
-          eventSystemFlags,
-          nativeEvent,
-          null,
-          targetContainer
-        );
-      }
+function popToNextHostParent(fiber) {
+  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
+    switch (hydrationParentFiber.tag) {
+      case 3:
+      case 27:
+        rootOrSingletonContext = !0;
+        return;
+      case 5:
+      case 13:
+        rootOrSingletonContext = !1;
+        return;
+      default:
+        hydrationParentFiber = hydrationParentFiber.return;
+    }
 }
-var return_targetInst = null;
-function findInstanceBlockingEvent(
-  domEventName,
-  eventSystemFlags,
-  targetContainer,
-  nativeEvent
-) {
-  return_targetInst = null;
-  domEventName = getEventTarget(nativeEvent);
-  domEventName = getClosestInstanceFromNode(domEventName);
-  if (null !== domEventName)
-    if (
-      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
-      null === eventSystemFlags)
-    )
-      domEventName = null;
-    else if (
-      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
-    ) {
-      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
-      if (null !== domEventName) return domEventName;
-      domEventName = null;
-    } else if (3 === targetContainer) {
-      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
-        return 3 === eventSystemFlags.tag
-          ? eventSystemFlags.stateNode.containerInfo
-          : null;
-      domEventName = null;
-    } else eventSystemFlags !== domEventName && (domEventName = null);
-  return_targetInst = domEventName;
-  return null;
-}
-function getEventPriority(domEventName) {
-  switch (domEventName) {
-    case "cancel":
-    case "click":
-    case "close":
-    case "contextmenu":
-    case "copy":
-    case "cut":
-    case "auxclick":
-    case "dblclick":
-    case "dragend":
-    case "dragstart":
-    case "drop":
-    case "focusin":
-    case "focusout":
-    case "input":
-    case "invalid":
-    case "keydown":
-    case "keypress":
-    case "keyup":
-    case "mousedown":
-    case "mouseup":
-    case "paste":
-    case "pause":
-    case "play":
-    case "pointercancel":
-    case "pointerdown":
-    case "pointerup":
-    case "ratechange":
-    case "reset":
-    case "resize":
-    case "seeked":
-    case "submit":
-    case "touchcancel":
-    case "touchend":
-    case "touchstart":
-    case "volumechange":
-    case "change":
-    case "selectionchange":
-    case "textInput":
-    case "compositionstart":
-    case "compositionend":
-    case "compositionupdate":
-    case "beforeblur":
-    case "afterblur":
-    case "beforeinput":
-    case "blur":
-    case "fullscreenchange":
-    case "focus":
-    case "hashchange":
-    case "popstate":
-    case "select":
-    case "selectstart":
-      return 2;
-    case "drag":
-    case "dragenter":
-    case "dragexit":
-    case "dragleave":
-    case "dragover":
-    case "mousemove":
-    case "mouseout":
-    case "mouseover":
-    case "pointermove":
-    case "pointerout":
-    case "pointerover":
-    case "scroll":
-    case "toggle":
-    case "touchmove":
-    case "wheel":
-    case "mouseenter":
-    case "mouseleave":
-    case "pointerenter":
-    case "pointerleave":
-      return 8;
-    case "message":
-      switch (getCurrentPriorityLevel()) {
-        case ImmediatePriority:
-          return 2;
-        case UserBlockingPriority:
-          return 8;
-        case NormalPriority$1:
-        case LowPriority:
-          return 32;
-        case IdlePriority:
-          return 536870912;
-        default:
-          return 32;
+function popHydrationState(fiber) {
+  if (fiber !== hydrationParentFiber) return !1;
+  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
+  var shouldClear = !1;
+  3 === fiber.tag ||
+    27 === fiber.tag ||
+    (5 === fiber.tag &&
+      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
+    (shouldClear = !0);
+  if (shouldClear && (shouldClear = nextHydratableInstance))
+    if (shouldClientRenderOnMismatch(fiber))
+      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
+    else
+      for (; shouldClear; )
+        deleteHydratableInstance(fiber, shouldClear),
+          (shouldClear = getNextHydratable(shouldClear.nextSibling));
+  popToNextHostParent(fiber);
+  if (13 === fiber.tag) {
+    fiber = fiber.memoizedState;
+    fiber = null !== fiber ? fiber.dehydrated : null;
+    if (!fiber) throw Error(formatProdErrorMessage(317));
+    a: {
+      fiber = fiber.nextSibling;
+      for (shouldClear = 0; fiber; ) {
+        if (8 === fiber.nodeType) {
+          var data = fiber.data;
+          if ("/$" === data) {
+            if (0 === shouldClear) {
+              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
+              break a;
+            }
+            shouldClear--;
+          } else
+            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
+        }
+        fiber = fiber.nextSibling;
       }
-    default:
-      return 32;
-  }
-}
-function addEventBubbleListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, !1);
-  return listener;
+      nextHydratableInstance = null;
+    }
+  } else
+    nextHydratableInstance = hydrationParentFiber
+      ? getNextHydratable(fiber.stateNode.nextSibling)
+      : null;
+  return !0;
 }
-function addEventCaptureListener(target, eventType, listener) {
-  target.addEventListener(eventType, listener, !0);
-  return listener;
+function warnIfUnhydratedTailNodes() {
+  for (var nextInstance = nextHydratableInstance; nextInstance; )
+    nextInstance = getNextHydratable(nextInstance.nextSibling);
 }
-function addEventCaptureListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, {
-    capture: !0,
-    passive: passive
-  });
-  return listener;
+function resetHydrationState() {
+  nextHydratableInstance = hydrationParentFiber = null;
+  isHydrating = !1;
 }
-function addEventBubbleListenerWithPassiveFlag(
-  target,
-  eventType,
-  listener,
-  passive
-) {
-  target.addEventListener(eventType, listener, { passive: passive });
-  return listener;
+function queueHydrationError(error) {
+  null === hydrationErrors
+    ? (hydrationErrors = [error])
+    : hydrationErrors.push(error);
 }
-var root = null,
-  startText = null,
-  fallbackText = null;
-function getData() {
-  if (fallbackText) return fallbackText;
-  var start,
-    startValue = startText,
-    startLength = startValue.length,
-    end,
-    endValue = "value" in root ? root.value : root.textContent,
-    endLength = endValue.length;
-  for (
-    start = 0;
-    start < startLength && startValue[start] === endValue[start];
-    start++
-  );
-  var minEnd = startLength - start;
+var concurrentQueues = [],
+  concurrentQueuesIndex = 0,
+  concurrentlyUpdatedLanes = 0;
+function finishQueueingConcurrentUpdates() {
   for (
-    end = 1;
-    end <= minEnd &&
-    startValue[startLength - end] === endValue[endLength - end];
-    end++
-  );
-  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
+    var endIndex = concurrentQueuesIndex,
+      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
+    i < endIndex;
+
+  ) {
+    var fiber = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var queue = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var update = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    var lane = concurrentQueues[i];
+    concurrentQueues[i++] = null;
+    if (null !== queue && null !== update) {
+      var pending = queue.pending;
+      null === pending
+        ? (update.next = update)
+        : ((update.next = pending.next), (pending.next = update));
+      queue.pending = update;
+    }
+    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+  }
 }
-function getEventCharCode(nativeEvent) {
-  var keyCode = nativeEvent.keyCode;
-  "charCode" in nativeEvent
-    ? ((nativeEvent = nativeEvent.charCode),
-      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
-    : (nativeEvent = keyCode);
-  10 === nativeEvent && (nativeEvent = 13);
-  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
+function enqueueUpdate$1(fiber, queue, update, lane) {
+  concurrentQueues[concurrentQueuesIndex++] = fiber;
+  concurrentQueues[concurrentQueuesIndex++] = queue;
+  concurrentQueues[concurrentQueuesIndex++] = update;
+  concurrentQueues[concurrentQueuesIndex++] = lane;
+  concurrentlyUpdatedLanes |= lane;
+  fiber.lanes |= lane;
+  fiber = fiber.alternate;
+  null !== fiber && (fiber.lanes |= lane);
 }
-function functionThatReturnsTrue() {
-  return !0;
+function enqueueConcurrentRenderForLane(fiber, lane) {
+  enqueueUpdate$1(fiber, null, null, lane);
+  return getRootForUpdatedFiber(fiber);
 }
-function functionThatReturnsFalse() {
-  return !1;
+function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+  sourceFiber.lanes |= lane;
+  var alternate = sourceFiber.alternate;
+  null !== alternate && (alternate.lanes |= lane);
+  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
+    (parent.childLanes |= lane),
+      (alternate = parent.alternate),
+      null !== alternate && (alternate.childLanes |= lane),
+      22 === parent.tag &&
+        ((sourceFiber = parent.stateNode),
+        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
+      (sourceFiber = parent),
+      (parent = parent.return);
+  isHidden &&
+    null !== update &&
+    3 === sourceFiber.tag &&
+    ((parent = sourceFiber.stateNode),
+    (isHidden = 31 - clz32(lane)),
+    (parent = parent.hiddenUpdates),
+    (sourceFiber = parent[isHidden]),
+    null === sourceFiber
+      ? (parent[isHidden] = [update])
+      : sourceFiber.push(update),
+    (update.lane = lane | 1073741824));
 }
-function createSyntheticEvent(Interface) {
-  function SyntheticBaseEvent(
-    reactName,
-    reactEventType,
-    targetInst,
-    nativeEvent,
-    nativeEventTarget
-  ) {
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
-    for (var propName in Interface)
-      Interface.hasOwnProperty(propName) &&
-        ((reactName = Interface[propName]),
-        (this[propName] = reactName
-          ? reactName(nativeEvent)
-          : nativeEvent[propName]));
-    this.isDefaultPrevented = (
-      null != nativeEvent.defaultPrevented
-        ? nativeEvent.defaultPrevented
-        : !1 === nativeEvent.returnValue
-    )
-      ? functionThatReturnsTrue
-      : functionThatReturnsFalse;
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  }
-  assign(SyntheticBaseEvent.prototype, {
-    preventDefault: function () {
-      this.defaultPrevented = !0;
-      var event = this.nativeEvent;
-      event &&
-        (event.preventDefault
-          ? event.preventDefault()
-          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
-        (this.isDefaultPrevented = functionThatReturnsTrue));
-    },
-    stopPropagation: function () {
-      var event = this.nativeEvent;
-      event &&
-        (event.stopPropagation
-          ? event.stopPropagation()
-          : "unknown" !== typeof event.cancelBubble &&
-            (event.cancelBubble = !0),
-        (this.isPropagationStopped = functionThatReturnsTrue));
-    },
-    persist: function () {},
-    isPersistent: functionThatReturnsTrue
-  });
-  return SyntheticBaseEvent;
+function getRootForUpdatedFiber(sourceFiber) {
+  if (50 < nestedUpdateCount)
+    throw (
+      ((nestedUpdateCount = 0),
+      (rootWithNestedUpdates = null),
+      Error(formatProdErrorMessage(185)))
+    );
+  for (var parent = sourceFiber.return; null !== parent; )
+    (sourceFiber = parent), (parent = sourceFiber.return);
+  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
 }
-var EventInterface = {
-    eventPhase: 0,
-    bubbles: 0,
-    cancelable: 0,
-    timeStamp: function (event) {
-      return event.timeStamp || Date.now();
-    },
-    defaultPrevented: 0,
-    isTrusted: 0
-  },
-  SyntheticEvent = createSyntheticEvent(EventInterface),
-  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
-  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
-  lastMovementX,
-  lastMovementY,
-  lastMouseEvent,
-  MouseEventInterface = assign({}, UIEventInterface, {
-    screenX: 0,
-    screenY: 0,
-    clientX: 0,
-    clientY: 0,
-    pageX: 0,
-    pageY: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    getModifierState: getEventModifierState,
-    button: 0,
-    buttons: 0,
-    relatedTarget: function (event) {
-      return void 0 === event.relatedTarget
-        ? event.fromElement === event.srcElement
-          ? event.toElement
-          : event.fromElement
-        : event.relatedTarget;
-    },
-    movementX: function (event) {
-      if ("movementX" in event) return event.movementX;
-      event !== lastMouseEvent &&
-        (lastMouseEvent && "mousemove" === event.type
-          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
-            (lastMovementY = event.screenY - lastMouseEvent.screenY))
-          : (lastMovementY = lastMovementX = 0),
-        (lastMouseEvent = event));
-      return lastMovementX;
-    },
-    movementY: function (event) {
-      return "movementY" in event ? event.movementY : lastMovementY;
-    }
-  }),
-  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
-  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
-  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
-  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
-  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
-  AnimationEventInterface = assign({}, EventInterface, {
-    animationName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
-  ClipboardEventInterface = assign({}, EventInterface, {
-    clipboardData: function (event) {
-      return "clipboardData" in event
-        ? event.clipboardData
-        : window.clipboardData;
-    }
-  }),
-  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
-  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
-  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
-  normalizeKey = {
-    Esc: "Escape",
-    Spacebar: " ",
-    Left: "ArrowLeft",
-    Up: "ArrowUp",
-    Right: "ArrowRight",
-    Down: "ArrowDown",
-    Del: "Delete",
-    Win: "OS",
-    Menu: "ContextMenu",
-    Apps: "ContextMenu",
-    Scroll: "ScrollLock",
-    MozPrintableKey: "Unidentified"
-  },
-  translateToKey = {
-    8: "Backspace",
-    9: "Tab",
-    12: "Clear",
-    13: "Enter",
-    16: "Shift",
-    17: "Control",
-    18: "Alt",
-    19: "Pause",
-    20: "CapsLock",
-    27: "Escape",
-    32: " ",
-    33: "PageUp",
-    34: "PageDown",
-    35: "End",
-    36: "Home",
-    37: "ArrowLeft",
-    38: "ArrowUp",
-    39: "ArrowRight",
-    40: "ArrowDown",
-    45: "Insert",
-    46: "Delete",
-    112: "F1",
-    113: "F2",
-    114: "F3",
-    115: "F4",
-    116: "F5",
-    117: "F6",
-    118: "F7",
-    119: "F8",
-    120: "F9",
-    121: "F10",
-    122: "F11",
-    123: "F12",
-    144: "NumLock",
-    145: "ScrollLock",
-    224: "Meta"
-  },
-  modifierKeyToProp = {
-    Alt: "altKey",
-    Control: "ctrlKey",
-    Meta: "metaKey",
-    Shift: "shiftKey"
+var hasForceUpdate = !1;
+function initializeUpdateQueue(fiber) {
+  fiber.updateQueue = {
+    baseState: fiber.memoizedState,
+    firstBaseUpdate: null,
+    lastBaseUpdate: null,
+    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
+    callbacks: null
   };
-function modifierStateGetter(keyArg) {
-  var nativeEvent = this.nativeEvent;
-  return nativeEvent.getModifierState
-    ? nativeEvent.getModifierState(keyArg)
-    : (keyArg = modifierKeyToProp[keyArg])
-    ? !!nativeEvent[keyArg]
-    : !1;
 }
-function getEventModifierState() {
-  return modifierStateGetter;
+function cloneUpdateQueue(current, workInProgress) {
+  current = current.updateQueue;
+  workInProgress.updateQueue === current &&
+    (workInProgress.updateQueue = {
+      baseState: current.baseState,
+      firstBaseUpdate: current.firstBaseUpdate,
+      lastBaseUpdate: current.lastBaseUpdate,
+      shared: current.shared,
+      callbacks: null
+    });
 }
-var KeyboardEventInterface = assign({}, UIEventInterface, {
-    key: function (nativeEvent) {
-      if (nativeEvent.key) {
-        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
-        if ("Unidentified" !== key) return key;
-      }
-      return "keypress" === nativeEvent.type
-        ? ((nativeEvent = getEventCharCode(nativeEvent)),
-          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
-        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
-        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
-        : "";
-    },
-    code: 0,
-    location: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    altKey: 0,
-    metaKey: 0,
-    repeat: 0,
-    locale: 0,
-    getModifierState: getEventModifierState,
-    charCode: function (event) {
-      return "keypress" === event.type ? getEventCharCode(event) : 0;
-    },
-    keyCode: function (event) {
-      return "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    },
-    which: function (event) {
-      return "keypress" === event.type
-        ? getEventCharCode(event)
-        : "keydown" === event.type || "keyup" === event.type
-        ? event.keyCode
-        : 0;
-    }
-  }),
-  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
-  PointerEventInterface = assign({}, MouseEventInterface, {
-    pointerId: 0,
-    width: 0,
-    height: 0,
-    pressure: 0,
-    tangentialPressure: 0,
-    tiltX: 0,
-    tiltY: 0,
-    twist: 0,
-    pointerType: 0,
-    isPrimary: 0
-  }),
-  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
-  TouchEventInterface = assign({}, UIEventInterface, {
-    touches: 0,
-    targetTouches: 0,
-    changedTouches: 0,
-    altKey: 0,
-    metaKey: 0,
-    ctrlKey: 0,
-    shiftKey: 0,
-    getModifierState: getEventModifierState
-  }),
-  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
-  TransitionEventInterface = assign({}, EventInterface, {
-    propertyName: 0,
-    elapsedTime: 0,
-    pseudoElement: 0
-  }),
-  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
-  WheelEventInterface = assign({}, MouseEventInterface, {
-    deltaX: function (event) {
-      return "deltaX" in event
-        ? event.deltaX
-        : "wheelDeltaX" in event
-        ? -event.wheelDeltaX
-        : 0;
-    },
-    deltaY: function (event) {
-      return "deltaY" in event
-        ? event.deltaY
-        : "wheelDeltaY" in event
-        ? -event.wheelDeltaY
-        : "wheelDelta" in event
-        ? -event.wheelDelta
-        : 0;
-    },
-    deltaZ: 0,
-    deltaMode: 0
-  }),
-  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
-  END_KEYCODES = [9, 13, 27, 32],
-  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
-  documentMode = null;
-canUseDOM &&
-  "documentMode" in document &&
-  (documentMode = document.documentMode);
-var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
-  useFallbackCompositionData =
-    canUseDOM &&
-    (!canUseCompositionEvent ||
-      (documentMode && 8 < documentMode && 11 >= documentMode)),
-  SPACEBAR_CHAR = String.fromCharCode(32),
-  hasSpaceKeypress = !1;
-function isFallbackCompositionEnd(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "keyup":
-      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
-    case "keydown":
-      return 229 !== nativeEvent.keyCode;
-    case "keypress":
-    case "mousedown":
-    case "focusout":
-      return !0;
-    default:
-      return !1;
-  }
+function createUpdate(lane) {
+  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
 }
-function getDataFromCustomEvent(nativeEvent) {
-  nativeEvent = nativeEvent.detail;
-  return "object" === typeof nativeEvent && "data" in nativeEvent
-    ? nativeEvent.data
-    : null;
+function enqueueUpdate(fiber, update, lane) {
+  var updateQueue = fiber.updateQueue;
+  if (null === updateQueue) return null;
+  updateQueue = updateQueue.shared;
+  if (
+    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
+    0 === (executionContext & 2)
+  )
+    return (
+      enqueueUpdate$1(fiber, updateQueue, update, lane),
+      getRootForUpdatedFiber(fiber)
+    );
+  var pending = updateQueue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  updateQueue.pending = update;
+  update = getRootForUpdatedFiber(fiber);
+  markUpdateLaneFromFiberToRoot(fiber, null, lane);
+  return update;
 }
-var isComposing = !1;
-function getNativeBeforeInputChars(domEventName, nativeEvent) {
-  switch (domEventName) {
-    case "compositionend":
-      return getDataFromCustomEvent(nativeEvent);
-    case "keypress":
-      if (32 !== nativeEvent.which) return null;
-      hasSpaceKeypress = !0;
-      return SPACEBAR_CHAR;
-    case "textInput":
-      return (
-        (domEventName = nativeEvent.data),
-        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
-      );
-    default:
-      return null;
+function entangleTransitions(root, fiber, lane) {
+  fiber = fiber.updateQueue;
+  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
+    var queueLanes = fiber.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    fiber.lanes = lane;
+    markRootEntangled(root, lane);
   }
 }
-function getFallbackBeforeInputChars(domEventName, nativeEvent) {
-  if (isComposing)
-    return "compositionend" === domEventName ||
-      (!canUseCompositionEvent &&
-        isFallbackCompositionEnd(domEventName, nativeEvent))
-      ? ((domEventName = getData()),
-        (fallbackText = startText = root = null),
-        (isComposing = !1),
-        domEventName)
-      : null;
-  switch (domEventName) {
-    case "paste":
-      return null;
-    case "keypress":
-      if (
-        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
-        (nativeEvent.ctrlKey && nativeEvent.altKey)
-      ) {
-        if (nativeEvent.char && 1 < nativeEvent.char.length)
-          return nativeEvent.char;
-        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
-      }
-      return null;
-    case "compositionend":
-      return useFallbackCompositionData && "ko" !== nativeEvent.locale
-        ? null
-        : nativeEvent.data;
-    default:
-      return null;
+function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+  var queue = workInProgress.updateQueue,
+    current = workInProgress.alternate;
+  if (
+    null !== current &&
+    ((current = current.updateQueue), queue === current)
+  ) {
+    var newFirst = null,
+      newLast = null;
+    queue = queue.firstBaseUpdate;
+    if (null !== queue) {
+      do {
+        var clone = {
+          lane: queue.lane,
+          tag: queue.tag,
+          payload: queue.payload,
+          callback: null,
+          next: null
+        };
+        null === newLast
+          ? (newFirst = newLast = clone)
+          : (newLast = newLast.next = clone);
+        queue = queue.next;
+      } while (null !== queue);
+      null === newLast
+        ? (newFirst = newLast = capturedUpdate)
+        : (newLast = newLast.next = capturedUpdate);
+    } else newFirst = newLast = capturedUpdate;
+    queue = {
+      baseState: current.baseState,
+      firstBaseUpdate: newFirst,
+      lastBaseUpdate: newLast,
+      shared: current.shared,
+      callbacks: current.callbacks
+    };
+    workInProgress.updateQueue = queue;
+    return;
   }
+  workInProgress = queue.lastBaseUpdate;
+  null === workInProgress
+    ? (queue.firstBaseUpdate = capturedUpdate)
+    : (workInProgress.next = capturedUpdate);
+  queue.lastBaseUpdate = capturedUpdate;
 }
-var supportedInputTypes = {
-  color: !0,
-  date: !0,
-  datetime: !0,
-  "datetime-local": !0,
-  email: !0,
-  month: !0,
-  number: !0,
-  password: !0,
-  range: !0,
-  search: !0,
-  tel: !0,
-  text: !0,
-  time: !0,
-  url: !0,
-  week: !0
-};
-function isTextInputElement(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return "input" === nodeName
-    ? !!supportedInputTypes[elem.type]
-    : "textarea" === nodeName
-    ? !0
-    : !1;
-}
-function createAndAccumulateChangeEvent(
-  dispatchQueue,
-  inst,
-  nativeEvent,
-  target
+function processUpdateQueue(
+  workInProgress$jscomp$0,
+  props,
+  instance$jscomp$0,
+  renderLanes
 ) {
-  enqueueStateRestore(target);
-  inst = accumulateTwoPhaseListeners(inst, "onChange");
-  0 < inst.length &&
-    ((nativeEvent = new SyntheticEvent(
-      "onChange",
-      "change",
-      null,
-      nativeEvent,
-      target
-    )),
-    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
-}
-var activeElement$1 = null,
-  activeElementInst$1 = null;
-function runEventInBatch(dispatchQueue) {
-  processDispatchQueue(dispatchQueue, 0);
-}
-function getInstIfValueChanged(targetInst) {
-  var targetNode = getNodeFromInstance(targetInst);
-  if (updateValueIfChanged(targetNode)) return targetInst;
-}
-function getTargetInstForChangeEvent(domEventName, targetInst) {
-  if ("change" === domEventName) return targetInst;
-}
-var isInputEventSupported = !1;
-if (canUseDOM) {
-  var JSCompiler_inline_result$jscomp$243;
-  if (canUseDOM) {
-    var isSupported$jscomp$inline_403 = "oninput" in document;
-    if (!isSupported$jscomp$inline_403) {
-      var element$jscomp$inline_404 = document.createElement("div");
-      element$jscomp$inline_404.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_403 =
-        "function" === typeof element$jscomp$inline_404.oninput;
-    }
-    JSCompiler_inline_result$jscomp$243 = isSupported$jscomp$inline_403;
-  } else JSCompiler_inline_result$jscomp$243 = !1;
-  isInputEventSupported =
-    JSCompiler_inline_result$jscomp$243 &&
-    (!document.documentMode || 9 < document.documentMode);
-}
-function stopWatchingForValueChange() {
-  activeElement$1 &&
-    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
-    (activeElementInst$1 = activeElement$1 = null));
-}
-function handlePropertyChange(nativeEvent) {
-  if (
-    "value" === nativeEvent.propertyName &&
-    getInstIfValueChanged(activeElementInst$1)
-  ) {
-    var dispatchQueue = [];
-    createAndAccumulateChangeEvent(
-      dispatchQueue,
-      activeElementInst$1,
-      nativeEvent,
-      getEventTarget(nativeEvent)
-    );
-    batchedUpdates$1(runEventInBatch, dispatchQueue);
+  var queue = workInProgress$jscomp$0.updateQueue;
+  hasForceUpdate = !1;
+  var firstBaseUpdate = queue.firstBaseUpdate,
+    lastBaseUpdate = queue.lastBaseUpdate,
+    pendingQueue = queue.shared.pending;
+  if (null !== pendingQueue) {
+    queue.shared.pending = null;
+    var lastPendingUpdate = pendingQueue,
+      firstPendingUpdate = lastPendingUpdate.next;
+    lastPendingUpdate.next = null;
+    null === lastBaseUpdate
+      ? (firstBaseUpdate = firstPendingUpdate)
+      : (lastBaseUpdate.next = firstPendingUpdate);
+    lastBaseUpdate = lastPendingUpdate;
+    var current = workInProgress$jscomp$0.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      (pendingQueue = current.lastBaseUpdate),
+      pendingQueue !== lastBaseUpdate &&
+        (null === pendingQueue
+          ? (current.firstBaseUpdate = firstPendingUpdate)
+          : (pendingQueue.next = firstPendingUpdate),
+        (current.lastBaseUpdate = lastPendingUpdate)));
+  }
+  if (null !== firstBaseUpdate) {
+    var newState = queue.baseState;
+    lastBaseUpdate = 0;
+    current = firstPendingUpdate = lastPendingUpdate = null;
+    pendingQueue = firstBaseUpdate;
+    do {
+      var updateLane = pendingQueue.lane & -1073741825,
+        isHiddenUpdate = updateLane !== pendingQueue.lane;
+      if (
+        isHiddenUpdate
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes & updateLane) === updateLane
+      ) {
+        null !== current &&
+          (current = current.next =
+            {
+              lane: 0,
+              tag: pendingQueue.tag,
+              payload: pendingQueue.payload,
+              callback: null,
+              next: null
+            });
+        a: {
+          var workInProgress = workInProgress$jscomp$0,
+            update = pendingQueue;
+          updateLane = props;
+          var instance = instance$jscomp$0;
+          switch (update.tag) {
+            case 1:
+              workInProgress = update.payload;
+              if ("function" === typeof workInProgress) {
+                newState = workInProgress.call(instance, newState, updateLane);
+                break a;
+              }
+              newState = workInProgress;
+              break a;
+            case 3:
+              workInProgress.flags = (workInProgress.flags & -65537) | 128;
+            case 0:
+              workInProgress = update.payload;
+              updateLane =
+                "function" === typeof workInProgress
+                  ? workInProgress.call(instance, newState, updateLane)
+                  : workInProgress;
+              if (null === updateLane || void 0 === updateLane) break a;
+              newState = assign({}, newState, updateLane);
+              break a;
+            case 2:
+              hasForceUpdate = !0;
+          }
+        }
+        updateLane = pendingQueue.callback;
+        null !== updateLane &&
+          ((workInProgress$jscomp$0.flags |= 64),
+          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
+          (isHiddenUpdate = queue.callbacks),
+          null === isHiddenUpdate
+            ? (queue.callbacks = [updateLane])
+            : isHiddenUpdate.push(updateLane));
+      } else
+        (isHiddenUpdate = {
+          lane: updateLane,
+          tag: pendingQueue.tag,
+          payload: pendingQueue.payload,
+          callback: pendingQueue.callback,
+          next: null
+        }),
+          null === current
+            ? ((firstPendingUpdate = current = isHiddenUpdate),
+              (lastPendingUpdate = newState))
+            : (current = current.next = isHiddenUpdate),
+          (lastBaseUpdate |= updateLane);
+      pendingQueue = pendingQueue.next;
+      if (null === pendingQueue)
+        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
+          break;
+        else
+          (isHiddenUpdate = pendingQueue),
+            (pendingQueue = isHiddenUpdate.next),
+            (isHiddenUpdate.next = null),
+            (queue.lastBaseUpdate = isHiddenUpdate),
+            (queue.shared.pending = null);
+    } while (1);
+    null === current && (lastPendingUpdate = newState);
+    queue.baseState = lastPendingUpdate;
+    queue.firstBaseUpdate = firstPendingUpdate;
+    queue.lastBaseUpdate = current;
+    null === firstBaseUpdate && (queue.shared.lanes = 0);
+    workInProgressRootSkippedLanes |= lastBaseUpdate;
+    workInProgress$jscomp$0.lanes = lastBaseUpdate;
+    workInProgress$jscomp$0.memoizedState = newState;
   }
 }
-function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
-  "focusin" === domEventName
-    ? (stopWatchingForValueChange(),
-      (activeElement$1 = target),
-      (activeElementInst$1 = targetInst),
-      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
-    : "focusout" === domEventName && stopWatchingForValueChange();
-}
-function getTargetInstForInputEventPolyfill(domEventName) {
-  if (
-    "selectionchange" === domEventName ||
-    "keyup" === domEventName ||
-    "keydown" === domEventName
-  )
-    return getInstIfValueChanged(activeElementInst$1);
-}
-function getTargetInstForClickEvent(domEventName, targetInst) {
-  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
-}
-function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
-  if ("input" === domEventName || "change" === domEventName)
-    return getInstIfValueChanged(targetInst);
+function callCallback(callback, context) {
+  if ("function" !== typeof callback)
+    throw Error(formatProdErrorMessage(191, callback));
+  callback.call(context);
 }
-function is(x, y) {
-  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
+function commitCallbacks(updateQueue, context) {
+  var callbacks = updateQueue.callbacks;
+  if (null !== callbacks)
+    for (
+      updateQueue.callbacks = null, updateQueue = 0;
+      updateQueue < callbacks.length;
+      updateQueue++
+    )
+      callCallback(callbacks[updateQueue], context);
 }
-var objectIs = "function" === typeof Object.is ? Object.is : is;
 function shallowEqual(objA, objB) {
   if (objectIs(objA, objB)) return !0;
   if (
@@ -3072,5262 +2515,2490 @@ function shallowEqual(objA, objB) {
   }
   return !0;
 }
-function getLeafNode(node) {
-  for (; node && node.firstChild; ) node = node.firstChild;
-  return node;
-}
-function getNodeForCharacterOffset(root, offset) {
-  var node = getLeafNode(root);
-  root = 0;
-  for (var nodeEnd; node; ) {
-    if (3 === node.nodeType) {
-      nodeEnd = root + node.textContent.length;
-      if (root <= offset && nodeEnd >= offset)
-        return { node: node, offset: offset - root };
-      root = nodeEnd;
-    }
-    a: {
-      for (; node; ) {
-        if (node.nextSibling) {
-          node = node.nextSibling;
-          break a;
-        }
-        node = node.parentNode;
-      }
-      node = void 0;
-    }
-    node = getLeafNode(node);
-  }
-}
-function containsNode$1(outerNode, innerNode) {
-  return outerNode && innerNode
-    ? outerNode === innerNode
-      ? !0
-      : outerNode && 3 === outerNode.nodeType
-      ? !1
-      : innerNode && 3 === innerNode.nodeType
-      ? containsNode$1(outerNode, innerNode.parentNode)
-      : "contains" in outerNode
-      ? outerNode.contains(innerNode)
-      : outerNode.compareDocumentPosition
-      ? !!(outerNode.compareDocumentPosition(innerNode) & 16)
-      : !1
-    : !1;
+var SuspenseException = Error(formatProdErrorMessage(460));
+function isThenableResolved(thenable) {
+  thenable = thenable.status;
+  return "fulfilled" === thenable || "rejected" === thenable;
 }
-function getActiveElementDeep() {
-  for (
-    var win = window, element = getActiveElement();
-    element instanceof win.HTMLIFrameElement;
-
-  ) {
-    try {
-      var JSCompiler_inline_result =
-        "string" === typeof element.contentWindow.location.href;
-    } catch (err) {
-      JSCompiler_inline_result = !1;
-    }
-    if (JSCompiler_inline_result) win = element.contentWindow;
-    else break;
-    element = getActiveElement(win.document);
+function noop$1() {}
+function trackUsedThenable(thenableState, thenable, index) {
+  index = thenableState[index];
+  void 0 === index
+    ? thenableState.push(thenable)
+    : index !== thenable && (thenable.then(noop$1, noop$1), (thenable = index));
+  switch (thenable.status) {
+    case "fulfilled":
+      return thenable.value;
+    case "rejected":
+      throw thenable.reason;
+    default:
+      "string" === typeof thenable.status
+        ? thenable.then(noop$1, noop$1)
+        : ((thenableState = thenable),
+          (thenableState.status = "pending"),
+          thenableState.then(
+            function (fulfilledValue) {
+              if ("pending" === thenable.status) {
+                var fulfilledThenable = thenable;
+                fulfilledThenable.status = "fulfilled";
+                fulfilledThenable.value = fulfilledValue;
+              }
+            },
+            function (error) {
+              if ("pending" === thenable.status) {
+                var rejectedThenable = thenable;
+                rejectedThenable.status = "rejected";
+                rejectedThenable.reason = error;
+              }
+            }
+          ));
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+      }
+      suspendedThenable = thenable;
+      throw SuspenseException;
   }
-  return element;
 }
-function hasSelectionCapabilities(elem) {
-  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-  return (
-    nodeName &&
-    (("input" === nodeName &&
-      ("text" === elem.type ||
-        "search" === elem.type ||
-        "tel" === elem.type ||
-        "url" === elem.type ||
-        "password" === elem.type)) ||
-      "textarea" === nodeName ||
-      "true" === elem.contentEditable)
-  );
+var suspendedThenable = null,
+  thenableState$1 = null,
+  thenableIndexCounter$1 = 0;
+function unwrapThenable(thenable) {
+  var index = thenableIndexCounter$1;
+  thenableIndexCounter$1 += 1;
+  null === thenableState$1 && (thenableState$1 = []);
+  return trackUsedThenable(thenableState$1, thenable, index);
 }
-function restoreSelection(priorSelectionInformation) {
-  var curFocusedElem = getActiveElementDeep(),
-    priorFocusedElem = priorSelectionInformation.focusedElem,
-    priorSelectionRange = priorSelectionInformation.selectionRange;
+function coerceRef(returnFiber, current, element) {
+  returnFiber = element.ref;
   if (
-    curFocusedElem !== priorFocusedElem &&
-    priorFocusedElem &&
-    priorFocusedElem.ownerDocument &&
-    containsNode$1(
-      priorFocusedElem.ownerDocument.documentElement,
-      priorFocusedElem
-    )
+    null !== returnFiber &&
+    "function" !== typeof returnFiber &&
+    "object" !== typeof returnFiber
   ) {
-    if (
-      null !== priorSelectionRange &&
-      hasSelectionCapabilities(priorFocusedElem)
-    )
+    if (element._owner) {
+      element = element._owner;
+      if (element) {
+        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
+        var inst = element.stateNode;
+      }
+      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
+      var resolvedInst = inst,
+        stringRef = "" + returnFiber;
       if (
-        ((curFocusedElem = priorSelectionRange.start),
-        (priorSelectionInformation = priorSelectionRange.end),
-        void 0 === priorSelectionInformation &&
-          (priorSelectionInformation = curFocusedElem),
-        "selectionStart" in priorFocusedElem)
+        null !== current &&
+        null !== current.ref &&
+        "function" === typeof current.ref &&
+        current.ref._stringRef === stringRef
       )
-        (priorFocusedElem.selectionStart = curFocusedElem),
-          (priorFocusedElem.selectionEnd = Math.min(
-            priorSelectionInformation,
-            priorFocusedElem.value.length
-          ));
-      else if (
-        ((priorSelectionInformation =
-          ((curFocusedElem = priorFocusedElem.ownerDocument || document) &&
-            curFocusedElem.defaultView) ||
-          window),
-        priorSelectionInformation.getSelection)
-      ) {
-        priorSelectionInformation = priorSelectionInformation.getSelection();
-        var length = priorFocusedElem.textContent.length,
-          start = Math.min(priorSelectionRange.start, length);
-        priorSelectionRange =
-          void 0 === priorSelectionRange.end
-            ? start
-            : Math.min(priorSelectionRange.end, length);
-        !priorSelectionInformation.extend &&
-          start > priorSelectionRange &&
-          ((length = priorSelectionRange),
-          (priorSelectionRange = start),
-          (start = length));
-        length = getNodeForCharacterOffset(priorFocusedElem, start);
-        var endMarker = getNodeForCharacterOffset(
-          priorFocusedElem,
-          priorSelectionRange
-        );
-        length &&
-          endMarker &&
-          (1 !== priorSelectionInformation.rangeCount ||
-            priorSelectionInformation.anchorNode !== length.node ||
-            priorSelectionInformation.anchorOffset !== length.offset ||
-            priorSelectionInformation.focusNode !== endMarker.node ||
-            priorSelectionInformation.focusOffset !== endMarker.offset) &&
-          ((curFocusedElem = curFocusedElem.createRange()),
-          curFocusedElem.setStart(length.node, length.offset),
-          priorSelectionInformation.removeAllRanges(),
-          start > priorSelectionRange
-            ? (priorSelectionInformation.addRange(curFocusedElem),
-              priorSelectionInformation.extend(
-                endMarker.node,
-                endMarker.offset
-              ))
-            : (curFocusedElem.setEnd(endMarker.node, endMarker.offset),
-              priorSelectionInformation.addRange(curFocusedElem)));
-      }
-    curFocusedElem = [];
-    for (
-      priorSelectionInformation = priorFocusedElem;
-      (priorSelectionInformation = priorSelectionInformation.parentNode);
-
-    )
-      1 === priorSelectionInformation.nodeType &&
-        curFocusedElem.push({
-          element: priorSelectionInformation,
-          left: priorSelectionInformation.scrollLeft,
-          top: priorSelectionInformation.scrollTop
-        });
-    "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
-    for (
-      priorFocusedElem = 0;
-      priorFocusedElem < curFocusedElem.length;
-      priorFocusedElem++
-    )
-      (priorSelectionInformation = curFocusedElem[priorFocusedElem]),
-        (priorSelectionInformation.element.scrollLeft =
-          priorSelectionInformation.left),
-        (priorSelectionInformation.element.scrollTop =
-          priorSelectionInformation.top);
+        return current.ref;
+      current = function (value) {
+        var refs = resolvedInst.refs;
+        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
+      };
+      current._stringRef = stringRef;
+      return current;
+    }
+    if ("string" !== typeof returnFiber)
+      throw Error(formatProdErrorMessage(284));
+    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
   }
+  return returnFiber;
 }
-var skipSelectionChangeEvent =
-    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
-  activeElement = null,
-  activeElementInst = null,
-  lastSelection = null,
-  mouseDown = !1;
-function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
-  var doc =
-    nativeEventTarget.window === nativeEventTarget
-      ? nativeEventTarget.document
-      : 9 === nativeEventTarget.nodeType
-      ? nativeEventTarget
-      : nativeEventTarget.ownerDocument;
-  mouseDown ||
-    null == activeElement ||
-    activeElement !== getActiveElement(doc) ||
-    ((doc = activeElement),
-    "selectionStart" in doc && hasSelectionCapabilities(doc)
-      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
-      : ((doc = (
-          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
-          window
-        ).getSelection()),
-        (doc = {
-          anchorNode: doc.anchorNode,
-          anchorOffset: doc.anchorOffset,
-          focusNode: doc.focusNode,
-          focusOffset: doc.focusOffset
-        })),
-    (lastSelection && shallowEqual(lastSelection, doc)) ||
-      ((lastSelection = doc),
-      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
-      0 < doc.length &&
-        ((nativeEvent = new SyntheticEvent(
-          "onSelect",
-          "select",
-          null,
-          nativeEvent,
-          nativeEventTarget
-        )),
-        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
-        (nativeEvent.target = activeElement))));
+function throwOnInvalidObjectType(returnFiber, newChild) {
+  returnFiber = Object.prototype.toString.call(newChild);
+  throw Error(
+    formatProdErrorMessage(
+      31,
+      "[object Object]" === returnFiber
+        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
+        : returnFiber
+    )
+  );
 }
-function makePrefixMap(styleProp, eventName) {
-  var prefixes = {};
-  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-  prefixes["Webkit" + styleProp] = "webkit" + eventName;
-  prefixes["Moz" + styleProp] = "moz" + eventName;
-  return prefixes;
+function resolveLazy(lazyType) {
+  var init = lazyType._init;
+  return init(lazyType._payload);
 }
-var vendorPrefixes = {
-    animationend: makePrefixMap("Animation", "AnimationEnd"),
-    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
-    animationstart: makePrefixMap("Animation", "AnimationStart"),
-    transitionend: makePrefixMap("Transition", "TransitionEnd")
-  },
-  prefixedEventNames = {},
-  style = {};
-canUseDOM &&
-  ((style = document.createElement("div").style),
-  "AnimationEvent" in window ||
-    (delete vendorPrefixes.animationend.animation,
-    delete vendorPrefixes.animationiteration.animation,
-    delete vendorPrefixes.animationstart.animation),
-  "TransitionEvent" in window ||
-    delete vendorPrefixes.transitionend.transition);
-function getVendorPrefixedEventName(eventName) {
-  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
-  if (!vendorPrefixes[eventName]) return eventName;
-  var prefixMap = vendorPrefixes[eventName],
-    styleProp;
-  for (styleProp in prefixMap)
-    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
-      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
-  return eventName;
-}
-var ANIMATION_END = getVendorPrefixedEventName("animationend"),
-  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
-  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
-  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
-  topLevelEventsToReactNames = new Map(),
-  simpleEventPluginEvents =
-    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
-      " "
-    );
-topLevelEventsToReactNames.set("beforeblur", null);
-topLevelEventsToReactNames.set("afterblur", null);
-function registerSimpleEvent(domEventName, reactName) {
-  topLevelEventsToReactNames.set(domEventName, reactName);
-  registerTwoPhaseEvent(reactName, [domEventName]);
-}
-for (
-  var i$jscomp$inline_444 = 0;
-  i$jscomp$inline_444 < simpleEventPluginEvents.length;
-  i$jscomp$inline_444++
-) {
-  var eventName$jscomp$inline_445 =
-      simpleEventPluginEvents[i$jscomp$inline_444],
-    domEventName$jscomp$inline_446 = eventName$jscomp$inline_445.toLowerCase(),
-    capitalizedEvent$jscomp$inline_447 =
-      eventName$jscomp$inline_445[0].toUpperCase() +
-      eventName$jscomp$inline_445.slice(1);
-  registerSimpleEvent(
-    domEventName$jscomp$inline_446,
-    "on" + capitalizedEvent$jscomp$inline_447
-  );
-}
-registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
-registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
-registerSimpleEvent(ANIMATION_START, "onAnimationStart");
-registerSimpleEvent("dblclick", "onDoubleClick");
-registerSimpleEvent("focusin", "onFocus");
-registerSimpleEvent("focusout", "onBlur");
-registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
-registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
-registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
-registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
-registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
-registerTwoPhaseEvent(
-  "onChange",
-  "change click focusin focusout input keydown keyup selectionchange".split(" ")
-);
-registerTwoPhaseEvent(
-  "onSelect",
-  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
-    " "
-  )
-);
-registerTwoPhaseEvent("onBeforeInput", [
-  "compositionend",
-  "keypress",
-  "textInput",
-  "paste"
-]);
-registerTwoPhaseEvent(
-  "onCompositionEnd",
-  "compositionend focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionStart",
-  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
-);
-registerTwoPhaseEvent(
-  "onCompositionUpdate",
-  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
-);
-var mediaEventTypes =
-    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
-      " "
-    ),
-  nonDelegatedEvents = new Set(
-    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
-  );
-function executeDispatch(event, listener, currentTarget) {
-  var type = event.type || "unknown-event";
-  event.currentTarget = currentTarget;
-  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
-  event.currentTarget = null;
-}
-function processDispatchQueue(dispatchQueue, eventSystemFlags) {
-  eventSystemFlags = 0 !== (eventSystemFlags & 4);
-  for (var i = 0; i < dispatchQueue.length; i++) {
-    var _dispatchQueue$i = dispatchQueue[i],
-      event = _dispatchQueue$i.event;
-    _dispatchQueue$i = _dispatchQueue$i.listeners;
-    a: {
-      var previousInstance = void 0;
-      if (eventSystemFlags)
-        for (
-          var i$jscomp$0 = _dispatchQueue$i.length - 1;
-          0 <= i$jscomp$0;
-          i$jscomp$0--
-        ) {
-          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
-            instance = _dispatchListeners$i.instance,
-            currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
-      else
-        for (
-          i$jscomp$0 = 0;
-          i$jscomp$0 < _dispatchQueue$i.length;
-          i$jscomp$0++
-        ) {
-          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
-          instance = _dispatchListeners$i.instance;
-          currentTarget = _dispatchListeners$i.currentTarget;
-          _dispatchListeners$i = _dispatchListeners$i.listener;
-          if (instance !== previousInstance && event.isPropagationStopped())
-            break a;
-          executeDispatch(event, _dispatchListeners$i, currentTarget);
-          previousInstance = instance;
-        }
+function createChildReconciler(shouldTrackSideEffects) {
+  function deleteChild(returnFiber, childToDelete) {
+    if (shouldTrackSideEffects) {
+      var deletions = returnFiber.deletions;
+      null === deletions
+        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
+        : deletions.push(childToDelete);
     }
   }
-  if (hasRethrowError)
-    throw (
-      ((dispatchQueue = rethrowError),
-      (hasRethrowError = !1),
-      (rethrowError = null),
-      dispatchQueue)
-    );
-}
-function listenToNonDelegatedEvent(domEventName, targetElement) {
-  var listenerSet = getEventListenerSet(targetElement),
-    listenerSetKey = domEventName + "__bubble";
-  listenerSet.has(listenerSetKey) ||
-    (addTrappedEventListener(targetElement, domEventName, 2, !1),
-    listenerSet.add(listenerSetKey));
-}
-function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
-  var eventSystemFlags = 0;
-  isCapturePhaseListener && (eventSystemFlags |= 4);
-  addTrappedEventListener(
-    target,
-    domEventName,
-    eventSystemFlags,
-    isCapturePhaseListener
-  );
-}
-var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
-function listenToAllSupportedEvents(rootContainerElement) {
-  if (!rootContainerElement[listeningMarker]) {
-    rootContainerElement[listeningMarker] = !0;
-    allNativeEvents.forEach(function (domEventName) {
-      "selectionchange" !== domEventName &&
-        (nonDelegatedEvents.has(domEventName) ||
-          listenToNativeEvent(domEventName, !1, rootContainerElement),
-        listenToNativeEvent(domEventName, !0, rootContainerElement));
-    });
-    var ownerDocument =
-      9 === rootContainerElement.nodeType
-        ? rootContainerElement
-        : rootContainerElement.ownerDocument;
-    null === ownerDocument ||
-      ownerDocument[listeningMarker] ||
-      ((ownerDocument[listeningMarker] = !0),
-      listenToNativeEvent("selectionchange", !1, ownerDocument));
+  function deleteRemainingChildren(returnFiber, currentFirstChild) {
+    if (!shouldTrackSideEffects) return null;
+    for (; null !== currentFirstChild; )
+      deleteChild(returnFiber, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return null;
   }
-}
-function addTrappedEventListener(
-  targetContainer,
-  domEventName,
-  eventSystemFlags,
-  isCapturePhaseListener,
-  isDeferredListenerForLegacyFBSupport
-) {
-  eventSystemFlags = createEventListenerWrapperWithPriority(
-    targetContainer,
-    domEventName,
-    eventSystemFlags
-  );
-  var isPassiveListener = void 0;
-  !passiveBrowserEventsSupported ||
-    ("touchstart" !== domEventName &&
-      "touchmove" !== domEventName &&
-      "wheel" !== domEventName) ||
-    (isPassiveListener = !0);
-  targetContainer =
-    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
-      ? targetContainer.ownerDocument
-      : targetContainer;
-  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
-    var originalListener = eventSystemFlags;
-    eventSystemFlags = function () {
-      targetContainer.removeEventListener(
-        domEventName,
-        unsubscribeListener,
-        isCapturePhaseListener
+  function mapRemainingChildren(returnFiber, currentFirstChild) {
+    for (returnFiber = new Map(); null !== currentFirstChild; )
+      null !== currentFirstChild.key
+        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
+        : returnFiber.set(currentFirstChild.index, currentFirstChild),
+        (currentFirstChild = currentFirstChild.sibling);
+    return returnFiber;
+  }
+  function useFiber(fiber, pendingProps) {
+    fiber = createWorkInProgress(fiber, pendingProps);
+    fiber.index = 0;
+    fiber.sibling = null;
+    return fiber;
+  }
+  function placeChild(newFiber, lastPlacedIndex, newIndex) {
+    newFiber.index = newIndex;
+    if (!shouldTrackSideEffects)
+      return (newFiber.flags |= 1048576), lastPlacedIndex;
+    newIndex = newFiber.alternate;
+    if (null !== newIndex)
+      return (
+        (newIndex = newIndex.index),
+        newIndex < lastPlacedIndex
+          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
+          : newIndex
       );
-      for (
-        var _len = arguments.length, p = Array(_len), _key = 0;
-        _key < _len;
-        _key++
-      )
-        p[_key] = arguments[_key];
-      return originalListener.apply(this, p);
-    };
+    newFiber.flags |= 16777218;
+    return lastPlacedIndex;
   }
-  var unsubscribeListener = isCapturePhaseListener
-    ? void 0 !== isPassiveListener
-      ? addEventCaptureListenerWithPassiveFlag(
-          targetContainer,
-          domEventName,
-          eventSystemFlags,
-          isPassiveListener
-        )
-      : addEventCaptureListener(targetContainer, domEventName, eventSystemFlags)
-    : void 0 !== isPassiveListener
-    ? addEventBubbleListenerWithPassiveFlag(
-        targetContainer,
-        domEventName,
-        eventSystemFlags,
-        isPassiveListener
-      )
-    : addEventBubbleListener(targetContainer, domEventName, eventSystemFlags);
-}
-function dispatchEventForPluginEventSystem(
-  domEventName,
-  eventSystemFlags,
-  nativeEvent,
-  targetInst$jscomp$0,
-  targetContainer
-) {
-  var ancestorInst = targetInst$jscomp$0;
-  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+  function placeSingleChild(newFiber) {
+    shouldTrackSideEffects &&
+      null === newFiber.alternate &&
+      (newFiber.flags |= 16777218);
+    return newFiber;
+  }
+  function updateTextNode(returnFiber, current, textContent, lanes) {
+    if (null === current || 6 !== current.tag)
+      return (
+        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, textContent);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateElement(returnFiber, current, element, lanes) {
+    var elementType = element.type;
+    if (elementType === REACT_FRAGMENT_TYPE)
+      return updateFragment(
+        returnFiber,
+        current,
+        element.props.children,
+        lanes,
+        element.key
+      );
     if (
-      enableLegacyFBSupport &&
-      "click" === domEventName &&
-      0 === (eventSystemFlags & 20) &&
-      nativeEvent !== currentReplayingEvent
-    ) {
-      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
-      return;
-    }
-    if (null !== targetInst$jscomp$0)
-      a: for (;;) {
-        if (null === targetInst$jscomp$0) return;
-        var nodeTag = targetInst$jscomp$0.tag;
-        if (3 === nodeTag || 4 === nodeTag) {
-          var container = targetInst$jscomp$0.stateNode.containerInfo;
-          if (
-            container === targetContainer ||
-            (8 === container.nodeType &&
-              container.parentNode === targetContainer)
-          )
-            break;
-          if (4 === nodeTag)
-            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
-              var grandTag = nodeTag.tag;
-              if (3 === grandTag || 4 === grandTag)
-                if (
-                  ((grandTag = nodeTag.stateNode.containerInfo),
-                  grandTag === targetContainer ||
-                    (8 === grandTag.nodeType &&
-                      grandTag.parentNode === targetContainer))
-                )
-                  return;
-              nodeTag = nodeTag.return;
-            }
-          for (; null !== container; ) {
-            nodeTag = getClosestInstanceFromNode(container);
-            if (null === nodeTag) return;
-            grandTag = nodeTag.tag;
-            if (
-              5 === grandTag ||
-              6 === grandTag ||
-              26 === grandTag ||
-              27 === grandTag
-            ) {
-              targetInst$jscomp$0 = ancestorInst = nodeTag;
-              continue a;
-            }
-            container = container.parentNode;
-          }
-        }
-        targetInst$jscomp$0 = targetInst$jscomp$0.return;
+      null !== current &&
+      (current.elementType === elementType ||
+        ("object" === typeof elementType &&
+          null !== elementType &&
+          elementType.$$typeof === REACT_LAZY_TYPE &&
+          resolveLazy(elementType) === current.type))
+    )
+      return (
+        (lanes = useFiber(current, element.props)),
+        (lanes.ref = coerceRef(returnFiber, current, element)),
+        (lanes.return = returnFiber),
+        lanes
+      );
+    lanes = createFiberFromTypeAndProps(
+      element.type,
+      element.key,
+      element.props,
+      null,
+      returnFiber.mode,
+      lanes
+    );
+    lanes.ref = coerceRef(returnFiber, current, element);
+    lanes.return = returnFiber;
+    return lanes;
+  }
+  function updatePortal(returnFiber, current, portal, lanes) {
+    if (
+      null === current ||
+      4 !== current.tag ||
+      current.stateNode.containerInfo !== portal.containerInfo ||
+      current.stateNode.implementation !== portal.implementation
+    )
+      return (
+        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, portal.children || []);
+    current.return = returnFiber;
+    return current;
+  }
+  function updateFragment(returnFiber, current, fragment, lanes, key) {
+    if (null === current || 7 !== current.tag)
+      return (
+        (current = createFiberFromFragment(
+          fragment,
+          returnFiber.mode,
+          lanes,
+          key
+        )),
+        (current.return = returnFiber),
+        current
+      );
+    current = useFiber(current, fragment);
+    current.return = returnFiber;
+    return current;
+  }
+  function createChild(returnFiber, newChild, lanes) {
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return (
+        (newChild = createFiberFromText(
+          "" + newChild,
+          returnFiber.mode,
+          lanes
+        )),
+        (newChild.return = returnFiber),
+        newChild
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (lanes = createFiberFromTypeAndProps(
+              newChild.type,
+              newChild.key,
+              newChild.props,
+              null,
+              returnFiber.mode,
+              lanes
+            )),
+            (lanes.ref = coerceRef(returnFiber, null, newChild)),
+            (lanes.return = returnFiber),
+            lanes
+          );
+        case REACT_PORTAL_TYPE:
+          return (
+            (newChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
+            )),
+            (newChild.return = returnFiber),
+            newChild
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return createChild(returnFiber, init(newChild._payload), lanes);
       }
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (newChild = createFiberFromFragment(
+            newChild,
+            returnFiber.mode,
+            lanes,
+            null
+          )),
+          (newChild.return = returnFiber),
+          newChild
+        );
+      if ("function" === typeof newChild.then)
+        return createChild(returnFiber, unwrapThenable(newChild), lanes);
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return createChild(
+          returnFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return null;
   }
-  batchedUpdates$1(function () {
-    var targetInst = ancestorInst,
-      nativeEventTarget = getEventTarget(nativeEvent),
-      dispatchQueue = [];
-    a: {
-      var reactName = topLevelEventsToReactNames.get(domEventName);
-      if (void 0 !== reactName) {
-        var SyntheticEventCtor = SyntheticEvent,
-          reactEventType = domEventName;
-        switch (domEventName) {
-          case "keypress":
-            if (0 === getEventCharCode(nativeEvent)) break a;
-          case "keydown":
-          case "keyup":
-            SyntheticEventCtor = SyntheticKeyboardEvent;
-            break;
-          case "focusin":
-            reactEventType = "focus";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "focusout":
-            reactEventType = "blur";
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "beforeblur":
-          case "afterblur":
-            SyntheticEventCtor = SyntheticFocusEvent;
-            break;
-          case "click":
-            if (2 === nativeEvent.button) break a;
-          case "auxclick":
-          case "dblclick":
-          case "mousedown":
-          case "mousemove":
-          case "mouseup":
-          case "mouseout":
-          case "mouseover":
-          case "contextmenu":
-            SyntheticEventCtor = SyntheticMouseEvent;
-            break;
-          case "drag":
-          case "dragend":
-          case "dragenter":
-          case "dragexit":
-          case "dragleave":
-          case "dragover":
-          case "dragstart":
-          case "drop":
-            SyntheticEventCtor = SyntheticDragEvent;
-            break;
-          case "touchcancel":
-          case "touchend":
-          case "touchmove":
-          case "touchstart":
-            SyntheticEventCtor = SyntheticTouchEvent;
-            break;
-          case ANIMATION_END:
-          case ANIMATION_ITERATION:
-          case ANIMATION_START:
-            SyntheticEventCtor = SyntheticAnimationEvent;
-            break;
-          case TRANSITION_END:
-            SyntheticEventCtor = SyntheticTransitionEvent;
-            break;
-          case "scroll":
-            SyntheticEventCtor = SyntheticUIEvent;
-            break;
-          case "wheel":
-            SyntheticEventCtor = SyntheticWheelEvent;
-            break;
-          case "copy":
-          case "cut":
-          case "paste":
-            SyntheticEventCtor = SyntheticClipboardEvent;
-            break;
-          case "gotpointercapture":
-          case "lostpointercapture":
-          case "pointercancel":
-          case "pointerdown":
-          case "pointermove":
-          case "pointerout":
-          case "pointerover":
-          case "pointerup":
-            SyntheticEventCtor = SyntheticPointerEvent;
-        }
-        var inCapturePhase = 0 !== (eventSystemFlags & 4);
-        eventSystemFlags & 1
-          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
-              reactEventType,
-              targetContainer,
-              inCapturePhase
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })))
-          : ((inCapturePhase = accumulateSinglePhaseListeners(
-              targetInst,
-              reactName,
-              nativeEvent.type,
-              inCapturePhase,
-              !inCapturePhase && "scroll" === domEventName,
-              nativeEvent
-            )),
-            0 < inCapturePhase.length &&
-              ((reactName = new SyntheticEventCtor(
-                reactName,
-                reactEventType,
-                null,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              dispatchQueue.push({
-                event: reactName,
-                listeners: inCapturePhase
-              })));
+  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+    var key = null !== oldFiber ? oldFiber.key : null;
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return null !== key
+        ? null
+        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return newChild.key === key
+            ? updateElement(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_PORTAL_TYPE:
+          return newChild.key === key
+            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
+            : null;
+        case REACT_LAZY_TYPE:
+          return (
+            (key = newChild._init),
+            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
+          );
       }
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return null !== key
+          ? null
+          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+      if ("function" === typeof newChild.then)
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return updateSlot(
+          returnFiber,
+          oldFiber,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-    if (0 === (eventSystemFlags & 7)) {
-      a: {
-        reactName =
-          "mouseover" === domEventName || "pointerover" === domEventName;
-        SyntheticEventCtor =
-          "mouseout" === domEventName || "pointerout" === domEventName;
-        if (
-          reactName &&
-          nativeEvent !== currentReplayingEvent &&
-          (reactEventType =
-            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
-          (getClosestInstanceFromNode(reactEventType) ||
-            reactEventType[internalContainerInstanceKey])
-        )
-          break a;
-        if (SyntheticEventCtor || reactName) {
-          reactName =
-            nativeEventTarget.window === nativeEventTarget
-              ? nativeEventTarget
-              : (reactName = nativeEventTarget.ownerDocument)
-              ? reactName.defaultView || reactName.parentWindow
-              : window;
-          if (SyntheticEventCtor) {
-            if (
-              ((reactEventType =
-                nativeEvent.relatedTarget || nativeEvent.toElement),
-              (SyntheticEventCtor = targetInst),
-              (reactEventType = reactEventType
-                ? getClosestInstanceFromNode(reactEventType)
-                : null),
-              null !== reactEventType)
-            ) {
-              inCapturePhase = getNearestMountedFiber(reactEventType);
-              var tag = reactEventType.tag;
-              if (
-                reactEventType !== inCapturePhase ||
-                (5 !== tag && 27 !== tag && 6 !== tag)
-              )
-                reactEventType = null;
-            }
-          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
-          if (SyntheticEventCtor !== reactEventType) {
-            tag = SyntheticMouseEvent;
-            var leaveEventType = "onMouseLeave",
-              enterEventType = "onMouseEnter",
-              eventTypePrefix = "mouse";
-            if ("pointerout" === domEventName || "pointerover" === domEventName)
-              (tag = SyntheticPointerEvent),
-                (leaveEventType = "onPointerLeave"),
-                (enterEventType = "onPointerEnter"),
-                (eventTypePrefix = "pointer");
-            inCapturePhase =
-              null == SyntheticEventCtor
-                ? reactName
-                : getNodeFromInstance(SyntheticEventCtor);
-            var toNode =
-              null == reactEventType
-                ? reactName
-                : getNodeFromInstance(reactEventType);
-            reactName = new tag(
-              leaveEventType,
-              eventTypePrefix + "leave",
-              SyntheticEventCtor,
-              nativeEvent,
-              nativeEventTarget
-            );
-            reactName.target = inCapturePhase;
-            reactName.relatedTarget = toNode;
-            leaveEventType = null;
-            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
-              ((tag = new tag(
-                enterEventType,
-                eventTypePrefix + "enter",
-                reactEventType,
-                nativeEvent,
-                nativeEventTarget
-              )),
-              (tag.target = toNode),
-              (tag.relatedTarget = inCapturePhase),
-              (leaveEventType = tag));
-            inCapturePhase = leaveEventType;
-            if (SyntheticEventCtor && reactEventType)
-              b: {
-                tag = SyntheticEventCtor;
-                enterEventType = reactEventType;
-                eventTypePrefix = 0;
-                for (toNode = tag; toNode; toNode = getParent(toNode))
-                  eventTypePrefix++;
-                toNode = 0;
-                for (
-                  leaveEventType = enterEventType;
-                  leaveEventType;
-                  leaveEventType = getParent(leaveEventType)
-                )
-                  toNode++;
-                for (; 0 < eventTypePrefix - toNode; )
-                  (tag = getParent(tag)), eventTypePrefix--;
-                for (; 0 < toNode - eventTypePrefix; )
-                  (enterEventType = getParent(enterEventType)), toNode--;
-                for (; eventTypePrefix--; ) {
-                  if (
-                    tag === enterEventType ||
-                    (null !== enterEventType &&
-                      tag === enterEventType.alternate)
-                  )
-                    break b;
-                  tag = getParent(tag);
-                  enterEventType = getParent(enterEventType);
-                }
-                tag = null;
-              }
-            else tag = null;
-            null !== SyntheticEventCtor &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                reactName,
-                SyntheticEventCtor,
-                tag,
-                !1
-              );
-            null !== reactEventType &&
-              null !== inCapturePhase &&
-              accumulateEnterLeaveListenersForEvent(
-                dispatchQueue,
-                inCapturePhase,
-                reactEventType,
-                tag,
-                !0
-              );
-          }
-        }
-      }
-      a: {
-        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
-        SyntheticEventCtor =
-          reactName.nodeName && reactName.nodeName.toLowerCase();
-        if (
-          "select" === SyntheticEventCtor ||
-          ("input" === SyntheticEventCtor && "file" === reactName.type)
-        )
-          var getTargetInstFunc = getTargetInstForChangeEvent;
-        else if (isTextInputElement(reactName))
-          if (isInputEventSupported)
-            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
-          else {
-            getTargetInstFunc = getTargetInstForInputEventPolyfill;
-            var handleEventFunc = handleEventsForInputEventPolyfill;
-          }
-        else
-          (SyntheticEventCtor = reactName.nodeName),
-            !SyntheticEventCtor ||
-            "input" !== SyntheticEventCtor.toLowerCase() ||
-            ("checkbox" !== reactName.type && "radio" !== reactName.type)
-              ? enableCustomElementPropertySupport &&
-                targetInst &&
-                isCustomComponent(
-                  targetInst.elementType,
-                  targetInst.memoizedProps
-                ) &&
-                (getTargetInstFunc = getTargetInstForChangeEvent)
-              : (getTargetInstFunc = getTargetInstForClickEvent);
-        if (
-          getTargetInstFunc &&
-          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
-        ) {
-          createAndAccumulateChangeEvent(
-            dispatchQueue,
-            getTargetInstFunc,
-            nativeEvent,
-            nativeEventTarget
+    return null;
+  }
+  function updateFromMap(
+    existingChildren,
+    returnFiber,
+    newIdx,
+    newChild,
+    lanes
+  ) {
+    if (
+      ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+    )
+      return (
+        (existingChildren = existingChildren.get(newIdx) || null),
+        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
+      );
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updateElement(returnFiber, existingChildren, newChild, lanes)
+          );
+        case REACT_PORTAL_TYPE:
+          return (
+            (existingChildren =
+              existingChildren.get(
+                null === newChild.key ? newIdx : newChild.key
+              ) || null),
+            updatePortal(returnFiber, existingChildren, newChild, lanes)
+          );
+        case REACT_LAZY_TYPE:
+          var init = newChild._init;
+          return updateFromMap(
+            existingChildren,
+            returnFiber,
+            newIdx,
+            init(newChild._payload),
+            lanes
           );
-          break a;
-        }
-        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
-        "focusout" === domEventName &&
-          (handleEventFunc = reactName._wrapperState) &&
-          handleEventFunc.controlled &&
-          "number" === reactName.type &&
-          (disableInputAttributeSyncing ||
-            setDefaultValue(reactName, "number", reactName.value));
-      }
-      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
-      switch (domEventName) {
-        case "focusin":
-          if (
-            isTextInputElement(handleEventFunc) ||
-            "true" === handleEventFunc.contentEditable
-          )
-            (activeElement = handleEventFunc),
-              (activeElementInst = targetInst),
-              (lastSelection = null);
-          break;
-        case "focusout":
-          lastSelection = activeElementInst = activeElement = null;
-          break;
-        case "mousedown":
-          mouseDown = !0;
-          break;
-        case "contextmenu":
-        case "mouseup":
-        case "dragend":
-          mouseDown = !1;
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
-          break;
-        case "selectionchange":
-          if (skipSelectionChangeEvent) break;
-        case "keydown":
-        case "keyup":
-          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
       }
-      var fallbackData;
-      if (canUseCompositionEvent)
-        b: {
-          switch (domEventName) {
-            case "compositionstart":
-              var eventType = "onCompositionStart";
-              break b;
-            case "compositionend":
-              eventType = "onCompositionEnd";
-              break b;
-            case "compositionupdate":
-              eventType = "onCompositionUpdate";
-              break b;
-          }
-          eventType = void 0;
-        }
-      else
-        isComposing
-          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
-            (eventType = "onCompositionEnd")
-          : "keydown" === domEventName &&
-            229 === nativeEvent.keyCode &&
-            (eventType = "onCompositionStart");
-      eventType &&
-        (useFallbackCompositionData &&
-          "ko" !== nativeEvent.locale &&
-          (isComposing || "onCompositionStart" !== eventType
-            ? "onCompositionEnd" === eventType &&
-              isComposing &&
-              (fallbackData = getData())
-            : ((root = nativeEventTarget),
-              (startText = "value" in root ? root.value : root.textContent),
-              (isComposing = !0))),
-        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
-        0 < handleEventFunc.length &&
-          ((eventType = new SyntheticCompositionEvent(
-            eventType,
-            domEventName,
-            null,
-            nativeEvent,
-            nativeEventTarget
-          )),
-          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
-          fallbackData
-            ? (eventType.data = fallbackData)
-            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
-              null !== fallbackData && (eventType.data = fallbackData))));
+      if (isArrayImpl(newChild) || getIteratorFn(newChild))
+        return (
+          (existingChildren = existingChildren.get(newIdx) || null),
+          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
+        );
+      if ("function" === typeof newChild.then)
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          unwrapThenable(newChild),
+          lanes
+        );
       if (
-        (fallbackData = canUseTextInputEvent
-          ? getNativeBeforeInputChars(domEventName, nativeEvent)
-          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
       )
-        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
-          0 < targetInst.length &&
-            ((nativeEventTarget = new SyntheticCompositionEvent(
-              "onBeforeInput",
-              "beforeinput",
-              null,
-              nativeEvent,
-              nativeEventTarget
-            )),
-            dispatchQueue.push({
-              event: nativeEventTarget,
-              listeners: targetInst
-            }),
-            (nativeEventTarget.data = fallbackData));
+        return updateFromMap(
+          existingChildren,
+          returnFiber,
+          newIdx,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
     }
-    processDispatchQueue(dispatchQueue, eventSystemFlags);
-  });
-}
-function createDispatchListener(instance, listener, currentTarget) {
-  return {
-    instance: instance,
-    listener: listener,
-    currentTarget: currentTarget
-  };
-}
-function accumulateSinglePhaseListeners(
-  targetFiber,
-  reactName,
-  nativeEventType,
-  inCapturePhase,
-  accumulateTargetOnly,
-  nativeEvent
-) {
-  reactName = inCapturePhase
-    ? null !== reactName
-      ? reactName + "Capture"
-      : null
-    : reactName;
-  for (
-    var listeners = [], instance = targetFiber, lastHostComponent = null;
-    null !== instance;
-
+    return null;
+  }
+  function reconcileChildrenArray(
+    returnFiber,
+    currentFirstChild,
+    newChildren,
+    lanes
   ) {
-    var _instance = instance;
-    targetFiber = _instance.stateNode;
-    _instance = _instance.tag;
-    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
-    null === targetFiber
-      ? 21 === _instance &&
-        null !== lastHostComponent &&
-        null !== targetFiber &&
-        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }))
-      : ((lastHostComponent = targetFiber),
-        (targetFiber =
-          lastHostComponent[internalEventHandlerListenersKey] || null),
-        null !== targetFiber &&
-          targetFiber.forEach(function (entry) {
-            entry.type === nativeEventType &&
-              entry.capture === inCapturePhase &&
-              listeners.push(
-                createDispatchListener(
-                  instance,
-                  entry.callback,
-                  lastHostComponent
-                )
-              );
-          }),
-        null !== reactName &&
-          ((targetFiber = getListener(instance, reactName)),
-          null != targetFiber &&
-            listeners.push(
-              createDispatchListener(instance, targetFiber, lastHostComponent)
-            )));
-    if (accumulateTargetOnly) break;
-    "beforeblur" === nativeEvent.type &&
-      ((targetFiber = nativeEvent._detachedInterceptFiber),
-      null === targetFiber ||
-        (targetFiber !== instance && targetFiber !== instance.alternate) ||
-        (listeners = []));
-    instance = instance.return;
+    for (
+      var resultingFirstChild = null,
+        previousNewFiber = null,
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null;
+      null !== oldFiber && newIdx < newChildren.length;
+      newIdx++
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(
+        returnFiber,
+        oldFiber,
+        newChildren[newIdx],
+        lanes
+      );
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
+        break;
+      }
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (resultingFirstChild = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+    if (newIdx === newChildren.length)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        resultingFirstChild
+      );
+    if (null === oldFiber) {
+      for (; newIdx < newChildren.length; newIdx++)
+        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
+          null !== oldFiber &&
+            ((currentFirstChild = placeChild(
+              oldFiber,
+              currentFirstChild,
+              newIdx
+            )),
+            null === previousNewFiber
+              ? (resultingFirstChild = oldFiber)
+              : (previousNewFiber.sibling = oldFiber),
+            (previousNewFiber = oldFiber));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return resultingFirstChild;
+    }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      newIdx < newChildren.length;
+      newIdx++
+    )
+      (nextOldFiber = updateFromMap(
+        oldFiber,
+        returnFiber,
+        newIdx,
+        newChildren[newIdx],
+        lanes
+      )),
+        null !== nextOldFiber &&
+          (shouldTrackSideEffects &&
+            null !== nextOldFiber.alternate &&
+            oldFiber.delete(
+              null === nextOldFiber.key ? newIdx : nextOldFiber.key
+            ),
+          (currentFirstChild = placeChild(
+            nextOldFiber,
+            currentFirstChild,
+            newIdx
+          )),
+          null === previousNewFiber
+            ? (resultingFirstChild = nextOldFiber)
+            : (previousNewFiber.sibling = nextOldFiber),
+          (previousNewFiber = nextOldFiber));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return resultingFirstChild;
   }
-  return listeners;
-}
-function accumulateTwoPhaseListeners(targetFiber, reactName) {
-  for (
-    var captureName = reactName + "Capture", listeners = [];
-    null !== targetFiber;
-
+  function reconcileChildrenIterator(
+    returnFiber,
+    currentFirstChild,
+    newChildrenIterable,
+    lanes
   ) {
-    var _instance2 = targetFiber,
-      stateNode = _instance2.stateNode;
-    _instance2 = _instance2.tag;
-    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
-      null === stateNode ||
-      ((_instance2 = getListener(targetFiber, captureName)),
-      null != _instance2 &&
-        listeners.unshift(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ),
-      (_instance2 = getListener(targetFiber, reactName)),
-      null != _instance2 &&
-        listeners.push(
-          createDispatchListener(targetFiber, _instance2, stateNode)
-        ));
-    targetFiber = targetFiber.return;
+    var iteratorFn = getIteratorFn(newChildrenIterable);
+    if ("function" !== typeof iteratorFn)
+      throw Error(formatProdErrorMessage(150));
+    newChildrenIterable = iteratorFn.call(newChildrenIterable);
+    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
+    for (
+      var previousNewFiber = (iteratorFn = null),
+        oldFiber = currentFirstChild,
+        newIdx = (currentFirstChild = 0),
+        nextOldFiber = null,
+        step = newChildrenIterable.next();
+      null !== oldFiber && !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    ) {
+      oldFiber.index > newIdx
+        ? ((nextOldFiber = oldFiber), (oldFiber = null))
+        : (nextOldFiber = oldFiber.sibling);
+      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+      if (null === newFiber) {
+        null === oldFiber && (oldFiber = nextOldFiber);
+        break;
+      }
+      shouldTrackSideEffects &&
+        oldFiber &&
+        null === newFiber.alternate &&
+        deleteChild(returnFiber, oldFiber);
+      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+      null === previousNewFiber
+        ? (iteratorFn = newFiber)
+        : (previousNewFiber.sibling = newFiber);
+      previousNewFiber = newFiber;
+      oldFiber = nextOldFiber;
+    }
+    if (step.done)
+      return (
+        deleteRemainingChildren(returnFiber, oldFiber),
+        isHydrating && pushTreeFork(returnFiber, newIdx),
+        iteratorFn
+      );
+    if (null === oldFiber) {
+      for (; !step.done; newIdx++, step = newChildrenIterable.next())
+        (step = createChild(returnFiber, step.value, lanes)),
+          null !== step &&
+            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+            null === previousNewFiber
+              ? (iteratorFn = step)
+              : (previousNewFiber.sibling = step),
+            (previousNewFiber = step));
+      isHydrating && pushTreeFork(returnFiber, newIdx);
+      return iteratorFn;
+    }
+    for (
+      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
+      !step.done;
+      newIdx++, step = newChildrenIterable.next()
+    )
+      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
+        null !== step &&
+          (shouldTrackSideEffects &&
+            null !== step.alternate &&
+            oldFiber.delete(null === step.key ? newIdx : step.key),
+          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
+          null === previousNewFiber
+            ? (iteratorFn = step)
+            : (previousNewFiber.sibling = step),
+          (previousNewFiber = step));
+    shouldTrackSideEffects &&
+      oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+    isHydrating && pushTreeFork(returnFiber, newIdx);
+    return iteratorFn;
   }
-  return listeners;
-}
-function getParent(inst) {
-  if (null === inst) return null;
-  do inst = inst.return;
-  while (inst && 5 !== inst.tag && 27 !== inst.tag);
-  return inst ? inst : null;
-}
-function accumulateEnterLeaveListenersForEvent(
-  dispatchQueue,
-  event,
-  target,
-  common,
-  inCapturePhase
-) {
-  for (
-    var registrationName = event._reactName, listeners = [];
-    null !== target && target !== common;
-
-  ) {
-    var _instance3 = target,
-      alternate = _instance3.alternate,
-      stateNode = _instance3.stateNode;
-    _instance3 = _instance3.tag;
-    if (null !== alternate && alternate === common) break;
-    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
-      null === stateNode ||
-      ((alternate = stateNode),
-      inCapturePhase
-        ? ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.unshift(
-              createDispatchListener(target, stateNode, alternate)
-            ))
-        : inCapturePhase ||
-          ((stateNode = getListener(target, registrationName)),
-          null != stateNode &&
-            listeners.push(
-              createDispatchListener(target, stateNode, alternate)
-            )));
-    target = target.return;
+  function reconcileChildFibersImpl(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    "object" === typeof newChild &&
+      null !== newChild &&
+      newChild.type === REACT_FRAGMENT_TYPE &&
+      null === newChild.key &&
+      (newChild = newChild.props.children);
+    if ("object" === typeof newChild && null !== newChild) {
+      switch (newChild.$$typeof) {
+        case REACT_ELEMENT_TYPE:
+          a: {
+            for (
+              var key = newChild.key, child = currentFirstChild;
+              null !== child;
+
+            ) {
+              if (child.key === key) {
+                key = newChild.type;
+                if (key === REACT_FRAGMENT_TYPE) {
+                  if (7 === child.tag) {
+                    deleteRemainingChildren(returnFiber, child.sibling);
+                    currentFirstChild = useFiber(
+                      child,
+                      newChild.props.children
+                    );
+                    currentFirstChild.return = returnFiber;
+                    returnFiber = currentFirstChild;
+                    break a;
+                  }
+                } else if (
+                  child.elementType === key ||
+                  ("object" === typeof key &&
+                    null !== key &&
+                    key.$$typeof === REACT_LAZY_TYPE &&
+                    resolveLazy(key) === child.type)
+                ) {
+                  deleteRemainingChildren(returnFiber, child.sibling);
+                  currentFirstChild = useFiber(child, newChild.props);
+                  currentFirstChild.ref = coerceRef(
+                    returnFiber,
+                    child,
+                    newChild
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                }
+                deleteRemainingChildren(returnFiber, child);
+                break;
+              } else deleteChild(returnFiber, child);
+              child = child.sibling;
+            }
+            newChild.type === REACT_FRAGMENT_TYPE
+              ? ((currentFirstChild = createFiberFromFragment(
+                  newChild.props.children,
+                  returnFiber.mode,
+                  lanes,
+                  newChild.key
+                )),
+                (currentFirstChild.return = returnFiber),
+                (returnFiber = currentFirstChild))
+              : ((lanes = createFiberFromTypeAndProps(
+                  newChild.type,
+                  newChild.key,
+                  newChild.props,
+                  null,
+                  returnFiber.mode,
+                  lanes
+                )),
+                (lanes.ref = coerceRef(
+                  returnFiber,
+                  currentFirstChild,
+                  newChild
+                )),
+                (lanes.return = returnFiber),
+                (returnFiber = lanes));
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_PORTAL_TYPE:
+          a: {
+            for (child = newChild.key; null !== currentFirstChild; ) {
+              if (currentFirstChild.key === child)
+                if (
+                  4 === currentFirstChild.tag &&
+                  currentFirstChild.stateNode.containerInfo ===
+                    newChild.containerInfo &&
+                  currentFirstChild.stateNode.implementation ===
+                    newChild.implementation
+                ) {
+                  deleteRemainingChildren(
+                    returnFiber,
+                    currentFirstChild.sibling
+                  );
+                  currentFirstChild = useFiber(
+                    currentFirstChild,
+                    newChild.children || []
+                  );
+                  currentFirstChild.return = returnFiber;
+                  returnFiber = currentFirstChild;
+                  break a;
+                } else {
+                  deleteRemainingChildren(returnFiber, currentFirstChild);
+                  break;
+                }
+              else deleteChild(returnFiber, currentFirstChild);
+              currentFirstChild = currentFirstChild.sibling;
+            }
+            currentFirstChild = createFiberFromPortal(
+              newChild,
+              returnFiber.mode,
+              lanes
+            );
+            currentFirstChild.return = returnFiber;
+            returnFiber = currentFirstChild;
+          }
+          return placeSingleChild(returnFiber);
+        case REACT_LAZY_TYPE:
+          return (
+            (child = newChild._init),
+            reconcileChildFibers(
+              returnFiber,
+              currentFirstChild,
+              child(newChild._payload),
+              lanes
+            )
+          );
+      }
+      if (isArrayImpl(newChild))
+        return reconcileChildrenArray(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if (getIteratorFn(newChild))
+        return reconcileChildrenIterator(
+          returnFiber,
+          currentFirstChild,
+          newChild,
+          lanes
+        );
+      if ("function" === typeof newChild.then)
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          unwrapThenable(newChild),
+          lanes
+        );
+      if (
+        newChild.$$typeof === REACT_CONTEXT_TYPE ||
+        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+      )
+        return reconcileChildFibersImpl(
+          returnFiber,
+          currentFirstChild,
+          readContextDuringReconcilation(returnFiber, newChild, lanes),
+          lanes
+        );
+      throwOnInvalidObjectType(returnFiber, newChild);
+    }
+    return ("string" === typeof newChild && "" !== newChild) ||
+      "number" === typeof newChild
+      ? ((newChild = "" + newChild),
+        null !== currentFirstChild && 6 === currentFirstChild.tag
+          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
+            (currentFirstChild = useFiber(currentFirstChild, newChild)),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild))
+          : (deleteRemainingChildren(returnFiber, currentFirstChild),
+            (currentFirstChild = createFiberFromText(
+              newChild,
+              returnFiber.mode,
+              lanes
+            )),
+            (currentFirstChild.return = returnFiber),
+            (returnFiber = currentFirstChild)),
+        placeSingleChild(returnFiber))
+      : deleteRemainingChildren(returnFiber, currentFirstChild);
   }
-  0 !== listeners.length &&
-    dispatchQueue.push({ event: event, listeners: listeners });
+  function reconcileChildFibers(
+    returnFiber,
+    currentFirstChild,
+    newChild,
+    lanes
+  ) {
+    thenableIndexCounter$1 = 0;
+    returnFiber = reconcileChildFibersImpl(
+      returnFiber,
+      currentFirstChild,
+      newChild,
+      lanes
+    );
+    thenableState$1 = null;
+    return returnFiber;
+  }
+  return reconcileChildFibers;
 }
-function accumulateEventHandleNonManagedNodeListeners(
-  reactEventType,
-  currentTarget,
-  inCapturePhase
-) {
-  var listeners = [],
-    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
-  null !== eventListeners &&
-    eventListeners.forEach(function (entry) {
-      entry.type === reactEventType &&
-        entry.capture === inCapturePhase &&
-        listeners.push(
-          createDispatchListener(null, entry.callback, currentTarget)
-        );
-    });
-  return listeners;
+var reconcileChildFibers = createChildReconciler(!0),
+  mountChildFibers = createChildReconciler(!1),
+  currentTreeHiddenStackCursor = createCursor(null),
+  prevRenderLanesStackCursor = createCursor(0);
+function pushHiddenContext(fiber, context) {
+  fiber = renderLanes;
+  push(prevRenderLanesStackCursor, fiber);
+  push(currentTreeHiddenStackCursor, context);
+  renderLanes = fiber | context.baseLanes;
 }
-var NORMALIZE_NEWLINES_REGEX = /\r\n?/g,
-  NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
-function normalizeMarkupForTextOrAttribute(markup) {
-  return ("string" === typeof markup ? markup : "" + markup)
-    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
-    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
+function reuseHiddenContextOnStack() {
+  push(prevRenderLanesStackCursor, renderLanes);
+  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
 }
-function getOwnerDocumentFromRootContainer(rootContainerElement) {
-  return 9 === rootContainerElement.nodeType
-    ? rootContainerElement
-    : rootContainerElement.ownerDocument;
+function popHiddenContext() {
+  renderLanes = prevRenderLanesStackCursor.current;
+  pop(currentTreeHiddenStackCursor);
+  pop(prevRenderLanesStackCursor);
 }
-function noop$1() {}
-function createHTMLElement(type, props, ownerDocument) {
-  return "string" === typeof props.is
-    ? ownerDocument.createElement(type, { is: props.is })
-    : ownerDocument.createElement(type);
+var suspenseHandlerStackCursor = createCursor(null),
+  shellBoundary = null;
+function pushPrimaryTreeSuspenseHandler(handler) {
+  var current = handler.alternate;
+  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
+  (null !== current && null === currentTreeHiddenStackCursor.current)
+    ? (push(suspenseHandlerStackCursor, handler),
+      null === shellBoundary &&
+        (null === current || null !== currentTreeHiddenStackCursor.current
+          ? (shellBoundary = handler)
+          : null !== current.memoizedState && (shellBoundary = handler)))
+    : null === shellBoundary
+    ? push(suspenseHandlerStackCursor, handler)
+    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
 }
-function setInitialProperties(domElement, tag, rawProps) {
-  var isCustomComponentTag = isCustomComponent(tag, rawProps);
-  switch (tag) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", domElement);
-      listenToNonDelegatedEvent("close", domElement);
-      var props = rawProps;
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
-    case "video":
-    case "audio":
-      for (props = 0; props < mediaEventTypes.length; props++)
-        listenToNonDelegatedEvent(mediaEventTypes[props], domElement);
-      props = rawProps;
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", domElement);
-      props = rawProps;
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", domElement);
-      listenToNonDelegatedEvent("load", domElement);
-      props = rawProps;
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", domElement);
-      props = rawProps;
-      break;
-    case "input":
-      initWrapperState$2(domElement, rawProps);
-      props = getHostProps$2(domElement, rawProps);
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    case "option":
-      props = rawProps;
-      break;
-    case "select":
-      domElement._wrapperState = { wasMultiple: !!rawProps.multiple };
-      props = assign({}, rawProps, { value: void 0 });
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    case "textarea":
-      initWrapperState(domElement, rawProps);
-      props = getHostProps(domElement, rawProps);
-      listenToNonDelegatedEvent("invalid", domElement);
-      break;
-    default:
-      props = rawProps;
-  }
-  assertValidProps(tag, props);
-  var nextProps = props,
-    propKey;
-  for (propKey in nextProps)
-    if (nextProps.hasOwnProperty(propKey)) {
-      var nextProp = nextProps[propKey];
-      "style" === propKey
-        ? setValueForStyles(domElement, nextProp)
-        : "dangerouslySetInnerHTML" === propKey
-        ? ((nextProp = nextProp ? nextProp.__html : void 0),
-          null != nextProp && setInnerHTML$1(domElement, nextProp))
-        : "children" === propKey
-        ? "string" === typeof nextProp
-          ? "body" === tag ||
-            ("textarea" === tag && "" === nextProp) ||
-            setTextContent(domElement, nextProp)
-          : "number" === typeof nextProp &&
-            "body" !== tag &&
-            setTextContent(domElement, "" + nextProp)
-        : "suppressContentEditableWarning" !== propKey &&
-          "suppressHydrationWarning" !== propKey &&
-          "autoFocus" !== propKey &&
-          (registrationNameDependencies.hasOwnProperty(propKey)
-            ? null != nextProp &&
-              "onScroll" === propKey &&
-              listenToNonDelegatedEvent("scroll", domElement)
-            : null != nextProp &&
-              setValueForProperty(
-                domElement,
-                propKey,
-                nextProp,
-                isCustomComponentTag
-              ));
+function pushOffscreenSuspenseHandler(fiber) {
+  if (22 === fiber.tag) {
+    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
+      var current = fiber.alternate;
+      null !== current &&
+        null !== current.memoizedState &&
+        (shellBoundary = fiber);
     }
-  switch (tag) {
-    case "input":
-      track(domElement);
-      postMountWrapper$3(domElement, rawProps, !1);
-      break;
-    case "textarea":
-      track(domElement);
-      postMountWrapper(domElement);
-      break;
-    case "option":
-      null != rawProps.value &&
-        domElement.setAttribute("value", "" + getToStringValue(rawProps.value));
-      break;
-    case "select":
-      domElement.multiple = !!rawProps.multiple;
-      tag = rawProps.value;
-      null != tag
-        ? updateOptions(domElement, !!rawProps.multiple, tag, !1)
-        : null != rawProps.defaultValue &&
-          updateOptions(
-            domElement,
-            !!rawProps.multiple,
-            rawProps.defaultValue,
-            !0
-          );
-      break;
-    default:
-      "function" === typeof props.onClick && (domElement.onclick = noop$1);
-  }
+  } else reuseSuspenseHandlerOnStack();
 }
-function updateProperties(
-  domElement,
-  updatePayload,
-  tag,
-  lastRawProps,
-  nextRawProps
-) {
-  "input" === tag &&
-    "radio" === nextRawProps.type &&
-    null != nextRawProps.name &&
-    updateChecked(domElement, nextRawProps);
-  isCustomComponent(tag, lastRawProps);
-  lastRawProps = isCustomComponent(tag, nextRawProps);
-  for (var i = 0; i < updatePayload.length; i += 2) {
-    var propKey = updatePayload[i],
-      propValue = updatePayload[i + 1];
-    "style" === propKey
-      ? setValueForStyles(domElement, propValue)
-      : "dangerouslySetInnerHTML" === propKey
-      ? setInnerHTML$1(domElement, propValue)
-      : "children" === propKey
-      ? setTextContent(domElement, propValue)
-      : setValueForProperty(domElement, propKey, propValue, lastRawProps);
-  }
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, nextRawProps);
-      break;
-    case "textarea":
-      updateWrapper(domElement, nextRawProps);
-      break;
-    case "select":
-      (updatePayload = domElement._wrapperState.wasMultiple),
-        (domElement._wrapperState.wasMultiple = !!nextRawProps.multiple),
-        (tag = nextRawProps.value),
-        null != tag
-          ? updateOptions(domElement, !!nextRawProps.multiple, tag, !1)
-          : updatePayload !== !!nextRawProps.multiple &&
-            (null != nextRawProps.defaultValue
-              ? updateOptions(
-                  domElement,
-                  !!nextRawProps.multiple,
-                  nextRawProps.defaultValue,
-                  !0
-                )
-              : updateOptions(
-                  domElement,
-                  !!nextRawProps.multiple,
-                  nextRawProps.multiple ? [] : "",
-                  !1
-                ));
-  }
+function reuseSuspenseHandlerOnStack() {
+  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
 }
-var valueStack = [],
-  index = -1;
-function createCursor(defaultValue) {
-  return { current: defaultValue };
+function popSuspenseHandler(fiber) {
+  pop(suspenseHandlerStackCursor);
+  shellBoundary === fiber && (shellBoundary = null);
 }
-function pop(cursor) {
-  0 > index ||
-    ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
+var suspenseStackCursor = createCursor(0);
+function findFirstSuspended(row) {
+  for (var node = row; null !== node; ) {
+    if (13 === node.tag) {
+      var state = node.memoizedState;
+      if (
+        null !== state &&
+        ((state = state.dehydrated),
+        null === state || "$?" === state.data || "$!" === state.data)
+      )
+        return node;
+    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+      if (0 !== (node.flags & 128)) return node;
+    } else if (null !== node.child) {
+      node.child.return = node;
+      node = node.child;
+      continue;
+    }
+    if (node === row) break;
+    for (; null === node.sibling; ) {
+      if (null === node.return || node.return === row) return null;
+      node = node.return;
+    }
+    node.sibling.return = node.return;
+    node = node.sibling;
+  }
+  return null;
 }
-function push(cursor, value) {
-  index++;
-  valueStack[index] = cursor.current;
-  cursor.current = value;
+var workInProgressSources = [];
+function resetWorkInProgressVersions() {
+  for (var i = 0; i < workInProgressSources.length; i++)
+    workInProgressSources[i]._workInProgressVersionPrimary = null;
+  workInProgressSources.length = 0;
 }
-var contextStackCursor = createCursor(null),
-  contextFiberStackCursor = createCursor(null),
-  rootInstanceStackCursor = createCursor(null);
-function pushHostContainer(fiber, nextRootInstance) {
-  push(rootInstanceStackCursor, nextRootInstance);
-  push(contextFiberStackCursor, fiber);
-  push(contextStackCursor, null);
-  fiber = nextRootInstance.nodeType;
-  switch (fiber) {
-    case 9:
-    case 11:
-      nextRootInstance = (nextRootInstance = nextRootInstance.documentElement)
-        ? nextRootInstance.namespaceURI
-        : getChildNamespace(null, "");
-      break;
-    default:
-      (fiber = 8 === fiber ? nextRootInstance.parentNode : nextRootInstance),
-        (nextRootInstance = fiber.namespaceURI || null),
-        (fiber = fiber.tagName),
-        (nextRootInstance = getChildNamespace(nextRootInstance, fiber));
-  }
-  pop(contextStackCursor);
-  push(contextStackCursor, nextRootInstance);
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
+  renderLanes$1 = 0,
+  currentlyRenderingFiber$1 = null,
+  currentHook = null,
+  workInProgressHook = null,
+  didScheduleRenderPhaseUpdate = !1,
+  didScheduleRenderPhaseUpdateDuringThisPass = !1,
+  shouldDoubleInvokeUserFnsInHooksDEV = !1,
+  localIdCounter = 0,
+  thenableIndexCounter = 0,
+  thenableState = null,
+  globalClientIdCounter = 0;
+function throwInvalidHookError() {
+  throw Error(formatProdErrorMessage(321));
 }
-function popHostContainer() {
-  pop(contextStackCursor);
-  pop(contextFiberStackCursor);
-  pop(rootInstanceStackCursor);
+function areHookInputsEqual(nextDeps, prevDeps) {
+  if (null === prevDeps) return !1;
+  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
+    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+  return !0;
 }
-function pushHostContext(fiber) {
-  var context = contextStackCursor.current;
-  var JSCompiler_inline_result = getChildNamespace(context, fiber.type);
-  context !== JSCompiler_inline_result &&
-    (push(contextFiberStackCursor, fiber),
-    push(contextStackCursor, JSCompiler_inline_result));
+function renderWithHooks(
+  current,
+  workInProgress,
+  Component,
+  props,
+  secondArg,
+  nextRenderLanes
+) {
+  renderLanes$1 = nextRenderLanes;
+  currentlyRenderingFiber$1 = workInProgress;
+  workInProgress.memoizedState = null;
+  workInProgress.updateQueue = null;
+  workInProgress.lanes = 0;
+  ReactCurrentDispatcher$1.current =
+    null === current || null === current.memoizedState
+      ? HooksDispatcherOnMount
+      : HooksDispatcherOnUpdate;
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  nextRenderLanes = Component(props, secondArg);
+  shouldDoubleInvokeUserFnsInHooksDEV = !1;
+  didScheduleRenderPhaseUpdateDuringThisPass &&
+    (nextRenderLanes = renderWithHooksAgain(
+      workInProgress,
+      Component,
+      props,
+      secondArg
+    ));
+  finishRenderingHooks(current);
+  return nextRenderLanes;
 }
-function popHostContext(fiber) {
-  contextFiberStackCursor.current === fiber &&
-    (pop(contextStackCursor), pop(contextFiberStackCursor));
+function finishRenderingHooks(current) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdate = !1;
+  thenableIndexCounter = 0;
+  thenableState = null;
+  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
+  enableLazyContextPropagation &&
+    null !== current &&
+    !didReceiveUpdate &&
+    ((current = current.dependencies),
+    null !== current &&
+      checkIfContextChanged(current) &&
+      (didReceiveUpdate = !0));
 }
-var Dispatcher$1 = Internals.Dispatcher,
-  lastCurrentDocument = null,
-  previousDispatcher = null,
-  ReactDOMClientDispatcher = {
-    prefetchDNS: prefetchDNS$1,
-    preconnect: preconnect$1,
-    preload: preload$1,
-    preinit: preinit$1
-  },
-  preloadPropsMap = new Map(),
-  preconnectsSet = new Set();
-function getHoistableRoot(container) {
-  return "function" === typeof container.getRootNode
-    ? container.getRootNode()
-    : container.ownerDocument;
+function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+  var numberOfReRenders = 0;
+  do {
+    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
+    thenableIndexCounter = 0;
+    didScheduleRenderPhaseUpdateDuringThisPass = !1;
+    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
+    numberOfReRenders += 1;
+    workInProgressHook = currentHook = null;
+    workInProgress.updateQueue = null;
+    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
+    var children = Component(props, secondArg);
+  } while (didScheduleRenderPhaseUpdateDuringThisPass);
+  return children;
 }
-function getCurrentResourceRoot() {
-  var currentContainer = rootInstanceStackCursor.current;
-  return currentContainer ? getHoistableRoot(currentContainer) : null;
+function checkDidRenderIdHook() {
+  var didRenderIdHook = 0 !== localIdCounter;
+  localIdCounter = 0;
+  return didRenderIdHook;
 }
-function getDocumentForPreloads() {
-  var root = getCurrentResourceRoot();
-  if (root) return root.ownerDocument || root;
-  try {
-    return lastCurrentDocument || window.document;
-  } catch (error) {
-    return null;
-  }
+function bailoutHooks(current, workInProgress, lanes) {
+  workInProgress.updateQueue = current.updateQueue;
+  workInProgress.flags &= -2053;
+  current.lanes &= ~lanes;
 }
-function preconnectAs(rel, crossOrigin, href) {
-  var ownerDocument = getDocumentForPreloads();
-  if ("string" === typeof href && href && ownerDocument) {
-    var limitedEscapedHref =
-      escapeSelectorAttributeValueInsideDoubleQuotes(href);
-    limitedEscapedHref =
-      'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
-    "string" === typeof crossOrigin &&
-      (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
-    preconnectsSet.has(limitedEscapedHref) ||
-      (preconnectsSet.add(limitedEscapedHref),
-      (rel = { rel: rel, crossOrigin: crossOrigin, href: href }),
-      null === ownerDocument.querySelector(limitedEscapedHref) &&
-        ((crossOrigin = ownerDocument.createElement("link")),
-        setInitialProperties(crossOrigin, "link", rel),
-        markNodeAsHoistable(crossOrigin),
-        ownerDocument.head.appendChild(crossOrigin)));
+function resetHooksOnUnwind() {
+  if (didScheduleRenderPhaseUpdate) {
+    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
+      var queue = hook.queue;
+      null !== queue && (queue.pending = null);
+      hook = hook.next;
+    }
+    didScheduleRenderPhaseUpdate = !1;
   }
+  renderLanes$1 = 0;
+  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
+  didScheduleRenderPhaseUpdateDuringThisPass = !1;
+  thenableIndexCounter = localIdCounter = 0;
+  thenableState = null;
 }
-function prefetchDNS$1(href) {
-  preconnectAs("dns-prefetch", null, href);
-}
-function preconnect$1(href, options) {
-  preconnectAs(
-    "preconnect",
-    null == options || "string" !== typeof options.crossOrigin
-      ? null
-      : "use-credentials" === options.crossOrigin
-      ? "use-credentials"
-      : "",
-    href
-  );
+function mountWorkInProgressHook() {
+  var hook = {
+    memoizedState: null,
+    baseState: null,
+    baseQueue: null,
+    queue: null,
+    next: null
+  };
+  null === workInProgressHook
+    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
+    : (workInProgressHook = workInProgressHook.next = hook);
+  return workInProgressHook;
 }
-function preload$1(href, options) {
-  var ownerDocument = getDocumentForPreloads();
-  if (
-    "string" === typeof href &&
-    href &&
-    "object" === typeof options &&
-    null !== options &&
-    ownerDocument
-  ) {
-    var as = options.as,
-      limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href),
-      key = (limitedEscapedHref =
-        'link[rel="preload"][as="' +
-        as +
-        '"][href="' +
-        limitedEscapedHref +
-        '"]');
-    switch (as) {
-      case "style":
-        key = getStyleKey(href);
-        break;
-      case "script":
-        key = getScriptKey(href);
+function updateWorkInProgressHook() {
+  if (null === currentHook) {
+    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
+    nextCurrentHook =
+      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+  } else nextCurrentHook = currentHook.next;
+  var nextWorkInProgressHook =
+    null === workInProgressHook
+      ? currentlyRenderingFiber$1.memoizedState
+      : workInProgressHook.next;
+  if (null !== nextWorkInProgressHook)
+    (workInProgressHook = nextWorkInProgressHook),
+      (currentHook = nextCurrentHook);
+  else {
+    if (null === nextCurrentHook) {
+      if (null === currentlyRenderingFiber$1.alternate)
+        throw Error(formatProdErrorMessage(467));
+      throw Error(formatProdErrorMessage(310));
     }
-    preloadPropsMap.has(key) ||
-      ((href = {
-        href: href,
-        rel: "preload",
-        as: as,
-        crossOrigin: "font" === as ? "" : options.crossOrigin,
-        integrity: options.integrity,
-        type: options.type
-      }),
-      preloadPropsMap.set(key, href),
-      null === ownerDocument.querySelector(limitedEscapedHref) &&
-        ((options = ownerDocument.createElement("link")),
-        setInitialProperties(options, "link", href),
-        markNodeAsHoistable(options),
-        ownerDocument.head.appendChild(options)));
-  }
-}
-function preinit$1(href, options) {
-  if (
-    "string" === typeof href &&
-    href &&
-    "object" === typeof options &&
-    null !== options
-  ) {
-    var resourceRoot = getCurrentResourceRoot(),
-      as = options.as;
-    if (resourceRoot)
-      switch (as) {
-        case "style":
-          as = getResourcesFromRoot(resourceRoot).hoistableStyles;
-          var key$34 = getStyleKey(href),
-            precedence = options.precedence || "default",
-            resource = as.get(key$34);
-          if (resource) break;
-          resource = resourceRoot.querySelector(
-            getStylesheetSelectorFromKey(key$34)
-          );
-          resource ||
-            ((href = {
-              rel: "stylesheet",
-              href: href,
-              "data-precedence": precedence,
-              crossOrigin: options.crossOrigin
-            }),
-            (options = preloadPropsMap.get(key$34)) &&
-              adoptPreloadPropsForStylesheet(href, options),
-            (resource = (
-              resourceRoot.ownerDocument || resourceRoot
-            ).createElement("link")),
-            markNodeAsHoistable(resource),
-            setInitialProperties(resource, "link", href),
-            insertStylesheet(resource, precedence, resourceRoot));
-          resource = { type: "stylesheet", instance: resource, count: 1 };
-          as.set(key$34, resource);
-          break;
-        case "script":
-          (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
-            (key$34 = getScriptKey(href)),
-            (precedence = as.get(key$34)),
-            precedence ||
-              ((precedence = resourceRoot.querySelector(
-                "script[async]" + key$34
-              )),
-              precedence ||
-                ((href = {
-                  src: href,
-                  async: !0,
-                  crossOrigin: options.crossOrigin,
-                  integrity: options.integrity
-                }),
-                (options = preloadPropsMap.get(key$34)) &&
-                  adoptPreloadPropsForScript(href, options),
-                (options = resourceRoot.ownerDocument || resourceRoot),
-                (precedence = options.createElement("script")),
-                markNodeAsHoistable(precedence),
-                setInitialProperties(precedence, "link", href),
-                options.head.appendChild(precedence)),
-              (precedence = { type: "script", instance: precedence, count: 1 }),
-              as.set(key$34, precedence));
-      }
-    else if ("style" === as || "script" === as)
-      if ((resourceRoot = getDocumentForPreloads())) {
-        key$34 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
-        precedence = key$34 =
-          'link[rel="preload"][as="' + as + '"][href="' + key$34 + '"]';
-        switch (as) {
-          case "style":
-            precedence = getStyleKey(href);
-            break;
-          case "script":
-            precedence = getScriptKey(href);
-        }
-        preloadPropsMap.has(precedence) ||
-          ((href = {
-            href: href,
-            rel: "preload",
-            as: as,
-            crossOrigin: "font" === as ? "" : options.crossOrigin,
-            integrity: options.integrity
-          }),
-          preloadPropsMap.set(precedence, href),
-          null === resourceRoot.querySelector(key$34) &&
-            ((options = resourceRoot.createElement("link")),
-            setInitialProperties(options, "link", href),
-            markNodeAsHoistable(options),
-            resourceRoot.head.appendChild(options)));
-      }
+    currentHook = nextCurrentHook;
+    nextCurrentHook = {
+      memoizedState: currentHook.memoizedState,
+      baseState: currentHook.baseState,
+      baseQueue: currentHook.baseQueue,
+      queue: currentHook.queue,
+      next: null
+    };
+    null === workInProgressHook
+      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
+          nextCurrentHook)
+      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
   }
+  return workInProgressHook;
 }
-function getResource(type, currentProps, pendingProps) {
-  currentProps = getCurrentResourceRoot();
-  if (!currentProps) throw Error(formatProdErrorMessage(446));
-  switch (type) {
-    case "meta":
-    case "title":
-      return null;
-    case "style":
-      return "string" === typeof pendingProps.precedence &&
-        "string" === typeof pendingProps.href
-        ? ((pendingProps = getStyleKey(pendingProps.href)),
-          (currentProps = getResourcesFromRoot(currentProps).hoistableStyles),
-          (type = currentProps.get(pendingProps)),
-          type ||
-            ((type = { type: "style", instance: null, count: 0 }),
-            currentProps.set(pendingProps, type)),
-          type)
-        : { type: "void", instance: null, count: 0 };
-    case "link":
-      if (
-        "stylesheet" === pendingProps.rel &&
-        "string" === typeof pendingProps.href &&
-        "string" === typeof pendingProps.precedence
-      ) {
-        var key$41 = getStyleKey(pendingProps.href),
-          styles$42 = getResourcesFromRoot(currentProps).hoistableStyles;
-        type = styles$42.get(key$41);
-        type ||
-          ((currentProps = currentProps.ownerDocument || currentProps),
-          (type = { type: "stylesheet", instance: null, count: 0 }),
-          styles$42.set(key$41, type),
-          preloadPropsMap.has(key$41) ||
-            ((pendingProps = {
-              rel: "preload",
-              as: "style",
-              href: pendingProps.href,
-              crossOrigin: pendingProps.crossOrigin,
-              integrity: pendingProps.integrity,
-              media: pendingProps.media,
-              hrefLang: pendingProps.hrefLang,
-              referrerPolicy: pendingProps.referrerPolicy
-            }),
-            preloadPropsMap.set(key$41, pendingProps),
-            currentProps.querySelector(getStylesheetSelectorFromKey(key$41)) ||
-              null !==
-                currentProps.querySelector(
-                  'link[rel="preload"][as="style"][' + key$41 + "]"
-                ) ||
-              ((key$41 = currentProps.createElement("link")),
-              setInitialProperties(key$41, "link", pendingProps),
-              markNodeAsHoistable(key$41),
-              currentProps.head.appendChild(key$41))));
-        return type;
-      }
-      return null;
-    case "script":
-      return "string" === typeof pendingProps.src && !0 === pendingProps.async
-        ? ((pendingProps = getScriptKey(pendingProps.src)),
-          (currentProps = getResourcesFromRoot(currentProps).hoistableScripts),
-          (type = currentProps.get(pendingProps)),
-          type ||
-            ((type = { type: "script", instance: null, count: 0 }),
-            currentProps.set(pendingProps, type)),
-          type)
-        : { type: "void", instance: null, count: 0 };
-    default:
-      throw Error(formatProdErrorMessage(444, type));
+var createFunctionComponentUpdateQueue;
+createFunctionComponentUpdateQueue = function () {
+  return { lastEffect: null, events: null, stores: null, memoCache: null };
+};
+function use(usable) {
+  if (null !== usable && "object" === typeof usable) {
+    if ("function" === typeof usable.then) {
+      var index$45 = thenableIndexCounter;
+      thenableIndexCounter += 1;
+      null === thenableState && (thenableState = []);
+      usable = trackUsedThenable(thenableState, usable, index$45);
+      null === currentlyRenderingFiber$1.alternate &&
+        (null === workInProgressHook
+          ? null === currentlyRenderingFiber$1.memoizedState
+          : null === workInProgressHook.next) &&
+        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
+      return usable;
+    }
+    if (
+      usable.$$typeof === REACT_CONTEXT_TYPE ||
+      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
+    )
+      return readContext(usable);
   }
+  throw Error(formatProdErrorMessage(438, String(usable)));
 }
-function getStyleKey(href) {
-  return 'href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
-}
-function getStylesheetSelectorFromKey(key) {
-  return 'link[rel="stylesheet"][' + key + "]";
+function useMemoCache(size) {
+  var memoCache = null,
+    updateQueue = currentlyRenderingFiber$1.updateQueue;
+  null !== updateQueue && (memoCache = updateQueue.memoCache);
+  if (null == memoCache) {
+    var current = currentlyRenderingFiber$1.alternate;
+    null !== current &&
+      ((current = current.updateQueue),
+      null !== current &&
+        ((current = current.memoCache),
+        null != current &&
+          (memoCache = {
+            data: current.data.map(function (array) {
+              return array.slice();
+            }),
+            index: 0
+          })));
+  }
+  null == memoCache && (memoCache = { data: [], index: 0 });
+  null === updateQueue &&
+    ((updateQueue = createFunctionComponentUpdateQueue()),
+    (currentlyRenderingFiber$1.updateQueue = updateQueue));
+  updateQueue.memoCache = memoCache;
+  updateQueue = memoCache.data[memoCache.index];
+  if (void 0 === updateQueue)
+    for (
+      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
+      current < size;
+      current++
+    )
+      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
+  memoCache.index++;
+  return updateQueue;
 }
-function getScriptKey(src) {
-  return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
+function basicStateReducer(state, action) {
+  return "function" === typeof action ? action(state) : action;
 }
-function acquireResource(hoistableRoot, resource, props) {
-  resource.count++;
-  if (null === resource.instance)
-    switch (resource.type) {
-      case "style":
-        var key = getStyleKey(props.href);
-        if ((key = hoistableRoot.querySelector("style[data-" + key + "]")))
-          return (resource.instance = key), markNodeAsHoistable(key), key;
-        var styleProps = assign({}, props, {
-          "data-href": props.href,
-          "data-precedence": props.precedence,
-          href: null,
-          precedence: null
-        });
-        key = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
-          "style"
-        );
-        markNodeAsHoistable(key);
-        setInitialProperties(key, "style", styleProps);
-        insertStylesheet(key, props.precedence, hoistableRoot);
-        return (resource.instance = key);
-      case "stylesheet":
-        styleProps = getStyleKey(props.href);
-        var instance$48 = hoistableRoot.querySelector(
-          getStylesheetSelectorFromKey(styleProps)
-        );
-        if (instance$48)
-          return (
-            (resource.instance = instance$48),
-            markNodeAsHoistable(instance$48),
-            instance$48
-          );
-        key = assign({}, props, {
-          "data-precedence": props.precedence,
-          precedence: null
-        });
-        (styleProps = preloadPropsMap.get(styleProps)) &&
-          adoptPreloadPropsForStylesheet(key, styleProps);
-        instance$48 = (
-          hoistableRoot.ownerDocument || hoistableRoot
-        ).createElement("link");
-        markNodeAsHoistable(instance$48);
-        var linkInstance = instance$48;
-        linkInstance._p = new Promise(function (resolve, reject) {
-          linkInstance.onload = resolve;
-          linkInstance.onerror = reject;
-        }).then(
-          function () {
-            return (linkInstance._p.s = "l");
-          },
-          function () {
-            return (linkInstance._p.s = "e");
-          }
-        );
-        setInitialProperties(instance$48, "link", key);
-        insertStylesheet(instance$48, props.precedence, hoistableRoot);
-        return (resource.instance = instance$48);
-      case "script":
-        instance$48 = getScriptKey(props.src);
-        if (
-          (styleProps = hoistableRoot.querySelector(
-            "script[async]" + instance$48
-          ))
-        )
-          return (
-            (resource.instance = styleProps),
-            markNodeAsHoistable(styleProps),
-            styleProps
-          );
-        key = props;
-        if ((styleProps = preloadPropsMap.get(instance$48)))
-          (key = assign({}, props)),
-            adoptPreloadPropsForScript(key, styleProps);
-        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
-        styleProps = hoistableRoot.createElement("script");
-        markNodeAsHoistable(styleProps);
-        setInitialProperties(styleProps, "link", key);
-        hoistableRoot.head.appendChild(styleProps);
-        return (resource.instance = styleProps);
-      case "void":
-        return null;
-      default:
-        throw Error(formatProdErrorMessage(443, resource.type));
+function updateReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var current = currentHook,
+    baseQueue = current.baseQueue,
+    pendingQueue = queue.pending;
+  if (null !== pendingQueue) {
+    if (null !== baseQueue) {
+      var baseFirst = baseQueue.next;
+      baseQueue.next = pendingQueue.next;
+      pendingQueue.next = baseFirst;
     }
-  return resource.instance;
-}
-function insertStylesheet(instance, precedence, root) {
-  for (
-    var nodes = root.querySelectorAll(
-        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
-      ),
-      last = nodes.length ? nodes[nodes.length - 1] : null,
-      prior = last,
-      i = 0;
-    i < nodes.length;
-    i++
-  ) {
-    var node = nodes[i];
-    if (node.dataset.precedence === precedence) prior = node;
-    else if (prior !== last) break;
+    current.baseQueue = baseQueue = pendingQueue;
+    queue.pending = null;
   }
-  prior
-    ? prior.parentNode.insertBefore(instance, prior.nextSibling)
-    : ((precedence = 9 === root.nodeType ? root.head : root),
-      precedence.insertBefore(instance, precedence.firstChild));
-}
-function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
-  null == stylesheetProps.crossOrigin &&
-    (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
-  null == stylesheetProps.referrerPolicy &&
-    (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
-  null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
-}
-function adoptPreloadPropsForScript(scriptProps, preloadProps) {
-  null == scriptProps.crossOrigin &&
-    (scriptProps.crossOrigin = preloadProps.crossOrigin);
-  null == scriptProps.referrerPolicy &&
-    (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
-  null == scriptProps.integrity &&
-    (scriptProps.referrerPolicy = preloadProps.integrity);
-}
-var tagCaches = null;
-function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
-  if (null === tagCaches) {
-    var cache = new Map();
-    var caches = (tagCaches = new Map());
-    caches.set(ownerDocument, cache);
-  } else
-    (caches = tagCaches),
-      (cache = caches.get(ownerDocument)),
-      cache || ((cache = new Map()), caches.set(ownerDocument, cache));
-  if (cache.has(type)) return cache;
-  cache.set(type, null);
-  ownerDocument = ownerDocument.getElementsByTagName(type);
-  for (caches = 0; caches < ownerDocument.length; caches++) {
-    var node = ownerDocument[caches];
-    if (
-      !(
-        node[internalHoistableMarker] ||
-        node[internalInstanceKey] ||
-        ("link" === type && "stylesheet" === node.getAttribute("rel"))
-      ) &&
-      "http://www.w3.org/2000/svg" !== node.namespaceURI
-    ) {
-      var nodeKey = node.getAttribute(keyAttribute) || "";
-      nodeKey = type + nodeKey;
-      var existing = cache.get(nodeKey);
-      existing ? existing.push(node) : cache.set(nodeKey, [node]);
-    }
+  if (null !== baseQueue) {
+    pendingQueue = baseQueue.next;
+    current = current.baseState;
+    var newBaseQueueFirst = (baseFirst = null),
+      newBaseQueueLast = null,
+      update = pendingQueue;
+    do {
+      var updateLane = update.lane & -1073741825;
+      if (
+        updateLane !== update.lane
+          ? (workInProgressRootRenderLanes & updateLane) === updateLane
+          : (renderLanes$1 & updateLane) === updateLane
+      )
+        null !== newBaseQueueLast &&
+          (newBaseQueueLast = newBaseQueueLast.next =
+            {
+              lane: 0,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            }),
+          (updateLane = update.action),
+          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
+          (current = update.hasEagerState
+            ? update.eagerState
+            : reducer(current, updateLane));
+      else {
+        var clone = {
+          lane: updateLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        };
+        null === newBaseQueueLast
+          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
+            (baseFirst = current))
+          : (newBaseQueueLast = newBaseQueueLast.next = clone);
+        currentlyRenderingFiber$1.lanes |= updateLane;
+        workInProgressRootSkippedLanes |= updateLane;
+      }
+      update = update.next;
+    } while (null !== update && update !== pendingQueue);
+    null === newBaseQueueLast
+      ? (baseFirst = current)
+      : (newBaseQueueLast.next = newBaseQueueFirst);
+    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = current;
+    hook.baseState = baseFirst;
+    hook.baseQueue = newBaseQueueLast;
+    queue.lastRenderedState = current;
   }
-  return cache;
+  null === baseQueue && (queue.lanes = 0);
+  return [hook.memoizedState, queue.dispatch];
 }
-function mountHoistable(hoistableRoot, type, instance) {
-  hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
-  hoistableRoot.head.insertBefore(
-    instance,
-    "title" === type ? hoistableRoot.querySelector("head > title") : null
-  );
+function rerenderReducer(reducer) {
+  var hook = updateWorkInProgressHook(),
+    queue = hook.queue;
+  if (null === queue) throw Error(formatProdErrorMessage(311));
+  queue.lastRenderedReducer = reducer;
+  var dispatch = queue.dispatch,
+    lastRenderPhaseUpdate = queue.pending,
+    newState = hook.memoizedState;
+  if (null !== lastRenderPhaseUpdate) {
+    queue.pending = null;
+    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
+    do (newState = reducer(newState, update.action)), (update = update.next);
+    while (update !== lastRenderPhaseUpdate);
+    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+    hook.memoizedState = newState;
+    null === hook.baseQueue && (hook.baseState = newState);
+    queue.lastRenderedState = newState;
+  }
+  return [newState, dispatch];
 }
-var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
-function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
-  return value.replace(
-    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
-    function (ch) {
-      return "\\" + ch.charCodeAt(0).toString(16);
-    }
-  );
+function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
+  var getVersion = source._getVersion;
+  getVersion = getVersion(source._source);
+  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
+  if (null !== JSCompiler_inline_result)
+    root = JSCompiler_inline_result === getVersion;
+  else if (
+    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
+  )
+    (source._workInProgressVersionPrimary = getVersion),
+      workInProgressSources.push(source);
+  if (root) return getSnapshot(source._source);
+  workInProgressSources.push(source);
+  throw Error(formatProdErrorMessage(350));
 }
-var eventsEnabled = null,
-  selectionInformation = null;
-function shouldSetTextContent(type, props) {
-  return (
-    "textarea" === type ||
-    "noscript" === type ||
-    "string" === typeof props.children ||
-    "number" === typeof props.children ||
-    ("object" === typeof props.dangerouslySetInnerHTML &&
-      null !== props.dangerouslySetInnerHTML &&
-      null != props.dangerouslySetInnerHTML.__html)
+function useMutableSource(hook, source, getSnapshot, subscribe) {
+  var root = workInProgressRoot;
+  if (null === root) throw Error(formatProdErrorMessage(349));
+  var getVersion = source._getVersion,
+    version = getVersion(source._source),
+    dispatcher = ReactCurrentDispatcher$1.current,
+    _dispatcher$useState = dispatcher.useState(function () {
+      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
+    }),
+    setSnapshot = _dispatcher$useState[1],
+    snapshot = _dispatcher$useState[0];
+  _dispatcher$useState = workInProgressHook;
+  var memoizedState = hook.memoizedState,
+    refs = memoizedState.refs,
+    prevGetSnapshot = refs.getSnapshot,
+    prevSource = memoizedState.source;
+  memoizedState = memoizedState.subscribe;
+  var fiber = currentlyRenderingFiber$1;
+  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
+  dispatcher.useEffect(
+    function () {
+      refs.getSnapshot = getSnapshot;
+      refs.setSnapshot = setSnapshot;
+      var maybeNewVersion = getVersion(source._source);
+      objectIs(version, maybeNewVersion) ||
+        ((maybeNewVersion = getSnapshot(source._source)),
+        objectIs(snapshot, maybeNewVersion) ||
+          (setSnapshot(maybeNewVersion),
+          (maybeNewVersion = requestUpdateLane(fiber)),
+          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
+        markRootEntangled(root, root.mutableReadLanes));
+    },
+    [getSnapshot, source, subscribe]
   );
-}
-var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
-  cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
-  localPromise = "function" === typeof Promise ? Promise : void 0,
-  localRequestAnimationFrame =
-    "function" === typeof requestAnimationFrame
-      ? requestAnimationFrame
-      : scheduleTimeout;
-function getInstanceFromScope(scopeInstance) {
-  scopeInstance = scopeInstance[internalInstanceKey] || null;
-  return scopeInstance;
-}
-var scheduleMicrotask =
-  "function" === typeof queueMicrotask
-    ? queueMicrotask
-    : "undefined" !== typeof localPromise
-    ? function (callback) {
-        return localPromise
-          .resolve(null)
-          .then(callback)
-          .catch(handleErrorInNextTick);
-      }
-    : scheduleTimeout;
-function handleErrorInNextTick(error) {
-  setTimeout(function () {
-    throw error;
-  });
-}
-function createEvent(type, bubbles) {
-  var event = document.createEvent("Event");
-  event.initEvent(type, bubbles, !1);
-  return event;
-}
-function dispatchBeforeDetachedBlur(target, internalInstanceHandle) {
-  var event = createEvent("beforeblur", !0);
-  event._detachedInterceptFiber = internalInstanceHandle;
-  target.dispatchEvent(event);
-}
-function dispatchAfterDetachedBlur(target) {
-  var event = createEvent("afterblur", !1);
-  event.relatedTarget = target;
-  document.dispatchEvent(event);
-}
-function clearSuspenseBoundary(parentInstance, suspenseInstance) {
-  var node = suspenseInstance,
-    depth = 0;
-  do {
-    var nextNode = node.nextSibling;
-    parentInstance.removeChild(node);
-    if (nextNode && 8 === nextNode.nodeType)
-      if (((node = nextNode.data), "/$" === node)) {
-        if (0 === depth) {
-          parentInstance.removeChild(nextNode);
-          retryIfBlockedOn(suspenseInstance);
-          return;
+  dispatcher.useEffect(
+    function () {
+      return subscribe(source._source, function () {
+        var latestGetSnapshot = refs.getSnapshot,
+          latestSetSnapshot = refs.setSnapshot;
+        try {
+          latestSetSnapshot(latestGetSnapshot(source._source));
+          var lane = requestUpdateLane(fiber);
+          root.mutableReadLanes |= lane & root.pendingLanes;
+        } catch (error) {
+          latestSetSnapshot(function () {
+            throw error;
+          });
         }
-        depth--;
-      } else ("$" !== node && "$?" !== node && "$!" !== node) || depth++;
-    node = nextNode;
-  } while (node);
-  retryIfBlockedOn(suspenseInstance);
+      });
+    },
+    [source, subscribe]
+  );
+  (objectIs(prevGetSnapshot, getSnapshot) &&
+    objectIs(prevSource, source) &&
+    objectIs(memoizedState, subscribe)) ||
+    ((hook = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: snapshot
+    }),
+    (hook.dispatch = setSnapshot =
+      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
+    (_dispatcher$useState.queue = hook),
+    (_dispatcher$useState.baseQueue = null),
+    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
+    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
+      snapshot));
+  return snapshot;
 }
-function clearContainerSparingly(container) {
-  var nextNode = container.firstChild;
-  nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
-  for (; nextNode; ) {
-    var node = nextNode;
-    nextNode = nextNode.nextSibling;
-    switch (node.nodeName) {
-      case "HTML":
-      case "HEAD":
-      case "BODY":
-        clearContainerSparingly(node);
-        detachDeletedInstance(node);
-        continue;
-      case "STYLE":
-        continue;
-      case "LINK":
-        if ("stylesheet" === node.rel.toLowerCase()) continue;
-    }
-    container.removeChild(node);
-  }
+function updateMutableSource(source, getSnapshot, subscribe) {
+  var hook = updateWorkInProgressHook();
+  return useMutableSource(hook, source, getSnapshot, subscribe);
 }
-function shouldSkipHydratableForInstance(instance, type, props) {
-  if (1 !== instance.nodeType) return !1;
+function updateSyncExternalStore(subscribe, getSnapshot) {
+  var fiber = currentlyRenderingFiber$1,
+    hook = updateWorkInProgressHook(),
+    nextSnapshot = getSnapshot(),
+    snapshotChanged = !objectIs(
+      (currentHook || hook).memoizedState,
+      nextSnapshot
+    );
+  snapshotChanged &&
+    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
+  hook = hook.queue;
+  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
+    subscribe
+  ]);
   if (
-    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
-    instance[internalHoistableMarker]
-  )
-    return !0;
-  switch (type) {
-    case "meta":
-      if (!instance.hasAttribute("itemprop")) return !0;
-      break;
-    case "link":
-      type = instance.getAttribute("rel");
-      if (
-        ("stylesheet" === type && instance.hasAttribute("data-precedence")) ||
-        type !== props.rel ||
-        instance.getAttribute("href") !==
-          (null == props.href ? null : props.href) ||
-        instance.getAttribute("crossorigin") !==
-          (null == props.crossOrigin ? null : props.crossOrigin) ||
-        instance.getAttribute("title") !==
-          (null == props.title ? null : props.title)
-      )
-        return !0;
-      break;
-    case "style":
-      if (instance.hasAttribute("data-precedence")) return !0;
-      break;
-    case "script":
-      if (
-        ((type = instance.getAttribute("src")) &&
-          instance.hasAttribute("async") &&
-          !instance.hasAttribute("itemprop")) ||
-        type !== (null == props.src ? null : props.src) ||
-        instance.getAttribute("type") !==
-          (null == props.type ? null : props.type) ||
-        instance.getAttribute("crossorigin") !==
-          (null == props.crossOrigin ? null : props.crossOrigin)
-      )
-        return !0;
-  }
-  return !1;
-}
-function getNextHydratable(node) {
-  for (; null != node; node = node.nextSibling) {
-    var nodeType = node.nodeType;
-    if (1 === nodeType || 3 === nodeType) break;
-    if (8 === nodeType) {
-      nodeType = node.data;
-      if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType) break;
-      if ("/$" === nodeType) return null;
-    }
+    hook.getSnapshot !== getSnapshot ||
+    snapshotChanged ||
+    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
+  ) {
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
+      void 0,
+      null
+    );
+    subscribe = workInProgressRoot;
+    if (null === subscribe) throw Error(formatProdErrorMessage(349));
+    includesBlockingLane(subscribe, renderLanes$1) ||
+      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
   }
-  return node;
+  return nextSnapshot;
 }
-function getParentSuspenseInstance(targetInstance) {
-  targetInstance = targetInstance.previousSibling;
-  for (var depth = 0; targetInstance; ) {
-    if (8 === targetInstance.nodeType) {
-      var data = targetInstance.data;
-      if ("$" === data || "$!" === data || "$?" === data) {
-        if (0 === depth) return targetInstance;
-        depth--;
-      } else "/$" === data && depth++;
-    }
-    targetInstance = targetInstance.previousSibling;
-  }
-  return null;
+function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+  fiber.flags |= 16384;
+  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
+  getSnapshot = currentlyRenderingFiber$1.updateQueue;
+  null === getSnapshot
+    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
+      (getSnapshot.stores = [fiber]))
+    : ((renderedSnapshot = getSnapshot.stores),
+      null === renderedSnapshot
+        ? (getSnapshot.stores = [fiber])
+        : renderedSnapshot.push(fiber));
 }
-function getBoundingRect(node) {
-  node = node.getBoundingClientRect();
-  return { x: node.left, y: node.top, width: node.width, height: node.height };
+function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+  inst.value = nextSnapshot;
+  inst.getSnapshot = getSnapshot;
+  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
 }
-function isHiddenSubtree(fiber) {
-  return 5 === fiber.tag && !0 === fiber.memoizedProps.hidden;
+function subscribeToStore(fiber, inst, subscribe) {
+  return subscribe(function () {
+    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+  });
 }
-function setFocusIfFocusable(node) {
-  function handleFocus() {
-    didFocus = !0;
-  }
-  var didFocus = !1;
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  inst = inst.value;
   try {
-    node.addEventListener("focus", handleFocus),
-      (node.focus || HTMLElement.prototype.focus).call(node);
-  } finally {
-    node.removeEventListener("focus", handleFocus);
+    var nextValue = latestGetSnapshot();
+    return !objectIs(inst, nextValue);
+  } catch (error) {
+    return !0;
   }
-  return didFocus;
 }
-function setupIntersectionObserver(targets, callback, options) {
-  var rectRatioCache = new Map();
-  targets.forEach(function (target) {
-    rectRatioCache.set(target, { rect: getBoundingRect(target), ratio: 0 });
-  });
-  var observer = new IntersectionObserver(function (entries) {
-    entries.forEach(function (entry) {
-      var boundingClientRect = entry.boundingClientRect;
-      rectRatioCache.set(entry.target, {
-        rect: {
-          x: boundingClientRect.left,
-          y: boundingClientRect.top,
-          width: boundingClientRect.width,
-          height: boundingClientRect.height
-        },
-        ratio: entry.intersectionRatio
-      });
-    });
-    callback(Array.from(rectRatioCache.values()));
-  }, options);
-  targets.forEach(function (target) {
-    observer.observe(target);
-  });
-  return {
-    disconnect: function () {
-      return observer.disconnect();
-    },
-    observe: function (target) {
-      rectRatioCache.set(target, { rect: getBoundingRect(target), ratio: 0 });
-      observer.observe(target);
-    },
-    unobserve: function (target) {
-      rectRatioCache.delete(target);
-      observer.unobserve(target);
-    }
+function forceStoreRerender(fiber) {
+  var root = enqueueConcurrentRenderForLane(fiber, 2);
+  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
+}
+function mountState(initialState) {
+  var hook = mountWorkInProgressHook();
+  "function" === typeof initialState && (initialState = initialState());
+  hook.memoizedState = hook.baseState = initialState;
+  initialState = {
+    pending: null,
+    lanes: 0,
+    dispatch: null,
+    lastRenderedReducer: basicStateReducer,
+    lastRenderedState: initialState
   };
+  hook.queue = initialState;
+  initialState = initialState.dispatch = dispatchSetState.bind(
+    null,
+    currentlyRenderingFiber$1,
+    initialState
+  );
+  return [hook.memoizedState, initialState];
 }
-function requestPostPaintCallback(callback) {
-  localRequestAnimationFrame(function () {
-    localRequestAnimationFrame(function (time) {
-      return callback(time);
-    });
-  });
+function pushEffect(tag, create, destroy, deps) {
+  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
+  create = currentlyRenderingFiber$1.updateQueue;
+  null === create
+    ? ((create = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = create),
+      (create.lastEffect = tag.next = tag))
+    : ((destroy = create.lastEffect),
+      null === destroy
+        ? (create.lastEffect = tag.next = tag)
+        : ((deps = destroy.next),
+          (destroy.next = tag),
+          (tag.next = deps),
+          (create.lastEffect = tag)));
+  return tag;
 }
-function isHostHoistableType(type, props, hostContext) {
-  if ("http://www.w3.org/2000/svg" === hostContext || null != props.itemProp)
-    return !1;
-  switch (type) {
-    case "meta":
-    case "title":
-      return !0;
-    case "style":
-      if (
-        "string" !== typeof props.precedence ||
-        "string" !== typeof props.href ||
-        "" === props.href
-      )
-        break;
-      return !0;
-    case "link":
-      if (
-        "string" !== typeof props.rel ||
-        "string" !== typeof props.href ||
-        "" === props.href ||
-        props.onLoad ||
-        props.onError
-      )
-        break;
-      switch (props.rel) {
-        case "stylesheet":
-          return (
-            (type = props.disabled),
-            "string" === typeof props.precedence && null == type
-          );
-        default:
-          return !0;
-      }
-    case "script":
-      if (
-        !0 === props.async &&
-        !props.onLoad &&
-        !props.onError &&
-        "string" === typeof props.src &&
-        props.src
-      )
-        return !0;
+function updateRef() {
+  return updateWorkInProgressHook().memoizedState;
+}
+function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = mountWorkInProgressHook();
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(
+    1 | hookFlags,
+    create,
+    void 0,
+    void 0 === deps ? null : deps
+  );
+}
+function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var destroy = void 0;
+  if (null !== currentHook) {
+    var prevEffect = currentHook.memoizedState;
+    destroy = prevEffect.destroy;
+    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
+      return;
+    }
   }
-  return !1;
+  currentlyRenderingFiber$1.flags |= fiberFlags;
+  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
 }
-function resolveSingletonInstance(type, props, rootContainerInstance) {
-  props = getOwnerDocumentFromRootContainer(rootContainerInstance);
-  switch (type) {
-    case "html":
-      type = props.documentElement;
-      if (!type) throw Error(formatProdErrorMessage(452));
-      return type;
-    case "head":
-      type = props.head;
-      if (!type) throw Error(formatProdErrorMessage(453));
-      return type;
-    case "body":
-      type = props.body;
-      if (!type) throw Error(formatProdErrorMessage(454));
-      return type;
-    default:
-      throw Error(formatProdErrorMessage(451));
+function mountEffect(create, deps) {
+  mountEffectImpl(8390656, 8, create, deps);
+}
+function updateEffect(create, deps) {
+  updateEffectImpl(2048, 8, create, deps);
+}
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= 4;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+  if (null === componentUpdateQueue)
+    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
+      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
+      (componentUpdateQueue.events = [payload]);
+  else {
+    var events = componentUpdateQueue.events;
+    null === events
+      ? (componentUpdateQueue.events = [payload])
+      : events.push(payload);
   }
 }
-var emptyContextObject = {},
-  syncQueue = null,
-  includesLegacySyncCallbacks = !1,
-  isFlushingSyncQueue = !1;
-function scheduleSyncCallback(callback) {
-  null === syncQueue ? (syncQueue = [callback]) : syncQueue.push(callback);
+function updateEvent(callback) {
+  var ref = updateWorkInProgressHook().memoizedState;
+  useEffectEventImpl({ ref: ref, nextImpl: callback });
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
 }
-function scheduleLegacySyncCallback(callback) {
-  includesLegacySyncCallbacks = !0;
-  scheduleSyncCallback(callback);
+function updateInsertionEffect(create, deps) {
+  return updateEffectImpl(4, 2, create, deps);
 }
-function flushSyncCallbacks() {
-  if (!isFlushingSyncQueue && null !== syncQueue) {
-    isFlushingSyncQueue = !0;
-    var previousUpdatePriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    for (var errors = null, queue = syncQueue, i = 0; i < queue.length; i++) {
-      var callback = queue[i];
-      try {
-        do callback = callback(!0);
-        while (null !== callback);
-      } catch (error) {
-        null === errors ? (errors = [error]) : errors.push(error);
+function updateLayoutEffect(create, deps) {
+  return updateEffectImpl(4, 4, create, deps);
+}
+function imperativeHandleEffect(create, ref) {
+  if ("function" === typeof ref)
+    return (
+      (create = create()),
+      ref(create),
+      function () {
+        ref(null);
       }
-    }
-    syncQueue = null;
-    includesLegacySyncCallbacks = !1;
-    currentUpdatePriority = previousUpdatePriority;
-    isFlushingSyncQueue = !1;
-    if (null !== errors) {
-      if (1 < errors.length) {
-        if ("function" === typeof AggregateError)
-          throw new AggregateError(errors);
-        for (
-          previousUpdatePriority = 1;
-          previousUpdatePriority < errors.length;
-          previousUpdatePriority++
-        )
-          scheduleCallback$2(
-            ImmediatePriority,
-            throwError.bind(null, errors[previousUpdatePriority])
-          );
+    );
+  if (null !== ref && void 0 !== ref)
+    return (
+      (create = create()),
+      (ref.current = create),
+      function () {
+        ref.current = null;
       }
-      throw errors[0];
-    }
-  }
-  return null;
-}
-function throwError(error) {
-  throw error;
+    );
 }
-var forkStack = [],
-  forkStackIndex = 0,
-  treeForkProvider = null,
-  treeForkCount = 0,
-  idStack = [],
-  idStackIndex = 0,
-  treeContextProvider = null,
-  treeContextId = 1,
-  treeContextOverflow = "";
-function pushTreeFork(workInProgress, totalChildren) {
-  forkStack[forkStackIndex++] = treeForkCount;
-  forkStack[forkStackIndex++] = treeForkProvider;
-  treeForkProvider = workInProgress;
-  treeForkCount = totalChildren;
+function updateImperativeHandle(ref, create, deps) {
+  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
 }
-function pushTreeId(workInProgress, totalChildren, index) {
-  idStack[idStackIndex++] = treeContextId;
-  idStack[idStackIndex++] = treeContextOverflow;
-  idStack[idStackIndex++] = treeContextProvider;
-  treeContextProvider = workInProgress;
-  var baseIdWithLeadingBit = treeContextId;
-  workInProgress = treeContextOverflow;
-  var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
-  baseIdWithLeadingBit &= ~(1 << baseLength);
-  index += 1;
-  var length = 32 - clz32(totalChildren) + baseLength;
-  if (30 < length) {
-    var numberOfOverflowBits = baseLength - (baseLength % 5);
-    length = (
-      baseIdWithLeadingBit &
-      ((1 << numberOfOverflowBits) - 1)
-    ).toString(32);
-    baseIdWithLeadingBit >>= numberOfOverflowBits;
-    baseLength -= numberOfOverflowBits;
-    treeContextId =
-      (1 << (32 - clz32(totalChildren) + baseLength)) |
-      (index << baseLength) |
-      baseIdWithLeadingBit;
-    treeContextOverflow = length + workInProgress;
-  } else
-    (treeContextId =
-      (1 << length) | (index << baseLength) | baseIdWithLeadingBit),
-      (treeContextOverflow = workInProgress);
+function mountDebugValue() {}
+function updateCallback(callback, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  hook.memoizedState = [callback, deps];
+  return callback;
 }
-function pushMaterializedTreeId(workInProgress) {
-  null !== workInProgress.return &&
-    (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
+function updateMemo(nextCreate, deps) {
+  var hook = updateWorkInProgressHook();
+  deps = void 0 === deps ? null : deps;
+  var prevState = hook.memoizedState;
+  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+    return prevState[0];
+  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+  nextCreate = nextCreate();
+  hook.memoizedState = [nextCreate, deps];
+  return nextCreate;
 }
-function popTreeContext(workInProgress) {
-  for (; workInProgress === treeForkProvider; )
-    (treeForkProvider = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null),
-      (treeForkCount = forkStack[--forkStackIndex]),
-      (forkStack[forkStackIndex] = null);
-  for (; workInProgress === treeContextProvider; )
-    (treeContextProvider = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextOverflow = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null),
-      (treeContextId = idStack[--idStackIndex]),
-      (idStack[idStackIndex] = null);
+function updateDeferredValueImpl(hook, prevValue, value) {
+  if (0 === (renderLanes$1 & 42))
+    return (
+      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
+      (hook.memoizedState = value)
+    );
+  objectIs(value, prevValue) ||
+    ((value = claimNextTransitionLane()),
+    (currentlyRenderingFiber$1.lanes |= value),
+    (workInProgressRootSkippedLanes |= value),
+    (hook.baseState = !0));
+  return prevValue;
 }
-var hydrationParentFiber = null,
-  nextHydratableInstance = null,
-  isHydrating = !1,
-  hydrationErrors = null,
-  rootOrSingletonContext = !1;
-function deleteHydratableInstance(returnFiber, instance) {
-  var fiber = createFiber(5, null, null, 0);
-  fiber.elementType = "DELETED";
-  fiber.stateNode = instance;
-  fiber.return = returnFiber;
-  instance = returnFiber.deletions;
-  null === instance
-    ? ((returnFiber.deletions = [fiber]), (returnFiber.flags |= 16))
-    : instance.push(fiber);
+function startTransition(setPending, callback, options) {
+  var previousPriority = currentUpdatePriority;
+  currentUpdatePriority =
+    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
+  setPending(!0);
+  var prevTransition = ReactCurrentBatchConfig$3.transition;
+  ReactCurrentBatchConfig$3.transition = {};
+  enableTransitionTracing &&
+    void 0 !== options &&
+    void 0 !== options.name &&
+    ((ReactCurrentBatchConfig$3.transition.name = options.name),
+    (ReactCurrentBatchConfig$3.transition.startTime = now()));
+  try {
+    setPending(!1), callback();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$3.transition = prevTransition);
+  }
 }
-function insertNonHydratedInstance(returnFiber, fiber) {
-  fiber.flags = (fiber.flags & -4097) | 2;
+function updateId() {
+  return updateWorkInProgressHook().memoizedState;
 }
-function tryHydrateInstance(fiber, nextInstance) {
-  var type = fiber.type;
-  nextInstance =
-    1 !== nextInstance.nodeType ||
-    nextInstance.nodeName.toLowerCase() !== type.toLowerCase()
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = getNextHydratable(nextInstance.firstChild)),
-      (rootOrSingletonContext = !1),
-      !0)
-    : !1;
+function updateRefresh() {
+  return updateWorkInProgressHook().memoizedState;
 }
-function tryHydrateText(fiber, nextInstance) {
-  nextInstance =
-    "" === fiber.pendingProps
-      ? null
-      : 3 !== nextInstance.nodeType
-      ? null
-      : nextInstance;
-  return null !== nextInstance
-    ? ((fiber.stateNode = nextInstance),
-      (hydrationParentFiber = fiber),
-      (nextHydratableInstance = null),
-      !0)
-    : !1;
+function refreshCache(fiber, seedKey, seedValue) {
+  for (var provider = fiber.return; null !== provider; ) {
+    switch (provider.tag) {
+      case 24:
+      case 3:
+        var lane = requestUpdateLane(provider);
+        fiber = createUpdate(lane);
+        var root$51 = enqueueUpdate(provider, fiber, lane);
+        if (null !== root$51) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root$51, provider, lane, eventTime);
+          entangleTransitions(root$51, provider, lane);
+        }
+        provider = createCache();
+        null !== seedKey &&
+          void 0 !== seedKey &&
+          null !== root$51 &&
+          provider.data.set(seedKey, seedValue);
+        fiber.payload = { cache: provider };
+        return;
+    }
+    provider = provider.return;
+  }
 }
-function tryHydrateSuspense(fiber, nextInstance) {
-  nextInstance = 8 !== nextInstance.nodeType ? null : nextInstance;
-  if (null !== nextInstance) {
-    var JSCompiler_inline_result =
-      null !== treeContextProvider
-        ? { id: treeContextId, overflow: treeContextOverflow }
-        : null;
-    fiber.memoizedState = {
-      dehydrated: nextInstance,
-      treeContext: JSCompiler_inline_result,
-      retryLane: 1073741824
+function dispatchReducerAction(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber);
+  action = {
+    lane: lane,
+    action: action,
+    hasEagerState: !1,
+    eagerState: null,
+    next: null
+  };
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
+  else if (
+    (enqueueUpdate$1(fiber, queue, action, lane),
+    (action = getRootForUpdatedFiber(fiber)),
+    null !== action)
+  ) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
+    entangleTransitionUpdate(action, queue, lane);
+  }
+}
+function dispatchSetState(fiber, queue, action) {
+  var lane = requestUpdateLane(fiber),
+    update = {
+      lane: lane,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
     };
-    JSCompiler_inline_result = createFiber(18, null, null, 0);
-    JSCompiler_inline_result.stateNode = nextInstance;
-    JSCompiler_inline_result.return = fiber;
-    fiber.child = JSCompiler_inline_result;
-    hydrationParentFiber = fiber;
-    nextHydratableInstance = null;
-    return !0;
+  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
+  else {
+    var alternate = fiber.alternate;
+    if (
+      0 === fiber.lanes &&
+      (null === alternate || 0 === alternate.lanes) &&
+      ((alternate = queue.lastRenderedReducer), null !== alternate)
+    )
+      try {
+        var currentState = queue.lastRenderedState,
+          eagerState = alternate(currentState, action);
+        update.hasEagerState = !0;
+        update.eagerState = eagerState;
+        if (objectIs(eagerState, currentState)) {
+          enqueueUpdate$1(fiber, queue, update, 0);
+          null === workInProgressRoot && finishQueueingConcurrentUpdates();
+          return;
+        }
+      } catch (error) {
+      } finally {
+      }
+    enqueueUpdate$1(fiber, queue, update, lane);
+    action = getRootForUpdatedFiber(fiber);
+    null !== action &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(action, fiber, lane, update),
+      entangleTransitionUpdate(action, queue, lane));
   }
-  return !1;
 }
-function shouldClientRenderOnMismatch(fiber) {
-  return 0 !== (fiber.mode & 1) && 0 === (fiber.flags & 128);
+function isRenderPhaseUpdate(fiber) {
+  var alternate = fiber.alternate;
+  return (
+    fiber === currentlyRenderingFiber$1 ||
+    (null !== alternate && alternate === currentlyRenderingFiber$1)
+  );
 }
-function throwOnHydrationMismatch() {
-  throw Error(formatProdErrorMessage(418));
+function enqueueRenderPhaseUpdate(queue, update) {
+  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
+    !0;
+  var pending = queue.pending;
+  null === pending
+    ? (update.next = update)
+    : ((update.next = pending.next), (pending.next = update));
+  queue.pending = update;
 }
-function advanceToFirstAttemptableInstance(fiber) {
-  for (
-    ;
-    nextHydratableInstance &&
-    shouldSkipHydratableForInstance(
-      nextHydratableInstance,
-      fiber.type,
-      fiber.pendingProps
-    );
-
-  )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
-    );
+function entangleTransitionUpdate(root, queue, lane) {
+  if (0 !== (lane & 8388480)) {
+    var queueLanes = queue.lanes;
+    queueLanes &= root.pendingLanes;
+    lane |= queueLanes;
+    queue.lanes = lane;
+    markRootEntangled(root, lane);
+  }
 }
-function advanceToFirstAttemptableTextInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
+var ContextOnlyDispatcher = {
+  readContext: readContext,
+  useCallback: throwInvalidHookError,
+  useContext: throwInvalidHookError,
+  useEffect: throwInvalidHookError,
+  useImperativeHandle: throwInvalidHookError,
+  useInsertionEffect: throwInvalidHookError,
+  useLayoutEffect: throwInvalidHookError,
+  useMemo: throwInvalidHookError,
+  useReducer: throwInvalidHookError,
+  useRef: throwInvalidHookError,
+  useState: throwInvalidHookError,
+  useDebugValue: throwInvalidHookError,
+  useDeferredValue: throwInvalidHookError,
+  useTransition: throwInvalidHookError,
+  useMutableSource: throwInvalidHookError,
+  useSyncExternalStore: throwInvalidHookError,
+  useId: throwInvalidHookError
+};
+ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
+ContextOnlyDispatcher.use = throwInvalidHookError;
+ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+var HooksDispatcherOnMount = {
+  readContext: readContext,
+  useCallback: function (callback, deps) {
+    mountWorkInProgressHook().memoizedState = [
+      callback,
+      void 0 === deps ? null : deps
+    ];
+    return callback;
+  },
+  useContext: readContext,
+  useEffect: mountEffect,
+  useImperativeHandle: function (ref, create, deps) {
+    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+    mountEffectImpl(
+      4194308,
+      4,
+      imperativeHandleEffect.bind(null, create, ref),
+      deps
     );
-}
-function advanceToFirstAttemptableSuspenseInstance() {
-  for (; nextHydratableInstance && 1 === nextHydratableInstance.nodeType; )
-    nextHydratableInstance = getNextHydratable(
-      nextHydratableInstance.nextSibling
+  },
+  useLayoutEffect: function (create, deps) {
+    return mountEffectImpl(4194308, 4, create, deps);
+  },
+  useInsertionEffect: function (create, deps) {
+    mountEffectImpl(4, 2, create, deps);
+  },
+  useMemo: function (nextCreate, deps) {
+    var hook = mountWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
+    nextCreate = nextCreate();
+    hook.memoizedState = [nextCreate, deps];
+    return nextCreate;
+  },
+  useReducer: function (reducer, initialArg, init) {
+    var hook = mountWorkInProgressHook();
+    initialArg = void 0 !== init ? init(initialArg) : initialArg;
+    hook.memoizedState = hook.baseState = initialArg;
+    reducer = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: reducer,
+      lastRenderedState: initialArg
+    };
+    hook.queue = reducer;
+    reducer = reducer.dispatch = dispatchReducerAction.bind(
+      null,
+      currentlyRenderingFiber$1,
+      reducer
     );
-}
-function prepareToHydrateHostInstance(fiber) {
-  var instance = fiber.stateNode,
-    type = fiber.type,
-    props = fiber.memoizedProps;
-  instance[internalInstanceKey] = fiber;
-  instance[internalPropsKey] = props;
-  switch (type) {
-    case "dialog":
-      listenToNonDelegatedEvent("cancel", instance);
-      listenToNonDelegatedEvent("close", instance);
-      break;
-    case "iframe":
-    case "object":
-    case "embed":
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "video":
-    case "audio":
-      for (var i = 0; i < mediaEventTypes.length; i++)
-        listenToNonDelegatedEvent(mediaEventTypes[i], instance);
-      break;
-    case "source":
-      listenToNonDelegatedEvent("error", instance);
-      break;
-    case "img":
-    case "image":
-    case "link":
-      listenToNonDelegatedEvent("error", instance);
-      listenToNonDelegatedEvent("load", instance);
-      break;
-    case "details":
-      listenToNonDelegatedEvent("toggle", instance);
-      break;
-    case "input":
-      initWrapperState$2(instance, props);
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "select":
-      instance._wrapperState = { wasMultiple: !!props.multiple };
-      listenToNonDelegatedEvent("invalid", instance);
-      break;
-    case "textarea":
-      initWrapperState(instance, props),
-        listenToNonDelegatedEvent("invalid", instance);
-  }
-  assertValidProps(type, props);
-  var updatePayload = null,
-    propKey;
-  for (propKey in props)
-    props.hasOwnProperty(propKey) &&
-      ((i = props[propKey]),
-      "children" === propKey
-        ? "string" === typeof i
-          ? instance.textContent !== i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", i]))
-          : "number" === typeof i &&
-            instance.textContent !== "" + i &&
-            (!0 !== props.suppressHydrationWarning &&
-              ((updatePayload = instance.textContent),
-              normalizeMarkupForTextOrAttribute(i),
-              normalizeMarkupForTextOrAttribute(updatePayload)),
-            (updatePayload = ["children", "" + i]))
-        : registrationNameDependencies.hasOwnProperty(propKey) &&
-          null != i &&
-          "onScroll" === propKey &&
-          listenToNonDelegatedEvent("scroll", instance));
-  switch (type) {
-    case "input":
-      track(instance);
-      postMountWrapper$3(instance, props, !0);
-      break;
-    case "textarea":
-      track(instance);
-      postMountWrapper(instance);
-      break;
-    case "select":
-    case "option":
-      break;
-    default:
-      "function" === typeof props.onClick && (instance.onclick = noop$1);
-  }
-  instance = updatePayload;
-  fiber.updateQueue = instance;
-  return null !== instance ? !0 : !1;
-}
-function popToNextHostParent(fiber) {
-  for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
-    switch (hydrationParentFiber.tag) {
-      case 3:
-      case 27:
-        rootOrSingletonContext = !0;
-        return;
-      case 5:
-      case 13:
-        rootOrSingletonContext = !1;
-        return;
-      default:
-        hydrationParentFiber = hydrationParentFiber.return;
+    return [hook.memoizedState, reducer];
+  },
+  useRef: function (initialValue) {
+    var hook = mountWorkInProgressHook();
+    if (enableUseRefAccessWarning)
+      return (
+        (initialValue = { current: initialValue }),
+        (hook.memoizedState = initialValue)
+      );
+    initialValue = { current: initialValue };
+    return (hook.memoizedState = initialValue);
+  },
+  useState: mountState,
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    return (mountWorkInProgressHook().memoizedState = value);
+  },
+  useTransition: function () {
+    var _mountState = mountState(!1),
+      isPending = _mountState[0];
+    _mountState = startTransition.bind(null, _mountState[1]);
+    mountWorkInProgressHook().memoizedState = _mountState;
+    return [isPending, _mountState];
+  },
+  useMutableSource: function (source, getSnapshot, subscribe) {
+    var hook = mountWorkInProgressHook();
+    hook.memoizedState = {
+      refs: { getSnapshot: getSnapshot, setSnapshot: null },
+      source: source,
+      subscribe: subscribe
+    };
+    return useMutableSource(hook, source, getSnapshot, subscribe);
+  },
+  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
+    var fiber = currentlyRenderingFiber$1,
+      hook = mountWorkInProgressHook();
+    if (isHydrating) {
+      if (void 0 === getServerSnapshot)
+        throw Error(formatProdErrorMessage(407));
+      getServerSnapshot = getServerSnapshot();
+    } else {
+      getServerSnapshot = getSnapshot();
+      var root$47 = workInProgressRoot;
+      if (null === root$47) throw Error(formatProdErrorMessage(349));
+      includesBlockingLane(root$47, renderLanes$1) ||
+        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
     }
-}
-function popHydrationState(fiber) {
-  if (fiber !== hydrationParentFiber) return !1;
-  if (!isHydrating) return popToNextHostParent(fiber), (isHydrating = !0), !1;
-  var shouldClear = !1;
-  3 === fiber.tag ||
-    27 === fiber.tag ||
-    (5 === fiber.tag &&
-      shouldSetTextContent(fiber.type, fiber.memoizedProps)) ||
-    (shouldClear = !0);
-  if (shouldClear && (shouldClear = nextHydratableInstance))
-    if (shouldClientRenderOnMismatch(fiber))
-      warnIfUnhydratedTailNodes(), throwOnHydrationMismatch();
-    else
-      for (; shouldClear; )
-        deleteHydratableInstance(fiber, shouldClear),
-          (shouldClear = getNextHydratable(shouldClear.nextSibling));
-  popToNextHostParent(fiber);
-  if (13 === fiber.tag) {
-    fiber = fiber.memoizedState;
-    fiber = null !== fiber ? fiber.dehydrated : null;
-    if (!fiber) throw Error(formatProdErrorMessage(317));
-    a: {
-      fiber = fiber.nextSibling;
-      for (shouldClear = 0; fiber; ) {
-        if (8 === fiber.nodeType) {
-          var data = fiber.data;
-          if ("/$" === data) {
-            if (0 === shouldClear) {
-              nextHydratableInstance = getNextHydratable(fiber.nextSibling);
-              break a;
-            }
-            shouldClear--;
-          } else
-            ("$" !== data && "$!" !== data && "$?" !== data) || shouldClear++;
-        }
-        fiber = fiber.nextSibling;
-      }
-      nextHydratableInstance = null;
-    }
-  } else
-    nextHydratableInstance = hydrationParentFiber
-      ? getNextHydratable(fiber.stateNode.nextSibling)
-      : null;
-  return !0;
-}
-function warnIfUnhydratedTailNodes() {
-  for (var nextInstance = nextHydratableInstance; nextInstance; )
-    nextInstance = getNextHydratable(nextInstance.nextSibling);
-}
-function resetHydrationState() {
-  nextHydratableInstance = hydrationParentFiber = null;
-  isHydrating = !1;
-}
-function queueHydrationError(error) {
-  null === hydrationErrors
-    ? (hydrationErrors = [error])
-    : hydrationErrors.push(error);
-}
-var concurrentQueues = [],
-  concurrentQueuesIndex = 0,
-  concurrentlyUpdatedLanes = 0;
-function finishQueueingConcurrentUpdates() {
-  for (
-    var endIndex = concurrentQueuesIndex,
-      i = (concurrentlyUpdatedLanes = concurrentQueuesIndex = 0);
-    i < endIndex;
-
-  ) {
-    var fiber = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var queue = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var update = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    var lane = concurrentQueues[i];
-    concurrentQueues[i++] = null;
-    if (null !== queue && null !== update) {
-      var pending = queue.pending;
-      null === pending
-        ? (update.next = update)
-        : ((update.next = pending.next), (pending.next = update));
-      queue.pending = update;
-    }
-    0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    hook.memoizedState = getServerSnapshot;
+    root$47 = { value: getServerSnapshot, getSnapshot: getSnapshot };
+    hook.queue = root$47;
+    mountEffect(subscribeToStore.bind(null, fiber, root$47, subscribe), [
+      subscribe
+    ]);
+    fiber.flags |= 2048;
+    pushEffect(
+      9,
+      updateStoreInstance.bind(
+        null,
+        fiber,
+        root$47,
+        getServerSnapshot,
+        getSnapshot
+      ),
+      void 0,
+      null
+    );
+    return getServerSnapshot;
+  },
+  useId: function () {
+    var hook = mountWorkInProgressHook(),
+      identifierPrefix = workInProgressRoot.identifierPrefix;
+    if (isHydrating) {
+      var JSCompiler_inline_result = treeContextOverflow;
+      var idWithLeadingBit = treeContextId;
+      JSCompiler_inline_result =
+        (
+          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
+        ).toString(32) + JSCompiler_inline_result;
+      identifierPrefix =
+        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
+      JSCompiler_inline_result = localIdCounter++;
+      0 < JSCompiler_inline_result &&
+        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
+      identifierPrefix += ":";
+    } else
+      (JSCompiler_inline_result = globalClientIdCounter++),
+        (identifierPrefix =
+          ":" +
+          identifierPrefix +
+          "r" +
+          JSCompiler_inline_result.toString(32) +
+          ":");
+    return (hook.memoizedState = identifierPrefix);
+  },
+  useCacheRefresh: function () {
+    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
+      null,
+      currentlyRenderingFiber$1
+    ));
   }
+};
+HooksDispatcherOnMount.use = use;
+HooksDispatcherOnMount.useMemoCache = useMemoCache;
+HooksDispatcherOnMount.useEffectEvent = function (callback) {
+  var hook = mountWorkInProgressHook(),
+    ref = { impl: callback };
+  hook.memoizedState = ref;
+  return function () {
+    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+    return ref.impl.apply(void 0, arguments);
+  };
+};
+var HooksDispatcherOnUpdate = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: updateReducer,
+  useRef: updateRef,
+  useState: function () {
+    return updateReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = updateReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
+HooksDispatcherOnUpdate.use = use;
+HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+var HooksDispatcherOnRerender = {
+  readContext: readContext,
+  useCallback: updateCallback,
+  useContext: readContext,
+  useEffect: updateEffect,
+  useImperativeHandle: updateImperativeHandle,
+  useInsertionEffect: updateInsertionEffect,
+  useLayoutEffect: updateLayoutEffect,
+  useMemo: updateMemo,
+  useReducer: rerenderReducer,
+  useRef: updateRef,
+  useState: function () {
+    return rerenderReducer(basicStateReducer);
+  },
+  useDebugValue: mountDebugValue,
+  useDeferredValue: function (value) {
+    var hook = updateWorkInProgressHook();
+    return null === currentHook
+      ? (hook.memoizedState = value)
+      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
+  },
+  useTransition: function () {
+    var isPending = rerenderReducer(basicStateReducer)[0],
+      start = updateWorkInProgressHook().memoizedState;
+    return [isPending, start];
+  },
+  useMutableSource: updateMutableSource,
+  useSyncExternalStore: updateSyncExternalStore,
+  useId: updateId
+};
+HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
+HooksDispatcherOnRerender.use = use;
+HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+function resolveDefaultProps(Component, baseProps) {
+  if (Component && Component.defaultProps) {
+    baseProps = assign({}, baseProps);
+    Component = Component.defaultProps;
+    for (var propName in Component)
+      void 0 === baseProps[propName] &&
+        (baseProps[propName] = Component[propName]);
+    return baseProps;
+  }
+  return baseProps;
 }
-function enqueueUpdate$1(fiber, queue, update, lane) {
-  concurrentQueues[concurrentQueuesIndex++] = fiber;
-  concurrentQueues[concurrentQueuesIndex++] = queue;
-  concurrentQueues[concurrentQueuesIndex++] = update;
-  concurrentQueues[concurrentQueuesIndex++] = lane;
-  concurrentlyUpdatedLanes |= lane;
-  fiber.lanes |= lane;
-  fiber = fiber.alternate;
-  null !== fiber && (fiber.lanes |= lane);
-}
-function enqueueConcurrentRenderForLane(fiber, lane) {
-  enqueueUpdate$1(fiber, null, null, lane);
-  return getRootForUpdatedFiber(fiber);
-}
-function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
-  sourceFiber.lanes |= lane;
-  var alternate = sourceFiber.alternate;
-  null !== alternate && (alternate.lanes |= lane);
-  for (var isHidden = !1, parent = sourceFiber.return; null !== parent; )
-    (parent.childLanes |= lane),
-      (alternate = parent.alternate),
-      null !== alternate && (alternate.childLanes |= lane),
-      22 === parent.tag &&
-        ((sourceFiber = parent.stateNode),
-        null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)),
-      (sourceFiber = parent),
-      (parent = parent.return);
-  isHidden &&
-    null !== update &&
-    3 === sourceFiber.tag &&
-    ((parent = sourceFiber.stateNode),
-    (isHidden = 31 - clz32(lane)),
-    (parent = parent.hiddenUpdates),
-    (sourceFiber = parent[isHidden]),
-    null === sourceFiber
-      ? (parent[isHidden] = [update])
-      : sourceFiber.push(update),
-    (update.lane = lane | 1073741824));
+function applyDerivedStateFromProps(
+  workInProgress,
+  ctor,
+  getDerivedStateFromProps,
+  nextProps
+) {
+  ctor = workInProgress.memoizedState;
+  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+  getDerivedStateFromProps =
+    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
+      ? ctor
+      : assign({}, ctor, getDerivedStateFromProps);
+  workInProgress.memoizedState = getDerivedStateFromProps;
+  0 === workInProgress.lanes &&
+    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
 }
-function getRootForUpdatedFiber(sourceFiber) {
-  if (50 < nestedUpdateCount)
-    throw (
-      ((nestedUpdateCount = 0),
-      (rootWithNestedUpdates = null),
-      Error(formatProdErrorMessage(185)))
-    );
-  for (var parent = sourceFiber.return; null !== parent; )
-    (sourceFiber = parent), (parent = sourceFiber.return);
-  return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
-}
-var hasForceUpdate = !1;
-function initializeUpdateQueue(fiber) {
-  fiber.updateQueue = {
-    baseState: fiber.memoizedState,
-    firstBaseUpdate: null,
-    lastBaseUpdate: null,
-    shared: { pending: null, lanes: 0, hiddenCallbacks: null },
-    callbacks: null
-  };
+var classComponentUpdater = {
+  isMounted: function (component) {
+    return (component = component._reactInternals)
+      ? getNearestMountedFiber(component) === component
+      : !1;
+  },
+  enqueueSetState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+  },
+  enqueueReplaceState: function (inst, payload, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 1;
+    update.payload = payload;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    payload = enqueueUpdate(inst, update, lane);
+    null !== payload &&
+      ((callback = requestEventTime()),
+      scheduleUpdateOnFiber(payload, inst, lane, callback),
+      entangleTransitions(payload, inst, lane));
+  },
+  enqueueForceUpdate: function (inst, callback) {
+    inst = inst._reactInternals;
+    var lane = requestUpdateLane(inst),
+      update = createUpdate(lane);
+    update.tag = 2;
+    void 0 !== callback && null !== callback && (update.callback = callback);
+    callback = enqueueUpdate(inst, update, lane);
+    null !== callback &&
+      ((update = requestEventTime()),
+      scheduleUpdateOnFiber(callback, inst, lane, update),
+      entangleTransitions(callback, inst, lane));
+  }
+};
+function checkShouldComponentUpdate(
+  workInProgress,
+  ctor,
+  oldProps,
+  newProps,
+  oldState,
+  newState,
+  nextContext
+) {
+  workInProgress = workInProgress.stateNode;
+  return "function" === typeof workInProgress.shouldComponentUpdate
+    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
+    : ctor.prototype && ctor.prototype.isPureReactComponent
+    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
+    : !0;
 }
-function cloneUpdateQueue(current, workInProgress) {
-  current = current.updateQueue;
-  workInProgress.updateQueue === current &&
-    (workInProgress.updateQueue = {
-      baseState: current.baseState,
-      firstBaseUpdate: current.firstBaseUpdate,
-      lastBaseUpdate: current.lastBaseUpdate,
-      shared: current.shared,
-      callbacks: null
-    });
+function constructClassInstance(workInProgress, ctor, props) {
+  var context = emptyContextObject,
+    contextType = ctor.contextType;
+  "object" === typeof contextType &&
+    null !== contextType &&
+    (context = readContext(contextType));
+  ctor = new ctor(props, context);
+  workInProgress.memoizedState =
+    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+  ctor.updater = classComponentUpdater;
+  workInProgress.stateNode = ctor;
+  ctor._reactInternals = workInProgress;
+  return ctor;
 }
-function createUpdate(lane) {
-  return { lane: lane, tag: 0, payload: null, callback: null, next: null };
+function callComponentWillReceiveProps(
+  workInProgress,
+  instance,
+  newProps,
+  nextContext
+) {
+  workInProgress = instance.state;
+  "function" === typeof instance.componentWillReceiveProps &&
+    instance.componentWillReceiveProps(newProps, nextContext);
+  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+  instance.state !== workInProgress &&
+    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
 }
-function enqueueUpdate(fiber, update, lane) {
-  var updateQueue = fiber.updateQueue;
-  if (null === updateQueue) return null;
-  updateQueue = updateQueue.shared;
-  if (
-    (deferRenderPhaseUpdateToNextBatch && 0 !== (fiber.mode & 1)) ||
-    0 === (executionContext & 2)
-  )
-    return (
-      enqueueUpdate$1(fiber, updateQueue, update, lane),
-      getRootForUpdatedFiber(fiber)
-    );
-  var pending = updateQueue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  updateQueue.pending = update;
-  update = getRootForUpdatedFiber(fiber);
-  markUpdateLaneFromFiberToRoot(fiber, null, lane);
-  return update;
+function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+  var instance = workInProgress.stateNode;
+  instance.props = newProps;
+  instance.state = workInProgress.memoizedState;
+  instance.refs = {};
+  initializeUpdateQueue(workInProgress);
+  var contextType = ctor.contextType;
+  instance.context =
+    "object" === typeof contextType && null !== contextType
+      ? readContext(contextType)
+      : emptyContextObject;
+  instance.state = workInProgress.memoizedState;
+  contextType = ctor.getDerivedStateFromProps;
+  "function" === typeof contextType &&
+    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof ctor.getDerivedStateFromProps ||
+    "function" === typeof instance.getSnapshotBeforeUpdate ||
+    ("function" !== typeof instance.UNSAFE_componentWillMount &&
+      "function" !== typeof instance.componentWillMount) ||
+    ((ctor = instance.state),
+    "function" === typeof instance.componentWillMount &&
+      instance.componentWillMount(),
+    "function" === typeof instance.UNSAFE_componentWillMount &&
+      instance.UNSAFE_componentWillMount(),
+    ctor !== instance.state &&
+      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
+    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
+    (instance.state = workInProgress.memoizedState));
+  "function" === typeof instance.componentDidMount &&
+    (workInProgress.flags |= 4194308);
 }
-function entangleTransitions(root, fiber, lane) {
-  fiber = fiber.updateQueue;
-  if (null !== fiber && ((fiber = fiber.shared), 0 !== (lane & 8388480))) {
-    var queueLanes = fiber.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    fiber.lanes = lane;
-    markRootEntangled(root, lane);
+function createCapturedValueAtFiber(value, source) {
+  try {
+    var info = "",
+      node = source;
+    do (info += describeFiber(node)), (node = node.return);
+    while (node);
+    var JSCompiler_inline_result = info;
+  } catch (x) {
+    JSCompiler_inline_result =
+      "\nError generating stack: " + x.message + "\n" + x.stack;
   }
+  return {
+    value: value,
+    source: source,
+    stack: JSCompiler_inline_result,
+    digest: null
+  };
 }
-function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
-  var queue = workInProgress.updateQueue,
-    current = workInProgress.alternate;
-  if (
-    null !== current &&
-    ((current = current.updateQueue), queue === current)
-  ) {
-    var newFirst = null,
-      newLast = null;
-    queue = queue.firstBaseUpdate;
-    if (null !== queue) {
-      do {
-        var clone = {
-          lane: queue.lane,
-          tag: queue.tag,
-          payload: queue.payload,
-          callback: null,
-          next: null
-        };
-        null === newLast
-          ? (newFirst = newLast = clone)
-          : (newLast = newLast.next = clone);
-        queue = queue.next;
-      } while (null !== queue);
-      null === newLast
-        ? (newFirst = newLast = capturedUpdate)
-        : (newLast = newLast.next = capturedUpdate);
-    } else newFirst = newLast = capturedUpdate;
-    queue = {
-      baseState: current.baseState,
-      firstBaseUpdate: newFirst,
-      lastBaseUpdate: newLast,
-      shared: current.shared,
-      callbacks: current.callbacks
-    };
-    workInProgress.updateQueue = queue;
-    return;
+function createCapturedValue(value, digest, stack) {
+  return {
+    value: value,
+    source: null,
+    stack: null != stack ? stack : null,
+    digest: null != digest ? digest : null
+  };
+}
+var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
+if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
+  throw Error(formatProdErrorMessage(320));
+function logCapturedError(boundary, errorInfo) {
+  try {
+    !1 !==
+      ReactFiberErrorDialogWWW.showErrorDialog({
+        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
+        error: errorInfo.value,
+        errorBoundary:
+          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
+      }) && console.error(errorInfo.value);
+  } catch (e) {
+    setTimeout(function () {
+      throw e;
+    });
   }
-  workInProgress = queue.lastBaseUpdate;
-  null === workInProgress
-    ? (queue.firstBaseUpdate = capturedUpdate)
-    : (workInProgress.next = capturedUpdate);
-  queue.lastBaseUpdate = capturedUpdate;
 }
-function processUpdateQueue(
-  workInProgress$jscomp$0,
-  props,
-  instance$jscomp$0,
-  renderLanes
-) {
-  var queue = workInProgress$jscomp$0.updateQueue;
-  hasForceUpdate = !1;
-  var firstBaseUpdate = queue.firstBaseUpdate,
-    lastBaseUpdate = queue.lastBaseUpdate,
-    pendingQueue = queue.shared.pending;
-  if (null !== pendingQueue) {
-    queue.shared.pending = null;
-    var lastPendingUpdate = pendingQueue,
-      firstPendingUpdate = lastPendingUpdate.next;
-    lastPendingUpdate.next = null;
-    null === lastBaseUpdate
-      ? (firstBaseUpdate = firstPendingUpdate)
-      : (lastBaseUpdate.next = firstPendingUpdate);
-    lastBaseUpdate = lastPendingUpdate;
-    var current = workInProgress$jscomp$0.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      (pendingQueue = current.lastBaseUpdate),
-      pendingQueue !== lastBaseUpdate &&
-        (null === pendingQueue
-          ? (current.firstBaseUpdate = firstPendingUpdate)
-          : (pendingQueue.next = firstPendingUpdate),
-        (current.lastBaseUpdate = lastPendingUpdate)));
-  }
-  if (null !== firstBaseUpdate) {
-    var newState = queue.baseState;
-    lastBaseUpdate = 0;
-    current = firstPendingUpdate = lastPendingUpdate = null;
-    pendingQueue = firstBaseUpdate;
-    do {
-      var updateLane = pendingQueue.lane & -1073741825,
-        isHiddenUpdate = updateLane !== pendingQueue.lane;
-      if (
-        isHiddenUpdate
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes & updateLane) === updateLane
-      ) {
-        null !== current &&
-          (current = current.next =
-            {
-              lane: 0,
-              tag: pendingQueue.tag,
-              payload: pendingQueue.payload,
-              callback: null,
-              next: null
-            });
-        a: {
-          var workInProgress = workInProgress$jscomp$0,
-            update = pendingQueue;
-          updateLane = props;
-          var instance = instance$jscomp$0;
-          switch (update.tag) {
-            case 1:
-              workInProgress = update.payload;
-              if ("function" === typeof workInProgress) {
-                newState = workInProgress.call(instance, newState, updateLane);
-                break a;
-              }
-              newState = workInProgress;
-              break a;
-            case 3:
-              workInProgress.flags = (workInProgress.flags & -65537) | 128;
-            case 0:
-              workInProgress = update.payload;
-              updateLane =
-                "function" === typeof workInProgress
-                  ? workInProgress.call(instance, newState, updateLane)
-                  : workInProgress;
-              if (null === updateLane || void 0 === updateLane) break a;
-              newState = assign({}, newState, updateLane);
-              break a;
-            case 2:
-              hasForceUpdate = !0;
-          }
-        }
-        updateLane = pendingQueue.callback;
-        null !== updateLane &&
-          ((workInProgress$jscomp$0.flags |= 64),
-          isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192),
-          (isHiddenUpdate = queue.callbacks),
-          null === isHiddenUpdate
-            ? (queue.callbacks = [updateLane])
-            : isHiddenUpdate.push(updateLane));
-      } else
-        (isHiddenUpdate = {
-          lane: updateLane,
-          tag: pendingQueue.tag,
-          payload: pendingQueue.payload,
-          callback: pendingQueue.callback,
-          next: null
-        }),
-          null === current
-            ? ((firstPendingUpdate = current = isHiddenUpdate),
-              (lastPendingUpdate = newState))
-            : (current = current.next = isHiddenUpdate),
-          (lastBaseUpdate |= updateLane);
-      pendingQueue = pendingQueue.next;
-      if (null === pendingQueue)
-        if (((pendingQueue = queue.shared.pending), null === pendingQueue))
-          break;
-        else
-          (isHiddenUpdate = pendingQueue),
-            (pendingQueue = isHiddenUpdate.next),
-            (isHiddenUpdate.next = null),
-            (queue.lastBaseUpdate = isHiddenUpdate),
-            (queue.shared.pending = null);
-    } while (1);
-    null === current && (lastPendingUpdate = newState);
-    queue.baseState = lastPendingUpdate;
-    queue.firstBaseUpdate = firstPendingUpdate;
-    queue.lastBaseUpdate = current;
-    null === firstBaseUpdate && (queue.shared.lanes = 0);
-    workInProgressRootSkippedLanes |= lastBaseUpdate;
-    workInProgress$jscomp$0.lanes = lastBaseUpdate;
-    workInProgress$jscomp$0.memoizedState = newState;
-  }
-}
-function callCallback(callback, context) {
-  if ("function" !== typeof callback)
-    throw Error(formatProdErrorMessage(191, callback));
-  callback.call(context);
-}
-function commitCallbacks(updateQueue, context) {
-  var callbacks = updateQueue.callbacks;
-  if (null !== callbacks)
-    for (
-      updateQueue.callbacks = null, updateQueue = 0;
-      updateQueue < callbacks.length;
-      updateQueue++
-    )
-      callCallback(callbacks[updateQueue], context);
-}
-var SuspenseException = Error(formatProdErrorMessage(460));
-function isThenableResolved(thenable) {
-  thenable = thenable.status;
-  return "fulfilled" === thenable || "rejected" === thenable;
+function createRootErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  lane.payload = { element: null };
+  var error = errorInfo.value;
+  lane.callback = function () {
+    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
+    logCapturedError(fiber, errorInfo);
+  };
+  return lane;
 }
-function noop() {}
-function trackUsedThenable(thenableState, thenable, index) {
-  index = thenableState[index];
-  void 0 === index
-    ? thenableState.push(thenable)
-    : index !== thenable && (thenable.then(noop, noop), (thenable = index));
-  switch (thenable.status) {
-    case "fulfilled":
-      return thenable.value;
-    case "rejected":
-      throw thenable.reason;
-    default:
-      "string" === typeof thenable.status
-        ? thenable.then(noop, noop)
-        : ((thenableState = thenable),
-          (thenableState.status = "pending"),
-          thenableState.then(
-            function (fulfilledValue) {
-              if ("pending" === thenable.status) {
-                var fulfilledThenable = thenable;
-                fulfilledThenable.status = "fulfilled";
-                fulfilledThenable.value = fulfilledValue;
-              }
-            },
-            function (error) {
-              if ("pending" === thenable.status) {
-                var rejectedThenable = thenable;
-                rejectedThenable.status = "rejected";
-                rejectedThenable.reason = error;
-              }
-            }
-          ));
-      switch (thenable.status) {
-        case "fulfilled":
-          return thenable.value;
-        case "rejected":
-          throw thenable.reason;
-      }
-      suspendedThenable = thenable;
-      throw SuspenseException;
+function createClassErrorUpdate(fiber, errorInfo, lane) {
+  lane = createUpdate(lane);
+  lane.tag = 3;
+  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+  if ("function" === typeof getDerivedStateFromError) {
+    var error = errorInfo.value;
+    lane.payload = function () {
+      return getDerivedStateFromError(error);
+    };
+    lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+    };
   }
+  var inst = fiber.stateNode;
+  null !== inst &&
+    "function" === typeof inst.componentDidCatch &&
+    (lane.callback = function () {
+      logCapturedError(fiber, errorInfo);
+      "function" !== typeof getDerivedStateFromError &&
+        (null === legacyErrorBoundariesThatAlreadyFailed
+          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
+          : legacyErrorBoundariesThatAlreadyFailed.add(this));
+      var stack = errorInfo.stack;
+      this.componentDidCatch(errorInfo.value, {
+        componentStack: null !== stack ? stack : ""
+      });
+    });
+  return lane;
 }
-var suspendedThenable = null,
-  thenableState$1 = null,
-  thenableIndexCounter$1 = 0;
-function unwrapThenable(thenable) {
-  var index = thenableIndexCounter$1;
-  thenableIndexCounter$1 += 1;
-  null === thenableState$1 && (thenableState$1 = []);
-  return trackUsedThenable(thenableState$1, thenable, index);
+function markSuspenseBoundaryShouldCapture(
+  suspenseBoundary,
+  returnFiber,
+  sourceFiber,
+  root,
+  rootRenderLanes
+) {
+  if (0 === (suspenseBoundary.mode & 1))
+    return (
+      suspenseBoundary === returnFiber
+        ? (suspenseBoundary.flags |= 65536)
+        : ((suspenseBoundary.flags |= 128),
+          (sourceFiber.flags |= 131072),
+          (sourceFiber.flags &= -52805),
+          1 === sourceFiber.tag &&
+            (null === sourceFiber.alternate
+              ? (sourceFiber.tag = 17)
+              : ((returnFiber = createUpdate(2)),
+                (returnFiber.tag = 2),
+                enqueueUpdate(sourceFiber, returnFiber, 2))),
+          (sourceFiber.lanes |= 2)),
+      suspenseBoundary
+    );
+  suspenseBoundary.flags |= 65536;
+  suspenseBoundary.lanes = rootRenderLanes;
+  return suspenseBoundary;
 }
-function coerceRef(returnFiber, current, element) {
-  returnFiber = element.ref;
-  if (
-    null !== returnFiber &&
-    "function" !== typeof returnFiber &&
-    "object" !== typeof returnFiber
-  ) {
-    if (element._owner) {
-      element = element._owner;
-      if (element) {
-        if (1 !== element.tag) throw Error(formatProdErrorMessage(309));
-        var inst = element.stateNode;
-      }
-      if (!inst) throw Error(formatProdErrorMessage(147, returnFiber));
-      var resolvedInst = inst,
-        stringRef = "" + returnFiber;
-      if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
-      )
-        return current.ref;
-      current = function (value) {
-        var refs = resolvedInst.refs;
-        null === value ? delete refs[stringRef] : (refs[stringRef] = value);
-      };
-      current._stringRef = stringRef;
-      return current;
-    }
-    if ("string" !== typeof returnFiber)
-      throw Error(formatProdErrorMessage(284));
-    if (!element._owner) throw Error(formatProdErrorMessage(290, returnFiber));
+function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
+  if (enableTransitionTracing && null !== pendingTransitions) {
+    var transitionStart = pendingTransitions.transitionStart,
+      onTransitionStart = callbacks.onTransitionStart;
+    null !== transitionStart &&
+      null != onTransitionStart &&
+      transitionStart.forEach(function (transition) {
+        return onTransitionStart(transition.name, transition.startTime);
+      });
+    transitionStart = pendingTransitions.markerProgress;
+    var onMarkerProgress = callbacks.onMarkerProgress;
+    null != onMarkerProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (markerInstance, markerName) {
+        if (null !== markerInstance.transitions) {
+          var pending =
+            null !== markerInstance.pendingBoundaries
+              ? Array.from(markerInstance.pendingBoundaries.values())
+              : [];
+          markerInstance.transitions.forEach(function (transition) {
+            onMarkerProgress(
+              transition.name,
+              markerName,
+              transition.startTime,
+              endTime,
+              pending
+            );
+          });
+        }
+      });
+    transitionStart = pendingTransitions.markerComplete;
+    var onMarkerComplete = callbacks.onMarkerComplete;
+    null !== transitionStart &&
+      null != onMarkerComplete &&
+      transitionStart.forEach(function (transitions, markerName) {
+        transitions.forEach(function (transition) {
+          onMarkerComplete(
+            transition.name,
+            markerName,
+            transition.startTime,
+            endTime
+          );
+        });
+      });
+    transitionStart = pendingTransitions.markerIncomplete;
+    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
+    null != onMarkerIncomplete &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (_ref, markerName) {
+        var aborts = _ref.aborts;
+        _ref.transitions.forEach(function (transition) {
+          var filteredAborts = [];
+          aborts.forEach(function (abort) {
+            switch (abort.reason) {
+              case "marker":
+                filteredAborts.push({
+                  type: "marker",
+                  name: abort.name,
+                  endTime: endTime
+                });
+                break;
+              case "suspense":
+                filteredAborts.push({
+                  type: "suspense",
+                  name: abort.name,
+                  endTime: endTime
+                });
+            }
+          });
+          0 < filteredAborts.length &&
+            onMarkerIncomplete(
+              transition.name,
+              markerName,
+              transition.startTime,
+              filteredAborts
+            );
+        });
+      });
+    transitionStart = pendingTransitions.transitionProgress;
+    var onTransitionProgress = callbacks.onTransitionProgress;
+    null != onTransitionProgress &&
+      null !== transitionStart &&
+      transitionStart.forEach(function (pending, transition) {
+        onTransitionProgress(
+          transition.name,
+          transition.startTime,
+          endTime,
+          Array.from(pending.values())
+        );
+      });
+    pendingTransitions = pendingTransitions.transitionComplete;
+    var onTransitionComplete = callbacks.onTransitionComplete;
+    null !== pendingTransitions &&
+      null != onTransitionComplete &&
+      pendingTransitions.forEach(function (transition) {
+        return onTransitionComplete(
+          transition.name,
+          transition.startTime,
+          endTime
+        );
+      });
   }
-  return returnFiber;
 }
-function throwOnInvalidObjectType(returnFiber, newChild) {
-  returnFiber = Object.prototype.toString.call(newChild);
-  throw Error(
-    formatProdErrorMessage(
-      31,
-      "[object Object]" === returnFiber
-        ? "object with keys {" + Object.keys(newChild).join(", ") + "}"
-        : returnFiber
-    )
-  );
+var markerInstanceStack = createCursor(null);
+function pushRootMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    var transitions = workInProgressTransitions,
+      root$61 = workInProgress.stateNode;
+    null !== transitions &&
+      transitions.forEach(function (transition) {
+        if (!root$61.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: 0,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root$61.incompleteTransitions.set(transition, markerInstance);
+        }
+      });
+    var markerInstances = [];
+    root$61.incompleteTransitions.forEach(function (markerInstance) {
+      markerInstances.push(markerInstance);
+    });
+    push(markerInstanceStack, markerInstances);
+  }
 }
-function resolveLazy(lazyType) {
-  var init = lazyType._init;
-  return init(lazyType._payload);
+function pushMarkerInstance(workInProgress, markerInstance) {
+  enableTransitionTracing &&
+    (null === markerInstanceStack.current
+      ? push(markerInstanceStack, [markerInstance])
+      : push(
+          markerInstanceStack,
+          markerInstanceStack.current.concat(markerInstance)
+        ));
 }
-function createChildReconciler(shouldTrackSideEffects) {
-  function deleteChild(returnFiber, childToDelete) {
-    if (shouldTrackSideEffects) {
-      var deletions = returnFiber.deletions;
-      null === deletions
-        ? ((returnFiber.deletions = [childToDelete]), (returnFiber.flags |= 16))
-        : deletions.push(childToDelete);
-    }
-  }
-  function deleteRemainingChildren(returnFiber, currentFirstChild) {
-    if (!shouldTrackSideEffects) return null;
-    for (; null !== currentFirstChild; )
-      deleteChild(returnFiber, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return null;
-  }
-  function mapRemainingChildren(returnFiber, currentFirstChild) {
-    for (returnFiber = new Map(); null !== currentFirstChild; )
-      null !== currentFirstChild.key
-        ? returnFiber.set(currentFirstChild.key, currentFirstChild)
-        : returnFiber.set(currentFirstChild.index, currentFirstChild),
-        (currentFirstChild = currentFirstChild.sibling);
-    return returnFiber;
-  }
-  function useFiber(fiber, pendingProps) {
-    fiber = createWorkInProgress(fiber, pendingProps);
-    fiber.index = 0;
-    fiber.sibling = null;
-    return fiber;
-  }
-  function placeChild(newFiber, lastPlacedIndex, newIndex) {
-    newFiber.index = newIndex;
-    if (!shouldTrackSideEffects)
-      return (newFiber.flags |= 1048576), lastPlacedIndex;
-    newIndex = newFiber.alternate;
-    if (null !== newIndex)
-      return (
-        (newIndex = newIndex.index),
-        newIndex < lastPlacedIndex
-          ? ((newFiber.flags |= 16777218), lastPlacedIndex)
-          : newIndex
-      );
-    newFiber.flags |= 16777218;
-    return lastPlacedIndex;
-  }
-  function placeSingleChild(newFiber) {
-    shouldTrackSideEffects &&
-      null === newFiber.alternate &&
-      (newFiber.flags |= 16777218);
-    return newFiber;
-  }
-  function updateTextNode(returnFiber, current, textContent, lanes) {
-    if (null === current || 6 !== current.tag)
-      return (
-        (current = createFiberFromText(textContent, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, textContent);
-    current.return = returnFiber;
-    return current;
-  }
-  function updateElement(returnFiber, current, element, lanes) {
-    var elementType = element.type;
-    if (elementType === REACT_FRAGMENT_TYPE)
-      return updateFragment(
-        returnFiber,
-        current,
-        element.props.children,
-        lanes,
-        element.key
-      );
-    if (
-      null !== current &&
-      (current.elementType === elementType ||
-        ("object" === typeof elementType &&
-          null !== elementType &&
-          elementType.$$typeof === REACT_LAZY_TYPE &&
-          resolveLazy(elementType) === current.type))
-    )
-      return (
-        (lanes = useFiber(current, element.props)),
-        (lanes.ref = coerceRef(returnFiber, current, element)),
-        (lanes.return = returnFiber),
-        lanes
-      );
-    lanes = createFiberFromTypeAndProps(
-      element.type,
-      element.key,
-      element.props,
-      null,
-      returnFiber.mode,
-      lanes
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
+  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
+  didReceiveUpdate = !1;
+function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+  workInProgress.child =
+    null === current
+      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
+      : reconcileChildFibers(
+          workInProgress,
+          current.child,
+          nextChildren,
+          renderLanes
+        );
+}
+function updateForwardRef(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  Component = Component.render;
+  var ref = workInProgress.ref;
+  prepareToReadContext(workInProgress, renderLanes);
+  nextProps = renderWithHooks(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    ref,
+    renderLanes
+  );
+  Component = checkDidRenderIdHook();
+  if (null !== current && !didReceiveUpdate)
+    return (
+      bailoutHooks(current, workInProgress, renderLanes),
+      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
     );
-    lanes.ref = coerceRef(returnFiber, current, element);
-    lanes.return = returnFiber;
-    return lanes;
-  }
-  function updatePortal(returnFiber, current, portal, lanes) {
+  isHydrating && Component && pushMaterializedTreeId(workInProgress);
+  workInProgress.flags |= 1;
+  reconcileChildren(current, workInProgress, nextProps, renderLanes);
+  return workInProgress.child;
+}
+function updateMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null === current) {
+    var type = Component.type;
     if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
+      "function" === typeof type &&
+      !shouldConstruct(type) &&
+      void 0 === type.defaultProps &&
+      null === Component.compare &&
+      void 0 === Component.defaultProps
     )
       return (
-        (current = createFiberFromPortal(portal, returnFiber.mode, lanes)),
-        (current.return = returnFiber),
-        current
+        (workInProgress.tag = 15),
+        (workInProgress.type = type),
+        updateSimpleMemoComponent(
+          current,
+          workInProgress,
+          type,
+          nextProps,
+          renderLanes
+        )
       );
-    current = useFiber(current, portal.children || []);
-    current.return = returnFiber;
-    return current;
+    current = createFiberFromTypeAndProps(
+      Component.type,
+      null,
+      nextProps,
+      workInProgress,
+      workInProgress.mode,
+      renderLanes
+    );
+    current.ref = workInProgress.ref;
+    current.return = workInProgress;
+    return (workInProgress.child = current);
   }
-  function updateFragment(returnFiber, current, fragment, lanes, key) {
-    if (null === current || 7 !== current.tag)
-      return (
-        (current = createFiberFromFragment(
-          fragment,
-          returnFiber.mode,
-          lanes,
-          key
-        )),
-        (current.return = returnFiber),
-        current
-      );
-    current = useFiber(current, fragment);
-    current.return = returnFiber;
-    return current;
+  type = current.child;
+  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+    var prevProps = type.memoizedProps;
+    Component = Component.compare;
+    Component = null !== Component ? Component : shallowEqual;
+    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
   }
-  function createChild(returnFiber, newChild, lanes) {
+  workInProgress.flags |= 1;
+  current = createWorkInProgress(type, nextProps);
+  current.ref = workInProgress.ref;
+  current.return = workInProgress;
+  return (workInProgress.child = current);
+}
+function updateSimpleMemoComponent(
+  current,
+  workInProgress,
+  Component,
+  nextProps,
+  renderLanes
+) {
+  if (null !== current) {
+    var prevProps = current.memoizedProps;
     if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
+      shallowEqual(prevProps, nextProps) &&
+      current.ref === workInProgress.ref
     )
-      return (
-        (newChild = createFiberFromText(
-          "" + newChild,
-          returnFiber.mode,
-          lanes
-        )),
-        (newChild.return = returnFiber),
-        newChild
-      );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (lanes = createFiberFromTypeAndProps(
-              newChild.type,
-              newChild.key,
-              newChild.props,
-              null,
-              returnFiber.mode,
-              lanes
-            )),
-            (lanes.ref = coerceRef(returnFiber, null, newChild)),
-            (lanes.return = returnFiber),
-            lanes
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (newChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (newChild.return = returnFiber),
-            newChild
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return createChild(returnFiber, init(newChild._payload), lanes);
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (newChild = createFiberFromFragment(
-            newChild,
-            returnFiber.mode,
-            lanes,
-            null
-          )),
-          (newChild.return = returnFiber),
-          newChild
-        );
-      if ("function" === typeof newChild.then)
-        return createChild(returnFiber, unwrapThenable(newChild), lanes);
       if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
+        ((didReceiveUpdate = !1),
+        (workInProgress.pendingProps = nextProps = prevProps),
+        checkScheduledUpdateOrContext(current, renderLanes))
       )
-        return createChild(
-          returnFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
+        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
+      else
+        return (
+          (workInProgress.lanes = current.lanes),
+          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
         );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
   }
-  function updateSlot(returnFiber, oldFiber, newChild, lanes) {
-    var key = null !== oldFiber ? oldFiber.key : null;
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return null !== key
-        ? null
-        : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return newChild.key === key
-            ? updateElement(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_PORTAL_TYPE:
-          return newChild.key === key
-            ? updatePortal(returnFiber, oldFiber, newChild, lanes)
-            : null;
-        case REACT_LAZY_TYPE:
-          return (
-            (key = newChild._init),
-            updateSlot(returnFiber, oldFiber, key(newChild._payload), lanes)
-          );
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return null !== key
-          ? null
-          : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
-      if ("function" === typeof newChild.then)
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return updateSlot(
-          returnFiber,
-          oldFiber,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
-  }
-  function updateFromMap(
-    existingChildren,
-    returnFiber,
-    newIdx,
-    newChild,
-    lanes
-  ) {
-    if (
-      ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-    )
-      return (
-        (existingChildren = existingChildren.get(newIdx) || null),
-        updateTextNode(returnFiber, existingChildren, "" + newChild, lanes)
-      );
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updateElement(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_PORTAL_TYPE:
-          return (
-            (existingChildren =
-              existingChildren.get(
-                null === newChild.key ? newIdx : newChild.key
-              ) || null),
-            updatePortal(returnFiber, existingChildren, newChild, lanes)
-          );
-        case REACT_LAZY_TYPE:
-          var init = newChild._init;
-          return updateFromMap(
-            existingChildren,
-            returnFiber,
-            newIdx,
-            init(newChild._payload),
-            lanes
-          );
-      }
-      if (isArrayImpl(newChild) || getIteratorFn(newChild))
-        return (
-          (existingChildren = existingChildren.get(newIdx) || null),
-          updateFragment(returnFiber, existingChildren, newChild, lanes, null)
-        );
-      if ("function" === typeof newChild.then)
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return updateFromMap(
-          existingChildren,
-          returnFiber,
-          newIdx,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return null;
-  }
-  function reconcileChildrenArray(
-    returnFiber,
-    currentFirstChild,
-    newChildren,
-    lanes
+  return updateFunctionComponent(
+    current,
+    workInProgress,
+    Component,
+    nextProps,
+    renderLanes
+  );
+}
+function updateOffscreenComponent(current, workInProgress, renderLanes) {
+  var nextProps = workInProgress.pendingProps,
+    nextChildren = nextProps.children,
+    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
+    prevState = null !== current ? current.memoizedState : null;
+  markRef$1(current, workInProgress);
+  if (
+    "hidden" === nextProps.mode ||
+    "unstable-defer-without-hiding" === nextProps.mode ||
+    nextIsDetached
   ) {
-    for (
-      var resultingFirstChild = null,
-        previousNewFiber = null,
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null;
-      null !== oldFiber && newIdx < newChildren.length;
-      newIdx++
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(
-        returnFiber,
-        oldFiber,
-        newChildren[newIdx],
-        lanes
+    if (0 !== (workInProgress.flags & 128)) {
+      nextChildren =
+        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+      if (null !== current) {
+        prevState = workInProgress.child = current.child;
+        for (nextProps = 0; null !== prevState; )
+          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
+            (prevState = prevState.sibling);
+        workInProgress.childLanes = nextProps & ~nextChildren;
+      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
+      return deferHiddenOffscreenComponent(
+        current,
+        workInProgress,
+        nextChildren,
+        renderLanes
       );
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
-      }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (resultingFirstChild = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
     }
-    if (newIdx === newChildren.length)
+    if (0 === (workInProgress.mode & 1))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current && pushTransition(workInProgress, null, null),
+        reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else if (0 !== (renderLanes & 1073741824))
+      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
+        null !== current &&
+          pushTransition(
+            workInProgress,
+            null !== prevState ? prevState.cachePool : null,
+            null
+          ),
+        null !== prevState
+          ? pushHiddenContext(workInProgress, prevState)
+          : reuseHiddenContextOnStack(),
+        pushOffscreenSuspenseHandler(workInProgress);
+    else
       return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        resultingFirstChild
+        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
+        deferHiddenOffscreenComponent(
+          current,
+          workInProgress,
+          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
+          renderLanes
+        )
       );
-    if (null === oldFiber) {
-      for (; newIdx < newChildren.length; newIdx++)
-        (oldFiber = createChild(returnFiber, newChildren[newIdx], lanes)),
-          null !== oldFiber &&
-            ((currentFirstChild = placeChild(
-              oldFiber,
-              currentFirstChild,
-              newIdx
-            )),
-            null === previousNewFiber
-              ? (resultingFirstChild = oldFiber)
-              : (previousNewFiber.sibling = oldFiber),
-            (previousNewFiber = oldFiber));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return resultingFirstChild;
-    }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      newIdx < newChildren.length;
-      newIdx++
-    )
-      (nextOldFiber = updateFromMap(
-        oldFiber,
-        returnFiber,
-        newIdx,
-        newChildren[newIdx],
-        lanes
-      )),
-        null !== nextOldFiber &&
-          (shouldTrackSideEffects &&
-            null !== nextOldFiber.alternate &&
-            oldFiber.delete(
-              null === nextOldFiber.key ? newIdx : nextOldFiber.key
-            ),
-          (currentFirstChild = placeChild(
-            nextOldFiber,
-            currentFirstChild,
-            newIdx
-          )),
-          null === previousNewFiber
-            ? (resultingFirstChild = nextOldFiber)
-            : (previousNewFiber.sibling = nextOldFiber),
-          (previousNewFiber = nextOldFiber));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return resultingFirstChild;
-  }
-  function reconcileChildrenIterator(
-    returnFiber,
-    currentFirstChild,
-    newChildrenIterable,
-    lanes
-  ) {
-    var iteratorFn = getIteratorFn(newChildrenIterable);
-    if ("function" !== typeof iteratorFn)
-      throw Error(formatProdErrorMessage(150));
-    newChildrenIterable = iteratorFn.call(newChildrenIterable);
-    if (null == newChildrenIterable) throw Error(formatProdErrorMessage(151));
-    for (
-      var previousNewFiber = (iteratorFn = null),
-        oldFiber = currentFirstChild,
-        newIdx = (currentFirstChild = 0),
-        nextOldFiber = null,
-        step = newChildrenIterable.next();
-      null !== oldFiber && !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    ) {
-      oldFiber.index > newIdx
-        ? ((nextOldFiber = oldFiber), (oldFiber = null))
-        : (nextOldFiber = oldFiber.sibling);
-      var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
-      if (null === newFiber) {
-        null === oldFiber && (oldFiber = nextOldFiber);
-        break;
-      }
-      shouldTrackSideEffects &&
-        oldFiber &&
-        null === newFiber.alternate &&
-        deleteChild(returnFiber, oldFiber);
-      currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
-      null === previousNewFiber
-        ? (iteratorFn = newFiber)
-        : (previousNewFiber.sibling = newFiber);
-      previousNewFiber = newFiber;
-      oldFiber = nextOldFiber;
-    }
-    if (step.done)
-      return (
-        deleteRemainingChildren(returnFiber, oldFiber),
-        isHydrating && pushTreeFork(returnFiber, newIdx),
-        iteratorFn
-      );
-    if (null === oldFiber) {
-      for (; !step.done; newIdx++, step = newChildrenIterable.next())
-        (step = createChild(returnFiber, step.value, lanes)),
-          null !== step &&
-            ((currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-            null === previousNewFiber
-              ? (iteratorFn = step)
-              : (previousNewFiber.sibling = step),
-            (previousNewFiber = step));
-      isHydrating && pushTreeFork(returnFiber, newIdx);
-      return iteratorFn;
-    }
-    for (
-      oldFiber = mapRemainingChildren(returnFiber, oldFiber);
-      !step.done;
-      newIdx++, step = newChildrenIterable.next()
-    )
-      (step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes)),
-        null !== step &&
-          (shouldTrackSideEffects &&
-            null !== step.alternate &&
-            oldFiber.delete(null === step.key ? newIdx : step.key),
-          (currentFirstChild = placeChild(step, currentFirstChild, newIdx)),
-          null === previousNewFiber
-            ? (iteratorFn = step)
-            : (previousNewFiber.sibling = step),
-          (previousNewFiber = step));
-    shouldTrackSideEffects &&
-      oldFiber.forEach(function (child) {
-        return deleteChild(returnFiber, child);
-      });
-    isHydrating && pushTreeFork(returnFiber, newIdx);
-    return iteratorFn;
-  }
-  function reconcileChildFibersImpl(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    "object" === typeof newChild &&
-      null !== newChild &&
-      newChild.type === REACT_FRAGMENT_TYPE &&
-      null === newChild.key &&
-      (newChild = newChild.props.children);
-    if ("object" === typeof newChild && null !== newChild) {
-      switch (newChild.$$typeof) {
-        case REACT_ELEMENT_TYPE:
-          a: {
-            for (
-              var key = newChild.key, child = currentFirstChild;
-              null !== child;
-
-            ) {
-              if (child.key === key) {
-                key = newChild.type;
-                if (key === REACT_FRAGMENT_TYPE) {
-                  if (7 === child.tag) {
-                    deleteRemainingChildren(returnFiber, child.sibling);
-                    currentFirstChild = useFiber(
-                      child,
-                      newChild.props.children
-                    );
-                    currentFirstChild.return = returnFiber;
-                    returnFiber = currentFirstChild;
-                    break a;
-                  }
-                } else if (
-                  child.elementType === key ||
-                  ("object" === typeof key &&
-                    null !== key &&
-                    key.$$typeof === REACT_LAZY_TYPE &&
-                    resolveLazy(key) === child.type)
-                ) {
-                  deleteRemainingChildren(returnFiber, child.sibling);
-                  currentFirstChild = useFiber(child, newChild.props);
-                  currentFirstChild.ref = coerceRef(
-                    returnFiber,
-                    child,
-                    newChild
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                }
-                deleteRemainingChildren(returnFiber, child);
-                break;
-              } else deleteChild(returnFiber, child);
-              child = child.sibling;
-            }
-            newChild.type === REACT_FRAGMENT_TYPE
-              ? ((currentFirstChild = createFiberFromFragment(
-                  newChild.props.children,
-                  returnFiber.mode,
-                  lanes,
-                  newChild.key
-                )),
-                (currentFirstChild.return = returnFiber),
-                (returnFiber = currentFirstChild))
-              : ((lanes = createFiberFromTypeAndProps(
-                  newChild.type,
-                  newChild.key,
-                  newChild.props,
-                  null,
-                  returnFiber.mode,
-                  lanes
-                )),
-                (lanes.ref = coerceRef(
-                  returnFiber,
-                  currentFirstChild,
-                  newChild
-                )),
-                (lanes.return = returnFiber),
-                (returnFiber = lanes));
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_PORTAL_TYPE:
-          a: {
-            for (child = newChild.key; null !== currentFirstChild; ) {
-              if (currentFirstChild.key === child)
-                if (
-                  4 === currentFirstChild.tag &&
-                  currentFirstChild.stateNode.containerInfo ===
-                    newChild.containerInfo &&
-                  currentFirstChild.stateNode.implementation ===
-                    newChild.implementation
-                ) {
-                  deleteRemainingChildren(
-                    returnFiber,
-                    currentFirstChild.sibling
-                  );
-                  currentFirstChild = useFiber(
-                    currentFirstChild,
-                    newChild.children || []
-                  );
-                  currentFirstChild.return = returnFiber;
-                  returnFiber = currentFirstChild;
-                  break a;
-                } else {
-                  deleteRemainingChildren(returnFiber, currentFirstChild);
-                  break;
-                }
-              else deleteChild(returnFiber, currentFirstChild);
-              currentFirstChild = currentFirstChild.sibling;
-            }
-            currentFirstChild = createFiberFromPortal(
-              newChild,
-              returnFiber.mode,
-              lanes
-            );
-            currentFirstChild.return = returnFiber;
-            returnFiber = currentFirstChild;
-          }
-          return placeSingleChild(returnFiber);
-        case REACT_LAZY_TYPE:
-          return (
-            (child = newChild._init),
-            reconcileChildFibers(
-              returnFiber,
-              currentFirstChild,
-              child(newChild._payload),
-              lanes
-            )
-          );
-      }
-      if (isArrayImpl(newChild))
-        return reconcileChildrenArray(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if (getIteratorFn(newChild))
-        return reconcileChildrenIterator(
-          returnFiber,
-          currentFirstChild,
-          newChild,
-          lanes
-        );
-      if ("function" === typeof newChild.then)
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          unwrapThenable(newChild),
-          lanes
-        );
-      if (
-        newChild.$$typeof === REACT_CONTEXT_TYPE ||
-        newChild.$$typeof === REACT_SERVER_CONTEXT_TYPE
-      )
-        return reconcileChildFibersImpl(
-          returnFiber,
-          currentFirstChild,
-          readContextDuringReconcilation(returnFiber, newChild, lanes),
-          lanes
-        );
-      throwOnInvalidObjectType(returnFiber, newChild);
-    }
-    return ("string" === typeof newChild && "" !== newChild) ||
-      "number" === typeof newChild
-      ? ((newChild = "" + newChild),
-        null !== currentFirstChild && 6 === currentFirstChild.tag
-          ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling),
-            (currentFirstChild = useFiber(currentFirstChild, newChild)),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild))
-          : (deleteRemainingChildren(returnFiber, currentFirstChild),
-            (currentFirstChild = createFiberFromText(
-              newChild,
-              returnFiber.mode,
-              lanes
-            )),
-            (currentFirstChild.return = returnFiber),
-            (returnFiber = currentFirstChild)),
-        placeSingleChild(returnFiber))
-      : deleteRemainingChildren(returnFiber, currentFirstChild);
-  }
-  function reconcileChildFibers(
-    returnFiber,
-    currentFirstChild,
-    newChild,
-    lanes
-  ) {
-    thenableIndexCounter$1 = 0;
-    returnFiber = reconcileChildFibersImpl(
-      returnFiber,
-      currentFirstChild,
-      newChild,
-      lanes
-    );
-    thenableState$1 = null;
-    return returnFiber;
-  }
-  return reconcileChildFibers;
-}
-var reconcileChildFibers = createChildReconciler(!0),
-  mountChildFibers = createChildReconciler(!1),
-  currentTreeHiddenStackCursor = createCursor(null),
-  prevRenderLanesStackCursor = createCursor(0);
-function pushHiddenContext(fiber, context) {
-  fiber = renderLanes;
-  push(prevRenderLanesStackCursor, fiber);
-  push(currentTreeHiddenStackCursor, context);
-  renderLanes = fiber | context.baseLanes;
-}
-function reuseHiddenContextOnStack() {
-  push(prevRenderLanesStackCursor, renderLanes);
-  push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
-}
-function popHiddenContext() {
-  renderLanes = prevRenderLanesStackCursor.current;
-  pop(currentTreeHiddenStackCursor);
-  pop(prevRenderLanesStackCursor);
-}
-var suspenseHandlerStackCursor = createCursor(null),
-  shellBoundary = null;
-function pushPrimaryTreeSuspenseHandler(handler) {
-  var current = handler.alternate;
-  !0 !== handler.pendingProps.unstable_avoidThisFallback ||
-  (null !== current && null === currentTreeHiddenStackCursor.current)
-    ? (push(suspenseHandlerStackCursor, handler),
-      null === shellBoundary &&
-        (null === current || null !== currentTreeHiddenStackCursor.current
-          ? (shellBoundary = handler)
-          : null !== current.memoizedState && (shellBoundary = handler)))
-    : null === shellBoundary
-    ? push(suspenseHandlerStackCursor, handler)
-    : push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
-}
-function pushOffscreenSuspenseHandler(fiber) {
-  if (22 === fiber.tag) {
-    if ((push(suspenseHandlerStackCursor, fiber), null === shellBoundary)) {
-      var current = fiber.alternate;
-      null !== current &&
-        null !== current.memoizedState &&
-        (shellBoundary = fiber);
-    }
-  } else reuseSuspenseHandlerOnStack();
-}
-function reuseSuspenseHandlerOnStack() {
-  push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
-}
-function popSuspenseHandler(fiber) {
-  pop(suspenseHandlerStackCursor);
-  shellBoundary === fiber && (shellBoundary = null);
-}
-var suspenseStackCursor = createCursor(0);
-function findFirstSuspended(row) {
-  for (var node = row; null !== node; ) {
-    if (13 === node.tag) {
-      var state = node.memoizedState;
-      if (
-        null !== state &&
-        ((state = state.dehydrated),
-        null === state || "$?" === state.data || "$!" === state.data)
-      )
-        return node;
-    } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
-      if (0 !== (node.flags & 128)) return node;
-    } else if (null !== node.child) {
-      node.child.return = node;
-      node = node.child;
-      continue;
-    }
-    if (node === row) break;
-    for (; null === node.sibling; ) {
-      if (null === node.return || node.return === row) return null;
-      node = node.return;
-    }
-    node.sibling.return = node.return;
-    node = node.sibling;
-  }
-  return null;
-}
-var workInProgressSources = [];
-function resetWorkInProgressVersions() {
-  for (var i = 0; i < workInProgressSources.length; i++)
-    workInProgressSources[i]._workInProgressVersionPrimary = null;
-  workInProgressSources.length = 0;
-}
-var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
-  renderLanes$1 = 0,
-  currentlyRenderingFiber$1 = null,
-  currentHook = null,
-  workInProgressHook = null,
-  didScheduleRenderPhaseUpdate = !1,
-  didScheduleRenderPhaseUpdateDuringThisPass = !1,
-  shouldDoubleInvokeUserFnsInHooksDEV = !1,
-  localIdCounter = 0,
-  thenableIndexCounter = 0,
-  thenableState = null,
-  globalClientIdCounter = 0;
-function throwInvalidHookError() {
-  throw Error(formatProdErrorMessage(321));
-}
-function areHookInputsEqual(nextDeps, prevDeps) {
-  if (null === prevDeps) return !1;
-  for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
-    if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
-  return !0;
-}
-function renderWithHooks(
-  current,
-  workInProgress,
-  Component,
-  props,
-  secondArg,
-  nextRenderLanes
-) {
-  renderLanes$1 = nextRenderLanes;
-  currentlyRenderingFiber$1 = workInProgress;
-  workInProgress.memoizedState = null;
-  workInProgress.updateQueue = null;
-  workInProgress.lanes = 0;
-  ReactCurrentDispatcher$1.current =
-    null === current || null === current.memoizedState
-      ? HooksDispatcherOnMount
-      : HooksDispatcherOnUpdate;
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  nextRenderLanes = Component(props, secondArg);
-  shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  didScheduleRenderPhaseUpdateDuringThisPass &&
-    (nextRenderLanes = renderWithHooksAgain(
-      workInProgress,
-      Component,
-      props,
-      secondArg
-    ));
-  finishRenderingHooks(current);
-  return nextRenderLanes;
-}
-function finishRenderingHooks(current) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdate = !1;
-  thenableIndexCounter = 0;
-  thenableState = null;
-  if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
-  enableLazyContextPropagation &&
-    null !== current &&
-    !didReceiveUpdate &&
-    ((current = current.dependencies),
-    null !== current &&
-      checkIfContextChanged(current) &&
-      (didReceiveUpdate = !0));
-}
-function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
-  var numberOfReRenders = 0;
-  do {
-    didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
-    thenableIndexCounter = 0;
-    didScheduleRenderPhaseUpdateDuringThisPass = !1;
-    if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
-    numberOfReRenders += 1;
-    workInProgressHook = currentHook = null;
-    workInProgress.updateQueue = null;
-    ReactCurrentDispatcher$1.current = HooksDispatcherOnRerender;
-    var children = Component(props, secondArg);
-  } while (didScheduleRenderPhaseUpdateDuringThisPass);
-  return children;
-}
-function checkDidRenderIdHook() {
-  var didRenderIdHook = 0 !== localIdCounter;
-  localIdCounter = 0;
-  return didRenderIdHook;
-}
-function bailoutHooks(current, workInProgress, lanes) {
-  workInProgress.updateQueue = current.updateQueue;
-  workInProgress.flags &= -2053;
-  current.lanes &= ~lanes;
-}
-function resetHooksOnUnwind() {
-  if (didScheduleRenderPhaseUpdate) {
-    for (var hook = currentlyRenderingFiber$1.memoizedState; null !== hook; ) {
-      var queue = hook.queue;
-      null !== queue && (queue.pending = null);
-      hook = hook.next;
-    }
-    didScheduleRenderPhaseUpdate = !1;
-  }
-  renderLanes$1 = 0;
-  workInProgressHook = currentHook = currentlyRenderingFiber$1 = null;
-  didScheduleRenderPhaseUpdateDuringThisPass = !1;
-  thenableIndexCounter = localIdCounter = 0;
-  thenableState = null;
-}
-function mountWorkInProgressHook() {
-  var hook = {
-    memoizedState: null,
-    baseState: null,
-    baseQueue: null,
-    queue: null,
-    next: null
-  };
-  null === workInProgressHook
-    ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook)
-    : (workInProgressHook = workInProgressHook.next = hook);
-  return workInProgressHook;
-}
-function updateWorkInProgressHook() {
-  if (null === currentHook) {
-    var nextCurrentHook = currentlyRenderingFiber$1.alternate;
-    nextCurrentHook =
-      null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
-  } else nextCurrentHook = currentHook.next;
-  var nextWorkInProgressHook =
-    null === workInProgressHook
-      ? currentlyRenderingFiber$1.memoizedState
-      : workInProgressHook.next;
-  if (null !== nextWorkInProgressHook)
-    (workInProgressHook = nextWorkInProgressHook),
-      (currentHook = nextCurrentHook);
-  else {
-    if (null === nextCurrentHook) {
-      if (null === currentlyRenderingFiber$1.alternate)
-        throw Error(formatProdErrorMessage(467));
-      throw Error(formatProdErrorMessage(310));
-    }
-    currentHook = nextCurrentHook;
-    nextCurrentHook = {
-      memoizedState: currentHook.memoizedState,
-      baseState: currentHook.baseState,
-      baseQueue: currentHook.baseQueue,
-      queue: currentHook.queue,
-      next: null
-    };
-    null === workInProgressHook
-      ? (currentlyRenderingFiber$1.memoizedState = workInProgressHook =
-          nextCurrentHook)
-      : (workInProgressHook = workInProgressHook.next = nextCurrentHook);
-  }
-  return workInProgressHook;
-}
-var createFunctionComponentUpdateQueue;
-createFunctionComponentUpdateQueue = function () {
-  return { lastEffect: null, events: null, stores: null, memoCache: null };
-};
-function use(usable) {
-  if (null !== usable && "object" === typeof usable) {
-    if ("function" === typeof usable.then) {
-      var index$88 = thenableIndexCounter;
-      thenableIndexCounter += 1;
-      null === thenableState && (thenableState = []);
-      usable = trackUsedThenable(thenableState, usable, index$88);
-      null === currentlyRenderingFiber$1.alternate &&
-        (null === workInProgressHook
-          ? null === currentlyRenderingFiber$1.memoizedState
-          : null === workInProgressHook.next) &&
-        (ReactCurrentDispatcher$1.current = HooksDispatcherOnMount);
-      return usable;
-    }
-    if (
-      usable.$$typeof === REACT_CONTEXT_TYPE ||
-      usable.$$typeof === REACT_SERVER_CONTEXT_TYPE
-    )
-      return readContext(usable);
-  }
-  throw Error(formatProdErrorMessage(438, String(usable)));
-}
-function useMemoCache(size) {
-  var memoCache = null,
-    updateQueue = currentlyRenderingFiber$1.updateQueue;
-  null !== updateQueue && (memoCache = updateQueue.memoCache);
-  if (null == memoCache) {
-    var current = currentlyRenderingFiber$1.alternate;
-    null !== current &&
-      ((current = current.updateQueue),
-      null !== current &&
-        ((current = current.memoCache),
-        null != current &&
-          (memoCache = {
-            data: current.data.map(function (array) {
-              return array.slice();
-            }),
-            index: 0
-          })));
-  }
-  null == memoCache && (memoCache = { data: [], index: 0 });
-  null === updateQueue &&
-    ((updateQueue = createFunctionComponentUpdateQueue()),
-    (currentlyRenderingFiber$1.updateQueue = updateQueue));
-  updateQueue.memoCache = memoCache;
-  updateQueue = memoCache.data[memoCache.index];
-  if (void 0 === updateQueue)
-    for (
-      updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0;
-      current < size;
-      current++
-    )
-      updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
-  memoCache.index++;
-  return updateQueue;
-}
-function basicStateReducer(state, action) {
-  return "function" === typeof action ? action(state) : action;
-}
-function updateReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var current = currentHook,
-    baseQueue = current.baseQueue,
-    pendingQueue = queue.pending;
-  if (null !== pendingQueue) {
-    if (null !== baseQueue) {
-      var baseFirst = baseQueue.next;
-      baseQueue.next = pendingQueue.next;
-      pendingQueue.next = baseFirst;
-    }
-    current.baseQueue = baseQueue = pendingQueue;
-    queue.pending = null;
-  }
-  if (null !== baseQueue) {
-    pendingQueue = baseQueue.next;
-    current = current.baseState;
-    var newBaseQueueFirst = (baseFirst = null),
-      newBaseQueueLast = null,
-      update = pendingQueue;
-    do {
-      var updateLane = update.lane & -1073741825;
-      if (
-        updateLane !== update.lane
-          ? (workInProgressRootRenderLanes & updateLane) === updateLane
-          : (renderLanes$1 & updateLane) === updateLane
-      )
-        null !== newBaseQueueLast &&
-          (newBaseQueueLast = newBaseQueueLast.next =
-            {
-              lane: 0,
-              action: update.action,
-              hasEagerState: update.hasEagerState,
-              eagerState: update.eagerState,
-              next: null
-            }),
-          (updateLane = update.action),
-          shouldDoubleInvokeUserFnsInHooksDEV && reducer(current, updateLane),
-          (current = update.hasEagerState
-            ? update.eagerState
-            : reducer(current, updateLane));
-      else {
-        var clone = {
-          lane: updateLane,
-          action: update.action,
-          hasEagerState: update.hasEagerState,
-          eagerState: update.eagerState,
-          next: null
-        };
-        null === newBaseQueueLast
-          ? ((newBaseQueueFirst = newBaseQueueLast = clone),
-            (baseFirst = current))
-          : (newBaseQueueLast = newBaseQueueLast.next = clone);
-        currentlyRenderingFiber$1.lanes |= updateLane;
-        workInProgressRootSkippedLanes |= updateLane;
-      }
-      update = update.next;
-    } while (null !== update && update !== pendingQueue);
-    null === newBaseQueueLast
-      ? (baseFirst = current)
-      : (newBaseQueueLast.next = newBaseQueueFirst);
-    objectIs(current, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = current;
-    hook.baseState = baseFirst;
-    hook.baseQueue = newBaseQueueLast;
-    queue.lastRenderedState = current;
-  }
-  null === baseQueue && (queue.lanes = 0);
-  return [hook.memoizedState, queue.dispatch];
-}
-function rerenderReducer(reducer) {
-  var hook = updateWorkInProgressHook(),
-    queue = hook.queue;
-  if (null === queue) throw Error(formatProdErrorMessage(311));
-  queue.lastRenderedReducer = reducer;
-  var dispatch = queue.dispatch,
-    lastRenderPhaseUpdate = queue.pending,
-    newState = hook.memoizedState;
-  if (null !== lastRenderPhaseUpdate) {
-    queue.pending = null;
-    var update = (lastRenderPhaseUpdate = lastRenderPhaseUpdate.next);
-    do (newState = reducer(newState, update.action)), (update = update.next);
-    while (update !== lastRenderPhaseUpdate);
-    objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
-    hook.memoizedState = newState;
-    null === hook.baseQueue && (hook.baseState = newState);
-    queue.lastRenderedState = newState;
-  }
-  return [newState, dispatch];
-}
-function readFromUnsubscribedMutableSource(root, source, getSnapshot) {
-  var getVersion = source._getVersion;
-  getVersion = getVersion(source._source);
-  var JSCompiler_inline_result = source._workInProgressVersionPrimary;
-  if (null !== JSCompiler_inline_result)
-    root = JSCompiler_inline_result === getVersion;
-  else if (
-    ((root = root.mutableReadLanes), (root = (renderLanes$1 & root) === root))
-  )
-    (source._workInProgressVersionPrimary = getVersion),
-      workInProgressSources.push(source);
-  if (root) return getSnapshot(source._source);
-  workInProgressSources.push(source);
-  throw Error(formatProdErrorMessage(350));
-}
-function useMutableSource(hook, source, getSnapshot, subscribe) {
-  var root = workInProgressRoot;
-  if (null === root) throw Error(formatProdErrorMessage(349));
-  var getVersion = source._getVersion,
-    version = getVersion(source._source),
-    dispatcher = ReactCurrentDispatcher$1.current,
-    _dispatcher$useState = dispatcher.useState(function () {
-      return readFromUnsubscribedMutableSource(root, source, getSnapshot);
-    }),
-    setSnapshot = _dispatcher$useState[1],
-    snapshot = _dispatcher$useState[0];
-  _dispatcher$useState = workInProgressHook;
-  var memoizedState = hook.memoizedState,
-    refs = memoizedState.refs,
-    prevGetSnapshot = refs.getSnapshot,
-    prevSource = memoizedState.source;
-  memoizedState = memoizedState.subscribe;
-  var fiber = currentlyRenderingFiber$1;
-  hook.memoizedState = { refs: refs, source: source, subscribe: subscribe };
-  dispatcher.useEffect(
-    function () {
-      refs.getSnapshot = getSnapshot;
-      refs.setSnapshot = setSnapshot;
-      var maybeNewVersion = getVersion(source._source);
-      objectIs(version, maybeNewVersion) ||
-        ((maybeNewVersion = getSnapshot(source._source)),
-        objectIs(snapshot, maybeNewVersion) ||
-          (setSnapshot(maybeNewVersion),
-          (maybeNewVersion = requestUpdateLane(fiber)),
-          (root.mutableReadLanes |= maybeNewVersion & root.pendingLanes)),
-        markRootEntangled(root, root.mutableReadLanes));
-    },
-    [getSnapshot, source, subscribe]
-  );
-  dispatcher.useEffect(
-    function () {
-      return subscribe(source._source, function () {
-        var latestGetSnapshot = refs.getSnapshot,
-          latestSetSnapshot = refs.setSnapshot;
-        try {
-          latestSetSnapshot(latestGetSnapshot(source._source));
-          var lane = requestUpdateLane(fiber);
-          root.mutableReadLanes |= lane & root.pendingLanes;
-        } catch (error) {
-          latestSetSnapshot(function () {
-            throw error;
-          });
-        }
-      });
-    },
-    [source, subscribe]
-  );
-  (objectIs(prevGetSnapshot, getSnapshot) &&
-    objectIs(prevSource, source) &&
-    objectIs(memoizedState, subscribe)) ||
-    ((hook = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: basicStateReducer,
-      lastRenderedState: snapshot
-    }),
-    (hook.dispatch = setSnapshot =
-      dispatchSetState.bind(null, currentlyRenderingFiber$1, hook)),
-    (_dispatcher$useState.queue = hook),
-    (_dispatcher$useState.baseQueue = null),
-    (snapshot = readFromUnsubscribedMutableSource(root, source, getSnapshot)),
-    (_dispatcher$useState.memoizedState = _dispatcher$useState.baseState =
-      snapshot));
-  return snapshot;
-}
-function updateMutableSource(source, getSnapshot, subscribe) {
-  var hook = updateWorkInProgressHook();
-  return useMutableSource(hook, source, getSnapshot, subscribe);
-}
-function updateSyncExternalStore(subscribe, getSnapshot) {
-  var fiber = currentlyRenderingFiber$1,
-    hook = updateWorkInProgressHook(),
-    nextSnapshot = getSnapshot(),
-    snapshotChanged = !objectIs(
-      (currentHook || hook).memoizedState,
-      nextSnapshot
-    );
-  snapshotChanged &&
-    ((hook.memoizedState = nextSnapshot), (didReceiveUpdate = !0));
-  hook = hook.queue;
-  updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
-    subscribe
-  ]);
-  if (
-    hook.getSnapshot !== getSnapshot ||
-    snapshotChanged ||
-    (null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1)
-  ) {
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot),
-      void 0,
-      null
-    );
-    subscribe = workInProgressRoot;
-    if (null === subscribe) throw Error(formatProdErrorMessage(349));
-    includesBlockingLane(subscribe, renderLanes$1) ||
-      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
-  }
-  return nextSnapshot;
-}
-function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
-  fiber.flags |= 16384;
-  fiber = { getSnapshot: getSnapshot, value: renderedSnapshot };
-  getSnapshot = currentlyRenderingFiber$1.updateQueue;
-  null === getSnapshot
-    ? ((getSnapshot = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = getSnapshot),
-      (getSnapshot.stores = [fiber]))
-    : ((renderedSnapshot = getSnapshot.stores),
-      null === renderedSnapshot
-        ? (getSnapshot.stores = [fiber])
-        : renderedSnapshot.push(fiber));
-}
-function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
-  inst.value = nextSnapshot;
-  inst.getSnapshot = getSnapshot;
-  checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
-}
-function subscribeToStore(fiber, inst, subscribe) {
-  return subscribe(function () {
-    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
-  });
-}
-function checkIfSnapshotChanged(inst) {
-  var latestGetSnapshot = inst.getSnapshot;
-  inst = inst.value;
-  try {
-    var nextValue = latestGetSnapshot();
-    return !objectIs(inst, nextValue);
-  } catch (error) {
-    return !0;
-  }
-}
-function forceStoreRerender(fiber) {
-  var root = enqueueConcurrentRenderForLane(fiber, 2);
-  null !== root && scheduleUpdateOnFiber(root, fiber, 2, -1);
-}
-function mountState(initialState) {
-  var hook = mountWorkInProgressHook();
-  "function" === typeof initialState && (initialState = initialState());
-  hook.memoizedState = hook.baseState = initialState;
-  initialState = {
-    pending: null,
-    lanes: 0,
-    dispatch: null,
-    lastRenderedReducer: basicStateReducer,
-    lastRenderedState: initialState
-  };
-  hook.queue = initialState;
-  initialState = initialState.dispatch = dispatchSetState.bind(
-    null,
-    currentlyRenderingFiber$1,
-    initialState
-  );
-  return [hook.memoizedState, initialState];
-}
-function pushEffect(tag, create, destroy, deps) {
-  tag = { tag: tag, create: create, destroy: destroy, deps: deps, next: null };
-  create = currentlyRenderingFiber$1.updateQueue;
-  null === create
-    ? ((create = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = create),
-      (create.lastEffect = tag.next = tag))
-    : ((destroy = create.lastEffect),
-      null === destroy
-        ? (create.lastEffect = tag.next = tag)
-        : ((deps = destroy.next),
-          (destroy.next = tag),
-          (tag.next = deps),
-          (create.lastEffect = tag)));
-  return tag;
-}
-function updateRef() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = mountWorkInProgressHook();
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(
-    1 | hookFlags,
-    create,
-    void 0,
-    void 0 === deps ? null : deps
-  );
-}
-function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var destroy = void 0;
-  if (null !== currentHook) {
-    var prevEffect = currentHook.memoizedState;
-    destroy = prevEffect.destroy;
-    if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
-      hook.memoizedState = pushEffect(hookFlags, create, destroy, deps);
-      return;
-    }
-  }
-  currentlyRenderingFiber$1.flags |= fiberFlags;
-  hook.memoizedState = pushEffect(1 | hookFlags, create, destroy, deps);
-}
-function mountEffect(create, deps) {
-  mountEffectImpl(8390656, 8, create, deps);
-}
-function updateEffect(create, deps) {
-  updateEffectImpl(2048, 8, create, deps);
-}
-function useEffectEventImpl(payload) {
-  currentlyRenderingFiber$1.flags |= 4;
-  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
-  if (null === componentUpdateQueue)
-    (componentUpdateQueue = createFunctionComponentUpdateQueue()),
-      (currentlyRenderingFiber$1.updateQueue = componentUpdateQueue),
-      (componentUpdateQueue.events = [payload]);
-  else {
-    var events = componentUpdateQueue.events;
-    null === events
-      ? (componentUpdateQueue.events = [payload])
-      : events.push(payload);
-  }
-}
-function updateEvent(callback) {
-  var ref = updateWorkInProgressHook().memoizedState;
-  useEffectEventImpl({ ref: ref, nextImpl: callback });
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
-}
-function updateInsertionEffect(create, deps) {
-  return updateEffectImpl(4, 2, create, deps);
-}
-function updateLayoutEffect(create, deps) {
-  return updateEffectImpl(4, 4, create, deps);
-}
-function imperativeHandleEffect(create, ref) {
-  if ("function" === typeof ref)
-    return (
-      (create = create()),
-      ref(create),
-      function () {
-        ref(null);
-      }
-    );
-  if (null !== ref && void 0 !== ref)
-    return (
-      (create = create()),
-      (ref.current = create),
-      function () {
-        ref.current = null;
-      }
-    );
-}
-function updateImperativeHandle(ref, create, deps) {
-  deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-  updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
-}
-function mountDebugValue() {}
-function updateCallback(callback, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  hook.memoizedState = [callback, deps];
-  return callback;
-}
-function updateMemo(nextCreate, deps) {
-  var hook = updateWorkInProgressHook();
-  deps = void 0 === deps ? null : deps;
-  var prevState = hook.memoizedState;
-  if (null !== deps && areHookInputsEqual(deps, prevState[1]))
-    return prevState[0];
-  shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-  nextCreate = nextCreate();
-  hook.memoizedState = [nextCreate, deps];
-  return nextCreate;
-}
-function updateDeferredValueImpl(hook, prevValue, value) {
-  if (0 === (renderLanes$1 & 42))
-    return (
-      hook.baseState && ((hook.baseState = !1), (didReceiveUpdate = !0)),
-      (hook.memoizedState = value)
-    );
-  objectIs(value, prevValue) ||
-    ((value = claimNextTransitionLane()),
-    (currentlyRenderingFiber$1.lanes |= value),
-    (workInProgressRootSkippedLanes |= value),
-    (hook.baseState = !0));
-  return prevValue;
-}
-function startTransition(setPending, callback, options) {
-  var previousPriority = currentUpdatePriority;
-  currentUpdatePriority =
-    0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
-  setPending(!0);
-  var prevTransition = ReactCurrentBatchConfig$2.transition;
-  ReactCurrentBatchConfig$2.transition = {};
-  enableTransitionTracing &&
-    void 0 !== options &&
-    void 0 !== options.name &&
-    ((ReactCurrentBatchConfig$2.transition.name = options.name),
-    (ReactCurrentBatchConfig$2.transition.startTime = now()));
-  try {
-    setPending(!1), callback();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig$2.transition = prevTransition);
-  }
-}
-function updateId() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function updateRefresh() {
-  return updateWorkInProgressHook().memoizedState;
-}
-function refreshCache(fiber, seedKey, seedValue) {
-  for (var provider = fiber.return; null !== provider; ) {
-    switch (provider.tag) {
-      case 24:
-      case 3:
-        var lane = requestUpdateLane(provider);
-        fiber = createUpdate(lane);
-        var root$94 = enqueueUpdate(provider, fiber, lane);
-        if (null !== root$94) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root$94, provider, lane, eventTime);
-          entangleTransitions(root$94, provider, lane);
-        }
-        provider = createCache();
-        null !== seedKey &&
-          void 0 !== seedKey &&
-          null !== root$94 &&
-          provider.data.set(seedKey, seedValue);
-        fiber.payload = { cache: provider };
-        return;
-    }
-    provider = provider.return;
-  }
-}
-function dispatchReducerAction(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber);
-  action = {
-    lane: lane,
-    action: action,
-    hasEagerState: !1,
-    eagerState: null,
-    next: null
-  };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, action);
-  else if (
-    (enqueueUpdate$1(fiber, queue, action, lane),
-    (action = getRootForUpdatedFiber(fiber)),
-    null !== action)
-  ) {
-    var eventTime = requestEventTime();
-    scheduleUpdateOnFiber(action, fiber, lane, eventTime);
-    entangleTransitionUpdate(action, queue, lane);
-  }
-}
-function dispatchSetState(fiber, queue, action) {
-  var lane = requestUpdateLane(fiber),
-    update = {
-      lane: lane,
-      action: action,
-      hasEagerState: !1,
-      eagerState: null,
-      next: null
-    };
-  if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
-  else {
-    var alternate = fiber.alternate;
-    if (
-      0 === fiber.lanes &&
-      (null === alternate || 0 === alternate.lanes) &&
-      ((alternate = queue.lastRenderedReducer), null !== alternate)
-    )
-      try {
-        var currentState = queue.lastRenderedState,
-          eagerState = alternate(currentState, action);
-        update.hasEagerState = !0;
-        update.eagerState = eagerState;
-        if (objectIs(eagerState, currentState)) {
-          enqueueUpdate$1(fiber, queue, update, 0);
-          null === workInProgressRoot && finishQueueingConcurrentUpdates();
-          return;
-        }
-      } catch (error) {
-      } finally {
-      }
-    enqueueUpdate$1(fiber, queue, update, lane);
-    action = getRootForUpdatedFiber(fiber);
-    null !== action &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(action, fiber, lane, update),
-      entangleTransitionUpdate(action, queue, lane));
-  }
-}
-function isRenderPhaseUpdate(fiber) {
-  var alternate = fiber.alternate;
-  return (
-    fiber === currentlyRenderingFiber$1 ||
-    (null !== alternate && alternate === currentlyRenderingFiber$1)
-  );
-}
-function enqueueRenderPhaseUpdate(queue, update) {
-  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate =
-    !0;
-  var pending = queue.pending;
-  null === pending
-    ? (update.next = update)
-    : ((update.next = pending.next), (pending.next = update));
-  queue.pending = update;
-}
-function entangleTransitionUpdate(root, queue, lane) {
-  if (0 !== (lane & 8388480)) {
-    var queueLanes = queue.lanes;
-    queueLanes &= root.pendingLanes;
-    lane |= queueLanes;
-    queue.lanes = lane;
-    markRootEntangled(root, lane);
-  }
-}
-var ContextOnlyDispatcher = {
-  readContext: readContext,
-  useCallback: throwInvalidHookError,
-  useContext: throwInvalidHookError,
-  useEffect: throwInvalidHookError,
-  useImperativeHandle: throwInvalidHookError,
-  useInsertionEffect: throwInvalidHookError,
-  useLayoutEffect: throwInvalidHookError,
-  useMemo: throwInvalidHookError,
-  useReducer: throwInvalidHookError,
-  useRef: throwInvalidHookError,
-  useState: throwInvalidHookError,
-  useDebugValue: throwInvalidHookError,
-  useDeferredValue: throwInvalidHookError,
-  useTransition: throwInvalidHookError,
-  useMutableSource: throwInvalidHookError,
-  useSyncExternalStore: throwInvalidHookError,
-  useId: throwInvalidHookError
-};
-ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
-ContextOnlyDispatcher.use = throwInvalidHookError;
-ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
-ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
-var HooksDispatcherOnMount = {
-  readContext: readContext,
-  useCallback: function (callback, deps) {
-    mountWorkInProgressHook().memoizedState = [
-      callback,
-      void 0 === deps ? null : deps
-    ];
-    return callback;
-  },
-  useContext: readContext,
-  useEffect: mountEffect,
-  useImperativeHandle: function (ref, create, deps) {
-    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
-    mountEffectImpl(
-      4194308,
-      4,
-      imperativeHandleEffect.bind(null, create, ref),
-      deps
-    );
-  },
-  useLayoutEffect: function (create, deps) {
-    return mountEffectImpl(4194308, 4, create, deps);
-  },
-  useInsertionEffect: function (create, deps) {
-    mountEffectImpl(4, 2, create, deps);
-  },
-  useMemo: function (nextCreate, deps) {
-    var hook = mountWorkInProgressHook();
-    deps = void 0 === deps ? null : deps;
-    shouldDoubleInvokeUserFnsInHooksDEV && nextCreate();
-    nextCreate = nextCreate();
-    hook.memoizedState = [nextCreate, deps];
-    return nextCreate;
-  },
-  useReducer: function (reducer, initialArg, init) {
-    var hook = mountWorkInProgressHook();
-    initialArg = void 0 !== init ? init(initialArg) : initialArg;
-    hook.memoizedState = hook.baseState = initialArg;
-    reducer = {
-      pending: null,
-      lanes: 0,
-      dispatch: null,
-      lastRenderedReducer: reducer,
-      lastRenderedState: initialArg
-    };
-    hook.queue = reducer;
-    reducer = reducer.dispatch = dispatchReducerAction.bind(
-      null,
-      currentlyRenderingFiber$1,
-      reducer
-    );
-    return [hook.memoizedState, reducer];
-  },
-  useRef: function (initialValue) {
-    var hook = mountWorkInProgressHook();
-    if (enableUseRefAccessWarning)
-      return (
-        (initialValue = { current: initialValue }),
-        (hook.memoizedState = initialValue)
-      );
-    initialValue = { current: initialValue };
-    return (hook.memoizedState = initialValue);
-  },
-  useState: mountState,
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    return (mountWorkInProgressHook().memoizedState = value);
-  },
-  useTransition: function () {
-    var _mountState = mountState(!1),
-      isPending = _mountState[0];
-    _mountState = startTransition.bind(null, _mountState[1]);
-    mountWorkInProgressHook().memoizedState = _mountState;
-    return [isPending, _mountState];
-  },
-  useMutableSource: function (source, getSnapshot, subscribe) {
-    var hook = mountWorkInProgressHook();
-    hook.memoizedState = {
-      refs: { getSnapshot: getSnapshot, setSnapshot: null },
-      source: source,
-      subscribe: subscribe
-    };
-    return useMutableSource(hook, source, getSnapshot, subscribe);
-  },
-  useSyncExternalStore: function (subscribe, getSnapshot, getServerSnapshot) {
-    var fiber = currentlyRenderingFiber$1,
-      hook = mountWorkInProgressHook();
-    if (isHydrating) {
-      if (void 0 === getServerSnapshot)
-        throw Error(formatProdErrorMessage(407));
-      getServerSnapshot = getServerSnapshot();
-    } else {
-      getServerSnapshot = getSnapshot();
-      var root$90 = workInProgressRoot;
-      if (null === root$90) throw Error(formatProdErrorMessage(349));
-      includesBlockingLane(root$90, renderLanes$1) ||
-        pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
-    }
-    hook.memoizedState = getServerSnapshot;
-    root$90 = { value: getServerSnapshot, getSnapshot: getSnapshot };
-    hook.queue = root$90;
-    mountEffect(subscribeToStore.bind(null, fiber, root$90, subscribe), [
-      subscribe
-    ]);
-    fiber.flags |= 2048;
-    pushEffect(
-      9,
-      updateStoreInstance.bind(
-        null,
-        fiber,
-        root$90,
-        getServerSnapshot,
-        getSnapshot
-      ),
-      void 0,
-      null
-    );
-    return getServerSnapshot;
-  },
-  useId: function () {
-    var hook = mountWorkInProgressHook(),
-      identifierPrefix = workInProgressRoot.identifierPrefix;
-    if (isHydrating) {
-      var JSCompiler_inline_result = treeContextOverflow;
-      var idWithLeadingBit = treeContextId;
-      JSCompiler_inline_result =
-        (
-          idWithLeadingBit & ~(1 << (32 - clz32(idWithLeadingBit) - 1))
-        ).toString(32) + JSCompiler_inline_result;
-      identifierPrefix =
-        ":" + identifierPrefix + "R" + JSCompiler_inline_result;
-      JSCompiler_inline_result = localIdCounter++;
-      0 < JSCompiler_inline_result &&
-        (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
-      identifierPrefix += ":";
-    } else
-      (JSCompiler_inline_result = globalClientIdCounter++),
-        (identifierPrefix =
-          ":" +
-          identifierPrefix +
-          "r" +
-          JSCompiler_inline_result.toString(32) +
-          ":");
-    return (hook.memoizedState = identifierPrefix);
-  },
-  useCacheRefresh: function () {
-    return (mountWorkInProgressHook().memoizedState = refreshCache.bind(
-      null,
-      currentlyRenderingFiber$1
-    ));
-  }
-};
-HooksDispatcherOnMount.use = use;
-HooksDispatcherOnMount.useMemoCache = useMemoCache;
-HooksDispatcherOnMount.useEffectEvent = function (callback) {
-  var hook = mountWorkInProgressHook(),
-    ref = { impl: callback };
-  hook.memoizedState = ref;
-  return function () {
-    if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
-    return ref.impl.apply(void 0, arguments);
-  };
-};
-var HooksDispatcherOnUpdate = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: updateReducer,
-  useRef: updateRef,
-  useState: function () {
-    return updateReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = updateReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
-HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
-HooksDispatcherOnUpdate.use = use;
-HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
-var HooksDispatcherOnRerender = {
-  readContext: readContext,
-  useCallback: updateCallback,
-  useContext: readContext,
-  useEffect: updateEffect,
-  useImperativeHandle: updateImperativeHandle,
-  useInsertionEffect: updateInsertionEffect,
-  useLayoutEffect: updateLayoutEffect,
-  useMemo: updateMemo,
-  useReducer: rerenderReducer,
-  useRef: updateRef,
-  useState: function () {
-    return rerenderReducer(basicStateReducer);
-  },
-  useDebugValue: mountDebugValue,
-  useDeferredValue: function (value) {
-    var hook = updateWorkInProgressHook();
-    return null === currentHook
-      ? (hook.memoizedState = value)
-      : updateDeferredValueImpl(hook, currentHook.memoizedState, value);
-  },
-  useTransition: function () {
-    var isPending = rerenderReducer(basicStateReducer)[0],
-      start = updateWorkInProgressHook().memoizedState;
-    return [isPending, start];
-  },
-  useMutableSource: updateMutableSource,
-  useSyncExternalStore: updateSyncExternalStore,
-  useId: updateId
-};
-HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
-HooksDispatcherOnRerender.use = use;
-HooksDispatcherOnRerender.useMemoCache = useMemoCache;
-HooksDispatcherOnRerender.useEffectEvent = updateEvent;
-function resolveDefaultProps(Component, baseProps) {
-  if (Component && Component.defaultProps) {
-    baseProps = assign({}, baseProps);
-    Component = Component.defaultProps;
-    for (var propName in Component)
-      void 0 === baseProps[propName] &&
-        (baseProps[propName] = Component[propName]);
-    return baseProps;
-  }
-  return baseProps;
-}
-function applyDerivedStateFromProps(
-  workInProgress,
-  ctor,
-  getDerivedStateFromProps,
-  nextProps
-) {
-  ctor = workInProgress.memoizedState;
-  getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
-  getDerivedStateFromProps =
-    null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps
-      ? ctor
-      : assign({}, ctor, getDerivedStateFromProps);
-  workInProgress.memoizedState = getDerivedStateFromProps;
-  0 === workInProgress.lanes &&
-    (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
-}
-var classComponentUpdater = {
-  isMounted: function (component) {
-    return (component = component._reactInternals)
-      ? getNearestMountedFiber(component) === component
-      : !1;
-  },
-  enqueueSetState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-  },
-  enqueueReplaceState: function (inst, payload, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 1;
-    update.payload = payload;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    payload = enqueueUpdate(inst, update, lane);
-    null !== payload &&
-      ((callback = requestEventTime()),
-      scheduleUpdateOnFiber(payload, inst, lane, callback),
-      entangleTransitions(payload, inst, lane));
-  },
-  enqueueForceUpdate: function (inst, callback) {
-    inst = inst._reactInternals;
-    var lane = requestUpdateLane(inst),
-      update = createUpdate(lane);
-    update.tag = 2;
-    void 0 !== callback && null !== callback && (update.callback = callback);
-    callback = enqueueUpdate(inst, update, lane);
-    null !== callback &&
-      ((update = requestEventTime()),
-      scheduleUpdateOnFiber(callback, inst, lane, update),
-      entangleTransitions(callback, inst, lane));
-  }
-};
-function checkShouldComponentUpdate(
-  workInProgress,
-  ctor,
-  oldProps,
-  newProps,
-  oldState,
-  newState,
-  nextContext
-) {
-  workInProgress = workInProgress.stateNode;
-  return "function" === typeof workInProgress.shouldComponentUpdate
-    ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext)
-    : ctor.prototype && ctor.prototype.isPureReactComponent
-    ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
-    : !0;
-}
-function constructClassInstance(workInProgress, ctor, props) {
-  var context = emptyContextObject,
-    contextType = ctor.contextType;
-  "object" === typeof contextType &&
-    null !== contextType &&
-    (context = readContext(contextType));
-  ctor = new ctor(props, context);
-  workInProgress.memoizedState =
-    null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
-  ctor.updater = classComponentUpdater;
-  workInProgress.stateNode = ctor;
-  ctor._reactInternals = workInProgress;
-  return ctor;
-}
-function callComponentWillReceiveProps(
-  workInProgress,
-  instance,
-  newProps,
-  nextContext
-) {
-  workInProgress = instance.state;
-  "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, nextContext);
-  "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
-  instance.state !== workInProgress &&
-    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
-}
-function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
-  var instance = workInProgress.stateNode;
-  instance.props = newProps;
-  instance.state = workInProgress.memoizedState;
-  instance.refs = {};
-  initializeUpdateQueue(workInProgress);
-  var contextType = ctor.contextType;
-  instance.context =
-    "object" === typeof contextType && null !== contextType
-      ? readContext(contextType)
-      : emptyContextObject;
-  instance.state = workInProgress.memoizedState;
-  contextType = ctor.getDerivedStateFromProps;
-  "function" === typeof contextType &&
-    (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof ctor.getDerivedStateFromProps ||
-    "function" === typeof instance.getSnapshotBeforeUpdate ||
-    ("function" !== typeof instance.UNSAFE_componentWillMount &&
-      "function" !== typeof instance.componentWillMount) ||
-    ((ctor = instance.state),
-    "function" === typeof instance.componentWillMount &&
-      instance.componentWillMount(),
-    "function" === typeof instance.UNSAFE_componentWillMount &&
-      instance.UNSAFE_componentWillMount(),
-    ctor !== instance.state &&
-      classComponentUpdater.enqueueReplaceState(instance, instance.state, null),
-    processUpdateQueue(workInProgress, newProps, instance, renderLanes),
-    (instance.state = workInProgress.memoizedState));
-  "function" === typeof instance.componentDidMount &&
-    (workInProgress.flags |= 4194308);
-}
-function createCapturedValueAtFiber(value, source) {
-  try {
-    var info = "",
-      node = source;
-    do (info += describeFiber(node)), (node = node.return);
-    while (node);
-    var JSCompiler_inline_result = info;
-  } catch (x) {
-    JSCompiler_inline_result =
-      "\nError generating stack: " + x.message + "\n" + x.stack;
-  }
-  return {
-    value: value,
-    source: source,
-    stack: JSCompiler_inline_result,
-    digest: null
-  };
-}
-function createCapturedValue(value, digest, stack) {
-  return {
-    value: value,
-    source: null,
-    stack: null != stack ? stack : null,
-    digest: null != digest ? digest : null
-  };
-}
-var ReactFiberErrorDialogWWW = require("ReactFiberErrorDialog");
-if ("function" !== typeof ReactFiberErrorDialogWWW.showErrorDialog)
-  throw Error(formatProdErrorMessage(320));
-function logCapturedError(boundary, errorInfo) {
-  try {
-    !1 !==
-      ReactFiberErrorDialogWWW.showErrorDialog({
-        componentStack: null !== errorInfo.stack ? errorInfo.stack : "",
-        error: errorInfo.value,
-        errorBoundary:
-          null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
-      }) && console.error(errorInfo.value);
-  } catch (e$99) {
-    setTimeout(function () {
-      throw e$99;
-    });
-  }
-}
-function createRootErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  lane.payload = { element: null };
-  var error = errorInfo.value;
-  lane.callback = function () {
-    hasUncaughtError || ((hasUncaughtError = !0), (firstUncaughtError = error));
-    logCapturedError(fiber, errorInfo);
-  };
-  return lane;
-}
-function createClassErrorUpdate(fiber, errorInfo, lane) {
-  lane = createUpdate(lane);
-  lane.tag = 3;
-  var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
-  if ("function" === typeof getDerivedStateFromError) {
-    var error = errorInfo.value;
-    lane.payload = function () {
-      return getDerivedStateFromError(error);
-    };
-    lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-    };
-  }
-  var inst = fiber.stateNode;
-  null !== inst &&
-    "function" === typeof inst.componentDidCatch &&
-    (lane.callback = function () {
-      logCapturedError(fiber, errorInfo);
-      "function" !== typeof getDerivedStateFromError &&
-        (null === legacyErrorBoundariesThatAlreadyFailed
-          ? (legacyErrorBoundariesThatAlreadyFailed = new Set([this]))
-          : legacyErrorBoundariesThatAlreadyFailed.add(this));
-      var stack = errorInfo.stack;
-      this.componentDidCatch(errorInfo.value, {
-        componentStack: null !== stack ? stack : ""
-      });
-    });
-  return lane;
-}
-function markSuspenseBoundaryShouldCapture(
-  suspenseBoundary,
-  returnFiber,
-  sourceFiber,
-  root,
-  rootRenderLanes
-) {
-  if (0 === (suspenseBoundary.mode & 1))
-    return (
-      suspenseBoundary === returnFiber
-        ? (suspenseBoundary.flags |= 65536)
-        : ((suspenseBoundary.flags |= 128),
-          (sourceFiber.flags |= 131072),
-          (sourceFiber.flags &= -52805),
-          1 === sourceFiber.tag &&
-            (null === sourceFiber.alternate
-              ? (sourceFiber.tag = 17)
-              : ((returnFiber = createUpdate(2)),
-                (returnFiber.tag = 2),
-                enqueueUpdate(sourceFiber, returnFiber, 2))),
-          (sourceFiber.lanes |= 2)),
-      suspenseBoundary
-    );
-  suspenseBoundary.flags |= 65536;
-  suspenseBoundary.lanes = rootRenderLanes;
-  return suspenseBoundary;
-}
-function processTransitionCallbacks(pendingTransitions, endTime, callbacks) {
-  if (enableTransitionTracing && null !== pendingTransitions) {
-    var transitionStart = pendingTransitions.transitionStart,
-      onTransitionStart = callbacks.onTransitionStart;
-    null !== transitionStart &&
-      null != onTransitionStart &&
-      transitionStart.forEach(function (transition) {
-        return onTransitionStart(transition.name, transition.startTime);
-      });
-    transitionStart = pendingTransitions.markerProgress;
-    var onMarkerProgress = callbacks.onMarkerProgress;
-    null != onMarkerProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (markerInstance, markerName) {
-        if (null !== markerInstance.transitions) {
-          var pending =
-            null !== markerInstance.pendingBoundaries
-              ? Array.from(markerInstance.pendingBoundaries.values())
-              : [];
-          markerInstance.transitions.forEach(function (transition) {
-            onMarkerProgress(
-              transition.name,
-              markerName,
-              transition.startTime,
-              endTime,
-              pending
-            );
-          });
-        }
-      });
-    transitionStart = pendingTransitions.markerComplete;
-    var onMarkerComplete = callbacks.onMarkerComplete;
-    null !== transitionStart &&
-      null != onMarkerComplete &&
-      transitionStart.forEach(function (transitions, markerName) {
-        transitions.forEach(function (transition) {
-          onMarkerComplete(
-            transition.name,
-            markerName,
-            transition.startTime,
-            endTime
-          );
-        });
-      });
-    transitionStart = pendingTransitions.markerIncomplete;
-    var onMarkerIncomplete = callbacks.onMarkerIncomplete;
-    null != onMarkerIncomplete &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (_ref, markerName) {
-        var aborts = _ref.aborts;
-        _ref.transitions.forEach(function (transition) {
-          var filteredAborts = [];
-          aborts.forEach(function (abort) {
-            switch (abort.reason) {
-              case "marker":
-                filteredAborts.push({
-                  type: "marker",
-                  name: abort.name,
-                  endTime: endTime
-                });
-                break;
-              case "suspense":
-                filteredAborts.push({
-                  type: "suspense",
-                  name: abort.name,
-                  endTime: endTime
-                });
-            }
-          });
-          0 < filteredAborts.length &&
-            onMarkerIncomplete(
-              transition.name,
-              markerName,
-              transition.startTime,
-              filteredAborts
-            );
-        });
-      });
-    transitionStart = pendingTransitions.transitionProgress;
-    var onTransitionProgress = callbacks.onTransitionProgress;
-    null != onTransitionProgress &&
-      null !== transitionStart &&
-      transitionStart.forEach(function (pending, transition) {
-        onTransitionProgress(
-          transition.name,
-          transition.startTime,
-          endTime,
-          Array.from(pending.values())
-        );
-      });
-    pendingTransitions = pendingTransitions.transitionComplete;
-    var onTransitionComplete = callbacks.onTransitionComplete;
-    null !== pendingTransitions &&
-      null != onTransitionComplete &&
-      pendingTransitions.forEach(function (transition) {
-        return onTransitionComplete(
-          transition.name,
-          transition.startTime,
-          endTime
-        );
-      });
-  }
-}
-var markerInstanceStack = createCursor(null);
-function pushRootMarkerInstance(workInProgress) {
-  if (enableTransitionTracing) {
-    var transitions = workInProgressTransitions,
-      root$105 = workInProgress.stateNode;
-    null !== transitions &&
-      transitions.forEach(function (transition) {
-        if (!root$105.incompleteTransitions.has(transition)) {
-          var markerInstance = {
-            tag: 0,
-            transitions: new Set([transition]),
-            pendingBoundaries: null,
-            aborts: null,
-            name: null
-          };
-          root$105.incompleteTransitions.set(transition, markerInstance);
-        }
-      });
-    var markerInstances = [];
-    root$105.incompleteTransitions.forEach(function (markerInstance) {
-      markerInstances.push(markerInstance);
-    });
-    push(markerInstanceStack, markerInstances);
-  }
-}
-function pushMarkerInstance(workInProgress, markerInstance) {
-  enableTransitionTracing &&
-    (null === markerInstanceStack.current
-      ? push(markerInstanceStack, [markerInstance])
-      : push(
-          markerInstanceStack,
-          markerInstanceStack.current.concat(markerInstance)
-        ));
-}
-var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner,
-  SelectiveHydrationException = Error(formatProdErrorMessage(461)),
-  didReceiveUpdate = !1;
-function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
-  workInProgress.child =
-    null === current
-      ? mountChildFibers(workInProgress, null, nextChildren, renderLanes)
-      : reconcileChildFibers(
-          workInProgress,
-          current.child,
-          nextChildren,
-          renderLanes
-        );
-}
-function updateForwardRef(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  Component = Component.render;
-  var ref = workInProgress.ref;
-  prepareToReadContext(workInProgress, renderLanes);
-  nextProps = renderWithHooks(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    ref,
-    renderLanes
-  );
-  Component = checkDidRenderIdHook();
-  if (null !== current && !didReceiveUpdate)
-    return (
-      bailoutHooks(current, workInProgress, renderLanes),
-      bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-    );
-  isHydrating && Component && pushMaterializedTreeId(workInProgress);
-  workInProgress.flags |= 1;
-  reconcileChildren(current, workInProgress, nextProps, renderLanes);
-  return workInProgress.child;
-}
-function updateMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (null === current) {
-    var type = Component.type;
-    if (
-      "function" === typeof type &&
-      !shouldConstruct(type) &&
-      void 0 === type.defaultProps &&
-      null === Component.compare &&
-      void 0 === Component.defaultProps
-    )
-      return (
-        (workInProgress.tag = 15),
-        (workInProgress.type = type),
-        updateSimpleMemoComponent(
-          current,
-          workInProgress,
-          type,
-          nextProps,
-          renderLanes
-        )
-      );
-    current = createFiberFromTypeAndProps(
-      Component.type,
-      null,
-      nextProps,
-      workInProgress,
-      workInProgress.mode,
-      renderLanes
-    );
-    current.ref = workInProgress.ref;
-    current.return = workInProgress;
-    return (workInProgress.child = current);
-  }
-  type = current.child;
-  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
-    var prevProps = type.memoizedProps;
-    Component = Component.compare;
-    Component = null !== Component ? Component : shallowEqual;
-    if (Component(prevProps, nextProps) && current.ref === workInProgress.ref)
-      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
-  }
-  workInProgress.flags |= 1;
-  current = createWorkInProgress(type, nextProps);
-  current.ref = workInProgress.ref;
-  current.return = workInProgress;
-  return (workInProgress.child = current);
-}
-function updateSimpleMemoComponent(
-  current,
-  workInProgress,
-  Component,
-  nextProps,
-  renderLanes
-) {
-  if (null !== current) {
-    var prevProps = current.memoizedProps;
-    if (
-      shallowEqual(prevProps, nextProps) &&
-      current.ref === workInProgress.ref
-    )
-      if (
-        ((didReceiveUpdate = !1),
-        (workInProgress.pendingProps = nextProps = prevProps),
-        checkScheduledUpdateOrContext(current, renderLanes))
-      )
-        0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
-      else
-        return (
-          (workInProgress.lanes = current.lanes),
-          bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes)
-        );
-  }
-  return updateFunctionComponent(
-    current,
-    workInProgress,
-    Component,
-    nextProps,
-    renderLanes
-  );
-}
-function updateOffscreenComponent(current, workInProgress, renderLanes) {
-  var nextProps = workInProgress.pendingProps,
-    nextChildren = nextProps.children,
-    nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
-    prevState = null !== current ? current.memoizedState : null;
-  markRef$1(current, workInProgress);
-  if (
-    "hidden" === nextProps.mode ||
-    "unstable-defer-without-hiding" === nextProps.mode ||
-    nextIsDetached
-  ) {
-    if (0 !== (workInProgress.flags & 128)) {
-      nextChildren =
-        null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
-      if (null !== current) {
-        prevState = workInProgress.child = current.child;
-        for (nextProps = 0; null !== prevState; )
-          (nextProps = nextProps | prevState.lanes | prevState.childLanes),
-            (prevState = prevState.sibling);
-        workInProgress.childLanes = nextProps & ~nextChildren;
-      } else (workInProgress.childLanes = 0), (workInProgress.child = null);
-      return deferHiddenOffscreenComponent(
-        current,
-        workInProgress,
-        nextChildren,
-        renderLanes
-      );
-    }
-    if (0 === (workInProgress.mode & 1))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current && pushTransition(workInProgress, null, null),
-        reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else if (0 !== (renderLanes & 1073741824))
-      (workInProgress.memoizedState = { baseLanes: 0, cachePool: null }),
-        null !== current &&
-          pushTransition(
-            workInProgress,
-            null !== prevState ? prevState.cachePool : null,
-            null
-          ),
-        null !== prevState
-          ? pushHiddenContext(workInProgress, prevState)
-          : reuseHiddenContextOnStack(),
-        pushOffscreenSuspenseHandler(workInProgress);
-    else
-      return (
-        (workInProgress.lanes = workInProgress.childLanes = 1073741824),
-        deferHiddenOffscreenComponent(
-          current,
-          workInProgress,
-          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes,
-          renderLanes
-        )
-      );
-  } else if (null !== prevState) {
-    nextProps = prevState.cachePool;
-    nextIsDetached = null;
-    if (enableTransitionTracing) {
-      var instance = workInProgress.stateNode;
-      null !== instance &&
-        null != instance._transitions &&
-        (nextIsDetached = Array.from(instance._transitions));
+  } else if (null !== prevState) {
+    nextProps = prevState.cachePool;
+    nextIsDetached = null;
+    if (enableTransitionTracing) {
+      var instance = workInProgress.stateNode;
+      null !== instance &&
+        null != instance._transitions &&
+        (nextIsDetached = Array.from(instance._transitions));
     }
     pushTransition(workInProgress, nextProps, nextIsDetached);
     pushHiddenContext(workInProgress, prevState);
@@ -8785,14 +5456,14 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
   }
   JSCompiler_temp = current.memoizedState;
   if (null !== JSCompiler_temp) {
-    var dehydrated$112 = JSCompiler_temp.dehydrated;
-    if (null !== dehydrated$112)
+    var dehydrated$68 = JSCompiler_temp.dehydrated;
+    if (null !== dehydrated$68)
       return updateDehydratedSuspenseComponent(
         current,
         workInProgress,
         didSuspend,
         nextProps,
-        dehydrated$112,
+        dehydrated$68,
         JSCompiler_temp,
         renderLanes
       );
@@ -8802,7 +5473,7 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
     showFallback = nextProps.fallback;
     didSuspend = workInProgress.mode;
     JSCompiler_temp = current.child;
-    dehydrated$112 = JSCompiler_temp.sibling;
+    dehydrated$68 = JSCompiler_temp.sibling;
     var primaryChildProps = { mode: "hidden", children: nextProps.children };
     0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
       ? ((nextProps = workInProgress.child),
@@ -8811,8 +5482,8 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         (workInProgress.deletions = null))
       : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
         (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
-    null !== dehydrated$112
-      ? (showFallback = createWorkInProgress(dehydrated$112, showFallback))
+    null !== dehydrated$68
+      ? (showFallback = createWorkInProgress(dehydrated$68, showFallback))
       : ((showFallback = createFiberFromFragment(
           showFallback,
           didSuspend,
@@ -8831,10 +5502,10 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
       ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
       : ((JSCompiler_temp = didSuspend.cachePool),
         null !== JSCompiler_temp
-          ? ((dehydrated$112 = CacheContext._currentValue),
+          ? ((dehydrated$68 = CacheContext._currentValue),
             (JSCompiler_temp =
-              JSCompiler_temp.parent !== dehydrated$112
-                ? { parent: dehydrated$112, pool: dehydrated$112 }
+              JSCompiler_temp.parent !== dehydrated$68
+                ? { parent: dehydrated$68, pool: dehydrated$68 }
                 : JSCompiler_temp))
           : (JSCompiler_temp = getSuspendedCache()),
         (didSuspend = {
@@ -8848,23 +5519,23 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         ((JSCompiler_temp = enableTransitionTracing
           ? markerInstanceStack.current
           : null),
-        (dehydrated$112 = showFallback.updateQueue),
+        (dehydrated$68 = showFallback.updateQueue),
         (primaryChildProps = current.updateQueue),
-        null === dehydrated$112
+        null === dehydrated$68
           ? (showFallback.updateQueue = {
               transitions: didSuspend,
               markerInstances: JSCompiler_temp,
               wakeables: null
             })
-          : dehydrated$112 === primaryChildProps
+          : dehydrated$68 === primaryChildProps
           ? (showFallback.updateQueue = {
               transitions: didSuspend,
               markerInstances: JSCompiler_temp,
               wakeables:
                 null !== primaryChildProps ? primaryChildProps.wakeables : null
             })
-          : ((dehydrated$112.transitions = didSuspend),
-            (dehydrated$112.markerInstances = JSCompiler_temp))));
+          : ((dehydrated$68.transitions = didSuspend),
+            (dehydrated$68.markerInstances = JSCompiler_temp))));
     showFallback.childLanes = current.childLanes & ~renderLanes;
     workInProgress.memoizedState = SUSPENDED_MARKER;
     return nextProps;
@@ -9486,5975 +6157,9370 @@ function propagateContextChange(workInProgress, context, renderLanes) {
     }
   }
 }
-function propagateContextChanges(
-  workInProgress,
-  contexts,
-  renderLanes,
-  forcePropagateEntireTree
-) {
-  if (enableLazyContextPropagation) {
-    var fiber = workInProgress.child;
-    null !== fiber && (fiber.return = workInProgress);
-    for (; null !== fiber; ) {
-      var list = fiber.dependencies;
-      if (null !== list) {
-        var nextFiber = fiber.child;
-        list = list.firstContext;
-        a: for (; null !== list; ) {
-          var dependency = list;
-          list = fiber;
-          for (var i = 0; i < contexts.length; i++)
-            if (dependency.context === contexts[i]) {
-              list.lanes |= renderLanes;
-              dependency = list.alternate;
-              null !== dependency && (dependency.lanes |= renderLanes);
-              scheduleContextWorkOnParentPath(
-                list.return,
-                renderLanes,
-                workInProgress
-              );
-              forcePropagateEntireTree || (nextFiber = null);
-              break a;
-            }
-          list = dependency.next;
-        }
-      } else if (18 === fiber.tag) {
-        nextFiber = fiber.return;
-        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
-        nextFiber.lanes |= renderLanes;
-        list = nextFiber.alternate;
-        null !== list && (list.lanes |= renderLanes);
-        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
-        nextFiber = null;
-      } else 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;
+function propagateContextChanges(
+  workInProgress,
+  contexts,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (enableLazyContextPropagation) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber; ) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        list = list.firstContext;
+        a: for (; null !== list; ) {
+          var dependency = list;
+          list = fiber;
+          for (var i = 0; i < contexts.length; i++)
+            if (dependency.context === contexts[i]) {
+              list.lanes |= renderLanes;
+              dependency = list.alternate;
+              null !== dependency && (dependency.lanes |= renderLanes);
+              scheduleContextWorkOnParentPath(
+                list.return,
+                renderLanes,
+                workInProgress
+              );
+              forcePropagateEntireTree || (nextFiber = null);
+              break a;
+            }
+          list = dependency.next;
+        }
+      } else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error(formatProdErrorMessage(341));
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = null;
+      } else 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 propagateParentContextChanges(
+  current,
+  workInProgress,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  if (enableLazyContextPropagation) {
+    current = null;
+    for (
+      var parent = workInProgress, isInsidePropagationBailout = !1;
+      null !== parent;
+
+    ) {
+      if (!isInsidePropagationBailout)
+        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
+        else if (0 !== (parent.flags & 262144)) break;
+      if (10 === parent.tag) {
+        var currentParent = parent.alternate;
+        if (null === currentParent) throw Error(formatProdErrorMessage(387));
+        currentParent = currentParent.memoizedProps;
+        if (null !== currentParent) {
+          var context = parent.type._context;
+          objectIs(parent.pendingProps.value, currentParent.value) ||
+            (null !== current ? current.push(context) : (current = [context]));
+        }
+      }
+      parent = parent.return;
+    }
+    null !== current &&
+      propagateContextChanges(
+        workInProgress,
+        current,
+        renderLanes,
+        forcePropagateEntireTree
+      );
+    workInProgress.flags |= 262144;
+  }
+}
+function checkIfContextChanged(currentDependencies) {
+  if (!enableLazyContextPropagation) return !1;
+  for (
+    currentDependencies = currentDependencies.firstContext;
+    null !== currentDependencies;
+
+  ) {
+    if (
+      !objectIs(
+        currentDependencies.context._currentValue,
+        currentDependencies.memoizedValue
+      )
+    )
+      return !0;
+    currentDependencies = currentDependencies.next;
+  }
+  return !1;
+}
+function prepareToReadContext(workInProgress, renderLanes) {
+  currentlyRenderingFiber = workInProgress;
+  lastFullyObservedContext = lastContextDependency = null;
+  workInProgress = workInProgress.dependencies;
+  null !== workInProgress &&
+    (enableLazyContextPropagation
+      ? (workInProgress.firstContext = null)
+      : null !== workInProgress.firstContext &&
+        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
+        (workInProgress.firstContext = null)));
+}
+function readContext(context) {
+  return readContextForConsumer(currentlyRenderingFiber, context);
+}
+function readContextDuringReconcilation(consumer, context, renderLanes) {
+  null === currentlyRenderingFiber &&
+    prepareToReadContext(consumer, renderLanes);
+  return readContextForConsumer(consumer, context);
+}
+function readContextForConsumer(consumer, context) {
+  var value = context._currentValue;
+  if (lastFullyObservedContext !== context)
+    if (
+      ((context = { context: context, memoizedValue: value, next: null }),
+      null === lastContextDependency)
+    ) {
+      if (null === consumer) throw Error(formatProdErrorMessage(308));
+      lastContextDependency = context;
+      consumer.dependencies = { lanes: 0, firstContext: context };
+      enableLazyContextPropagation && (consumer.flags |= 524288);
+    } else lastContextDependency = lastContextDependency.next = context;
+  return value;
+}
+var AbortControllerLocal =
+    "undefined" !== typeof AbortController
+      ? AbortController
+      : function () {
+          var listeners = [],
+            signal = (this.signal = {
+              aborted: !1,
+              addEventListener: function (type, listener) {
+                listeners.push(listener);
+              }
+            });
+          this.abort = function () {
+            signal.aborted = !0;
+            listeners.forEach(function (listener) {
+              return listener();
+            });
+          };
+        },
+  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
+  NormalPriority = Scheduler.unstable_NormalPriority,
+  CacheContext = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    Consumer: null,
+    Provider: null,
+    _currentValue: null,
+    _currentValue2: null,
+    _threadCount: 0,
+    _defaultValue: null,
+    _globalName: null
+  };
+function createCache() {
+  return {
+    controller: new AbortControllerLocal(),
+    data: new Map(),
+    refCount: 0
+  };
+}
+function releaseCache(cache) {
+  cache.refCount--;
+  0 === cache.refCount &&
+    scheduleCallback$1(NormalPriority, function () {
+      cache.controller.abort();
+    });
+}
+var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
+  resumedCache = createCursor(null),
+  transitionStack = createCursor(null);
+function peekCacheFromPool() {
+  var cacheResumedFromPreviousRender = resumedCache.current;
+  return null !== cacheResumedFromPreviousRender
+    ? cacheResumedFromPreviousRender
+    : workInProgressRoot.pooledCache;
+}
+function pushTransition(
+  offscreenWorkInProgress,
+  prevCachePool,
+  newTransitions
+) {
+  null === prevCachePool
+    ? push(resumedCache, resumedCache.current)
+    : push(resumedCache, prevCachePool.pool);
+  enableTransitionTracing &&
+    (null === transitionStack.current
+      ? push(transitionStack, newTransitions)
+      : null === newTransitions
+      ? push(transitionStack, transitionStack.current)
+      : push(transitionStack, transitionStack.current.concat(newTransitions)));
+}
+function popTransition(workInProgress, current) {
+  null !== current &&
+    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
+}
+function getSuspendedCache() {
+  var cacheFromPool = peekCacheFromPool();
+  return null === cacheFromPool
+    ? null
+    : { parent: CacheContext._currentValue, pool: cacheFromPool };
+}
+var emptyObject = {};
+function collectScopedNodesFromChildren(
+  startingChild,
+  fn$jscomp$0,
+  scopedNodes$jscomp$0
+) {
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      fn = fn$jscomp$0,
+      scopedNodes = scopedNodes$jscomp$0;
+    if (5 === node.tag) {
+      var type = node.type,
+        memoizedProps = node.memoizedProps,
+        instance = node.stateNode;
+      null !== instance &&
+        !0 === fn(type, memoizedProps || emptyObject, instance) &&
+        scopedNodes.push(instance);
+    }
+    type = node.child;
+    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
+    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
+    startingChild = startingChild.sibling;
+  }
+}
+function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
+  for (; null !== startingChild; ) {
+    a: {
+      var JSCompiler_inline_result = startingChild;
+      var fn = fn$jscomp$0;
+      if (5 === JSCompiler_inline_result.tag) {
+        var type = JSCompiler_inline_result.type,
+          memoizedProps = JSCompiler_inline_result.memoizedProps,
+          instance = JSCompiler_inline_result.stateNode;
+        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
+          JSCompiler_inline_result = instance;
+          break a;
         }
-      fiber = nextFiber;
+      }
+      type = JSCompiler_inline_result.child;
+      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
+        (type = JSCompiler_inline_result.child.sibling.child);
+      JSCompiler_inline_result =
+        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
     }
+    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
+    startingChild = startingChild.sibling;
   }
+  return null;
 }
-function propagateParentContextChanges(
-  current,
-  workInProgress,
-  renderLanes,
-  forcePropagateEntireTree
+function collectNearestChildContextValues(
+  startingChild,
+  context$jscomp$0,
+  childContextValues$jscomp$0
 ) {
-  if (enableLazyContextPropagation) {
-    current = null;
-    for (
-      var parent = workInProgress, isInsidePropagationBailout = !1;
-      null !== parent;
-
-    ) {
-      if (!isInsidePropagationBailout)
-        if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
-        else if (0 !== (parent.flags & 262144)) break;
-      if (10 === parent.tag) {
-        var currentParent = parent.alternate;
-        if (null === currentParent) throw Error(formatProdErrorMessage(387));
-        currentParent = currentParent.memoizedProps;
-        if (null !== currentParent) {
-          var context = parent.type._context;
-          objectIs(parent.pendingProps.value, currentParent.value) ||
-            (null !== current ? current.push(context) : (current = [context]));
-        }
-      }
-      parent = parent.return;
+  for (; null !== startingChild; ) {
+    var node = startingChild,
+      context = context$jscomp$0,
+      childContextValues = childContextValues$jscomp$0;
+    if (10 === node.tag && node.type._context === context)
+      childContextValues.push(node.memoizedProps.value);
+    else {
+      var child = node.child;
+      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
+      null !== child &&
+        collectNearestChildContextValues(child, context, childContextValues);
     }
-    null !== current &&
-      propagateContextChanges(
-        workInProgress,
-        current,
-        renderLanes,
-        forcePropagateEntireTree
-      );
-    workInProgress.flags |= 262144;
+    startingChild = startingChild.sibling;
   }
 }
-function checkIfContextChanged(currentDependencies) {
-  if (!enableLazyContextPropagation) return !1;
-  for (
-    currentDependencies = currentDependencies.firstContext;
-    null !== currentDependencies;
-
-  ) {
-    if (
-      !objectIs(
-        currentDependencies.context._currentValue,
-        currentDependencies.memoizedValue
+function DO_NOT_USE_queryAllNodes(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  var scopedNodes = [];
+  null !== currentFiber &&
+    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
+  return 0 === scopedNodes.length ? null : scopedNodes;
+}
+function DO_NOT_USE_queryFirstNode(fn) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return null;
+  currentFiber = currentFiber.child;
+  return null !== currentFiber
+    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
+    : null;
+}
+function containsNode$1(node) {
+  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
+    if (21 === node.tag && node.stateNode === this) return !0;
+    node = node.return;
+  }
+  return !1;
+}
+function getChildContextValues(context) {
+  var currentFiber = getInstanceFromScope(this);
+  if (null === currentFiber) return [];
+  currentFiber = currentFiber.child;
+  var childContextValues = [];
+  null !== currentFiber &&
+    collectNearestChildContextValues(currentFiber, context, childContextValues);
+  return childContextValues;
+}
+function markUpdate(workInProgress) {
+  workInProgress.flags |= 4;
+}
+function markRef(workInProgress) {
+  workInProgress.flags |= 2097664;
+}
+function updateHostComponent(current, workInProgress, type, newProps) {
+  var oldProps = current.memoizedProps;
+  if (oldProps !== newProps) {
+    current = workInProgress.stateNode;
+    var updatePayload = null;
+    switch (type) {
+      case "input":
+        oldProps = getHostProps$2(current, oldProps);
+        newProps = getHostProps$2(current, newProps);
+        updatePayload = [];
+        break;
+      case "select":
+        oldProps = assign({}, oldProps, { value: void 0 });
+        newProps = assign({}, newProps, { value: void 0 });
+        updatePayload = [];
+        break;
+      case "textarea":
+        oldProps = getHostProps(current, oldProps);
+        newProps = getHostProps(current, newProps);
+        updatePayload = [];
+        break;
+      default:
+        "function" !== typeof oldProps.onClick &&
+          "function" === typeof newProps.onClick &&
+          (current.onclick = noop);
+    }
+    assertValidProps(type, newProps);
+    var styleName;
+    type = null;
+    for (JSCompiler_inline_result in oldProps)
+      if (
+        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
+        null != oldProps[JSCompiler_inline_result]
+      )
+        if ("style" === JSCompiler_inline_result) {
+          var lastStyle = oldProps[JSCompiler_inline_result];
+          for (styleName in lastStyle)
+            lastStyle.hasOwnProperty(styleName) &&
+              (type || (type = {}), (type[styleName] = ""));
+        } else
+          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
+            "children" !== JSCompiler_inline_result &&
+            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+            "suppressHydrationWarning" !== JSCompiler_inline_result &&
+            "autoFocus" !== JSCompiler_inline_result &&
+            (registrationNameDependencies.hasOwnProperty(
+              JSCompiler_inline_result
+            )
+              ? updatePayload || (updatePayload = [])
+              : (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  null
+                ));
+    for (JSCompiler_inline_result in newProps) {
+      var nextProp = newProps[JSCompiler_inline_result];
+      lastStyle =
+        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
+      if (
+        newProps.hasOwnProperty(JSCompiler_inline_result) &&
+        nextProp !== lastStyle &&
+        (null != nextProp || null != lastStyle)
       )
-    )
-      return !0;
-    currentDependencies = currentDependencies.next;
+        if ("style" === JSCompiler_inline_result)
+          if (lastStyle) {
+            for (styleName in lastStyle)
+              !lastStyle.hasOwnProperty(styleName) ||
+                (nextProp && nextProp.hasOwnProperty(styleName)) ||
+                (type || (type = {}), (type[styleName] = ""));
+            for (styleName in nextProp)
+              nextProp.hasOwnProperty(styleName) &&
+                lastStyle[styleName] !== nextProp[styleName] &&
+                (type || (type = {}), (type[styleName] = nextProp[styleName]));
+          } else
+            type ||
+              (updatePayload || (updatePayload = []),
+              updatePayload.push(JSCompiler_inline_result, type)),
+              (type = nextProp);
+        else
+          "dangerouslySetInnerHTML" === JSCompiler_inline_result
+            ? ((nextProp = nextProp ? nextProp.__html : void 0),
+              (lastStyle = lastStyle ? lastStyle.__html : void 0),
+              null != nextProp &&
+                lastStyle !== nextProp &&
+                (updatePayload = updatePayload || []).push(
+                  JSCompiler_inline_result,
+                  nextProp
+                ))
+            : "children" === JSCompiler_inline_result
+            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
+              (updatePayload = updatePayload || []).push(
+                JSCompiler_inline_result,
+                "" + nextProp
+              )
+            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
+              "suppressHydrationWarning" !== JSCompiler_inline_result &&
+              (registrationNameDependencies.hasOwnProperty(
+                JSCompiler_inline_result
+              )
+                ? (null != nextProp &&
+                    "onScroll" === JSCompiler_inline_result &&
+                    listenToNonDelegatedEvent("scroll", current),
+                  updatePayload ||
+                    lastStyle === nextProp ||
+                    (updatePayload = []))
+                : (updatePayload = updatePayload || []).push(
+                    JSCompiler_inline_result,
+                    nextProp
+                  ));
+    }
+    type && (updatePayload = updatePayload || []).push("style", type);
+    var JSCompiler_inline_result = updatePayload;
+    (workInProgress.updateQueue = JSCompiler_inline_result) &&
+      markUpdate(workInProgress);
   }
-  return !1;
-}
-function prepareToReadContext(workInProgress, renderLanes) {
-  currentlyRenderingFiber = workInProgress;
-  lastFullyObservedContext = lastContextDependency = null;
-  workInProgress = workInProgress.dependencies;
-  null !== workInProgress &&
-    (enableLazyContextPropagation
-      ? (workInProgress.firstContext = null)
-      : null !== workInProgress.firstContext &&
-        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
-        (workInProgress.firstContext = null)));
 }
-function readContext(context) {
-  return readContextForConsumer(currentlyRenderingFiber, context);
-}
-function readContextDuringReconcilation(consumer, context, renderLanes) {
-  null === currentlyRenderingFiber &&
-    prepareToReadContext(consumer, renderLanes);
-  return readContextForConsumer(consumer, context);
+function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+  if (!isHydrating)
+    switch (renderState.tailMode) {
+      case "hidden":
+        hasRenderedATailFallback = renderState.tail;
+        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
+          null !== hasRenderedATailFallback.alternate &&
+            (lastTailNode = hasRenderedATailFallback),
+            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
+        null === lastTailNode
+          ? (renderState.tail = null)
+          : (lastTailNode.sibling = null);
+        break;
+      case "collapsed":
+        lastTailNode = renderState.tail;
+        for (var lastTailNode$99 = null; null !== lastTailNode; )
+          null !== lastTailNode.alternate && (lastTailNode$99 = lastTailNode),
+            (lastTailNode = lastTailNode.sibling);
+        null === lastTailNode$99
+          ? hasRenderedATailFallback || null === renderState.tail
+            ? (renderState.tail = null)
+            : (renderState.tail.sibling = null)
+          : (lastTailNode$99.sibling = null);
+    }
 }
-function readContextForConsumer(consumer, context) {
-  var value = context._currentValue;
-  if (lastFullyObservedContext !== context)
-    if (
-      ((context = { context: context, memoizedValue: value, next: null }),
-      null === lastContextDependency)
-    ) {
-      if (null === consumer) throw Error(formatProdErrorMessage(308));
-      lastContextDependency = context;
-      consumer.dependencies = { lanes: 0, firstContext: context };
-      enableLazyContextPropagation && (consumer.flags |= 524288);
-    } else lastContextDependency = lastContextDependency.next = context;
-  return value;
+function bubbleProperties(completedWork) {
+  var didBailout =
+      null !== completedWork.alternate &&
+      completedWork.alternate.child === completedWork.child,
+    newChildLanes = 0,
+    subtreeFlags = 0;
+  if (didBailout)
+    for (var child$100 = completedWork.child; null !== child$100; )
+      (newChildLanes |= child$100.lanes | child$100.childLanes),
+        (subtreeFlags |= child$100.subtreeFlags & 14680064),
+        (subtreeFlags |= child$100.flags & 14680064),
+        (child$100.return = completedWork),
+        (child$100 = child$100.sibling);
+  else
+    for (child$100 = completedWork.child; null !== child$100; )
+      (newChildLanes |= child$100.lanes | child$100.childLanes),
+        (subtreeFlags |= child$100.subtreeFlags),
+        (subtreeFlags |= child$100.flags),
+        (child$100.return = completedWork),
+        (child$100 = child$100.sibling);
+  completedWork.subtreeFlags |= subtreeFlags;
+  completedWork.childLanes = newChildLanes;
+  return didBailout;
 }
-var AbortControllerLocal =
-    "undefined" !== typeof AbortController
-      ? AbortController
-      : function () {
-          var listeners = [],
-            signal = (this.signal = {
-              aborted: !1,
-              addEventListener: function (type, listener) {
-                listeners.push(listener);
+function completeWork(current, workInProgress, renderLanes) {
+  var newProps = workInProgress.pendingProps;
+  popTreeContext(workInProgress);
+  switch (workInProgress.tag) {
+    case 2:
+    case 16:
+    case 15:
+    case 0:
+    case 11:
+    case 7:
+    case 8:
+    case 12:
+    case 9:
+    case 14:
+      return bubbleProperties(workInProgress), null;
+    case 1:
+      return bubbleProperties(workInProgress), null;
+    case 3:
+      renderLanes = workInProgress.stateNode;
+      enableTransitionTracing &&
+        null !== workInProgressTransitions &&
+        (workInProgress.flags |= 2048);
+      newProps = null;
+      null !== current && (newProps = current.memoizedState.cache);
+      workInProgress.memoizedState.cache !== newProps &&
+        (workInProgress.flags |= 2048);
+      popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
+      popHostContainer();
+      resetWorkInProgressVersions();
+      renderLanes.pendingContext &&
+        ((renderLanes.context = renderLanes.pendingContext),
+        (renderLanes.pendingContext = null));
+      if (null === current || null === current.child)
+        popHydrationState(workInProgress)
+          ? markUpdate(workInProgress)
+          : null === current ||
+            (current.memoizedState.isDehydrated &&
+              0 === (workInProgress.flags & 256)) ||
+            ((workInProgress.flags |= 1024),
+            null !== hydrationErrors &&
+              (queueRecoverableErrors(hydrationErrors),
+              (hydrationErrors = null)));
+      bubbleProperties(workInProgress);
+      enableTransitionTracing &&
+        0 !== (workInProgress.subtreeFlags & 8192) &&
+        (workInProgress.flags |= 2048);
+      return null;
+    case 26:
+      return (
+        (current ? current.ref : null) !== workInProgress.ref &&
+          markRef(workInProgress),
+        null === current ||
+        current.memoizedState !== workInProgress.memoizedState
+          ? markUpdate(workInProgress)
+          : null === workInProgress.memoizedState &&
+            updateHostComponent(
+              current,
+              workInProgress,
+              workInProgress.type,
+              workInProgress.pendingProps
+            ),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 27:
+      popHostContext(workInProgress);
+      renderLanes = rootInstanceStackCursor.current;
+      var type = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, type, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor.current;
+        popHydrationState(workInProgress)
+          ? prepareToHydrateHostInstance(workInProgress, current)
+          : ((workInProgress.stateNode = resolveSingletonInstance(
+              type,
+              newProps,
+              renderLanes
+            )),
+            markUpdate(workInProgress));
+        null !== workInProgress.ref && markRef(workInProgress);
+      }
+      bubbleProperties(workInProgress);
+      return null;
+    case 5:
+      popHostContext(workInProgress);
+      renderLanes = workInProgress.type;
+      if (null !== current && null != workInProgress.stateNode)
+        updateHostComponent(current, workInProgress, renderLanes, newProps),
+          current.ref !== workInProgress.ref && markRef(workInProgress);
+      else {
+        if (!newProps) {
+          if (null === workInProgress.stateNode)
+            throw Error(formatProdErrorMessage(166));
+          bubbleProperties(workInProgress);
+          return null;
+        }
+        current = contextStackCursor.current;
+        if (popHydrationState(workInProgress))
+          prepareToHydrateHostInstance(workInProgress, current) &&
+            markUpdate(workInProgress);
+        else {
+          type = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          );
+          switch (current) {
+            case "http://www.w3.org/2000/svg":
+            case "http://www.w3.org/1998/Math/MathML":
+              current = type.createElementNS(current, renderLanes);
+              break;
+            default:
+              switch (renderLanes) {
+                case "svg":
+                  current = type.createElementNS(
+                    "http://www.w3.org/2000/svg",
+                    renderLanes
+                  );
+                  break;
+                case "math":
+                  current = type.createElementNS(
+                    "http://www.w3.org/1998/Math/MathML",
+                    renderLanes
+                  );
+                  break;
+                case "script":
+                  current = type.createElement("div");
+                  current.innerHTML = "<script>\x3c/script>";
+                  current = current.removeChild(current.firstChild);
+                  break;
+                case "select":
+                  current =
+                    "string" === typeof newProps.is
+                      ? type.createElement("select", { is: newProps.is })
+                      : type.createElement("select");
+                  newProps.multiple
+                    ? (current.multiple = !0)
+                    : newProps.size && (current.size = newProps.size);
+                  break;
+                default:
+                  current = createHTMLElement(renderLanes, newProps, type);
               }
-            });
-          this.abort = function () {
-            signal.aborted = !0;
-            listeners.forEach(function (listener) {
-              return listener();
-            });
-          };
-        },
-  scheduleCallback$1 = Scheduler.unstable_scheduleCallback,
-  NormalPriority = Scheduler.unstable_NormalPriority,
-  CacheContext = {
-    $$typeof: REACT_CONTEXT_TYPE,
-    Consumer: null,
-    Provider: null,
-    _currentValue: null,
-    _currentValue2: null,
-    _threadCount: 0,
-    _defaultValue: null,
-    _globalName: null
-  };
-function createCache() {
-  return {
-    controller: new AbortControllerLocal(),
-    data: new Map(),
-    refCount: 0
-  };
-}
-function releaseCache(cache) {
-  cache.refCount--;
-  0 === cache.refCount &&
-    scheduleCallback$1(NormalPriority, function () {
-      cache.controller.abort();
-    });
-}
-var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
-  resumedCache = createCursor(null),
-  transitionStack = createCursor(null);
-function peekCacheFromPool() {
-  var cacheResumedFromPreviousRender = resumedCache.current;
-  return null !== cacheResumedFromPreviousRender
-    ? cacheResumedFromPreviousRender
-    : workInProgressRoot.pooledCache;
-}
-function pushTransition(
-  offscreenWorkInProgress,
-  prevCachePool,
-  newTransitions
-) {
-  null === prevCachePool
-    ? push(resumedCache, resumedCache.current)
-    : push(resumedCache, prevCachePool.pool);
-  enableTransitionTracing &&
-    (null === transitionStack.current
-      ? push(transitionStack, newTransitions)
-      : null === newTransitions
-      ? push(transitionStack, transitionStack.current)
-      : push(transitionStack, transitionStack.current.concat(newTransitions)));
-}
-function popTransition(workInProgress, current) {
-  null !== current &&
-    (enableTransitionTracing && pop(transitionStack), pop(resumedCache));
-}
-function getSuspendedCache() {
-  var cacheFromPool = peekCacheFromPool();
-  return null === cacheFromPool
-    ? null
-    : { parent: CacheContext._currentValue, pool: cacheFromPool };
-}
-var emptyObject = {};
-function collectScopedNodesFromChildren(
-  startingChild,
-  fn$jscomp$0,
-  scopedNodes$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      fn = fn$jscomp$0,
-      scopedNodes = scopedNodes$jscomp$0;
-    if (5 === node.tag) {
-      var type = node.type,
-        memoizedProps = node.memoizedProps,
-        instance = node.stateNode;
-      null !== instance &&
-        !0 === fn(type, memoizedProps || emptyObject, instance) &&
-        scopedNodes.push(instance);
-    }
-    type = node.child;
-    isFiberSuspenseAndTimedOut(node) && (type = node.child.sibling.child);
-    null !== type && collectScopedNodesFromChildren(type, fn, scopedNodes);
-    startingChild = startingChild.sibling;
-  }
-}
-function collectFirstScopedNodeFromChildren(startingChild, fn$jscomp$0) {
-  for (; null !== startingChild; ) {
-    a: {
-      var JSCompiler_inline_result = startingChild;
-      var fn = fn$jscomp$0;
-      if (5 === JSCompiler_inline_result.tag) {
-        var type = JSCompiler_inline_result.type,
-          memoizedProps = JSCompiler_inline_result.memoizedProps,
-          instance = JSCompiler_inline_result.stateNode;
-        if (null !== instance && !0 === fn(type, memoizedProps, instance)) {
-          JSCompiler_inline_result = instance;
-          break a;
+          }
+          current[internalInstanceKey] = workInProgress;
+          current[internalPropsKey] = newProps;
+          a: for (type = workInProgress.child; null !== type; ) {
+            if (5 === type.tag || 6 === type.tag)
+              current.appendChild(type.stateNode);
+            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
+              type.child.return = type;
+              type = type.child;
+              continue;
+            }
+            if (type === workInProgress) break a;
+            for (; null === type.sibling; ) {
+              if (null === type.return || type.return === workInProgress)
+                break a;
+              type = type.return;
+            }
+            type.sibling.return = type.return;
+            type = type.sibling;
+          }
+          workInProgress.stateNode = current;
+          a: switch (
+            (setInitialProperties(current, renderLanes, newProps), renderLanes)
+          ) {
+            case "button":
+            case "input":
+            case "select":
+            case "textarea":
+              current = !!newProps.autoFocus;
+              break a;
+            case "img":
+              current = !0;
+              break a;
+            default:
+              current = !1;
+          }
+          current && markUpdate(workInProgress);
+        }
+        null !== workInProgress.ref && markRef(workInProgress);
+      }
+      bubbleProperties(workInProgress);
+      return null;
+    case 6:
+      if (current && null != workInProgress.stateNode)
+        current.memoizedProps !== newProps && markUpdate(workInProgress);
+      else {
+        if ("string" !== typeof newProps && null === workInProgress.stateNode)
+          throw Error(formatProdErrorMessage(166));
+        current = rootInstanceStackCursor.current;
+        if (popHydrationState(workInProgress)) {
+          newProps = workInProgress.stateNode;
+          current = workInProgress.memoizedProps;
+          newProps[internalInstanceKey] = workInProgress;
+          if ((renderLanes = newProps.nodeValue !== current))
+            if (((type = hydrationParentFiber), null !== type))
+              switch (type.tag) {
+                case 3:
+                  newProps = newProps.nodeValue;
+                  normalizeMarkupForTextOrAttribute(current);
+                  normalizeMarkupForTextOrAttribute(newProps);
+                  break;
+                case 27:
+                case 5:
+                  !0 !== type.memoizedProps.suppressHydrationWarning &&
+                    ((newProps = newProps.nodeValue),
+                    normalizeMarkupForTextOrAttribute(current),
+                    normalizeMarkupForTextOrAttribute(newProps));
+              }
+          renderLanes && markUpdate(workInProgress);
+        } else
+          (current =
+            getOwnerDocumentFromRootContainer(current).createTextNode(
+              newProps
+            )),
+            (current[internalInstanceKey] = workInProgress),
+            (workInProgress.stateNode = current);
+      }
+      bubbleProperties(workInProgress);
+      return null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      newProps = workInProgress.memoizedState;
+      if (
+        null === current ||
+        (null !== current.memoizedState &&
+          null !== current.memoizedState.dehydrated)
+      ) {
+        if (
+          isHydrating &&
+          null !== nextHydratableInstance &&
+          0 !== (workInProgress.mode & 1) &&
+          0 === (workInProgress.flags & 128)
+        )
+          warnIfUnhydratedTailNodes(),
+            resetHydrationState(),
+            (workInProgress.flags |= 98560),
+            (type = !1);
+        else if (
+          ((type = popHydrationState(workInProgress)),
+          null !== newProps && null !== newProps.dehydrated)
+        ) {
+          if (null === current) {
+            if (!type) throw Error(formatProdErrorMessage(318));
+            type = workInProgress.memoizedState;
+            type = null !== type ? type.dehydrated : null;
+            if (!type) throw Error(formatProdErrorMessage(317));
+            type[internalInstanceKey] = workInProgress;
+          } else
+            resetHydrationState(),
+              0 === (workInProgress.flags & 128) &&
+                (workInProgress.memoizedState = null),
+              (workInProgress.flags |= 4);
+          bubbleProperties(workInProgress);
+          type = !1;
+        } else
+          null !== hydrationErrors &&
+            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
+            (type = !0);
+        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
+      }
+      if (0 !== (workInProgress.flags & 128))
+        return (workInProgress.lanes = renderLanes), workInProgress;
+      renderLanes = null !== newProps;
+      current = null !== current && null !== current.memoizedState;
+      if (renderLanes) {
+        newProps = workInProgress.child;
+        type = null;
+        null !== newProps.alternate &&
+          null !== newProps.alternate.memoizedState &&
+          null !== newProps.alternate.memoizedState.cachePool &&
+          (type = newProps.alternate.memoizedState.cachePool.pool);
+        var cache$110 = null;
+        null !== newProps.memoizedState &&
+          null !== newProps.memoizedState.cachePool &&
+          (cache$110 = newProps.memoizedState.cachePool.pool);
+        cache$110 !== type && (newProps.flags |= 2048);
+      }
+      renderLanes !== current &&
+        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
+        renderLanes && (workInProgress.child.flags |= 8192));
+      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
+      null !== workInProgress.updateQueue &&
+        null != workInProgress.memoizedProps.suspenseCallback &&
+        (workInProgress.flags |= 4);
+      bubbleProperties(workInProgress);
+      return null;
+    case 4:
+      return (
+        popHostContainer(),
+        null === current &&
+          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 10:
+      return (
+        popProvider(workInProgress.type._context),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 17:
+      return bubbleProperties(workInProgress), null;
+    case 19:
+      pop(suspenseStackCursor);
+      type = workInProgress.memoizedState;
+      if (null === type) return bubbleProperties(workInProgress), null;
+      newProps = 0 !== (workInProgress.flags & 128);
+      cache$110 = type.rendering;
+      if (null === cache$110)
+        if (newProps) cutOffTailIfNeeded(type, !1);
+        else {
+          if (
+            0 !== workInProgressRootExitStatus ||
+            (null !== current && 0 !== (current.flags & 128))
+          )
+            for (current = workInProgress.child; null !== current; ) {
+              cache$110 = findFirstSuspended(current);
+              if (null !== cache$110) {
+                workInProgress.flags |= 128;
+                cutOffTailIfNeeded(type, !1);
+                current = cache$110.updateQueue;
+                null !== current &&
+                  ((workInProgress.updateQueue = current),
+                  (workInProgress.flags |= 4));
+                workInProgress.subtreeFlags = 0;
+                current = renderLanes;
+                for (renderLanes = workInProgress.child; null !== renderLanes; )
+                  resetWorkInProgress(renderLanes, current),
+                    (renderLanes = renderLanes.sibling);
+                push(
+                  suspenseStackCursor,
+                  (suspenseStackCursor.current & 1) | 2
+                );
+                return workInProgress.child;
+              }
+              current = current.sibling;
+            }
+          null !== type.tail &&
+            now() > workInProgressRootRenderTargetTime &&
+            ((workInProgress.flags |= 128),
+            (newProps = !0),
+            cutOffTailIfNeeded(type, !1),
+            (workInProgress.lanes = 8388608));
         }
+      else {
+        if (!newProps)
+          if (((current = findFirstSuspended(cache$110)), null !== current)) {
+            if (
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              (current = current.updateQueue),
+              null !== current &&
+                ((workInProgress.updateQueue = current),
+                (workInProgress.flags |= 4)),
+              cutOffTailIfNeeded(type, !0),
+              null === type.tail &&
+                "hidden" === type.tailMode &&
+                !cache$110.alternate &&
+                !isHydrating)
+            )
+              return bubbleProperties(workInProgress), null;
+          } else
+            2 * now() - type.renderingStartTime >
+              workInProgressRootRenderTargetTime &&
+              1073741824 !== renderLanes &&
+              ((workInProgress.flags |= 128),
+              (newProps = !0),
+              cutOffTailIfNeeded(type, !1),
+              (workInProgress.lanes = 8388608));
+        type.isBackwards
+          ? ((cache$110.sibling = workInProgress.child),
+            (workInProgress.child = cache$110))
+          : ((current = type.last),
+            null !== current
+              ? (current.sibling = cache$110)
+              : (workInProgress.child = cache$110),
+            (type.last = cache$110));
       }
-      type = JSCompiler_inline_result.child;
-      isFiberSuspenseAndTimedOut(JSCompiler_inline_result) &&
-        (type = JSCompiler_inline_result.child.sibling.child);
-      JSCompiler_inline_result =
-        null !== type ? collectFirstScopedNodeFromChildren(type, fn) : null;
-    }
-    if (null !== JSCompiler_inline_result) return JSCompiler_inline_result;
-    startingChild = startingChild.sibling;
+      if (null !== type.tail)
+        return (
+          (workInProgress = type.tail),
+          (type.rendering = workInProgress),
+          (type.tail = workInProgress.sibling),
+          (type.renderingStartTime = now()),
+          (workInProgress.sibling = null),
+          (current = suspenseStackCursor.current),
+          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
+          workInProgress
+        );
+      bubbleProperties(workInProgress);
+      return null;
+    case 21:
+      return (
+        null === current
+          ? ((current = {
+              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
+              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
+              containsNode: containsNode$1,
+              getChildContextValues: getChildContextValues
+            }),
+            (workInProgress.stateNode = current),
+            (current[internalInstanceKey] = workInProgress),
+            null !== workInProgress.ref &&
+              (markRef(workInProgress), markUpdate(workInProgress)))
+          : (null !== workInProgress.ref && markUpdate(workInProgress),
+            current.ref !== workInProgress.ref && markRef(workInProgress)),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        (newProps = null !== workInProgress.memoizedState),
+        23 !== workInProgress.tag &&
+          (null !== current
+            ? (null !== current.memoizedState) !== newProps &&
+              (workInProgress.flags |= 8192)
+            : newProps && (workInProgress.flags |= 8192)),
+        newProps && 0 !== (workInProgress.mode & 1)
+          ? 0 !== (renderLanes & 1073741824) &&
+            0 === (workInProgress.flags & 128) &&
+            (bubbleProperties(workInProgress),
+            23 !== workInProgress.tag &&
+              workInProgress.subtreeFlags & 6 &&
+              (workInProgress.flags |= 8192))
+          : bubbleProperties(workInProgress),
+        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
+        (renderLanes = null),
+        null !== current &&
+          null !== current.memoizedState &&
+          null !== current.memoizedState.cachePool &&
+          (renderLanes = current.memoizedState.cachePool.pool),
+        (newProps = null),
+        null !== workInProgress.memoizedState &&
+          null !== workInProgress.memoizedState.cachePool &&
+          (newProps = workInProgress.memoizedState.cachePool.pool),
+        newProps !== renderLanes && (workInProgress.flags |= 2048),
+        popTransition(workInProgress, current),
+        null
+      );
+    case 24:
+      return (
+        (renderLanes = null),
+        null !== current && (renderLanes = current.memoizedState.cache),
+        workInProgress.memoizedState.cache !== renderLanes &&
+          (workInProgress.flags |= 2048),
+        popProvider(CacheContext),
+        bubbleProperties(workInProgress),
+        null
+      );
+    case 25:
+      return (
+        enableTransitionTracing &&
+          (null !== workInProgress.stateNode &&
+            enableTransitionTracing &&
+            pop(markerInstanceStack),
+          bubbleProperties(workInProgress)),
+        null
+      );
   }
-  return null;
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
-function collectNearestChildContextValues(
-  startingChild,
-  context$jscomp$0,
-  childContextValues$jscomp$0
-) {
-  for (; null !== startingChild; ) {
-    var node = startingChild,
-      context = context$jscomp$0,
-      childContextValues = childContextValues$jscomp$0;
-    if (10 === node.tag && node.type._context === context)
-      childContextValues.push(node.memoizedProps.value);
-    else {
-      var child = node.child;
-      isFiberSuspenseAndTimedOut(node) && (child = node.child.sibling.child);
-      null !== child &&
-        collectNearestChildContextValues(child, context, childContextValues);
-    }
-    startingChild = startingChild.sibling;
+function unwindWork(current, workInProgress) {
+  popTreeContext(workInProgress);
+  switch (workInProgress.tag) {
+    case 1:
+      return (
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 3:
+      return (
+        popProvider(CacheContext),
+        enableTransitionTracing &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        enableTransitionTracing && pop(transitionStack),
+        popHostContainer(),
+        resetWorkInProgressVersions(),
+        (current = workInProgress.flags),
+        0 !== (current & 65536) && 0 === (current & 128)
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 26:
+    case 27:
+    case 5:
+      return popHostContext(workInProgress), null;
+    case 13:
+      popSuspenseHandler(workInProgress);
+      current = workInProgress.memoizedState;
+      if (null !== current && null !== current.dehydrated) {
+        if (null === workInProgress.alternate)
+          throw Error(formatProdErrorMessage(340));
+        resetHydrationState();
+      }
+      current = workInProgress.flags;
+      return current & 65536
+        ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+        : null;
+    case 19:
+      return pop(suspenseStackCursor), null;
+    case 4:
+      return popHostContainer(), null;
+    case 10:
+      return popProvider(workInProgress.type._context), null;
+    case 22:
+    case 23:
+      return (
+        popSuspenseHandler(workInProgress),
+        popHiddenContext(),
+        popTransition(workInProgress, current),
+        (current = workInProgress.flags),
+        current & 65536
+          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
+          : null
+      );
+    case 24:
+      return popProvider(CacheContext), null;
+    case 25:
+      return (
+        enableTransitionTracing &&
+          null !== workInProgress.stateNode &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        null
+      );
+    default:
+      return null;
   }
 }
-function DO_NOT_USE_queryAllNodes(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  var scopedNodes = [];
-  null !== currentFiber &&
-    collectScopedNodesFromChildren(currentFiber, fn, scopedNodes);
-  return 0 === scopedNodes.length ? null : scopedNodes;
-}
-function DO_NOT_USE_queryFirstNode(fn) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return null;
-  currentFiber = currentFiber.child;
-  return null !== currentFiber
-    ? collectFirstScopedNodeFromChildren(currentFiber, fn)
-    : null;
-}
-function containsNode(node) {
-  for (node = getClosestInstanceFromNode(node) || null; null !== node; ) {
-    if (21 === node.tag && node.stateNode === this) return !0;
-    node = node.return;
+function unwindInterruptedWork(current, interruptedWork) {
+  popTreeContext(interruptedWork);
+  switch (interruptedWork.tag) {
+    case 3:
+      popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
+      popHostContainer();
+      resetWorkInProgressVersions();
+      break;
+    case 26:
+    case 27:
+    case 5:
+      popHostContext(interruptedWork);
+      break;
+    case 4:
+      popHostContainer();
+      break;
+    case 13:
+      popSuspenseHandler(interruptedWork);
+      break;
+    case 19:
+      pop(suspenseStackCursor);
+      break;
+    case 10:
+      popProvider(interruptedWork.type._context);
+      break;
+    case 22:
+    case 23:
+      popSuspenseHandler(interruptedWork);
+      popHiddenContext();
+      popTransition(interruptedWork, current);
+      break;
+    case 24:
+      popProvider(CacheContext);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        null !== interruptedWork.stateNode &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
   }
-  return !1;
 }
-function getChildContextValues(context) {
-  var currentFiber = getInstanceFromScope(this);
-  if (null === currentFiber) return [];
-  currentFiber = currentFiber.child;
-  var childContextValues = [];
-  null !== currentFiber &&
-    collectNearestChildContextValues(currentFiber, context, childContextValues);
-  return childContextValues;
+var ReactFbErrorUtils = require("ReactFbErrorUtils");
+if ("function" !== typeof ReactFbErrorUtils.invokeGuardedCallback)
+  throw Error(formatProdErrorMessage(255));
+function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+  ReactFbErrorUtils.invokeGuardedCallback.apply(this, arguments);
 }
-function markUpdate(workInProgress) {
-  workInProgress.flags |= 4;
+var hasError = !1,
+  caughtError = null,
+  hasRethrowError = !1,
+  rethrowError = null,
+  reporter = {
+    onError: function (error) {
+      hasError = !0;
+      caughtError = error;
+    }
+  };
+function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+  hasError = !1;
+  caughtError = null;
+  invokeGuardedCallbackImpl.apply(reporter, arguments);
 }
-function markRef(workInProgress) {
-  workInProgress.flags |= 2097664;
+function invokeGuardedCallbackAndCatchFirstError(
+  name,
+  func,
+  context,
+  a,
+  b,
+  c,
+  d,
+  e,
+  f
+) {
+  invokeGuardedCallback.apply(this, arguments);
+  if (hasError) {
+    if (hasError) {
+      var error = caughtError;
+      hasError = !1;
+      caughtError = null;
+    } else throw Error(formatProdErrorMessage(198));
+    hasRethrowError || ((hasRethrowError = !0), (rethrowError = error));
+  }
 }
-function updateHostComponent(current, workInProgress, type, newProps) {
-  var oldProps = current.memoizedProps;
-  if (oldProps !== newProps) {
-    current = workInProgress.stateNode;
-    var updatePayload = null;
-    switch (type) {
-      case "input":
-        oldProps = getHostProps$2(current, oldProps);
-        newProps = getHostProps$2(current, newProps);
-        updatePayload = [];
-        break;
-      case "select":
-        oldProps = assign({}, oldProps, { value: void 0 });
-        newProps = assign({}, newProps, { value: void 0 });
-        updatePayload = [];
-        break;
-      case "textarea":
-        oldProps = getHostProps(current, oldProps);
-        newProps = getHostProps(current, newProps);
-        updatePayload = [];
-        break;
-      default:
-        "function" !== typeof oldProps.onClick &&
-          "function" === typeof newProps.onClick &&
-          (current.onclick = noop$1);
-    }
-    assertValidProps(type, newProps);
-    var styleName;
-    type = null;
-    for (JSCompiler_inline_result in oldProps)
-      if (
-        !newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        oldProps.hasOwnProperty(JSCompiler_inline_result) &&
-        null != oldProps[JSCompiler_inline_result]
-      )
-        if ("style" === JSCompiler_inline_result) {
-          var lastStyle = oldProps[JSCompiler_inline_result];
-          for (styleName in lastStyle)
-            lastStyle.hasOwnProperty(styleName) &&
-              (type || (type = {}), (type[styleName] = ""));
-        } else
-          "dangerouslySetInnerHTML" !== JSCompiler_inline_result &&
-            "children" !== JSCompiler_inline_result &&
-            "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-            "suppressHydrationWarning" !== JSCompiler_inline_result &&
-            "autoFocus" !== JSCompiler_inline_result &&
-            (registrationNameDependencies.hasOwnProperty(
-              JSCompiler_inline_result
-            )
-              ? updatePayload || (updatePayload = [])
-              : (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  null
-                ));
-    for (JSCompiler_inline_result in newProps) {
-      var nextProp = newProps[JSCompiler_inline_result];
-      lastStyle =
-        null != oldProps ? oldProps[JSCompiler_inline_result] : void 0;
-      if (
-        newProps.hasOwnProperty(JSCompiler_inline_result) &&
-        nextProp !== lastStyle &&
-        (null != nextProp || null != lastStyle)
-      )
-        if ("style" === JSCompiler_inline_result)
-          if (lastStyle) {
-            for (styleName in lastStyle)
-              !lastStyle.hasOwnProperty(styleName) ||
-                (nextProp && nextProp.hasOwnProperty(styleName)) ||
-                (type || (type = {}), (type[styleName] = ""));
-            for (styleName in nextProp)
-              nextProp.hasOwnProperty(styleName) &&
-                lastStyle[styleName] !== nextProp[styleName] &&
-                (type || (type = {}), (type[styleName] = nextProp[styleName]));
-          } else
-            type ||
-              (updatePayload || (updatePayload = []),
-              updatePayload.push(JSCompiler_inline_result, type)),
-              (type = nextProp);
-        else
-          "dangerouslySetInnerHTML" === JSCompiler_inline_result
-            ? ((nextProp = nextProp ? nextProp.__html : void 0),
-              (lastStyle = lastStyle ? lastStyle.__html : void 0),
-              null != nextProp &&
-                lastStyle !== nextProp &&
-                (updatePayload = updatePayload || []).push(
-                  JSCompiler_inline_result,
-                  nextProp
-                ))
-            : "children" === JSCompiler_inline_result
-            ? ("string" !== typeof nextProp && "number" !== typeof nextProp) ||
-              (updatePayload = updatePayload || []).push(
-                JSCompiler_inline_result,
-                "" + nextProp
-              )
-            : "suppressContentEditableWarning" !== JSCompiler_inline_result &&
-              "suppressHydrationWarning" !== JSCompiler_inline_result &&
-              (registrationNameDependencies.hasOwnProperty(
-                JSCompiler_inline_result
-              )
-                ? (null != nextProp &&
-                    "onScroll" === JSCompiler_inline_result &&
-                    listenToNonDelegatedEvent("scroll", current),
-                  updatePayload ||
-                    lastStyle === nextProp ||
-                    (updatePayload = []))
-                : (updatePayload = updatePayload || []).push(
-                    JSCompiler_inline_result,
-                    nextProp
-                  ));
+var offscreenSubtreeIsHidden = !1,
+  offscreenSubtreeWasHidden = !1,
+  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+  nextEffect = null;
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    var ref = current.ref;
+    if (null !== ref) {
+      var instance = current.stateNode;
+      switch (current.tag) {
+        case 26:
+        case 27:
+        case 5:
+          var instanceToUse = instance;
+          break;
+        default:
+          instanceToUse = instance;
+      }
+      21 === current.tag && (instanceToUse = instance);
+      "function" === typeof ref
+        ? (current.refCleanup = ref(instanceToUse))
+        : (ref.current = instanceToUse);
     }
-    type && (updatePayload = updatePayload || []).push("style", type);
-    var JSCompiler_inline_result = updatePayload;
-    (workInProgress.updateQueue = JSCompiler_inline_result) &&
-      markUpdate(workInProgress);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
   }
 }
-function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
-  if (!isHydrating)
-    switch (renderState.tailMode) {
-      case "hidden":
-        hasRenderedATailFallback = renderState.tail;
-        for (var lastTailNode = null; null !== hasRenderedATailFallback; )
-          null !== hasRenderedATailFallback.alternate &&
-            (lastTailNode = hasRenderedATailFallback),
-            (hasRenderedATailFallback = hasRenderedATailFallback.sibling);
-        null === lastTailNode
-          ? (renderState.tail = null)
-          : (lastTailNode.sibling = null);
-        break;
-      case "collapsed":
-        lastTailNode = renderState.tail;
-        for (var lastTailNode$143 = null; null !== lastTailNode; )
-          null !== lastTailNode.alternate && (lastTailNode$143 = lastTailNode),
-            (lastTailNode = lastTailNode.sibling);
-        null === lastTailNode$143
-          ? hasRenderedATailFallback || null === renderState.tail
-            ? (renderState.tail = null)
-            : (renderState.tail.sibling = null)
-          : (lastTailNode$143.sibling = null);
-    }
+function safelyDetachRef(current, nearestMountedAncestor) {
+  var ref = current.ref,
+    refCleanup = current.refCleanup;
+  if (null !== ref)
+    if ("function" === typeof refCleanup)
+      try {
+        refCleanup();
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        (current.refCleanup = null),
+          (current = current.alternate),
+          null != current && (current.refCleanup = null);
+      }
+    else if ("function" === typeof ref)
+      try {
+        ref(null);
+      } catch (error$125) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$125);
+      }
+    else ref.current = null;
 }
-function bubbleProperties(completedWork) {
-  var didBailout =
-      null !== completedWork.alternate &&
-      completedWork.alternate.child === completedWork.child,
-    newChildLanes = 0,
-    subtreeFlags = 0;
-  if (didBailout)
-    for (var child$144 = completedWork.child; null !== child$144; )
-      (newChildLanes |= child$144.lanes | child$144.childLanes),
-        (subtreeFlags |= child$144.subtreeFlags & 14680064),
-        (subtreeFlags |= child$144.flags & 14680064),
-        (child$144.return = completedWork),
-        (child$144 = child$144.sibling);
-  else
-    for (child$144 = completedWork.child; null !== child$144; )
-      (newChildLanes |= child$144.lanes | child$144.childLanes),
-        (subtreeFlags |= child$144.subtreeFlags),
-        (subtreeFlags |= child$144.flags),
-        (child$144.return = completedWork),
-        (child$144 = child$144.sibling);
-  completedWork.subtreeFlags |= subtreeFlags;
-  completedWork.childLanes = newChildLanes;
-  return didBailout;
+function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
+  try {
+    destroy();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
 }
-function completeWork(current, workInProgress, renderLanes) {
-  var newProps = workInProgress.pendingProps;
-  popTreeContext(workInProgress);
-  switch (workInProgress.tag) {
-    case 2:
-    case 16:
-    case 15:
-    case 0:
-    case 11:
-    case 7:
-    case 8:
-    case 12:
-    case 9:
-    case 14:
-      return bubbleProperties(workInProgress), null;
-    case 1:
-      return bubbleProperties(workInProgress), null;
-    case 3:
-      renderLanes = workInProgress.stateNode;
-      enableTransitionTracing &&
-        null !== workInProgressTransitions &&
-        (workInProgress.flags |= 2048);
-      newProps = null;
-      null !== current && (newProps = current.memoizedState.cache);
-      workInProgress.memoizedState.cache !== newProps &&
-        (workInProgress.flags |= 2048);
-      popProvider(CacheContext);
-      enableTransitionTracing &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
-      enableTransitionTracing && pop(transitionStack);
-      popHostContainer();
-      resetWorkInProgressVersions();
-      renderLanes.pendingContext &&
-        ((renderLanes.context = renderLanes.pendingContext),
-        (renderLanes.pendingContext = null));
-      if (null === current || null === current.child)
-        popHydrationState(workInProgress)
-          ? markUpdate(workInProgress)
-          : null === current ||
-            (current.memoizedState.isDehydrated &&
-              0 === (workInProgress.flags & 256)) ||
-            ((workInProgress.flags |= 1024),
-            null !== hydrationErrors &&
-              (queueRecoverableErrors(hydrationErrors),
-              (hydrationErrors = null)));
-      bubbleProperties(workInProgress);
-      enableTransitionTracing &&
-        0 !== (workInProgress.subtreeFlags & 8192) &&
-        (workInProgress.flags |= 2048);
-      return null;
-    case 26:
-      return (
-        (current ? current.ref : null) !== workInProgress.ref &&
-          markRef(workInProgress),
-        null === current ||
-        current.memoizedState !== workInProgress.memoizedState
-          ? markUpdate(workInProgress)
-          : null === workInProgress.memoizedState &&
-            updateHostComponent(
-              current,
-              workInProgress,
-              workInProgress.type,
-              workInProgress.pendingProps
-            ),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 27:
-      popHostContext(workInProgress);
-      renderLanes = rootInstanceStackCursor.current;
-      var type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, type, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor.current;
-        popHydrationState(workInProgress)
-          ? prepareToHydrateHostInstance(workInProgress, current)
-          : ((workInProgress.stateNode = resolveSingletonInstance(
-              type,
-              newProps,
-              renderLanes
-            )),
-            markUpdate(workInProgress));
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 5:
-      popHostContext(workInProgress);
-      renderLanes = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode)
-        updateHostComponent(current, workInProgress, renderLanes, newProps),
-          current.ref !== workInProgress.ref && markRef(workInProgress);
-      else {
-        if (!newProps) {
-          if (null === workInProgress.stateNode)
-            throw Error(formatProdErrorMessage(166));
-          bubbleProperties(workInProgress);
-          return null;
-        }
-        current = contextStackCursor.current;
-        if (popHydrationState(workInProgress))
-          prepareToHydrateHostInstance(workInProgress, current) &&
-            markUpdate(workInProgress);
-        else {
-          type = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
-          );
-          switch (current) {
-            case "http://www.w3.org/2000/svg":
-            case "http://www.w3.org/1998/Math/MathML":
-              current = type.createElementNS(current, renderLanes);
-              break;
-            default:
-              switch (renderLanes) {
-                case "svg":
-                  current = type.createElementNS(
-                    "http://www.w3.org/2000/svg",
-                    renderLanes
-                  );
-                  break;
-                case "math":
-                  current = type.createElementNS(
-                    "http://www.w3.org/1998/Math/MathML",
-                    renderLanes
-                  );
-                  break;
-                case "script":
-                  current = type.createElement("div");
-                  current.innerHTML = "<script>\x3c/script>";
-                  current = current.removeChild(current.firstChild);
-                  break;
-                case "select":
-                  current =
-                    "string" === typeof newProps.is
-                      ? type.createElement("select", { is: newProps.is })
-                      : type.createElement("select");
-                  newProps.multiple
-                    ? (current.multiple = !0)
-                    : newProps.size && (current.size = newProps.size);
-                  break;
-                default:
-                  current = createHTMLElement(renderLanes, newProps, type);
-              }
+var focusedInstanceHandle = null,
+  shouldFireAfterActiveInstanceBlur = !1;
+function commitBeforeMutationEffects(root, firstChild) {
+  eventsEnabled = _enabled;
+  root = getActiveElementDeep();
+  if (hasSelectionCapabilities(root)) {
+    if ("selectionStart" in root)
+      var JSCompiler_temp = {
+        start: root.selectionStart,
+        end: root.selectionEnd
+      };
+    else
+      a: {
+        JSCompiler_temp =
+          ((JSCompiler_temp = root.ownerDocument) &&
+            JSCompiler_temp.defaultView) ||
+          window;
+        var selection =
+          JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
+        if (selection && 0 !== selection.rangeCount) {
+          JSCompiler_temp = selection.anchorNode;
+          var anchorOffset = selection.anchorOffset,
+            focusNode = selection.focusNode;
+          selection = selection.focusOffset;
+          try {
+            JSCompiler_temp.nodeType, focusNode.nodeType;
+          } catch (e$188) {
+            JSCompiler_temp = null;
+            break a;
           }
-          current[internalInstanceKey] = workInProgress;
-          current[internalPropsKey] = newProps;
-          a: for (type = workInProgress.child; null !== type; ) {
-            if (5 === type.tag || 6 === type.tag)
-              current.appendChild(type.stateNode);
-            else if (4 !== type.tag && 27 !== type.tag && null !== type.child) {
-              type.child.return = type;
-              type = type.child;
-              continue;
+          var length = 0,
+            start = -1,
+            end = -1,
+            indexWithinAnchor = 0,
+            indexWithinFocus = 0,
+            node = root,
+            parentNode = null;
+          b: for (;;) {
+            for (var next; ; ) {
+              node !== JSCompiler_temp ||
+                (0 !== anchorOffset && 3 !== node.nodeType) ||
+                (start = length + anchorOffset);
+              node !== focusNode ||
+                (0 !== selection && 3 !== node.nodeType) ||
+                (end = length + selection);
+              3 === node.nodeType && (length += node.nodeValue.length);
+              if (null === (next = node.firstChild)) break;
+              parentNode = node;
+              node = next;
             }
-            if (type === workInProgress) break a;
-            for (; null === type.sibling; ) {
-              if (null === type.return || type.return === workInProgress)
-                break a;
-              type = type.return;
+            for (;;) {
+              if (node === root) break b;
+              parentNode === JSCompiler_temp &&
+                ++indexWithinAnchor === anchorOffset &&
+                (start = length);
+              parentNode === focusNode &&
+                ++indexWithinFocus === selection &&
+                (end = length);
+              if (null !== (next = node.nextSibling)) break;
+              node = parentNode;
+              parentNode = node.parentNode;
             }
-            type.sibling.return = type.return;
-            type = type.sibling;
-          }
-          workInProgress.stateNode = current;
-          a: switch (
-            (setInitialProperties(current, renderLanes, newProps), renderLanes)
-          ) {
-            case "button":
-            case "input":
-            case "select":
-            case "textarea":
-              current = !!newProps.autoFocus;
-              break a;
-            case "img":
-              current = !0;
-              break a;
-            default:
-              current = !1;
+            node = next;
           }
-          current && markUpdate(workInProgress);
-        }
-        null !== workInProgress.ref && markRef(workInProgress);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        current.memoizedProps !== newProps && markUpdate(workInProgress);
-      else {
-        if ("string" !== typeof newProps && null === workInProgress.stateNode)
-          throw Error(formatProdErrorMessage(166));
-        current = rootInstanceStackCursor.current;
-        if (popHydrationState(workInProgress)) {
-          newProps = workInProgress.stateNode;
-          current = workInProgress.memoizedProps;
-          newProps[internalInstanceKey] = workInProgress;
-          if ((renderLanes = newProps.nodeValue !== current))
-            if (((type = hydrationParentFiber), null !== type))
-              switch (type.tag) {
-                case 3:
-                  newProps = newProps.nodeValue;
-                  normalizeMarkupForTextOrAttribute(current);
-                  normalizeMarkupForTextOrAttribute(newProps);
-                  break;
-                case 27:
-                case 5:
-                  !0 !== type.memoizedProps.suppressHydrationWarning &&
-                    ((newProps = newProps.nodeValue),
-                    normalizeMarkupForTextOrAttribute(current),
-                    normalizeMarkupForTextOrAttribute(newProps));
-              }
-          renderLanes && markUpdate(workInProgress);
-        } else
-          (current =
-            getOwnerDocumentFromRootContainer(current).createTextNode(
-              newProps
-            )),
-            (current[internalInstanceKey] = workInProgress),
-            (workInProgress.stateNode = current);
-      }
-      bubbleProperties(workInProgress);
-      return null;
-    case 13:
-      popSuspenseHandler(workInProgress);
-      newProps = workInProgress.memoizedState;
-      if (
-        null === current ||
-        (null !== current.memoizedState &&
-          null !== current.memoizedState.dehydrated)
-      ) {
-        if (
-          isHydrating &&
-          null !== nextHydratableInstance &&
-          0 !== (workInProgress.mode & 1) &&
-          0 === (workInProgress.flags & 128)
-        )
-          warnIfUnhydratedTailNodes(),
-            resetHydrationState(),
-            (workInProgress.flags |= 98560),
-            (type = !1);
-        else if (
-          ((type = popHydrationState(workInProgress)),
-          null !== newProps && null !== newProps.dehydrated)
-        ) {
-          if (null === current) {
-            if (!type) throw Error(formatProdErrorMessage(318));
-            type = workInProgress.memoizedState;
-            type = null !== type ? type.dehydrated : null;
-            if (!type) throw Error(formatProdErrorMessage(317));
-            type[internalInstanceKey] = workInProgress;
-          } else
-            resetHydrationState(),
-              0 === (workInProgress.flags & 128) &&
-                (workInProgress.memoizedState = null),
-              (workInProgress.flags |= 4);
-          bubbleProperties(workInProgress);
-          type = !1;
-        } else
-          null !== hydrationErrors &&
-            (queueRecoverableErrors(hydrationErrors), (hydrationErrors = null)),
-            (type = !0);
-        if (!type) return workInProgress.flags & 65536 ? workInProgress : null;
-      }
-      if (0 !== (workInProgress.flags & 128))
-        return (workInProgress.lanes = renderLanes), workInProgress;
-      renderLanes = null !== newProps;
-      current = null !== current && null !== current.memoizedState;
-      if (renderLanes) {
-        newProps = workInProgress.child;
-        type = null;
-        null !== newProps.alternate &&
-          null !== newProps.alternate.memoizedState &&
-          null !== newProps.alternate.memoizedState.cachePool &&
-          (type = newProps.alternate.memoizedState.cachePool.pool);
-        var cache$154 = null;
-        null !== newProps.memoizedState &&
-          null !== newProps.memoizedState.cachePool &&
-          (cache$154 = newProps.memoizedState.cachePool.pool);
-        cache$154 !== type && (newProps.flags |= 2048);
+          JSCompiler_temp =
+            -1 === start || -1 === end ? null : { start: start, end: end };
+        } else JSCompiler_temp = null;
       }
-      renderLanes !== current &&
-        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
-        renderLanes && (workInProgress.child.flags |= 8192));
-      null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
-      null !== workInProgress.updateQueue &&
-        null != workInProgress.memoizedProps.suspenseCallback &&
-        (workInProgress.flags |= 4);
-      bubbleProperties(workInProgress);
-      return null;
-    case 4:
-      return (
-        popHostContainer(),
-        null === current &&
-          listenToAllSupportedEvents(workInProgress.stateNode.containerInfo),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 10:
-      return (
-        popProvider(workInProgress.type._context),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 17:
-      return bubbleProperties(workInProgress), null;
-    case 19:
-      pop(suspenseStackCursor);
-      type = workInProgress.memoizedState;
-      if (null === type) return bubbleProperties(workInProgress), null;
-      newProps = 0 !== (workInProgress.flags & 128);
-      cache$154 = type.rendering;
-      if (null === cache$154)
-        if (newProps) cutOffTailIfNeeded(type, !1);
-        else {
+    JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
+  } else JSCompiler_temp = null;
+  selectionInformation = { focusedElem: root, selectionRange: JSCompiler_temp };
+  root = null;
+  JSCompiler_temp = selectionInformation.focusedElem;
+  null !== JSCompiler_temp &&
+    (root = getClosestInstanceFromNode(JSCompiler_temp));
+  _enabled = !1;
+  focusedInstanceHandle = root;
+  for (nextEffect = firstChild; null !== nextEffect; ) {
+    firstChild = nextEffect;
+    root = firstChild.deletions;
+    if (null !== root)
+      for (
+        JSCompiler_temp = 0;
+        JSCompiler_temp < root.length;
+        JSCompiler_temp++
+      )
+        (anchorOffset = root[JSCompiler_temp]),
+          doesFiberContain(anchorOffset, focusedInstanceHandle) &&
+            ((shouldFireAfterActiveInstanceBlur = !0),
+            beforeActiveInstanceBlur(anchorOffset));
+    root = firstChild.child;
+    if (0 !== (firstChild.subtreeFlags & 9236) && null !== root)
+      (root.return = firstChild), (nextEffect = root);
+    else
+      for (; null !== nextEffect; ) {
+        firstChild = nextEffect;
+        try {
+          var current = firstChild.alternate,
+            flags = firstChild.flags,
+            JSCompiler_temp$jscomp$0;
           if (
-            0 !== workInProgressRootExitStatus ||
-            (null !== current && 0 !== (current.flags & 128))
-          )
-            for (current = workInProgress.child; null !== current; ) {
-              cache$154 = findFirstSuspended(current);
-              if (null !== cache$154) {
-                workInProgress.flags |= 128;
-                cutOffTailIfNeeded(type, !1);
-                current = cache$154.updateQueue;
-                null !== current &&
-                  ((workInProgress.updateQueue = current),
-                  (workInProgress.flags |= 4));
-                workInProgress.subtreeFlags = 0;
-                current = renderLanes;
-                for (renderLanes = workInProgress.child; null !== renderLanes; )
-                  resetWorkInProgress(renderLanes, current),
-                    (renderLanes = renderLanes.sibling);
-                push(
-                  suspenseStackCursor,
-                  (suspenseStackCursor.current & 1) | 2
-                );
-                return workInProgress.child;
+            (JSCompiler_temp$jscomp$0 =
+              !shouldFireAfterActiveInstanceBlur &&
+              null !== focusedInstanceHandle)
+          ) {
+            var JSCompiler_temp$jscomp$1;
+            if ((JSCompiler_temp$jscomp$1 = 13 === firstChild.tag))
+              a: {
+                if (null !== current) {
+                  var oldState = current.memoizedState;
+                  if (null === oldState || null !== oldState.dehydrated) {
+                    var newState = firstChild.memoizedState;
+                    JSCompiler_temp$jscomp$1 =
+                      null !== newState && null === newState.dehydrated;
+                    break a;
+                  }
+                }
+                JSCompiler_temp$jscomp$1 = !1;
+              }
+            JSCompiler_temp$jscomp$0 =
+              JSCompiler_temp$jscomp$1 &&
+              doesFiberContain(firstChild, focusedInstanceHandle);
+          }
+          JSCompiler_temp$jscomp$0 &&
+            ((shouldFireAfterActiveInstanceBlur = !0),
+            beforeActiveInstanceBlur(firstChild));
+          switch (firstChild.tag) {
+            case 0:
+              if (0 !== (flags & 4)) {
+                var updateQueue = firstChild.updateQueue,
+                  eventPayloads =
+                    null !== updateQueue ? updateQueue.events : null;
+                if (null !== eventPayloads)
+                  for (root = 0; root < eventPayloads.length; root++) {
+                    var _eventPayloads$ii = eventPayloads[root];
+                    _eventPayloads$ii.ref.impl = _eventPayloads$ii.nextImpl;
+                  }
               }
-              current = current.sibling;
-            }
-          null !== type.tail &&
-            now() > workInProgressRootRenderTargetTime &&
-            ((workInProgress.flags |= 128),
-            (newProps = !0),
-            cutOffTailIfNeeded(type, !1),
-            (workInProgress.lanes = 8388608));
+              break;
+            case 11:
+            case 15:
+              break;
+            case 1:
+              if (0 !== (flags & 1024) && null !== current) {
+                var prevProps = current.memoizedProps,
+                  prevState = current.memoizedState,
+                  instance = firstChild.stateNode,
+                  snapshot = instance.getSnapshotBeforeUpdate(
+                    firstChild.elementType === firstChild.type
+                      ? prevProps
+                      : resolveDefaultProps(firstChild.type, prevProps),
+                    prevState
+                  );
+                instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+              }
+              break;
+            case 3:
+              if (0 !== (flags & 1024)) {
+                var container = firstChild.stateNode.containerInfo,
+                  nodeType = container.nodeType;
+                if (9 === nodeType) clearContainerSparingly(container);
+                else if (1 === nodeType)
+                  switch (container.nodeName) {
+                    case "HEAD":
+                    case "HTML":
+                    case "BODY":
+                      clearContainerSparingly(container);
+                      break;
+                    default:
+                      container.textContent = "";
+                  }
+              }
+              break;
+            case 5:
+            case 26:
+            case 27:
+            case 6:
+            case 4:
+            case 17:
+              break;
+            default:
+              if (0 !== (flags & 1024))
+                throw Error(formatProdErrorMessage(163));
+          }
+        } catch (error) {
+          captureCommitPhaseError(firstChild, firstChild.return, error);
         }
-      else {
-        if (!newProps)
-          if (((current = findFirstSuspended(cache$154)), null !== current)) {
-            if (
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              (current = current.updateQueue),
-              null !== current &&
-                ((workInProgress.updateQueue = current),
-                (workInProgress.flags |= 4)),
-              cutOffTailIfNeeded(type, !0),
-              null === type.tail &&
-                "hidden" === type.tailMode &&
-                !cache$154.alternate &&
-                !isHydrating)
-            )
-              return bubbleProperties(workInProgress), null;
-          } else
-            2 * now() - type.renderingStartTime >
-              workInProgressRootRenderTargetTime &&
-              1073741824 !== renderLanes &&
-              ((workInProgress.flags |= 128),
-              (newProps = !0),
-              cutOffTailIfNeeded(type, !1),
-              (workInProgress.lanes = 8388608));
-        type.isBackwards
-          ? ((cache$154.sibling = workInProgress.child),
-            (workInProgress.child = cache$154))
-          : ((current = type.last),
-            null !== current
-              ? (current.sibling = cache$154)
-              : (workInProgress.child = cache$154),
-            (type.last = cache$154));
+        root = firstChild.sibling;
+        if (null !== root) {
+          root.return = firstChild.return;
+          nextEffect = root;
+          break;
+        }
+        nextEffect = firstChild.return;
       }
-      if (null !== type.tail)
-        return (
-          (workInProgress = type.tail),
-          (type.rendering = workInProgress),
-          (type.tail = workInProgress.sibling),
-          (type.renderingStartTime = now()),
-          (workInProgress.sibling = null),
-          (current = suspenseStackCursor.current),
-          push(suspenseStackCursor, newProps ? (current & 1) | 2 : current & 1),
-          workInProgress
-        );
-      bubbleProperties(workInProgress);
-      return null;
-    case 21:
-      return (
-        null === current
-          ? ((current = {
-              DO_NOT_USE_queryAllNodes: DO_NOT_USE_queryAllNodes,
-              DO_NOT_USE_queryFirstNode: DO_NOT_USE_queryFirstNode,
-              containsNode: containsNode,
-              getChildContextValues: getChildContextValues
-            }),
-            (workInProgress.stateNode = current),
-            (current[internalInstanceKey] = workInProgress),
-            null !== workInProgress.ref &&
-              (markRef(workInProgress), markUpdate(workInProgress)))
-          : (null !== workInProgress.ref && markUpdate(workInProgress),
-            current.ref !== workInProgress.ref && markRef(workInProgress)),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        (newProps = null !== workInProgress.memoizedState),
-        23 !== workInProgress.tag &&
-          (null !== current
-            ? (null !== current.memoizedState) !== newProps &&
-              (workInProgress.flags |= 8192)
-            : newProps && (workInProgress.flags |= 8192)),
-        newProps && 0 !== (workInProgress.mode & 1)
-          ? 0 !== (renderLanes & 1073741824) &&
-            0 === (workInProgress.flags & 128) &&
-            (bubbleProperties(workInProgress),
-            23 !== workInProgress.tag &&
-              workInProgress.subtreeFlags & 6 &&
-              (workInProgress.flags |= 8192))
-          : bubbleProperties(workInProgress),
-        null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
-        (renderLanes = null),
-        null !== current &&
-          null !== current.memoizedState &&
-          null !== current.memoizedState.cachePool &&
-          (renderLanes = current.memoizedState.cachePool.pool),
-        (newProps = null),
-        null !== workInProgress.memoizedState &&
-          null !== workInProgress.memoizedState.cachePool &&
-          (newProps = workInProgress.memoizedState.cachePool.pool),
-        newProps !== renderLanes && (workInProgress.flags |= 2048),
-        popTransition(workInProgress, current),
-        null
-      );
-    case 24:
-      return (
-        (renderLanes = null),
-        null !== current && (renderLanes = current.memoizedState.cache),
-        workInProgress.memoizedState.cache !== renderLanes &&
-          (workInProgress.flags |= 2048),
-        popProvider(CacheContext),
-        bubbleProperties(workInProgress),
-        null
-      );
-    case 25:
-      return (
-        enableTransitionTracing &&
-          (null !== workInProgress.stateNode &&
-            enableTransitionTracing &&
-            pop(markerInstanceStack),
-          bubbleProperties(workInProgress)),
-        null
-      );
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+  current = shouldFireAfterActiveInstanceBlur;
+  shouldFireAfterActiveInstanceBlur = !1;
+  focusedInstanceHandle = null;
+  return current;
+}
+function commitHookEffectListUnmount(
+  flags,
+  finishedWork,
+  nearestMountedAncestor
+) {
+  var updateQueue = finishedWork.updateQueue;
+  updateQueue = null !== updateQueue ? updateQueue.lastEffect : null;
+  if (null !== updateQueue) {
+    var effect = (updateQueue = updateQueue.next);
+    do {
+      if ((effect.tag & flags) === flags) {
+        var destroy = effect.destroy;
+        effect.destroy = void 0;
+        void 0 !== destroy &&
+          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+      }
+      effect = effect.next;
+    } while (effect !== updateQueue);
+  }
+}
+function commitHookEffectListMount(flags, finishedWork) {
+  finishedWork = finishedWork.updateQueue;
+  finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
+  if (null !== finishedWork) {
+    var effect = (finishedWork = finishedWork.next);
+    do {
+      if ((effect.tag & flags) === flags) {
+        var create = effect.create;
+        effect.destroy = create();
+      }
+      effect = effect.next;
+    } while (effect !== finishedWork);
+  }
+}
+function commitHookLayoutEffects(finishedWork, hookFlags) {
+  try {
+    commitHookEffectListMount(hookFlags, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
+}
+function commitClassCallbacks(finishedWork) {
+  var updateQueue = finishedWork.updateQueue;
+  if (null !== updateQueue) {
+    var instance = finishedWork.stateNode;
+    try {
+      commitCallbacks(updateQueue, instance);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+function commitHostComponentMount(finishedWork) {
+  var type = finishedWork.type,
+    props = finishedWork.memoizedProps,
+    instance = finishedWork.stateNode;
+  try {
+    a: switch (type) {
+      case "button":
+      case "input":
+      case "select":
+      case "textarea":
+        props.autoFocus && instance.focus();
+        break a;
+      case "img":
+        props.src && (instance.src = props.src);
+    }
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
 }
-function unwindWork(current, workInProgress) {
-  popTreeContext(workInProgress);
-  switch (workInProgress.tag) {
+function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+  var flags = finishedWork.flags;
+  switch (finishedWork.tag) {
+    case 0:
+    case 11:
+    case 15:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 && commitHookLayoutEffects(finishedWork, 5);
+      break;
     case 1:
-      return (
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      if (flags & 4)
+        if (((finishedRoot = finishedWork.stateNode), null === current))
+          try {
+            finishedRoot.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        else {
+          var prevProps =
+            finishedWork.elementType === finishedWork.type
+              ? current.memoizedProps
+              : resolveDefaultProps(finishedWork.type, current.memoizedProps);
+          current = current.memoizedState;
+          try {
+            finishedRoot.componentDidUpdate(
+              prevProps,
+              current,
+              finishedRoot.__reactInternalSnapshotBeforeUpdate
+            );
+          } catch (error$127) {
+            captureCommitPhaseError(
+              finishedWork,
+              finishedWork.return,
+              error$127
+            );
+          }
+        }
+      flags & 64 && commitClassCallbacks(finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+      break;
     case 3:
-      return (
-        popProvider(CacheContext),
-        enableTransitionTracing &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        enableTransitionTracing && pop(transitionStack),
-        popHostContainer(),
-        resetWorkInProgressVersions(),
-        (current = workInProgress.flags),
-        0 !== (current & 65536) && 0 === (current & 128)
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 26:
-    case 27:
-    case 5:
-      return popHostContext(workInProgress), null;
-    case 13:
-      popSuspenseHandler(workInProgress);
-      current = workInProgress.memoizedState;
-      if (null !== current && null !== current.dehydrated) {
-        if (null === workInProgress.alternate)
-          throw Error(formatProdErrorMessage(340));
-        resetHydrationState();
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      if (flags & 64 && ((flags = finishedWork.updateQueue), null !== flags)) {
+        finishedRoot = null;
+        if (null !== finishedWork.child)
+          switch (finishedWork.child.tag) {
+            case 27:
+            case 5:
+              finishedRoot = finishedWork.child.stateNode;
+              break;
+            case 1:
+              finishedRoot = finishedWork.child.stateNode;
+          }
+        try {
+          commitCallbacks(flags, finishedRoot);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
       }
-      current = workInProgress.flags;
-      return current & 65536
-        ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-        : null;
-    case 19:
-      return pop(suspenseStackCursor), null;
-    case 4:
-      return popHostContainer(), null;
-    case 10:
-      return popProvider(workInProgress.type._context), null;
-    case 22:
-    case 23:
-      return (
-        popSuspenseHandler(workInProgress),
-        popHiddenContext(),
-        popTransition(workInProgress, current),
-        (current = workInProgress.flags),
-        current & 65536
-          ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
-          : null
-      );
-    case 24:
-      return popProvider(CacheContext), null;
-    case 25:
-      return (
-        enableTransitionTracing &&
-          null !== workInProgress.stateNode &&
-          enableTransitionTracing &&
-          pop(markerInstanceStack),
-        null
-      );
-    default:
-      return null;
-  }
-}
-function unwindInterruptedWork(current, interruptedWork) {
-  popTreeContext(interruptedWork);
-  switch (interruptedWork.tag) {
-    case 3:
-      popProvider(CacheContext);
-      enableTransitionTracing &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
-      enableTransitionTracing && pop(transitionStack);
-      popHostContainer();
-      resetWorkInProgressVersions();
       break;
     case 26:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+      break;
     case 27:
     case 5:
-      popHostContext(interruptedWork);
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      null === current && flags & 4 && commitHostComponentMount(finishedWork);
+      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
       break;
-    case 4:
-      popHostContainer();
+    case 12:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
       break;
     case 13:
-      popSuspenseHandler(interruptedWork);
-      break;
-    case 19:
-      pop(suspenseStackCursor);
-      break;
-    case 10:
-      popProvider(interruptedWork.type._context);
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
       break;
     case 22:
-    case 23:
-      popSuspenseHandler(interruptedWork);
-      popHiddenContext();
-      popTransition(interruptedWork, current);
-      break;
-    case 24:
-      popProvider(CacheContext);
+      if (0 !== (finishedWork.mode & 1)) {
+        if (
+          ((prevProps =
+            null !== finishedWork.memoizedState || offscreenSubtreeIsHidden),
+          !prevProps)
+        ) {
+          current =
+            (null !== current && null !== current.memoizedState) ||
+            offscreenSubtreeWasHidden;
+          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
+            prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevProps;
+          (offscreenSubtreeWasHidden = current) &&
+          !prevOffscreenSubtreeWasHidden
+            ? recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                0 !== (finishedWork.subtreeFlags & 8772)
+              )
+            : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        }
+      } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 512 &&
+        ("manual" === finishedWork.memoizedProps.mode
+          ? safelyAttachRef(finishedWork, finishedWork.return)
+          : safelyDetachRef(finishedWork, finishedWork.return));
       break;
-    case 25:
-      enableTransitionTracing &&
-        null !== interruptedWork.stateNode &&
-        enableTransitionTracing &&
-        pop(markerInstanceStack);
+    default:
+      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+  }
+}
+function abortRootTransitions(
+  root,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance
+) {
+  if (enableTransitionTracing) {
+    var rootTransitions = root.incompleteTransitions;
+    deletedTransitions.forEach(function (transition) {
+      rootTransitions.has(transition) &&
+        ((transition = rootTransitions.get(transition)),
+        null === transition.aborts && (transition.aborts = []),
+        transition.aborts.push(abort),
+        null !== deletedOffscreenInstance &&
+          null !== transition.pendingBoundaries &&
+          transition.pendingBoundaries.has(deletedOffscreenInstance) &&
+          transition.pendingBoundaries.delete(deletedOffscreenInstance));
+    });
+  }
+}
+function abortTracingMarkerTransitions(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing) {
+    var markerInstance = abortedFiber.stateNode,
+      markerTransitions = markerInstance.transitions,
+      pendingBoundaries = markerInstance.pendingBoundaries;
+    null !== markerTransitions &&
+      deletedTransitions.forEach(function (transition) {
+        if (
+          null !== abortedFiber &&
+          markerTransitions.has(transition) &&
+          (null === markerInstance.aborts ||
+            !markerInstance.aborts.includes(abort)) &&
+          null !== markerInstance.transitions
+        ) {
+          if (null === markerInstance.aborts) {
+            markerInstance.aborts = [abort];
+            transition = abortedFiber.memoizedProps.name;
+            var transitions = markerInstance.transitions,
+              aborts = markerInstance.aborts;
+            enableTransitionTracing &&
+              (null === currentPendingTransitionCallbacks &&
+                (currentPendingTransitionCallbacks = {
+                  transitionStart: null,
+                  transitionProgress: null,
+                  transitionComplete: null,
+                  markerProgress: null,
+                  markerIncomplete: new Map(),
+                  markerComplete: null
+                }),
+              null === currentPendingTransitionCallbacks.markerIncomplete &&
+                (currentPendingTransitionCallbacks.markerIncomplete =
+                  new Map()),
+              currentPendingTransitionCallbacks.markerIncomplete.set(
+                transition,
+                { transitions: transitions, aborts: aborts }
+              ));
+          } else markerInstance.aborts.push(abort);
+          null !== deletedOffscreenInstance &&
+            !isInDeletedTree &&
+            null !== pendingBoundaries &&
+            pendingBoundaries.has(deletedOffscreenInstance) &&
+            (pendingBoundaries.delete(deletedOffscreenInstance),
+            addMarkerProgressCallbackToPendingTransition(
+              abortedFiber.memoizedProps.name,
+              deletedTransitions,
+              pendingBoundaries
+            ));
+        }
+      });
   }
 }
-var offscreenSubtreeIsHidden = !1,
-  offscreenSubtreeWasHidden = !1,
-  PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
-  nextEffect = null;
-function safelyAttachRef(current, nearestMountedAncestor) {
-  try {
-    var ref = current.ref;
-    if (null !== ref) {
-      var instance = current.stateNode;
-      switch (current.tag) {
-        case 26:
-        case 27:
-        case 5:
-          var instanceToUse = instance;
+function abortParentMarkerTransitionsForDeletedFiber(
+  abortedFiber,
+  abort,
+  deletedTransitions,
+  deletedOffscreenInstance,
+  isInDeletedTree
+) {
+  if (enableTransitionTracing)
+    for (; null !== abortedFiber; ) {
+      switch (abortedFiber.tag) {
+        case 25:
+          abortTracingMarkerTransitions(
+            abortedFiber,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance,
+            isInDeletedTree
+          );
           break;
-        default:
-          instanceToUse = instance;
+        case 3:
+          abortRootTransitions(
+            abortedFiber.stateNode,
+            abort,
+            deletedTransitions,
+            deletedOffscreenInstance
+          );
       }
-      21 === current.tag && (instanceToUse = instance);
-      "function" === typeof ref
-        ? (current.refCleanup = ref(instanceToUse))
-        : (ref.current = instanceToUse);
+      abortedFiber = abortedFiber.return;
     }
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+}
+function commitTransitionProgress(offscreenFiber) {
+  if (enableTransitionTracing) {
+    var offscreenInstance = offscreenFiber.stateNode,
+      prevState = null,
+      previousFiber = offscreenFiber.alternate;
+    null !== previousFiber &&
+      null !== previousFiber.memoizedState &&
+      (prevState = previousFiber.memoizedState);
+    prevState = null !== prevState;
+    previousFiber = null !== offscreenFiber.memoizedState;
+    var pendingMarkers = offscreenInstance._pendingMarkers,
+      name = null;
+    offscreenFiber = offscreenFiber.return;
+    null !== offscreenFiber &&
+      13 === offscreenFiber.tag &&
+      offscreenFiber.memoizedProps.unstable_name &&
+      (name = offscreenFiber.memoizedProps.unstable_name);
+    !prevState && previousFiber
+      ? null !== pendingMarkers &&
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries,
+            transitions = markerInstance.transitions,
+            markerName = markerInstance.name;
+          null === pendingBoundaries ||
+            pendingBoundaries.has(offscreenInstance) ||
+            (pendingBoundaries.set(offscreenInstance, { name: name }),
+            null !== transitions &&
+              (1 === markerInstance.tag && null !== markerName
+                ? addMarkerProgressCallbackToPendingTransition(
+                    markerName,
+                    transitions,
+                    pendingBoundaries
+                  )
+                : 0 === markerInstance.tag &&
+                  transitions.forEach(function (transition) {
+                    addTransitionProgressCallbackToPendingTransition(
+                      transition,
+                      pendingBoundaries
+                    );
+                  })));
+        })
+      : prevState &&
+        !previousFiber &&
+        null !== pendingMarkers &&
+        pendingMarkers.forEach(function (markerInstance) {
+          var pendingBoundaries = markerInstance.pendingBoundaries,
+            transitions = markerInstance.transitions,
+            markerName = markerInstance.name;
+          null !== pendingBoundaries &&
+            pendingBoundaries.has(offscreenInstance) &&
+            (pendingBoundaries.delete(offscreenInstance),
+            null !== transitions &&
+              (1 === markerInstance.tag && null !== markerName
+                ? (addMarkerProgressCallbackToPendingTransition(
+                    markerName,
+                    transitions,
+                    pendingBoundaries
+                  ),
+                  0 === pendingBoundaries.size &&
+                    (null === markerInstance.aborts &&
+                      addMarkerCompleteCallbackToPendingTransition(
+                        markerName,
+                        transitions
+                      ),
+                    (markerInstance.transitions = null),
+                    (markerInstance.pendingBoundaries = null),
+                    (markerInstance.aborts = null)))
+                : 0 === markerInstance.tag &&
+                  transitions.forEach(function (transition) {
+                    addTransitionProgressCallbackToPendingTransition(
+                      transition,
+                      pendingBoundaries
+                    );
+                  })));
+        });
   }
 }
-function safelyDetachRef(current, nearestMountedAncestor) {
-  var ref = current.ref,
-    refCleanup = current.refCleanup;
-  if (null !== ref)
-    if ("function" === typeof refCleanup)
-      try {
-        refCleanup();
-      } catch (error) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error);
-      } finally {
-        (current.refCleanup = null),
-          (current = current.alternate),
-          null != current && (current.refCleanup = null);
-      }
-    else if ("function" === typeof ref)
-      try {
-        ref(null);
-      } catch (error$169) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error$169);
-      }
-    else ref.current = null;
+function detachFiberAfterEffects(fiber) {
+  var alternate = fiber.alternate;
+  null !== alternate &&
+    ((fiber.alternate = null), detachFiberAfterEffects(alternate));
+  fiber.child = null;
+  fiber.deletions = null;
+  fiber.sibling = null;
+  5 === fiber.tag &&
+    ((alternate = fiber.stateNode),
+    null !== alternate && detachDeletedInstance(alternate));
+  fiber.stateNode = null;
+  fiber.return = null;
+  fiber.dependencies = null;
+  fiber.memoizedProps = null;
+  fiber.memoizedState = null;
+  fiber.pendingProps = null;
+  fiber.stateNode = null;
+  fiber.updateQueue = null;
 }
-function safelyCallDestroy(current, nearestMountedAncestor, destroy) {
-  try {
-    destroy();
-  } catch (error) {
-    captureCommitPhaseError(current, nearestMountedAncestor, error);
+function isHostParent(fiber) {
+  return (
+    5 === fiber.tag ||
+    3 === fiber.tag ||
+    26 === fiber.tag ||
+    27 === fiber.tag ||
+    4 === fiber.tag
+  );
+}
+function getHostSibling(fiber) {
+  a: for (;;) {
+    for (; null === fiber.sibling; ) {
+      if (null === fiber.return || isHostParent(fiber.return)) return null;
+      fiber = fiber.return;
+    }
+    fiber.sibling.return = fiber.return;
+    for (
+      fiber = fiber.sibling;
+      5 !== fiber.tag &&
+      6 !== fiber.tag &&
+      27 !== fiber.tag &&
+      18 !== fiber.tag;
+
+    ) {
+      if (fiber.flags & 2) continue a;
+      if (null === fiber.child || 4 === fiber.tag) continue a;
+      else (fiber.child.return = fiber), (fiber = fiber.child);
+    }
+    if (!(fiber.flags & 2)) return fiber.stateNode;
   }
 }
-var focusedInstanceHandle = null,
-  shouldFireAfterActiveInstanceBlur = !1;
-function commitBeforeMutationEffects(root, firstChild) {
-  eventsEnabled = _enabled;
-  root = getActiveElementDeep();
-  if (hasSelectionCapabilities(root)) {
-    if ("selectionStart" in root)
-      var JSCompiler_temp = {
-        start: root.selectionStart,
-        end: root.selectionEnd
-      };
-    else
-      a: {
-        JSCompiler_temp =
-          ((JSCompiler_temp = root.ownerDocument) &&
-            JSCompiler_temp.defaultView) ||
-          window;
-        var selection =
-          JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
-        if (selection && 0 !== selection.rangeCount) {
-          JSCompiler_temp = selection.anchorNode;
-          var anchorOffset = selection.anchorOffset,
-            focusNode = selection.focusNode;
-          selection = selection.focusOffset;
-          try {
-            JSCompiler_temp.nodeType, focusNode.nodeType;
-          } catch (e$25) {
-            JSCompiler_temp = null;
-            break a;
-          }
-          var length = 0,
-            start = -1,
-            end = -1,
-            indexWithinAnchor = 0,
-            indexWithinFocus = 0,
-            node = root,
-            parentNode = null;
-          b: for (;;) {
-            for (var next; ; ) {
-              node !== JSCompiler_temp ||
-                (0 !== anchorOffset && 3 !== node.nodeType) ||
-                (start = length + anchorOffset);
-              node !== focusNode ||
-                (0 !== selection && 3 !== node.nodeType) ||
-                (end = length + selection);
-              3 === node.nodeType && (length += node.nodeValue.length);
-              if (null === (next = node.firstChild)) break;
-              parentNode = node;
-              node = next;
-            }
-            for (;;) {
-              if (node === root) break b;
-              parentNode === JSCompiler_temp &&
-                ++indexWithinAnchor === anchorOffset &&
-                (start = length);
-              parentNode === focusNode &&
-                ++indexWithinFocus === selection &&
-                (end = length);
-              if (null !== (next = node.nextSibling)) break;
-              node = parentNode;
-              parentNode = node.parentNode;
-            }
-            node = next;
-          }
-          JSCompiler_temp =
-            -1 === start || -1 === end ? null : { start: start, end: end };
-        } else JSCompiler_temp = null;
-      }
-    JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
-  } else JSCompiler_temp = null;
-  selectionInformation = { focusedElem: root, selectionRange: JSCompiler_temp };
-  root = null;
-  JSCompiler_temp = selectionInformation.focusedElem;
-  null !== JSCompiler_temp &&
-    (root = getClosestInstanceFromNode(JSCompiler_temp));
-  _enabled = !1;
-  focusedInstanceHandle = root;
-  for (nextEffect = firstChild; null !== nextEffect; ) {
-    firstChild = nextEffect;
-    root = firstChild.deletions;
-    if (null !== root)
-      for (
-        JSCompiler_temp = 0;
-        JSCompiler_temp < root.length;
-        JSCompiler_temp++
-      )
-        (anchorOffset = root[JSCompiler_temp]),
-          doesFiberContain(anchorOffset, focusedInstanceHandle) &&
-            ((_enabled = shouldFireAfterActiveInstanceBlur = !0),
-            dispatchBeforeDetachedBlur(
-              selectionInformation.focusedElem,
-              anchorOffset
-            ),
-            (_enabled = !1));
-    root = firstChild.child;
-    if (0 !== (firstChild.subtreeFlags & 9236) && null !== root)
-      (root.return = firstChild), (nextEffect = root);
-    else
-      for (; null !== nextEffect; ) {
-        firstChild = nextEffect;
-        try {
-          var current = firstChild.alternate,
-            flags = firstChild.flags,
-            JSCompiler_temp$jscomp$0;
-          if (
-            (JSCompiler_temp$jscomp$0 =
-              !shouldFireAfterActiveInstanceBlur &&
-              null !== focusedInstanceHandle)
-          ) {
-            var JSCompiler_temp$jscomp$1;
-            if ((JSCompiler_temp$jscomp$1 = 13 === firstChild.tag))
-              a: {
-                if (null !== current) {
-                  var oldState = current.memoizedState;
-                  if (null === oldState || null !== oldState.dehydrated) {
-                    var newState = firstChild.memoizedState;
-                    JSCompiler_temp$jscomp$1 =
-                      null !== newState && null === newState.dehydrated;
-                    break a;
-                  }
-                }
-                JSCompiler_temp$jscomp$1 = !1;
-              }
-            JSCompiler_temp$jscomp$0 =
-              JSCompiler_temp$jscomp$1 &&
-              doesFiberContain(firstChild, focusedInstanceHandle);
-          }
-          JSCompiler_temp$jscomp$0 &&
-            ((shouldFireAfterActiveInstanceBlur = !0),
-            (root = firstChild),
-            (_enabled = !0),
-            dispatchBeforeDetachedBlur(selectionInformation.focusedElem, root),
-            (_enabled = !1));
-          switch (firstChild.tag) {
-            case 0:
-              if (0 !== (flags & 4)) {
-                var updateQueue = firstChild.updateQueue,
-                  eventPayloads =
-                    null !== updateQueue ? updateQueue.events : null;
-                if (null !== eventPayloads)
-                  for (root = 0; root < eventPayloads.length; root++) {
-                    var _eventPayloads$ii = eventPayloads[root];
-                    _eventPayloads$ii.ref.impl = _eventPayloads$ii.nextImpl;
-                  }
-              }
-              break;
-            case 11:
-            case 15:
-              break;
-            case 1:
-              if (0 !== (flags & 1024) && null !== current) {
-                var prevProps = current.memoizedProps,
-                  prevState = current.memoizedState,
-                  instance = firstChild.stateNode,
-                  snapshot = instance.getSnapshotBeforeUpdate(
-                    firstChild.elementType === firstChild.type
-                      ? prevProps
-                      : resolveDefaultProps(firstChild.type, prevProps),
-                    prevState
-                  );
-                instance.__reactInternalSnapshotBeforeUpdate = snapshot;
-              }
-              break;
-            case 3:
-              if (0 !== (flags & 1024)) {
-                var container = firstChild.stateNode.containerInfo,
-                  nodeType = container.nodeType;
-                if (9 === nodeType) clearContainerSparingly(container);
-                else if (1 === nodeType)
-                  switch (container.nodeName) {
-                    case "HEAD":
-                    case "HTML":
-                    case "BODY":
-                      clearContainerSparingly(container);
-                      break;
-                    default:
-                      container.textContent = "";
-                  }
-              }
-              break;
-            case 5:
-            case 26:
-            case 27:
-            case 6:
-            case 4:
-            case 17:
-              break;
-            default:
-              if (0 !== (flags & 1024))
-                throw Error(formatProdErrorMessage(163));
-          }
+function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+  var tag = node.tag;
+  if (5 === tag || 6 === tag)
+    (node = node.stateNode),
+      before
+        ? 8 === parent.nodeType
+          ? parent.parentNode.insertBefore(node, before)
+          : parent.insertBefore(node, before)
+        : (8 === parent.nodeType
+            ? ((before = parent.parentNode), before.insertBefore(node, parent))
+            : ((before = parent), before.appendChild(node)),
+          (parent = parent._reactRootContainer),
+          (null !== parent && void 0 !== parent) ||
+            null !== before.onclick ||
+            (before.onclick = noop));
+  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
+    for (
+      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
+        node = node.sibling;
+      null !== node;
+
+    )
+      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
+        (node = node.sibling);
+}
+function insertOrAppendPlacementNode(node, before, parent) {
+  var tag = node.tag;
+  if (5 === tag || 6 === tag)
+    (node = node.stateNode),
+      before ? parent.insertBefore(node, before) : parent.appendChild(node);
+  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
+    for (
+      insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
+      null !== node;
+
+    )
+      insertOrAppendPlacementNode(node, before, parent), (node = node.sibling);
+}
+var hostParent = null,
+  hostParentIsContainer = !1;
+function recursivelyTraverseDeletionEffects(
+  finishedRoot,
+  nearestMountedAncestor,
+  parent
+) {
+  for (parent = parent.child; null !== parent; )
+    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent),
+      (parent = parent.sibling);
+}
+function commitDeletionEffectsOnFiber(
+  finishedRoot,
+  nearestMountedAncestor,
+  deletedFiber
+) {
+  if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
+    try {
+      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+    } catch (err) {}
+  switch (deletedFiber.tag) {
+    case 26:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      deletedFiber.memoizedState
+        ? deletedFiber.memoizedState.count--
+        : deletedFiber.stateNode &&
+          ((deletedFiber = deletedFiber.stateNode),
+          deletedFiber.parentNode.removeChild(deletedFiber));
+      break;
+    case 27:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      var prevHostParent = hostParent,
+        prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = deletedFiber.stateNode;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      deletedFiber = deletedFiber.stateNode;
+      for (finishedRoot = deletedFiber.attributes; finishedRoot.length; )
+        deletedFiber.removeAttributeNode(finishedRoot[0]);
+      detachDeletedInstance(deletedFiber);
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      break;
+    case 5:
+      offscreenSubtreeWasHidden ||
+        safelyDetachRef(deletedFiber, nearestMountedAncestor);
+    case 6:
+      prevHostParent = hostParent;
+      prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = null;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      null !== hostParent &&
+        (hostParentIsContainer
+          ? ((finishedRoot = hostParent),
+            (deletedFiber = deletedFiber.stateNode),
+            8 === finishedRoot.nodeType
+              ? finishedRoot.parentNode.removeChild(deletedFiber)
+              : finishedRoot.removeChild(deletedFiber))
+          : hostParent.removeChild(deletedFiber.stateNode));
+      break;
+    case 18:
+      finishedRoot = finishedRoot.hydrationCallbacks;
+      null !== finishedRoot &&
+        (finishedRoot = finishedRoot.onDeleted) &&
+        finishedRoot(deletedFiber.stateNode);
+      null !== hostParent &&
+        (hostParentIsContainer
+          ? ((finishedRoot = hostParent),
+            (deletedFiber = deletedFiber.stateNode),
+            8 === finishedRoot.nodeType
+              ? clearSuspenseBoundary(finishedRoot.parentNode, deletedFiber)
+              : 1 === finishedRoot.nodeType &&
+                clearSuspenseBoundary(finishedRoot, deletedFiber),
+            retryIfBlockedOn(finishedRoot))
+          : clearSuspenseBoundary(hostParent, deletedFiber.stateNode));
+      break;
+    case 4:
+      prevHostParent = hostParent;
+      prevHostParentIsContainer = hostParentIsContainer;
+      hostParent = deletedFiber.stateNode.containerInfo;
+      hostParentIsContainer = !0;
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      hostParent = prevHostParent;
+      hostParentIsContainer = prevHostParentIsContainer;
+      break;
+    case 0:
+    case 11:
+    case 14:
+    case 15:
+      if (
+        !offscreenSubtreeWasHidden &&
+        ((prevHostParent = deletedFiber.updateQueue),
+        null !== prevHostParent &&
+          ((prevHostParent = prevHostParent.lastEffect),
+          null !== prevHostParent))
+      ) {
+        prevHostParentIsContainer = prevHostParent = prevHostParent.next;
+        do {
+          var _effect = prevHostParentIsContainer,
+            destroy = _effect.destroy;
+          _effect = _effect.tag;
+          void 0 !== destroy &&
+            (0 !== (_effect & 2)
+              ? safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy)
+              : 0 !== (_effect & 4) &&
+                safelyCallDestroy(
+                  deletedFiber,
+                  nearestMountedAncestor,
+                  destroy
+                ));
+          prevHostParentIsContainer = prevHostParentIsContainer.next;
+        } while (prevHostParentIsContainer !== prevHostParent);
+      }
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      break;
+    case 1:
+      if (
+        !offscreenSubtreeWasHidden &&
+        (safelyDetachRef(deletedFiber, nearestMountedAncestor),
+        (prevHostParent = deletedFiber.stateNode),
+        "function" === typeof prevHostParent.componentWillUnmount)
+      )
+        try {
+          (prevHostParent.props = deletedFiber.memoizedProps),
+            (prevHostParent.state = deletedFiber.memoizedState),
+            prevHostParent.componentWillUnmount();
         } catch (error) {
-          captureCommitPhaseError(firstChild, firstChild.return, error);
-        }
-        root = firstChild.sibling;
-        if (null !== root) {
-          root.return = firstChild.return;
-          nextEffect = root;
-          break;
+          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
         }
-        nextEffect = firstChild.return;
-      }
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      break;
+    case 21:
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
+      break;
+    case 22:
+      safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      deletedFiber.mode & 1
+        ? ((offscreenSubtreeWasHidden =
+            (prevHostParent = offscreenSubtreeWasHidden) ||
+            null !== deletedFiber.memoizedState),
+          recursivelyTraverseDeletionEffects(
+            finishedRoot,
+            nearestMountedAncestor,
+            deletedFiber
+          ),
+          (offscreenSubtreeWasHidden = prevHostParent))
+        : recursivelyTraverseDeletionEffects(
+            finishedRoot,
+            nearestMountedAncestor,
+            deletedFiber
+          );
+      break;
+    default:
+      recursivelyTraverseDeletionEffects(
+        finishedRoot,
+        nearestMountedAncestor,
+        deletedFiber
+      );
   }
-  current = shouldFireAfterActiveInstanceBlur;
-  shouldFireAfterActiveInstanceBlur = !1;
-  focusedInstanceHandle = null;
-  return current;
 }
-function commitHookEffectListUnmount(
-  flags,
-  finishedWork,
-  nearestMountedAncestor
-) {
-  var updateQueue = finishedWork.updateQueue;
-  updateQueue = null !== updateQueue ? updateQueue.lastEffect : null;
-  if (null !== updateQueue) {
-    var effect = (updateQueue = updateQueue.next);
-    do {
-      if ((effect.tag & flags) === flags) {
-        var destroy = effect.destroy;
-        effect.destroy = void 0;
-        void 0 !== destroy &&
-          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);
+function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+  if (null === finishedWork.memoizedState) {
+    var current = finishedWork.alternate;
+    if (
+      null !== current &&
+      ((current = current.memoizedState),
+      null !== current && ((current = current.dehydrated), null !== current))
+    )
+      try {
+        retryIfBlockedOn(current);
+        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
+        if (null !== hydrationCallbacks) {
+          var onHydrated = hydrationCallbacks.onHydrated;
+          onHydrated && onHydrated(current);
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
       }
-      effect = effect.next;
-    } while (effect !== updateQueue);
   }
 }
-function commitHookEffectListMount(flags, finishedWork) {
-  finishedWork = finishedWork.updateQueue;
-  finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
-  if (null !== finishedWork) {
-    var effect = (finishedWork = finishedWork.next);
-    do {
-      if ((effect.tag & flags) === flags) {
-        var create = effect.create;
-        effect.destroy = create();
-      }
-      effect = effect.next;
-    } while (effect !== finishedWork);
+function getRetryCache(finishedWork) {
+  switch (finishedWork.tag) {
+    case 13:
+    case 19:
+      var retryCache = finishedWork.stateNode;
+      null === retryCache &&
+        (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+      return retryCache;
+    case 22:
+      return (
+        (finishedWork = finishedWork.stateNode),
+        (retryCache = finishedWork._retryCache),
+        null === retryCache &&
+          (retryCache = finishedWork._retryCache = new PossiblyWeakSet()),
+        retryCache
+      );
+    default:
+      throw Error(formatProdErrorMessage(435, finishedWork.tag));
   }
 }
-function commitHookLayoutEffects(finishedWork, hookFlags) {
-  try {
-    commitHookEffectListMount(hookFlags, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+function detachOffscreenInstance(instance) {
+  var fiber = instance._current;
+  if (null === fiber) throw Error(formatProdErrorMessage(456));
+  if (0 === (instance._pendingVisibility & 2)) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root &&
+      ((instance._pendingVisibility |= 2),
+      scheduleUpdateOnFiber(root, fiber, 2, -1));
   }
 }
-function commitClassCallbacks(finishedWork) {
-  var updateQueue = finishedWork.updateQueue;
-  if (null !== updateQueue) {
-    var instance = finishedWork.stateNode;
-    try {
-      commitCallbacks(updateQueue, instance);
-    } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
-    }
+function attachOffscreenInstance(instance) {
+  var fiber = instance._current;
+  if (null === fiber) throw Error(formatProdErrorMessage(456));
+  if (0 !== (instance._pendingVisibility & 2)) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root &&
+      ((instance._pendingVisibility &= -3),
+      scheduleUpdateOnFiber(root, fiber, 2, -1));
   }
 }
-function commitHostComponentMount(finishedWork) {
-  var type = finishedWork.type,
-    props = finishedWork.memoizedProps,
-    instance = finishedWork.stateNode;
-  try {
-    a: switch (type) {
-      case "button":
-      case "input":
-      case "select":
-      case "textarea":
-        props.autoFocus && instance.focus();
-        break a;
-      case "img":
-        props.src && (instance.src = props.src);
+function attachSuspenseRetryListeners(finishedWork, wakeables) {
+  var retryCache = getRetryCache(finishedWork);
+  wakeables.forEach(function (wakeable) {
+    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+    retryCache.has(wakeable) ||
+      (retryCache.add(wakeable), wakeable.then(retry, retry));
+  });
+}
+function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (null !== deletions)
+    for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i];
+      try {
+        var root = root$jscomp$0,
+          returnFiber = parentFiber,
+          parent = returnFiber;
+        a: for (; null !== parent; ) {
+          switch (parent.tag) {
+            case 27:
+            case 5:
+              hostParent = parent.stateNode;
+              hostParentIsContainer = !1;
+              break a;
+            case 3:
+              hostParent = parent.stateNode.containerInfo;
+              hostParentIsContainer = !0;
+              break a;
+            case 4:
+              hostParent = parent.stateNode.containerInfo;
+              hostParentIsContainer = !0;
+              break a;
+          }
+          parent = parent.return;
+        }
+        if (null === hostParent) throw Error(formatProdErrorMessage(160));
+        commitDeletionEffectsOnFiber(root, returnFiber, childToDelete);
+        hostParent = null;
+        hostParentIsContainer = !1;
+        var alternate = childToDelete.alternate;
+        null !== alternate && (alternate.return = null);
+        childToDelete.return = null;
+      } catch (error) {
+        captureCommitPhaseError(childToDelete, parentFiber, error);
+      }
     }
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
-  }
+  if (parentFiber.subtreeFlags & 12854)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitMutationEffectsOnFiber(parentFiber, root$jscomp$0),
+        (parentFiber = parentFiber.sibling);
 }
-function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
-  var flags = finishedWork.flags;
+var currentHoistableRoot = null;
+function commitMutationEffectsOnFiber(finishedWork, root) {
+  var current = finishedWork.alternate,
+    flags = finishedWork.flags;
   switch (finishedWork.tag) {
     case 0:
     case 11:
+    case 14:
     case 15:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 4 && commitHookLayoutEffects(finishedWork, 5);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4) {
+        try {
+          commitHookEffectListUnmount(3, finishedWork, finishedWork.return),
+            commitHookEffectListMount(3, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+        try {
+          commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
+        } catch (error$140) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$140);
+        }
+      }
       break;
     case 1:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      flags & 64 &&
+        offscreenSubtreeIsHidden &&
+        ((finishedWork = finishedWork.updateQueue),
+        null !== finishedWork &&
+          ((current = finishedWork.callbacks),
+          null !== current &&
+            ((flags = finishedWork.shared.hiddenCallbacks),
+            (finishedWork.shared.hiddenCallbacks =
+              null === flags ? current : flags.concat(current)))));
+      break;
+    case 26:
+      var hoistableRoot = currentHoistableRoot;
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
       if (flags & 4)
-        if (((finishedRoot = finishedWork.stateNode), null === current))
-          try {
-            finishedRoot.componentDidMount();
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        else {
-          var prevProps =
-            finishedWork.elementType === finishedWork.type
-              ? current.memoizedProps
-              : resolveDefaultProps(finishedWork.type, current.memoizedProps);
-          current = current.memoizedState;
-          try {
-            finishedRoot.componentDidUpdate(
-              prevProps,
-              current,
-              finishedRoot.__reactInternalSnapshotBeforeUpdate
-            );
-          } catch (error$171) {
-            captureCommitPhaseError(
-              finishedWork,
-              finishedWork.return,
-              error$171
+        if (
+          ((root = null !== current ? current.memoizedState : null),
+          (flags = finishedWork.memoizedState),
+          null === current)
+        )
+          if (null === flags)
+            if (null === finishedWork.stateNode) {
+              a: {
+                current = finishedWork.type;
+                flags = finishedWork.memoizedProps;
+                root = hoistableRoot.ownerDocument || hoistableRoot;
+                b: switch (current) {
+                  case "title":
+                    hoistableRoot = root.getElementsByTagName("title")[0];
+                    if (
+                      !hoistableRoot ||
+                      hoistableRoot[internalHoistableMarker] ||
+                      hoistableRoot[internalInstanceKey] ||
+                      "http://www.w3.org/2000/svg" ===
+                        hoistableRoot.namespaceURI ||
+                      hoistableRoot.hasAttribute("itemprop")
+                    )
+                      (hoistableRoot = root.createElement(current)),
+                        root.head.insertBefore(
+                          hoistableRoot,
+                          root.querySelector("head > title")
+                        );
+                    setInitialProperties(hoistableRoot, current, flags);
+                    hoistableRoot[internalInstanceKey] = finishedWork;
+                    markNodeAsHoistable(hoistableRoot);
+                    current = hoistableRoot;
+                    break a;
+                  case "link":
+                    var maybeNodes = getHydratableHoistableCache(
+                      "link",
+                      "href",
+                      root
+                    ).get(current + (flags.href || ""));
+                    if (maybeNodes)
+                      for (var i = 0; i < maybeNodes.length; i++)
+                        if (
+                          ((hoistableRoot = maybeNodes[i]),
+                          hoistableRoot.getAttribute("href") ===
+                            (null == flags.href ? null : flags.href) &&
+                            hoistableRoot.getAttribute("rel") ===
+                              (null == flags.rel ? null : flags.rel) &&
+                            hoistableRoot.getAttribute("title") ===
+                              (null == flags.title ? null : flags.title) &&
+                            hoistableRoot.getAttribute("crossorigin") ===
+                              (null == flags.crossOrigin
+                                ? null
+                                : flags.crossOrigin))
+                        ) {
+                          maybeNodes.splice(i, 1);
+                          break b;
+                        }
+                    hoistableRoot = root.createElement(current);
+                    setInitialProperties(hoistableRoot, current, flags);
+                    root.head.appendChild(hoistableRoot);
+                    break;
+                  case "meta":
+                    if (
+                      (maybeNodes = getHydratableHoistableCache(
+                        "meta",
+                        "content",
+                        root
+                      ).get(current + (flags.content || "")))
+                    )
+                      for (i = 0; i < maybeNodes.length; i++)
+                        if (
+                          ((hoistableRoot = maybeNodes[i]),
+                          hoistableRoot.getAttribute("content") ===
+                            (null == flags.content
+                              ? null
+                              : "" + flags.content) &&
+                            hoistableRoot.getAttribute("name") ===
+                              (null == flags.name ? null : flags.name) &&
+                            hoistableRoot.getAttribute("property") ===
+                              (null == flags.property
+                                ? null
+                                : flags.property) &&
+                            hoistableRoot.getAttribute("http-equiv") ===
+                              (null == flags.httpEquiv
+                                ? null
+                                : flags.httpEquiv) &&
+                            hoistableRoot.getAttribute("charset") ===
+                              (null == flags.charSet ? null : flags.charSet))
+                        ) {
+                          maybeNodes.splice(i, 1);
+                          break b;
+                        }
+                    hoistableRoot = root.createElement(current);
+                    setInitialProperties(hoistableRoot, current, flags);
+                    root.head.appendChild(hoistableRoot);
+                    break;
+                  default:
+                    throw Error(formatProdErrorMessage(468, current));
+                }
+                hoistableRoot[internalInstanceKey] = finishedWork;
+                markNodeAsHoistable(hoistableRoot);
+                current = hoistableRoot;
+              }
+              finishedWork.stateNode = current;
+            } else
+              mountHoistable(
+                hoistableRoot,
+                finishedWork.type,
+                finishedWork.stateNode
+              );
+          else
+            finishedWork.stateNode = acquireResource(
+              hoistableRoot,
+              flags,
+              finishedWork.memoizedProps
+            );
+        else if (root !== flags)
+          null === root
+            ? null !== current.stateNode &&
+              ((current = current.stateNode),
+              current.parentNode.removeChild(current))
+            : root.count--,
+            null === flags
+              ? mountHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.stateNode
+                )
+              : acquireResource(
+                  hoistableRoot,
+                  flags,
+                  finishedWork.memoizedProps
+                );
+        else if (
+          null === flags &&
+          null !== finishedWork.stateNode &&
+          ((flags = finishedWork.updateQueue),
+          (finishedWork.updateQueue = null),
+          null !== flags)
+        )
+          try {
+            var domElement = finishedWork.stateNode,
+              newProps = finishedWork.memoizedProps;
+            updateProperties(
+              domElement,
+              flags,
+              finishedWork.type,
+              current.memoizedProps,
+              newProps
+            );
+            domElement[internalPropsKey] = newProps;
+          } catch (error$141) {
+            captureCommitPhaseError(
+              finishedWork,
+              finishedWork.return,
+              error$141
             );
           }
-        }
-      flags & 64 && commitClassCallbacks(finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
-      break;
-    case 3:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      if (flags & 64 && ((flags = finishedWork.updateQueue), null !== flags)) {
-        finishedRoot = null;
-        if (null !== finishedWork.child)
-          switch (finishedWork.child.tag) {
-            case 27:
-            case 5:
-              finishedRoot = finishedWork.child.stateNode;
-              break;
-            case 1:
-              finishedRoot = finishedWork.child.stateNode;
-          }
+      break;
+    case 27:
+      if (flags & 4 && null === finishedWork.alternate) {
+        hoistableRoot = finishedWork.stateNode;
+        maybeNodes = finishedWork.memoizedProps;
+        for (i = hoistableRoot.firstChild; i; ) {
+          var nextNode = i.nextSibling,
+            nodeName = i.nodeName;
+          i[internalHoistableMarker] ||
+            "HEAD" === nodeName ||
+            "BODY" === nodeName ||
+            "STYLE" === nodeName ||
+            ("LINK" === nodeName && "stylesheet" === i.rel.toLowerCase()) ||
+            hoistableRoot.removeChild(i);
+          i = nextNode;
+        }
+        i = finishedWork.type;
+        for (nextNode = hoistableRoot.attributes; nextNode.length; )
+          hoistableRoot.removeAttributeNode(nextNode[0]);
+        setInitialProperties(hoistableRoot, i, maybeNodes);
+        hoistableRoot[internalInstanceKey] = finishedWork;
+        hoistableRoot[internalPropsKey] = maybeNodes;
+      }
+    case 5:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      if (finishedWork.flags & 32) {
+        root = finishedWork.stateNode;
         try {
-          commitCallbacks(flags, finishedRoot);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          setTextContent(root, "");
+        } catch (error$142) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$142);
         }
       }
+      if (
+        flags & 4 &&
+        ((flags = finishedWork.stateNode),
+        null != flags &&
+          ((root = finishedWork.memoizedProps),
+          (current = null !== current ? current.memoizedProps : root),
+          (hoistableRoot = finishedWork.type),
+          (maybeNodes = finishedWork.updateQueue),
+          (finishedWork.updateQueue = null),
+          null !== maybeNodes))
+      )
+        try {
+          updateProperties(flags, maybeNodes, hoistableRoot, current, root),
+            (flags[internalPropsKey] = root);
+        } catch (error$145) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$145);
+        }
       break;
-    case 26:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+    case 6:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4) {
+        if (null === finishedWork.stateNode)
+          throw Error(formatProdErrorMessage(162));
+        current = finishedWork.stateNode;
+        flags = finishedWork.memoizedProps;
+        try {
+          current.nodeValue = flags;
+        } catch (error$146) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$146);
+        }
+      }
       break;
-    case 27:
-    case 5:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      null === current && flags & 4 && commitHostComponentMount(finishedWork);
-      flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+    case 3:
+      tagCaches = null;
+      hoistableRoot = currentHoistableRoot;
+      currentHoistableRoot = getHoistableRoot(root.containerInfo);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      currentHoistableRoot = hoistableRoot;
+      commitReconciliationEffects(finishedWork);
+      if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
+        try {
+          retryIfBlockedOn(root.containerInfo);
+        } catch (error$147) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$147);
+        }
       break;
-    case 12:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    case 4:
+      current = currentHoistableRoot;
+      currentHoistableRoot = getHoistableRoot(
+        finishedWork.stateNode.containerInfo
+      );
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      currentHoistableRoot = current;
       break;
     case 13:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-      flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      current = finishedWork.child;
+      current.flags & 8192 &&
+        null !== current.memoizedState &&
+        (null === current.alternate ||
+          null === current.alternate.memoizedState) &&
+        (globalMostRecentFallbackTime = now());
+      if (flags & 4) {
+        try {
+          if (null !== finishedWork.memoizedState) {
+            var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
+            if ("function" === typeof suspenseCallback) {
+              var wakeables = finishedWork.updateQueue;
+              null !== wakeables && suspenseCallback(new Set(wakeables));
+            }
+          }
+        } catch (error$149) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$149);
+        }
+        current = finishedWork.updateQueue;
+        null !== current &&
+          ((finishedWork.updateQueue = null),
+          attachSuspenseRetryListeners(finishedWork, current));
+      }
       break;
     case 22:
-      if (0 !== (finishedWork.mode & 1)) {
-        if (
-          ((prevProps =
-            null !== finishedWork.memoizedState || offscreenSubtreeIsHidden),
-          !prevProps)
-        ) {
-          current =
-            (null !== current && null !== current.memoizedState) ||
-            offscreenSubtreeWasHidden;
-          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
-            prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
-          offscreenSubtreeIsHidden = prevProps;
-          (offscreenSubtreeWasHidden = current) &&
-          !prevOffscreenSubtreeWasHidden
-            ? recursivelyTraverseReappearLayoutEffects(
-                finishedRoot,
-                finishedWork,
-                0 !== (finishedWork.subtreeFlags & 8772)
-              )
-            : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
-          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
-          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+      flags & 512 &&
+        null !== current &&
+        safelyDetachRef(current, current.return);
+      domElement = null !== finishedWork.memoizedState;
+      newProps = null !== current && null !== current.memoizedState;
+      finishedWork.mode & 1
+        ? ((suspenseCallback = offscreenSubtreeIsHidden),
+          (wakeables = offscreenSubtreeWasHidden),
+          (offscreenSubtreeIsHidden = suspenseCallback || domElement),
+          (offscreenSubtreeWasHidden = wakeables || newProps),
+          recursivelyTraverseMutationEffects(root, finishedWork),
+          (offscreenSubtreeWasHidden = wakeables),
+          (offscreenSubtreeIsHidden = suspenseCallback))
+        : recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      root = finishedWork.stateNode;
+      root._current = finishedWork;
+      root._visibility &= -3;
+      root._visibility |= root._pendingVisibility & 2;
+      if (
+        flags & 8192 &&
+        ((root._visibility = domElement
+          ? root._visibility & -2
+          : root._visibility | 1),
+        domElement &&
+          ((root = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden),
+          null === current ||
+            newProps ||
+            root ||
+            (0 !== (finishedWork.mode & 1) &&
+              recursivelyTraverseDisappearLayoutEffects(finishedWork))),
+        null === finishedWork.memoizedProps ||
+          "manual" !== finishedWork.memoizedProps.mode)
+      )
+        a: for (current = null, root = finishedWork; ; ) {
+          if (5 === root.tag || 26 === root.tag || 27 === root.tag) {
+            if (null === current) {
+              current = root;
+              try {
+                (hoistableRoot = root.stateNode),
+                  domElement
+                    ? ((maybeNodes = hoistableRoot.style),
+                      "function" === typeof maybeNodes.setProperty
+                        ? maybeNodes.setProperty("display", "none", "important")
+                        : (maybeNodes.display = "none"))
+                    : ((i = root.stateNode),
+                      (nextNode = root.memoizedProps.style),
+                      (nodeName =
+                        void 0 !== nextNode &&
+                        null !== nextNode &&
+                        nextNode.hasOwnProperty("display")
+                          ? nextNode.display
+                          : null),
+                      (i.style.display = dangerousStyleValue(
+                        "display",
+                        nodeName
+                      )));
+              } catch (error) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error
+                );
+              }
+            }
+          } else if (6 === root.tag) {
+            if (null === current)
+              try {
+                root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
+              } catch (error$130) {
+                captureCommitPhaseError(
+                  finishedWork,
+                  finishedWork.return,
+                  error$130
+                );
+              }
+          } else if (
+            ((22 !== root.tag && 23 !== root.tag) ||
+              null === root.memoizedState ||
+              root === finishedWork) &&
+            null !== root.child
+          ) {
+            root.child.return = root;
+            root = root.child;
+            continue;
+          }
+          if (root === finishedWork) break a;
+          for (; null === root.sibling; ) {
+            if (null === root.return || root.return === finishedWork) break a;
+            current === root && (current = null);
+            root = root.return;
+          }
+          current === root && (current = null);
+          root.sibling.return = root.return;
+          root = root.sibling;
         }
-      } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      flags & 4 &&
+        ((current = finishedWork.updateQueue),
+        null !== current &&
+          ((flags = current.wakeables),
+          null !== flags &&
+            ((current.wakeables = null),
+            attachSuspenseRetryListeners(finishedWork, flags))));
+      break;
+    case 19:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
+      flags & 4 &&
+        ((current = finishedWork.updateQueue),
+        null !== current &&
+          ((finishedWork.updateQueue = null),
+          attachSuspenseRetryListeners(finishedWork, current)));
+      break;
+    case 21:
+      recursivelyTraverseMutationEffects(root, finishedWork);
+      commitReconciliationEffects(finishedWork);
       flags & 512 &&
-        ("manual" === finishedWork.memoizedProps.mode
-          ? safelyAttachRef(finishedWork, finishedWork.return)
-          : safelyDetachRef(finishedWork, finishedWork.return));
+        (null !== current && safelyDetachRef(finishedWork, finishedWork.return),
+        safelyAttachRef(finishedWork, finishedWork.return));
+      flags & 4 && (finishedWork.stateNode[internalInstanceKey] = finishedWork);
       break;
     default:
-      recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      recursivelyTraverseMutationEffects(root, finishedWork),
+        commitReconciliationEffects(finishedWork);
   }
 }
-function abortRootTransitions(
-  root,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance
-) {
-  if (enableTransitionTracing) {
-    var rootTransitions = root.incompleteTransitions;
-    deletedTransitions.forEach(function (transition) {
-      rootTransitions.has(transition) &&
-        ((transition = rootTransitions.get(transition)),
-        null === transition.aborts && (transition.aborts = []),
-        transition.aborts.push(abort),
-        null !== deletedOffscreenInstance &&
-          null !== transition.pendingBoundaries &&
-          transition.pendingBoundaries.has(deletedOffscreenInstance) &&
-          transition.pendingBoundaries.delete(deletedOffscreenInstance));
-    });
+function commitReconciliationEffects(finishedWork) {
+  var flags = finishedWork.flags;
+  if (flags & 2) {
+    try {
+      if (27 !== finishedWork.tag) {
+        b: {
+          for (var parent = finishedWork.return; null !== parent; ) {
+            if (isHostParent(parent)) {
+              var JSCompiler_inline_result = parent;
+              break b;
+            }
+            parent = parent.return;
+          }
+          throw Error(formatProdErrorMessage(160));
+        }
+        switch (JSCompiler_inline_result.tag) {
+          case 27:
+            var parent$jscomp$0 = JSCompiler_inline_result.stateNode,
+              before = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
+            break;
+          case 5:
+            var parent$131 = JSCompiler_inline_result.stateNode;
+            JSCompiler_inline_result.flags & 32 &&
+              (setTextContent(parent$131, ""),
+              (JSCompiler_inline_result.flags &= -33));
+            var before$132 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before$132, parent$131);
+            break;
+          case 3:
+          case 4:
+            var parent$133 = JSCompiler_inline_result.stateNode.containerInfo,
+              before$134 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNodeIntoContainer(
+              finishedWork,
+              before$134,
+              parent$133
+            );
+            break;
+          default:
+            throw Error(formatProdErrorMessage(161));
+        }
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+    finishedWork.flags &= -3;
   }
+  flags & 4096 && (finishedWork.flags &= -4097);
 }
-function abortTracingMarkerTransitions(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
-) {
-  if (enableTransitionTracing) {
-    var markerInstance = abortedFiber.stateNode,
-      markerTransitions = markerInstance.transitions,
-      pendingBoundaries = markerInstance.pendingBoundaries;
-    null !== markerTransitions &&
-      deletedTransitions.forEach(function (transition) {
-        if (
-          null !== abortedFiber &&
-          markerTransitions.has(transition) &&
-          (null === markerInstance.aborts ||
-            !markerInstance.aborts.includes(abort)) &&
-          null !== markerInstance.transitions
-        ) {
-          if (null === markerInstance.aborts) {
-            markerInstance.aborts = [abort];
-            transition = abortedFiber.memoizedProps.name;
-            var transitions = markerInstance.transitions,
-              aborts = markerInstance.aborts;
-            enableTransitionTracing &&
-              (null === currentPendingTransitionCallbacks &&
-                (currentPendingTransitionCallbacks = {
-                  transitionStart: null,
-                  transitionProgress: null,
-                  transitionComplete: null,
-                  markerProgress: null,
-                  markerIncomplete: new Map(),
-                  markerComplete: null
-                }),
-              null === currentPendingTransitionCallbacks.markerIncomplete &&
-                (currentPendingTransitionCallbacks.markerIncomplete =
-                  new Map()),
-              currentPendingTransitionCallbacks.markerIncomplete.set(
-                transition,
-                { transitions: transitions, aborts: aborts }
-              ));
-          } else markerInstance.aborts.push(abort);
-          null !== deletedOffscreenInstance &&
-            !isInDeletedTree &&
-            null !== pendingBoundaries &&
-            pendingBoundaries.has(deletedOffscreenInstance) &&
-            (pendingBoundaries.delete(deletedOffscreenInstance),
-            addMarkerProgressCallbackToPendingTransition(
-              abortedFiber.memoizedProps.name,
-              deletedTransitions,
-              pendingBoundaries
-            ));
+function recursivelyTraverseLayoutEffects(root, parentFiber) {
+  if (parentFiber.subtreeFlags & 8772)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber),
+        (parentFiber = parentFiber.sibling);
+}
+function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var finishedWork = parentFiber;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 14:
+      case 15:
+        commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 1:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        var instance = finishedWork.stateNode;
+        if ("function" === typeof instance.componentWillUnmount) {
+          var current = finishedWork,
+            nearestMountedAncestor = finishedWork.return;
+          try {
+            var current$jscomp$0 = current;
+            instance.props = current$jscomp$0.memoizedProps;
+            instance.state = current$jscomp$0.memoizedState;
+            instance.componentWillUnmount();
+          } catch (error) {
+            captureCommitPhaseError(current, nearestMountedAncestor, error);
+          }
         }
-      });
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 26:
+      case 27:
+      case 5:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      case 22:
+        safelyDetachRef(finishedWork, finishedWork.return);
+        null === finishedWork.memoizedState &&
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+        break;
+      default:
+        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+    }
+    parentFiber = parentFiber.sibling;
   }
 }
-function abortParentMarkerTransitionsForDeletedFiber(
-  abortedFiber,
-  abort,
-  deletedTransitions,
-  deletedOffscreenInstance,
-  isInDeletedTree
+function recursivelyTraverseReappearLayoutEffects(
+  finishedRoot$jscomp$0,
+  parentFiber,
+  includeWorkInProgressEffects
 ) {
-  if (enableTransitionTracing)
-    for (; null !== abortedFiber; ) {
-      switch (abortedFiber.tag) {
-        case 25:
-          abortTracingMarkerTransitions(
-            abortedFiber,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance,
-            isInDeletedTree
-          );
-          break;
-        case 3:
-          abortRootTransitions(
-            abortedFiber.stateNode,
-            abort,
-            deletedTransitions,
-            deletedOffscreenInstance
+  includeWorkInProgressEffects =
+    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var current = parentFiber.alternate,
+      finishedRoot = finishedRoot$jscomp$0,
+      finishedWork = parentFiber,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        commitHookLayoutEffects(finishedWork, 4);
+        break;
+      case 1:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        finishedRoot = finishedWork.stateNode;
+        if ("function" === typeof finishedRoot.componentDidMount)
+          try {
+            finishedRoot.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        current = finishedWork.updateQueue;
+        if (null !== current) {
+          var hiddenCallbacks = current.shared.hiddenCallbacks;
+          if (null !== hiddenCallbacks)
+            for (
+              current.shared.hiddenCallbacks = null, current = 0;
+              current < hiddenCallbacks.length;
+              current++
+            )
+              callCallback(hiddenCallbacks[current], finishedRoot);
+        }
+        includeWorkInProgressEffects &&
+          flags & 64 &&
+          commitClassCallbacks(finishedWork);
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 26:
+      case 27:
+      case 5:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          null === current &&
+          flags & 4 &&
+          commitHostComponentMount(finishedWork);
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 12:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        break;
+      case 13:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 4 &&
+          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+        break;
+      case 22:
+        null === finishedWork.memoizedState &&
+          recursivelyTraverseReappearLayoutEffects(
+            finishedRoot,
+            finishedWork,
+            includeWorkInProgressEffects
           );
-      }
-      abortedFiber = abortedFiber.return;
+        safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      default:
+        recursivelyTraverseReappearLayoutEffects(
+          finishedRoot,
+          finishedWork,
+          includeWorkInProgressEffects
+        );
     }
-}
-function commitTransitionProgress(offscreenFiber) {
-  if (enableTransitionTracing) {
-    var offscreenInstance = offscreenFiber.stateNode,
-      prevState = null,
-      previousFiber = offscreenFiber.alternate;
-    null !== previousFiber &&
-      null !== previousFiber.memoizedState &&
-      (prevState = previousFiber.memoizedState);
-    prevState = null !== prevState;
-    previousFiber = null !== offscreenFiber.memoizedState;
-    var pendingMarkers = offscreenInstance._pendingMarkers,
-      name = null;
-    offscreenFiber = offscreenFiber.return;
-    null !== offscreenFiber &&
-      13 === offscreenFiber.tag &&
-      offscreenFiber.memoizedProps.unstable_name &&
-      (name = offscreenFiber.memoizedProps.unstable_name);
-    !prevState && previousFiber
-      ? null !== pendingMarkers &&
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries,
-            transitions = markerInstance.transitions,
-            markerName = markerInstance.name;
-          null === pendingBoundaries ||
-            pendingBoundaries.has(offscreenInstance) ||
-            (pendingBoundaries.set(offscreenInstance, { name: name }),
-            null !== transitions &&
-              (1 === markerInstance.tag && null !== markerName
-                ? addMarkerProgressCallbackToPendingTransition(
-                    markerName,
-                    transitions,
-                    pendingBoundaries
-                  )
-                : 0 === markerInstance.tag &&
-                  transitions.forEach(function (transition) {
-                    addTransitionProgressCallbackToPendingTransition(
-                      transition,
-                      pendingBoundaries
-                    );
-                  })));
-        })
-      : prevState &&
-        !previousFiber &&
-        null !== pendingMarkers &&
-        pendingMarkers.forEach(function (markerInstance) {
-          var pendingBoundaries = markerInstance.pendingBoundaries,
-            transitions = markerInstance.transitions,
-            markerName = markerInstance.name;
-          null !== pendingBoundaries &&
-            pendingBoundaries.has(offscreenInstance) &&
-            (pendingBoundaries.delete(offscreenInstance),
-            null !== transitions &&
-              (1 === markerInstance.tag && null !== markerName
-                ? (addMarkerProgressCallbackToPendingTransition(
-                    markerName,
-                    transitions,
-                    pendingBoundaries
-                  ),
-                  0 === pendingBoundaries.size &&
-                    (null === markerInstance.aborts &&
-                      addMarkerCompleteCallbackToPendingTransition(
-                        markerName,
-                        transitions
-                      ),
-                    (markerInstance.transitions = null),
-                    (markerInstance.pendingBoundaries = null),
-                    (markerInstance.aborts = null)))
-                : 0 === markerInstance.tag &&
-                  transitions.forEach(function (transition) {
-                    addTransitionProgressCallbackToPendingTransition(
-                      transition,
-                      pendingBoundaries
-                    );
-                  })));
-        });
+    parentFiber = parentFiber.sibling;
   }
 }
-function detachFiberAfterEffects(fiber) {
-  var alternate = fiber.alternate;
-  null !== alternate &&
-    ((fiber.alternate = null), detachFiberAfterEffects(alternate));
-  fiber.child = null;
-  fiber.deletions = null;
-  fiber.sibling = null;
-  5 === fiber.tag &&
-    ((alternate = fiber.stateNode),
-    null !== alternate && detachDeletedInstance(alternate));
-  fiber.stateNode = null;
-  fiber.return = null;
-  fiber.dependencies = null;
-  fiber.memoizedProps = null;
-  fiber.memoizedState = null;
-  fiber.pendingProps = null;
-  fiber.stateNode = null;
-  fiber.updateQueue = null;
-}
-function isHostParent(fiber) {
-  return (
-    5 === fiber.tag ||
-    3 === fiber.tag ||
-    26 === fiber.tag ||
-    27 === fiber.tag ||
-    4 === fiber.tag
-  );
+function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+  try {
+    commitHookEffectListMount(hookFlags, finishedWork);
+  } catch (error) {
+    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+  }
 }
-function getHostSibling(fiber) {
-  a: for (;;) {
-    for (; null === fiber.sibling; ) {
-      if (null === fiber.return || isHostParent(fiber.return)) return null;
-      fiber = fiber.return;
-    }
-    fiber.sibling.return = fiber.return;
-    for (
-      fiber = fiber.sibling;
-      5 !== fiber.tag &&
-      6 !== fiber.tag &&
-      27 !== fiber.tag &&
-      18 !== fiber.tag;
-
-    ) {
-      if (fiber.flags & 2) continue a;
-      if (null === fiber.child || 4 === fiber.tag) continue a;
-      else (fiber.child.return = fiber), (fiber = fiber.child);
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
+  var previousCache = null;
+  null !== current &&
+    null !== current.memoizedState &&
+    null !== current.memoizedState.cachePool &&
+    (previousCache = current.memoizedState.cachePool.pool);
+  current = null;
+  null !== finishedWork.memoizedState &&
+    null !== finishedWork.memoizedState.cachePool &&
+    (current = finishedWork.memoizedState.cachePool.pool);
+  current !== previousCache &&
+    (null != current && current.refCount++,
+    null != previousCache && releaseCache(previousCache));
+  if (enableTransitionTracing) {
+    current = finishedWork.updateQueue;
+    previousCache = null !== finishedWork.memoizedState;
+    if (null !== current) {
+      if (previousCache) {
+        var transitions = current.transitions;
+        null !== transitions &&
+          transitions.forEach(function (transition) {
+            null === instance._transitions &&
+              (instance._transitions = new Set());
+            instance._transitions.add(transition);
+          });
+        current = current.markerInstances;
+        null !== current &&
+          current.forEach(function (markerInstance) {
+            var markerTransitions = markerInstance.transitions;
+            null !== markerTransitions &&
+              markerTransitions.forEach(function (transition) {
+                null === instance._transitions
+                  ? (instance._transitions = new Set())
+                  : instance._transitions.has(transition) &&
+                    (null === markerInstance.pendingBoundaries &&
+                      (markerInstance.pendingBoundaries = new Map()),
+                    null === instance._pendingMarkers &&
+                      (instance._pendingMarkers = new Set()),
+                    instance._pendingMarkers.add(markerInstance));
+              });
+          });
+      }
+      finishedWork.updateQueue = null;
     }
-    if (!(fiber.flags & 2)) return fiber.stateNode;
+    commitTransitionProgress(finishedWork);
+    previousCache ||
+      ((instance._transitions = null), (instance._pendingMarkers = null));
   }
 }
-function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
-  var tag = node.tag;
-  if (5 === tag || 6 === tag)
-    (node = node.stateNode),
-      before
-        ? 8 === parent.nodeType
-          ? parent.parentNode.insertBefore(node, before)
-          : parent.insertBefore(node, before)
-        : (8 === parent.nodeType
-            ? ((before = parent.parentNode), before.insertBefore(node, parent))
-            : ((before = parent), before.appendChild(node)),
-          (parent = parent._reactRootContainer),
-          (null !== parent && void 0 !== parent) ||
-            null !== before.onclick ||
-            (before.onclick = noop$1));
-  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
-    for (
-      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
-        node = node.sibling;
-      null !== node;
-
-    )
-      insertOrAppendPlacementNodeIntoContainer(node, before, parent),
-        (node = node.sibling);
-}
-function insertOrAppendPlacementNode(node, before, parent) {
-  var tag = node.tag;
-  if (5 === tag || 6 === tag)
-    (node = node.stateNode),
-      before ? parent.insertBefore(node, before) : parent.appendChild(node);
-  else if (4 !== tag && 27 !== tag && ((node = node.child), null !== node))
-    for (
-      insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
-      null !== node;
-
-    )
-      insertOrAppendPlacementNode(node, before, parent), (node = node.sibling);
+function commitCachePassiveMountEffect(current, finishedWork) {
+  current = null;
+  null !== finishedWork.alternate &&
+    (current = finishedWork.alternate.memoizedState.cache);
+  finishedWork = finishedWork.memoizedState.cache;
+  finishedWork !== current &&
+    (finishedWork.refCount++, null != current && releaseCache(current));
 }
-var hostParent = null,
-  hostParentIsContainer = !1;
-function recursivelyTraverseDeletionEffects(
-  finishedRoot,
-  nearestMountedAncestor,
-  parent
+function commitTracingMarkerPassiveMountEffect(finishedWork) {
+  var instance = finishedWork.stateNode;
+  null !== instance.transitions &&
+    null === instance.pendingBoundaries &&
+    (addMarkerCompleteCallbackToPendingTransition(
+      finishedWork.memoizedProps.name,
+      instance.transitions
+    ),
+    (instance.transitions = null),
+    (instance.pendingBoundaries = null),
+    (instance.aborts = null),
+    (instance.name = null));
+}
+function recursivelyTraversePassiveMountEffects(
+  root,
+  parentFiber,
+  committedLanes,
+  committedTransitions
 ) {
-  for (parent = parent.child; null !== parent; )
-    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent),
-      (parent = parent.sibling);
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitPassiveMountOnFiber(
+        root,
+        parentFiber,
+        committedLanes,
+        committedTransitions
+      ),
+        (parentFiber = parentFiber.sibling);
 }
-function commitDeletionEffectsOnFiber(
+function commitPassiveMountOnFiber(
   finishedRoot,
-  nearestMountedAncestor,
-  deletedFiber
+  finishedWork,
+  committedLanes,
+  committedTransitions
 ) {
-  if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
-    try {
-      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
-    } catch (err) {}
-  switch (deletedFiber.tag) {
-    case 26:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      deletedFiber.memoizedState
-        ? deletedFiber.memoizedState.count--
-        : deletedFiber.stateNode &&
-          ((deletedFiber = deletedFiber.stateNode),
-          deletedFiber.parentNode.removeChild(deletedFiber));
-      break;
-    case 27:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      var prevHostParent = hostParent,
-        prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = deletedFiber.stateNode;
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      deletedFiber = deletedFiber.stateNode;
-      for (finishedRoot = deletedFiber.attributes; finishedRoot.length; )
-        deletedFiber.removeAttributeNode(finishedRoot[0]);
-      detachDeletedInstance(deletedFiber);
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
-      break;
-    case 5:
-      offscreenSubtreeWasHidden ||
-        safelyDetachRef(deletedFiber, nearestMountedAncestor);
-    case 6:
-      prevHostParent = hostParent;
-      prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = null;
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
-      null !== hostParent &&
-        (hostParentIsContainer
-          ? ((finishedRoot = hostParent),
-            (deletedFiber = deletedFiber.stateNode),
-            8 === finishedRoot.nodeType
-              ? finishedRoot.parentNode.removeChild(deletedFiber)
-              : finishedRoot.removeChild(deletedFiber))
-          : hostParent.removeChild(deletedFiber.stateNode));
-      break;
-    case 18:
-      finishedRoot = finishedRoot.hydrationCallbacks;
-      null !== finishedRoot &&
-        (finishedRoot = finishedRoot.onDeleted) &&
-        finishedRoot(deletedFiber.stateNode);
-      null !== hostParent &&
-        (hostParentIsContainer
-          ? ((finishedRoot = hostParent),
-            (deletedFiber = deletedFiber.stateNode),
-            8 === finishedRoot.nodeType
-              ? clearSuspenseBoundary(finishedRoot.parentNode, deletedFiber)
-              : 1 === finishedRoot.nodeType &&
-                clearSuspenseBoundary(finishedRoot, deletedFiber),
-            retryIfBlockedOn(finishedRoot))
-          : clearSuspenseBoundary(hostParent, deletedFiber.stateNode));
-      break;
-    case 4:
-      prevHostParent = hostParent;
-      prevHostParentIsContainer = hostParentIsContainer;
-      hostParent = deletedFiber.stateNode.containerInfo;
-      hostParentIsContainer = !0;
-      recursivelyTraverseDeletionEffects(
-        finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
-      );
-      hostParent = prevHostParent;
-      hostParentIsContainer = prevHostParentIsContainer;
-      break;
+  var flags = finishedWork.flags;
+  switch (finishedWork.tag) {
     case 0:
     case 11:
-    case 14:
     case 15:
-      if (
-        !offscreenSubtreeWasHidden &&
-        ((prevHostParent = deletedFiber.updateQueue),
-        null !== prevHostParent &&
-          ((prevHostParent = prevHostParent.lastEffect),
-          null !== prevHostParent))
-      ) {
-        prevHostParentIsContainer = prevHostParent = prevHostParent.next;
-        do {
-          var _effect = prevHostParentIsContainer,
-            destroy = _effect.destroy;
-          _effect = _effect.tag;
-          void 0 !== destroy &&
-            (0 !== (_effect & 2)
-              ? safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy)
-              : 0 !== (_effect & 4) &&
-                safelyCallDestroy(
-                  deletedFiber,
-                  nearestMountedAncestor,
-                  destroy
-                ));
-          prevHostParentIsContainer = prevHostParentIsContainer.next;
-        } while (prevHostParentIsContainer !== prevHostParent);
-      }
-      recursivelyTraverseDeletionEffects(
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
+      flags & 2048 && commitHookPassiveMountEffects(finishedWork, 9);
       break;
-    case 1:
-      if (
-        !offscreenSubtreeWasHidden &&
-        (safelyDetachRef(deletedFiber, nearestMountedAncestor),
-        (prevHostParent = deletedFiber.stateNode),
-        "function" === typeof prevHostParent.componentWillUnmount)
-      )
-        try {
-          (prevHostParent.props = deletedFiber.memoizedProps),
-            (prevHostParent.state = deletedFiber.memoizedState),
-            prevHostParent.componentWillUnmount();
-        } catch (error) {
-          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
-        }
-      recursivelyTraverseDeletionEffects(
+    case 3:
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
+      if (flags & 2048) {
+        flags = null;
+        null !== finishedWork.alternate &&
+          (flags = finishedWork.alternate.memoizedState.cache);
+        var nextCache = finishedWork.memoizedState.cache;
+        nextCache !== flags &&
+          (nextCache.refCount++, null != flags && releaseCache(flags));
+        if (enableTransitionTracing) {
+          var incompleteTransitions =
+            finishedWork.stateNode.incompleteTransitions;
+          null !== committedTransitions &&
+            (committedTransitions.forEach(function (transition) {
+              enableTransitionTracing &&
+                (null === currentPendingTransitionCallbacks &&
+                  (currentPendingTransitionCallbacks = {
+                    transitionStart: [],
+                    transitionProgress: null,
+                    transitionComplete: null,
+                    markerProgress: null,
+                    markerIncomplete: null,
+                    markerComplete: null
+                  }),
+                null === currentPendingTransitionCallbacks.transitionStart &&
+                  (currentPendingTransitionCallbacks.transitionStart = []),
+                currentPendingTransitionCallbacks.transitionStart.push(
+                  transition
+                ));
+            }),
+            clearTransitionsForLanes(finishedRoot, committedLanes));
+          incompleteTransitions.forEach(function (markerInstance, transition) {
+            var pendingBoundaries = markerInstance.pendingBoundaries;
+            if (null === pendingBoundaries || 0 === pendingBoundaries.size)
+              null === markerInstance.aborts &&
+                enableTransitionTracing &&
+                (null === currentPendingTransitionCallbacks &&
+                  (currentPendingTransitionCallbacks = {
+                    transitionStart: null,
+                    transitionProgress: null,
+                    transitionComplete: [],
+                    markerProgress: null,
+                    markerIncomplete: null,
+                    markerComplete: null
+                  }),
+                null === currentPendingTransitionCallbacks.transitionComplete &&
+                  (currentPendingTransitionCallbacks.transitionComplete = []),
+                currentPendingTransitionCallbacks.transitionComplete.push(
+                  transition
+                )),
+                incompleteTransitions.delete(transition);
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
+        }
+      }
       break;
-    case 21:
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      recursivelyTraverseDeletionEffects(
+    case 23:
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
+      flags & 2048 &&
+        commitOffscreenPassiveMountEffects(
+          finishedWork.alternate,
+          finishedWork,
+          finishedWork.stateNode
+        );
       break;
     case 22:
-      safelyDetachRef(deletedFiber, nearestMountedAncestor);
-      deletedFiber.mode & 1
-        ? ((offscreenSubtreeWasHidden =
-            (prevHostParent = offscreenSubtreeWasHidden) ||
-            null !== deletedFiber.memoizedState),
-          recursivelyTraverseDeletionEffects(
+      nextCache = finishedWork.stateNode;
+      null !== finishedWork.memoizedState
+        ? nextCache._visibility & 4
+          ? recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            )
+          : finishedWork.mode & 1
+          ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
+          : ((nextCache._visibility |= 4),
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            ))
+        : nextCache._visibility & 4
+        ? recursivelyTraversePassiveMountEffects(
             finishedRoot,
-            nearestMountedAncestor,
-            deletedFiber
-          ),
-          (offscreenSubtreeWasHidden = prevHostParent))
-        : recursivelyTraverseDeletionEffects(
+            finishedWork,
+            committedLanes,
+            committedTransitions
+          )
+        : ((nextCache._visibility |= 4),
+          recursivelyTraverseReconnectPassiveEffects(
             finishedRoot,
-            nearestMountedAncestor,
-            deletedFiber
-          );
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            0 !== (finishedWork.subtreeFlags & 10256)
+          ));
+      flags & 2048 &&
+        commitOffscreenPassiveMountEffects(
+          finishedWork.alternate,
+          finishedWork,
+          nextCache
+        );
+      break;
+    case 24:
+      recursivelyTraversePassiveMountEffects(
+        finishedRoot,
+        finishedWork,
+        committedLanes,
+        committedTransitions
+      );
+      flags & 2048 &&
+        commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
       break;
+    case 25:
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
+        break;
+      }
     default:
-      recursivelyTraverseDeletionEffects(
+      recursivelyTraversePassiveMountEffects(
         finishedRoot,
-        nearestMountedAncestor,
-        deletedFiber
+        finishedWork,
+        committedLanes,
+        committedTransitions
       );
   }
 }
-function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
-  if (null === finishedWork.memoizedState) {
-    var current = finishedWork.alternate;
-    if (
-      null !== current &&
-      ((current = current.memoizedState),
-      null !== current && ((current = current.dehydrated), null !== current))
-    )
-      try {
-        retryIfBlockedOn(current);
-        var hydrationCallbacks = finishedRoot.hydrationCallbacks;
-        if (null !== hydrationCallbacks) {
-          var onHydrated = hydrationCallbacks.onHydrated;
-          onHydrated && onHydrated(current);
+function recursivelyTraverseReconnectPassiveEffects(
+  finishedRoot$jscomp$0,
+  parentFiber,
+  committedLanes$jscomp$0,
+  committedTransitions$jscomp$0,
+  includeWorkInProgressEffects
+) {
+  includeWorkInProgressEffects =
+    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    var finishedRoot = finishedRoot$jscomp$0,
+      finishedWork = parentFiber,
+      committedLanes = committedLanes$jscomp$0,
+      committedTransitions = committedTransitions$jscomp$0,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        commitHookPassiveMountEffects(finishedWork, 8);
+        break;
+      case 23:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitOffscreenPassiveMountEffects(
+            finishedWork.alternate,
+            finishedWork,
+            finishedWork.stateNode
+          );
+        break;
+      case 22:
+        var instance$159 = finishedWork.stateNode;
+        null !== finishedWork.memoizedState
+          ? instance$159._visibility & 4
+            ? recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              )
+            : finishedWork.mode & 1
+            ? recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              )
+            : ((instance$159._visibility |= 4),
+              recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              ))
+          : ((instance$159._visibility |= 4),
+            recursivelyTraverseReconnectPassiveEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions,
+              includeWorkInProgressEffects
+            ));
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitOffscreenPassiveMountEffects(
+            finishedWork.alternate,
+            finishedWork,
+            instance$159
+          );
+        break;
+      case 24:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+        includeWorkInProgressEffects &&
+          flags & 2048 &&
+          commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+        break;
+      case 25:
+        if (enableTransitionTracing) {
+          recursivelyTraverseReconnectPassiveEffects(
+            finishedRoot,
+            finishedWork,
+            committedLanes,
+            committedTransitions,
+            includeWorkInProgressEffects
+          );
+          includeWorkInProgressEffects &&
+            flags & 2048 &&
+            commitTracingMarkerPassiveMountEffect(finishedWork);
+          break;
         }
-      } catch (error) {
-        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      default:
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+    }
+    parentFiber = parentFiber.sibling;
+  }
+}
+function recursivelyTraverseAtomicPassiveEffects(
+  finishedRoot$jscomp$0,
+  parentFiber
+) {
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 22:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 &&
+            commitOffscreenPassiveMountEffects(
+              finishedWork.alternate,
+              finishedWork,
+              finishedWork.stateNode
+            );
+          break;
+        case 24:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 &&
+            commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+}
+function detachAlternateSiblings(parentFiber) {
+  var previousFiber = parentFiber.alternate;
+  if (
+    null !== previousFiber &&
+    ((parentFiber = previousFiber.child), null !== parentFiber)
+  ) {
+    previousFiber.child = null;
+    do
+      (previousFiber = parentFiber.sibling),
+        (parentFiber.sibling = null),
+        (parentFiber = previousFiber);
+    while (null !== parentFiber);
+  }
+}
+function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (0 !== (parentFiber.flags & 16)) {
+    if (null !== deletions)
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
       }
+    detachAlternateSiblings(parentFiber);
   }
+  if (parentFiber.subtreeFlags & 10256)
+    for (parentFiber = parentFiber.child; null !== parentFiber; )
+      commitPassiveUnmountOnFiber(parentFiber),
+        (parentFiber = parentFiber.sibling);
 }
-function getRetryCache(finishedWork) {
+function commitPassiveUnmountOnFiber(finishedWork) {
   switch (finishedWork.tag) {
-    case 13:
-    case 19:
-      var retryCache = finishedWork.stateNode;
-      null === retryCache &&
-        (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
-      return retryCache;
+    case 0:
+    case 11:
+    case 15:
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
+      finishedWork.flags & 2048 &&
+        commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
+      break;
     case 22:
-      return (
-        (finishedWork = finishedWork.stateNode),
-        (retryCache = finishedWork._retryCache),
-        null === retryCache &&
-          (retryCache = finishedWork._retryCache = new PossiblyWeakSet()),
-        retryCache
-      );
+      var instance = finishedWork.stateNode;
+      null !== finishedWork.memoizedState &&
+      instance._visibility & 4 &&
+      (null === finishedWork.return || 13 !== finishedWork.return.tag)
+        ? ((instance._visibility &= -5),
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork))
+        : recursivelyTraversePassiveUnmountEffects(finishedWork);
+      break;
     default:
-      throw Error(formatProdErrorMessage(435, finishedWork.tag));
+      recursivelyTraversePassiveUnmountEffects(finishedWork);
   }
 }
-function detachOffscreenInstance(instance) {
-  var fiber = instance._current;
-  if (null === fiber) throw Error(formatProdErrorMessage(456));
-  if (0 === (instance._pendingVisibility & 2)) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    null !== root &&
-      ((instance._pendingVisibility |= 2),
-      scheduleUpdateOnFiber(root, fiber, 2, -1));
+function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+  var deletions = parentFiber.deletions;
+  if (0 !== (parentFiber.flags & 16)) {
+    if (null !== deletions)
+      for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+          childToDelete,
+          parentFiber
+        );
+      }
+    detachAlternateSiblings(parentFiber);
   }
-}
-function attachOffscreenInstance(instance) {
-  var fiber = instance._current;
-  if (null === fiber) throw Error(formatProdErrorMessage(456));
-  if (0 !== (instance._pendingVisibility & 2)) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    null !== root &&
-      ((instance._pendingVisibility &= -3),
-      scheduleUpdateOnFiber(root, fiber, 2, -1));
+  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+    deletions = parentFiber;
+    switch (deletions.tag) {
+      case 0:
+      case 11:
+      case 15:
+        commitHookEffectListUnmount(8, deletions, deletions.return);
+        recursivelyTraverseDisconnectPassiveEffects(deletions);
+        break;
+      case 22:
+        i = deletions.stateNode;
+        i._visibility & 4 &&
+          ((i._visibility &= -5),
+          recursivelyTraverseDisconnectPassiveEffects(deletions));
+        break;
+      default:
+        recursivelyTraverseDisconnectPassiveEffects(deletions);
+    }
+    parentFiber = parentFiber.sibling;
   }
 }
-function attachSuspenseRetryListeners(finishedWork, wakeables) {
-  var retryCache = getRetryCache(finishedWork);
-  wakeables.forEach(function (wakeable) {
-    var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
-    retryCache.has(wakeable) ||
-      (retryCache.add(wakeable), wakeable.then(retry, retry));
-  });
-}
-function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (null !== deletions)
-    for (var i = 0; i < deletions.length; i++) {
-      var childToDelete = deletions[i];
-      try {
-        var root = root$jscomp$0,
-          returnFiber = parentFiber,
-          parent = returnFiber;
-        a: for (; null !== parent; ) {
-          switch (parent.tag) {
-            case 27:
-            case 5:
-              hostParent = parent.stateNode;
-              hostParentIsContainer = !1;
-              break a;
-            case 3:
-              hostParent = parent.stateNode.containerInfo;
-              hostParentIsContainer = !0;
-              break a;
-            case 4:
-              hostParent = parent.stateNode.containerInfo;
-              hostParentIsContainer = !0;
-              break a;
+function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+  deletedSubtreeRoot,
+  nearestMountedAncestor$jscomp$0
+) {
+  for (; null !== nextEffect; ) {
+    var fiber = nextEffect,
+      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
+    switch (fiber.tag) {
+      case 0:
+      case 11:
+      case 15:
+        commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
+        break;
+      case 23:
+      case 22:
+        null !== fiber.memoizedState &&
+          null !== fiber.memoizedState.cachePool &&
+          ((nearestMountedAncestor = fiber.memoizedState.cachePool.pool),
+          null != nearestMountedAncestor && nearestMountedAncestor.refCount++);
+        break;
+      case 13:
+        if (enableTransitionTracing) {
+          var offscreenFiber = fiber.child,
+            instance = offscreenFiber.stateNode,
+            transitions = instance._transitions;
+          if (null !== transitions) {
+            var abortReason = {
+              reason: "suspense",
+              name: fiber.memoizedProps.unstable_name || null
+            };
+            if (
+              null === fiber.memoizedState ||
+              null === fiber.memoizedState.dehydrated
+            )
+              abortParentMarkerTransitionsForDeletedFiber(
+                offscreenFiber,
+                abortReason,
+                transitions,
+                instance,
+                !0
+              ),
+                null !== nearestMountedAncestor &&
+                  abortParentMarkerTransitionsForDeletedFiber(
+                    nearestMountedAncestor,
+                    abortReason,
+                    transitions,
+                    instance,
+                    !1
+                  );
           }
-          parent = parent.return;
         }
-        if (null === hostParent) throw Error(formatProdErrorMessage(160));
-        commitDeletionEffectsOnFiber(root, returnFiber, childToDelete);
-        hostParent = null;
-        hostParentIsContainer = !1;
-        var alternate = childToDelete.alternate;
-        null !== alternate && (alternate.return = null);
-        childToDelete.return = null;
-      } catch (error) {
-        captureCommitPhaseError(childToDelete, parentFiber, error);
+        break;
+      case 24:
+        releaseCache(fiber.memoizedState.cache);
+        break;
+      case 25:
+        enableTransitionTracing &&
+          ((offscreenFiber = fiber.stateNode.transitions),
+          null !== offscreenFiber &&
+            ((instance = { reason: "marker", name: fiber.memoizedProps.name }),
+            abortParentMarkerTransitionsForDeletedFiber(
+              fiber,
+              instance,
+              offscreenFiber,
+              null,
+              !0
+            ),
+            null !== nearestMountedAncestor &&
+              abortParentMarkerTransitionsForDeletedFiber(
+                nearestMountedAncestor,
+                instance,
+                offscreenFiber,
+                null,
+                !1
+              )));
+    }
+    nearestMountedAncestor = fiber.child;
+    if (null !== nearestMountedAncestor)
+      (nearestMountedAncestor.return = fiber),
+        (nextEffect = nearestMountedAncestor);
+    else
+      a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
+        nearestMountedAncestor = nextEffect;
+        offscreenFiber = nearestMountedAncestor.sibling;
+        instance = nearestMountedAncestor.return;
+        detachFiberAfterEffects(nearestMountedAncestor);
+        if (nearestMountedAncestor === fiber) {
+          nextEffect = null;
+          break a;
+        }
+        if (null !== offscreenFiber) {
+          offscreenFiber.return = instance;
+          nextEffect = offscreenFiber;
+          break a;
+        }
+        nextEffect = instance;
+      }
+  }
+}
+var DefaultCacheDispatcher = {
+    getCacheSignal: function () {
+      return readContext(CacheContext).controller.signal;
+    },
+    getCacheForType: function (resourceType) {
+      var cache = readContext(CacheContext),
+        cacheForType = cache.data.get(resourceType);
+      void 0 === cacheForType &&
+        ((cacheForType = resourceType()),
+        cache.data.set(resourceType, cacheForType));
+      return cacheForType;
+    }
+  },
+  COMPONENT_TYPE = 0,
+  HAS_PSEUDO_CLASS_TYPE = 1,
+  ROLE_TYPE = 2,
+  TEST_NAME_TYPE = 3,
+  TEXT_TYPE = 4;
+if ("function" === typeof Symbol && Symbol.for) {
+  var symbolFor = Symbol.for;
+  COMPONENT_TYPE = symbolFor("selector.component");
+  HAS_PSEUDO_CLASS_TYPE = symbolFor("selector.has_pseudo_class");
+  ROLE_TYPE = symbolFor("selector.role");
+  TEST_NAME_TYPE = symbolFor("selector.test_id");
+  TEXT_TYPE = symbolFor("selector.text");
+}
+function findFiberRootForHostRoot(hostRoot) {
+  var maybeFiber = getClosestInstanceFromNode(hostRoot) || null;
+  if (null != maybeFiber) {
+    if ("string" !== typeof maybeFiber.memoizedProps["data-testname"])
+      throw Error(formatProdErrorMessage(364));
+    return maybeFiber;
+  }
+  a: {
+    hostRoot = [hostRoot];
+    for (maybeFiber = 0; maybeFiber < hostRoot.length; ) {
+      var current = hostRoot[maybeFiber++];
+      if (current[internalContainerInstanceKey]) {
+        hostRoot = getInstanceFromNode$1(current);
+        break a;
       }
+      hostRoot.push.apply(hostRoot, current.children);
     }
-  if (parentFiber.subtreeFlags & 12854)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitMutationEffectsOnFiber(parentFiber, root$jscomp$0),
-        (parentFiber = parentFiber.sibling);
+    hostRoot = null;
+  }
+  if (null === hostRoot) throw Error(formatProdErrorMessage(362));
+  return hostRoot.stateNode.current;
 }
-var currentHoistableRoot = null;
-function commitMutationEffectsOnFiber(finishedWork, root) {
-  var current = finishedWork.alternate,
-    flags = finishedWork.flags;
-  switch (finishedWork.tag) {
-    case 0:
-    case 11:
-    case 14:
-    case 15:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4) {
-        try {
-          commitHookEffectListUnmount(3, finishedWork, finishedWork.return),
-            commitHookEffectListMount(3, finishedWork);
-        } catch (error) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error);
-        }
-        try {
-          commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-        } catch (error$184) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$184);
-        }
-      }
-      break;
-    case 1:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      flags & 64 &&
-        offscreenSubtreeIsHidden &&
-        ((finishedWork = finishedWork.updateQueue),
-        null !== finishedWork &&
-          ((current = finishedWork.callbacks),
-          null !== current &&
-            ((flags = finishedWork.shared.hiddenCallbacks),
-            (finishedWork.shared.hiddenCallbacks =
-              null === flags ? current : flags.concat(current)))));
+function matchSelector(fiber$jscomp$0, selector) {
+  var tag = fiber$jscomp$0.tag;
+  switch (selector.$$typeof) {
+    case COMPONENT_TYPE:
+      if (fiber$jscomp$0.type === selector.value) return !0;
       break;
-    case 26:
-      var hoistableRoot = currentHoistableRoot;
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      if (flags & 4)
-        if (
-          ((root = null !== current ? current.memoizedState : null),
-          (flags = finishedWork.memoizedState),
-          null === current)
-        )
-          if (null === flags)
-            if (null === finishedWork.stateNode) {
-              a: {
-                current = finishedWork.type;
-                flags = finishedWork.memoizedProps;
-                root = hoistableRoot.ownerDocument || hoistableRoot;
-                b: switch (current) {
-                  case "title":
-                    hoistableRoot = root.getElementsByTagName("title")[0];
-                    if (
-                      !hoistableRoot ||
-                      hoistableRoot[internalHoistableMarker] ||
-                      hoistableRoot[internalInstanceKey] ||
-                      "http://www.w3.org/2000/svg" ===
-                        hoistableRoot.namespaceURI ||
-                      hoistableRoot.hasAttribute("itemprop")
-                    )
-                      (hoistableRoot = root.createElement(current)),
-                        root.head.insertBefore(
-                          hoistableRoot,
-                          root.querySelector("head > title")
-                        );
-                    setInitialProperties(hoistableRoot, current, flags);
-                    hoistableRoot[internalInstanceKey] = finishedWork;
-                    markNodeAsHoistable(hoistableRoot);
-                    current = hoistableRoot;
-                    break a;
-                  case "link":
-                    var maybeNodes = getHydratableHoistableCache(
-                      "link",
-                      "href",
-                      root
-                    ).get(current + (flags.href || ""));
-                    if (maybeNodes)
-                      for (var i = 0; i < maybeNodes.length; i++)
-                        if (
-                          ((hoistableRoot = maybeNodes[i]),
-                          hoistableRoot.getAttribute("href") ===
-                            (null == flags.href ? null : flags.href) &&
-                            hoistableRoot.getAttribute("rel") ===
-                              (null == flags.rel ? null : flags.rel) &&
-                            hoistableRoot.getAttribute("title") ===
-                              (null == flags.title ? null : flags.title) &&
-                            hoistableRoot.getAttribute("crossorigin") ===
-                              (null == flags.crossOrigin
-                                ? null
-                                : flags.crossOrigin))
-                        ) {
-                          maybeNodes.splice(i, 1);
-                          break b;
-                        }
-                    hoistableRoot = root.createElement(current);
-                    setInitialProperties(hoistableRoot, current, flags);
-                    root.head.appendChild(hoistableRoot);
-                    break;
-                  case "meta":
-                    if (
-                      (maybeNodes = getHydratableHoistableCache(
-                        "meta",
-                        "content",
-                        root
-                      ).get(current + (flags.content || "")))
-                    )
-                      for (i = 0; i < maybeNodes.length; i++)
-                        if (
-                          ((hoistableRoot = maybeNodes[i]),
-                          hoistableRoot.getAttribute("content") ===
-                            (null == flags.content
-                              ? null
-                              : "" + flags.content) &&
-                            hoistableRoot.getAttribute("name") ===
-                              (null == flags.name ? null : flags.name) &&
-                            hoistableRoot.getAttribute("property") ===
-                              (null == flags.property
-                                ? null
-                                : flags.property) &&
-                            hoistableRoot.getAttribute("http-equiv") ===
-                              (null == flags.httpEquiv
-                                ? null
-                                : flags.httpEquiv) &&
-                            hoistableRoot.getAttribute("charset") ===
-                              (null == flags.charSet ? null : flags.charSet))
-                        ) {
-                          maybeNodes.splice(i, 1);
-                          break b;
-                        }
-                    hoistableRoot = root.createElement(current);
-                    setInitialProperties(hoistableRoot, current, flags);
-                    root.head.appendChild(hoistableRoot);
-                    break;
-                  default:
-                    throw Error(formatProdErrorMessage(468, current));
-                }
-                hoistableRoot[internalInstanceKey] = finishedWork;
-                markNodeAsHoistable(hoistableRoot);
-                current = hoistableRoot;
-              }
-              finishedWork.stateNode = current;
-            } else
-              mountHoistable(
-                hoistableRoot,
-                finishedWork.type,
-                finishedWork.stateNode
-              );
-          else
-            finishedWork.stateNode = acquireResource(
-              hoistableRoot,
-              flags,
-              finishedWork.memoizedProps
-            );
-        else if (root !== flags)
-          null === root
-            ? null !== current.stateNode &&
-              ((current = current.stateNode),
-              current.parentNode.removeChild(current))
-            : root.count--,
-            null === flags
-              ? mountHoistable(
-                  hoistableRoot,
-                  finishedWork.type,
-                  finishedWork.stateNode
-                )
-              : acquireResource(
-                  hoistableRoot,
-                  flags,
-                  finishedWork.memoizedProps
-                );
-        else if (
-          null === flags &&
-          null !== finishedWork.stateNode &&
-          ((flags = finishedWork.updateQueue),
-          (finishedWork.updateQueue = null),
-          null !== flags)
-        )
-          try {
-            var domElement = finishedWork.stateNode,
-              newProps = finishedWork.memoizedProps;
-            updateProperties(
-              domElement,
-              flags,
-              finishedWork.type,
-              current.memoizedProps,
-              newProps
-            );
-            domElement[internalPropsKey] = newProps;
-          } catch (error$185) {
-            captureCommitPhaseError(
-              finishedWork,
-              finishedWork.return,
-              error$185
-            );
+    case HAS_PSEUDO_CLASS_TYPE:
+      a: {
+        selector = selector.value;
+        tag = [fiber$jscomp$0, 0];
+        for (fiber$jscomp$0 = 0; fiber$jscomp$0 < tag.length; ) {
+          var fiber = tag[fiber$jscomp$0++],
+            tag$jscomp$0 = fiber.tag,
+            selectorIndex = tag[fiber$jscomp$0++],
+            selector$jscomp$0 = selector[selectorIndex];
+          if (
+            (5 !== tag$jscomp$0 &&
+              26 !== tag$jscomp$0 &&
+              27 !== tag$jscomp$0) ||
+            !isHiddenSubtree(fiber)
+          ) {
+            for (
+              ;
+              null != selector$jscomp$0 &&
+              matchSelector(fiber, selector$jscomp$0);
+
+            )
+              selectorIndex++, (selector$jscomp$0 = selector[selectorIndex]);
+            if (selectorIndex === selector.length) {
+              selector = !0;
+              break a;
+            } else
+              for (fiber = fiber.child; null !== fiber; )
+                tag.push(fiber, selectorIndex), (fiber = fiber.sibling);
           }
+        }
+        selector = !1;
+      }
+      return selector;
+    case ROLE_TYPE:
+      if (5 === tag || 26 === tag || 27 === tag)
+        if (
+          ((tag = fiber$jscomp$0.stateNode),
+          (selector = selector.value),
+          (fiber$jscomp$0 = (fiber$jscomp$0 = tag.getAttribute("role"))
+            ? fiber$jscomp$0.trim().split(" ")
+            : null),
+          (selector =
+            (null !== fiber$jscomp$0 &&
+              0 <= fiber$jscomp$0.indexOf(selector)) ||
+            selector === getImplicitRole(tag)
+              ? !0
+              : !1),
+          selector)
+        )
+          return !0;
       break;
-    case 27:
-      if (flags & 4 && null === finishedWork.alternate) {
-        hoistableRoot = finishedWork.stateNode;
-        maybeNodes = finishedWork.memoizedProps;
-        for (i = hoistableRoot.firstChild; i; ) {
-          var nextNode = i.nextSibling,
-            nodeName = i.nodeName;
-          i[internalHoistableMarker] ||
-            "HEAD" === nodeName ||
-            "BODY" === nodeName ||
-            "STYLE" === nodeName ||
-            ("LINK" === nodeName && "stylesheet" === i.rel.toLowerCase()) ||
-            hoistableRoot.removeChild(i);
-          i = nextNode;
+    case TEXT_TYPE:
+      if (5 === tag || 6 === tag || 26 === tag || 27 === tag) {
+        a: {
+          switch (fiber$jscomp$0.tag) {
+            case 26:
+            case 27:
+            case 5:
+              tag = "";
+              fiber$jscomp$0 = fiber$jscomp$0.stateNode.childNodes;
+              for (
+                selectorIndex = 0;
+                selectorIndex < fiber$jscomp$0.length;
+                selectorIndex++
+              )
+                (fiber = fiber$jscomp$0[selectorIndex]),
+                  fiber.nodeType === Node.TEXT_NODE &&
+                    (tag += fiber.textContent);
+              break a;
+            case 6:
+              tag = fiber$jscomp$0.stateNode.textContent;
+              break a;
+          }
+          tag = null;
         }
-        i = finishedWork.type;
-        for (nextNode = hoistableRoot.attributes; nextNode.length; )
-          hoistableRoot.removeAttributeNode(nextNode[0]);
-        setInitialProperties(hoistableRoot, i, maybeNodes);
-        hoistableRoot[internalInstanceKey] = finishedWork;
-        hoistableRoot[internalPropsKey] = maybeNodes;
+        if (null !== tag && 0 <= tag.indexOf(selector.value)) return !0;
+      }
+      break;
+    case TEST_NAME_TYPE:
+      if (5 === tag || 26 === tag || 27 === tag)
+        if (
+          ((tag = fiber$jscomp$0.memoizedProps["data-testname"]),
+          "string" === typeof tag &&
+            tag.toLowerCase() === selector.value.toLowerCase())
+        )
+          return !0;
+      break;
+    default:
+      throw Error(formatProdErrorMessage(365));
+  }
+  return !1;
+}
+function selectorToString(selector) {
+  switch (selector.$$typeof) {
+    case COMPONENT_TYPE:
+      return (
+        "<" + (getComponentNameFromType(selector.value) || "Unknown") + ">"
+      );
+    case HAS_PSEUDO_CLASS_TYPE:
+      return ":has(" + (selectorToString(selector) || "") + ")";
+    case ROLE_TYPE:
+      return '[role="' + selector.value + '"]';
+    case TEXT_TYPE:
+      return '"' + selector.value + '"';
+    case TEST_NAME_TYPE:
+      return '[data-testname="' + selector.value + '"]';
+    default:
+      throw Error(formatProdErrorMessage(365));
+  }
+}
+function findPaths(root, selectors) {
+  var matchingFibers = [];
+  root = [root, 0];
+  for (var index = 0; index < root.length; ) {
+    var fiber = root[index++],
+      tag = fiber.tag,
+      selectorIndex = root[index++],
+      selector = selectors[selectorIndex];
+    if ((5 !== tag && 26 !== tag && 27 !== tag) || !isHiddenSubtree(fiber)) {
+      for (; null != selector && matchSelector(fiber, selector); )
+        selectorIndex++, (selector = selectors[selectorIndex]);
+      if (selectorIndex === selectors.length) matchingFibers.push(fiber);
+      else
+        for (fiber = fiber.child; null !== fiber; )
+          root.push(fiber, selectorIndex), (fiber = fiber.sibling);
+    }
+  }
+  return matchingFibers;
+}
+function findAllNodes(hostRoot, selectors) {
+  hostRoot = findFiberRootForHostRoot(hostRoot);
+  hostRoot = findPaths(hostRoot, selectors);
+  selectors = [];
+  hostRoot = Array.from(hostRoot);
+  for (var index = 0; index < hostRoot.length; ) {
+    var node = hostRoot[index++],
+      tag = node.tag;
+    if (5 === tag || 26 === tag || 27 === tag)
+      isHiddenSubtree(node) || selectors.push(node.stateNode);
+    else
+      for (node = node.child; null !== node; )
+        hostRoot.push(node), (node = node.sibling);
+  }
+  return selectors;
+}
+var postPaintCallbackScheduled = !1,
+  callbacks = [];
+function schedulePostPaintCallback(callback) {
+  callbacks.push(callback);
+  postPaintCallbackScheduled ||
+    ((postPaintCallbackScheduled = !0),
+    requestPostPaintCallback(function (endTime) {
+      for (var i = 0; i < callbacks.length; i++) callbacks[i](endTime);
+      postPaintCallbackScheduled = !1;
+      callbacks = [];
+    }));
+}
+var ceil = Math.ceil,
+  PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+  ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
+  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
+  ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
+  executionContext = 0,
+  workInProgressRoot = null,
+  workInProgress = null,
+  workInProgressRootRenderLanes = 0,
+  workInProgressSuspendedReason = 0,
+  workInProgressThrownValue = null,
+  workInProgressRootDidAttachPingListener = !1,
+  renderLanes = 0,
+  workInProgressRootExitStatus = 0,
+  workInProgressRootFatalError = null,
+  workInProgressRootSkippedLanes = 0,
+  workInProgressRootInterleavedUpdatedLanes = 0,
+  workInProgressRootPingedLanes = 0,
+  workInProgressRootConcurrentErrors = null,
+  workInProgressRootRecoverableErrors = null,
+  globalMostRecentFallbackTime = 0,
+  workInProgressRootRenderTargetTime = Infinity,
+  workInProgressTransitions = null,
+  currentPendingTransitionCallbacks = null,
+  currentEndTime = null;
+function addMarkerProgressCallbackToPendingTransition(
+  markerName,
+  transitions,
+  pendingBoundaries
+) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: new Map(),
+        markerIncomplete: null,
+        markerComplete: null
+      }),
+    null === currentPendingTransitionCallbacks.markerProgress &&
+      (currentPendingTransitionCallbacks.markerProgress = new Map()),
+    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
+      pendingBoundaries: pendingBoundaries,
+      transitions: transitions
+    }));
+}
+function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: null,
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: new Map()
+      }),
+    null === currentPendingTransitionCallbacks.markerComplete &&
+      (currentPendingTransitionCallbacks.markerComplete = new Map()),
+    currentPendingTransitionCallbacks.markerComplete.set(
+      markerName,
+      transitions
+    ));
+}
+function addTransitionProgressCallbackToPendingTransition(
+  transition,
+  boundaries
+) {
+  enableTransitionTracing &&
+    (null === currentPendingTransitionCallbacks &&
+      (currentPendingTransitionCallbacks = {
+        transitionStart: null,
+        transitionProgress: new Map(),
+        transitionComplete: null,
+        markerProgress: null,
+        markerIncomplete: null,
+        markerComplete: null
+      }),
+    null === currentPendingTransitionCallbacks.transitionProgress &&
+      (currentPendingTransitionCallbacks.transitionProgress = new Map()),
+    currentPendingTransitionCallbacks.transitionProgress.set(
+      transition,
+      boundaries
+    ));
+}
+function resetRenderTimer() {
+  workInProgressRootRenderTargetTime = now() + 500;
+}
+var hasUncaughtError = !1,
+  firstUncaughtError = null,
+  legacyErrorBoundariesThatAlreadyFailed = null,
+  rootDoesHavePassiveEffects = !1,
+  rootWithPendingPassiveEffects = null,
+  pendingPassiveEffectsLanes = 0,
+  pendingPassiveEffectsRemainingLanes = 0,
+  pendingPassiveTransitions = null,
+  nestedUpdateCount = 0,
+  rootWithNestedUpdates = null,
+  currentEventTime = -1,
+  currentEventTransitionLane = 0;
+function requestEventTime() {
+  return 0 !== (executionContext & 6)
+    ? now()
+    : -1 !== currentEventTime
+    ? currentEventTime
+    : (currentEventTime = now());
+}
+function requestUpdateLane(fiber) {
+  if (0 === (fiber.mode & 1)) return 2;
+  if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    0 !== (executionContext & 2) &&
+    0 !== workInProgressRootRenderLanes
+  )
+    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
+  if (null !== ReactCurrentBatchConfig$2.transition)
+    return (
+      0 === currentEventTransitionLane &&
+        (currentEventTransitionLane = claimNextTransitionLane()),
+      currentEventTransitionLane
+    );
+  fiber = currentUpdatePriority;
+  if (0 !== fiber) return fiber;
+  fiber = window.event;
+  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
+  return fiber;
+}
+function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
+  2 === workInProgressSuspendedReason &&
+    root === workInProgressRoot &&
+    (prepareFreshStack(root, 0),
+    markRootSuspended(root, workInProgressRootRenderLanes));
+  markRootUpdated(root, lane, eventTime);
+  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig$1.transition;
+      if (
+        null !== transition &&
+        null != transition.name &&
+        (-1 === transition.startTime && (transition.startTime = now()),
+        enableTransitionTracing)
+      ) {
+        var transitionLanesMap = root.transitionLanes,
+          index$15 = 31 - clz32(lane),
+          transitions = transitionLanesMap[index$15];
+        null === transitions && (transitions = new Set());
+        transitions.add(transition);
+        transitionLanesMap[index$15] = transitions;
       }
-    case 5:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      if (finishedWork.flags & 32) {
-        root = finishedWork.stateNode;
-        try {
-          setTextContent(root, "");
-        } catch (error$186) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$186);
+    }
+    if (root === workInProgressRoot) {
+      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
+        workInProgressRootInterleavedUpdatedLanes |= lane;
+      4 === workInProgressRootExitStatus &&
+        markRootSuspended(root, workInProgressRootRenderLanes);
+    }
+    ensureRootIsScheduled(root, eventTime);
+    2 === lane &&
+      0 === executionContext &&
+      0 === (fiber.mode & 1) &&
+      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
+  }
+}
+function ensureRootIsScheduled(root, currentTime) {
+  var existingCallbackNode = root.callbackNode;
+  markStarvedLanesAsExpired(root, currentTime);
+  var nextLanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+  );
+  if (0 === nextLanes)
+    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
+      (root.callbackNode = null),
+      (root.callbackPriority = 0);
+  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
+    (root.callbackPriority = 0), (root.callbackNode = null);
+  else if (
+    ((currentTime = nextLanes & -nextLanes),
+    root.callbackPriority !== currentTime)
+  ) {
+    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
+    if (0 !== (currentTime & 3))
+      0 === root.tag
+        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
+        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
+        scheduleMicrotask(function () {
+          0 === (executionContext & 6) && flushSyncCallbacks();
+        }),
+        (existingCallbackNode = null);
+    else {
+      switch (lanesToEventPriority(nextLanes)) {
+        case 2:
+          existingCallbackNode = ImmediatePriority;
+          break;
+        case 8:
+          existingCallbackNode = UserBlockingPriority;
+          break;
+        case 32:
+          existingCallbackNode = NormalPriority$1;
+          break;
+        case 536870912:
+          existingCallbackNode = IdlePriority;
+          break;
+        default:
+          existingCallbackNode = NormalPriority$1;
+      }
+      existingCallbackNode = scheduleCallback(
+        existingCallbackNode,
+        performConcurrentWorkOnRoot.bind(null, root)
+      );
+    }
+    root.callbackPriority = currentTime;
+    root.callbackNode = existingCallbackNode;
+  }
+}
+function performConcurrentWorkOnRoot(root, didTimeout) {
+  currentEventTime = -1;
+  currentEventTransitionLane = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var originalCallbackNode = root.callbackNode;
+  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
+    return null;
+  var lanes = getNextLanes(
+    root,
+    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
+  );
+  if (0 === lanes) return null;
+  didTimeout =
+    includesBlockingLane(root, lanes) ||
+    0 !== (lanes & root.expiredLanes) ||
+    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
+      ? renderRootSync(root, lanes)
+      : renderRootConcurrent(root, lanes);
+  if (0 !== didTimeout) {
+    if (2 === didTimeout) {
+      var originallyAttemptedLanes = lanes,
+        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+          root,
+          originallyAttemptedLanes
+        );
+      0 !== errorRetryLanes &&
+        ((lanes = errorRetryLanes),
+        (didTimeout = recoverFromConcurrentError(
+          root,
+          originallyAttemptedLanes,
+          errorRetryLanes
+        )));
+    }
+    if (1 === didTimeout)
+      throw (
+        ((originalCallbackNode = workInProgressRootFatalError),
+        prepareFreshStack(root, 0),
+        markRootSuspended(root, lanes),
+        ensureRootIsScheduled(root, now()),
+        originalCallbackNode)
+      );
+    if (6 === didTimeout) markRootSuspended(root, lanes);
+    else {
+      errorRetryLanes = !includesBlockingLane(root, lanes);
+      originallyAttemptedLanes = root.current.alternate;
+      if (
+        errorRetryLanes &&
+        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
+      ) {
+        didTimeout = renderRootSync(root, lanes);
+        if (2 === didTimeout) {
+          errorRetryLanes = lanes;
+          var errorRetryLanes$169 = getLanesToRetrySynchronouslyOnError(
+            root,
+            errorRetryLanes
+          );
+          0 !== errorRetryLanes$169 &&
+            ((lanes = errorRetryLanes$169),
+            (didTimeout = recoverFromConcurrentError(
+              root,
+              errorRetryLanes,
+              errorRetryLanes$169
+            )));
         }
+        if (1 === didTimeout)
+          throw (
+            ((originalCallbackNode = workInProgressRootFatalError),
+            prepareFreshStack(root, 0),
+            markRootSuspended(root, lanes),
+            ensureRootIsScheduled(root, now()),
+            originalCallbackNode)
+          );
+      }
+      root.finishedWork = originallyAttemptedLanes;
+      root.finishedLanes = lanes;
+      switch (didTimeout) {
+        case 0:
+        case 1:
+          throw Error(formatProdErrorMessage(345));
+        case 2:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 3:
+          markRootSuspended(root, lanes);
+          if (
+            (lanes & 125829120) === lanes &&
+            ((lanes = globalMostRecentFallbackTime + 500 - now()), 10 < lanes)
+          ) {
+            if (0 !== getNextLanes(root, 0)) break;
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
+            );
+            break;
+          }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 4:
+          markRootSuspended(root, lanes);
+          if ((lanes & 8388480) === lanes) break;
+          didTimeout = root.eventTimes;
+          for (originallyAttemptedLanes = -1; 0 < lanes; )
+            (errorRetryLanes$169 = 31 - clz32(lanes)),
+              (errorRetryLanes = 1 << errorRetryLanes$169),
+              (errorRetryLanes$169 = didTimeout[errorRetryLanes$169]),
+              errorRetryLanes$169 > originallyAttemptedLanes &&
+                (originallyAttemptedLanes = errorRetryLanes$169),
+              (lanes &= ~errorRetryLanes);
+          lanes = originallyAttemptedLanes;
+          lanes = now() - lanes;
+          lanes =
+            (120 > lanes
+              ? 120
+              : 480 > lanes
+              ? 480
+              : 1080 > lanes
+              ? 1080
+              : 1920 > lanes
+              ? 1920
+              : 3e3 > lanes
+              ? 3e3
+              : 4320 > lanes
+              ? 4320
+              : 1960 * ceil(lanes / 1960)) - lanes;
+          if (10 < lanes) {
+            root.timeoutHandle = scheduleTimeout(
+              commitRoot.bind(
+                null,
+                root,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions
+              ),
+              lanes
+            );
+            break;
+          }
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        case 5:
+          commitRoot(
+            root,
+            workInProgressRootRecoverableErrors,
+            workInProgressTransitions
+          );
+          break;
+        default:
+          throw Error(formatProdErrorMessage(329));
       }
+    }
+  }
+  ensureRootIsScheduled(root, now());
+  return root.callbackNode === originalCallbackNode
+    ? performConcurrentWorkOnRoot.bind(null, root)
+    : null;
+}
+function recoverFromConcurrentError(
+  root,
+  originallyAttemptedLanes,
+  errorRetryLanes
+) {
+  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
+    wasRootDehydrated = root.current.memoizedState.isDehydrated;
+  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
+  errorRetryLanes = renderRootSync(root, errorRetryLanes);
+  if (2 !== errorRetryLanes) {
+    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
+      return (
+        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
+        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
+        4
+      );
+    root = workInProgressRootRecoverableErrors;
+    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
+    null !== root && queueRecoverableErrors(root);
+  }
+  return errorRetryLanes;
+}
+function queueRecoverableErrors(errors) {
+  null === workInProgressRootRecoverableErrors
+    ? (workInProgressRootRecoverableErrors = errors)
+    : workInProgressRootRecoverableErrors.push.apply(
+        workInProgressRootRecoverableErrors,
+        errors
+      );
+}
+function isRenderConsistentWithExternalStores(finishedWork) {
+  for (var node = finishedWork; ; ) {
+    if (node.flags & 16384) {
+      var updateQueue = node.updateQueue;
       if (
-        flags & 4 &&
-        ((flags = finishedWork.stateNode),
-        null != flags &&
-          ((root = finishedWork.memoizedProps),
-          (current = null !== current ? current.memoizedProps : root),
-          (hoistableRoot = finishedWork.type),
-          (maybeNodes = finishedWork.updateQueue),
-          (finishedWork.updateQueue = null),
-          null !== maybeNodes))
+        null !== updateQueue &&
+        ((updateQueue = updateQueue.stores), null !== updateQueue)
       )
-        try {
-          updateProperties(flags, maybeNodes, hoistableRoot, current, root),
-            (flags[internalPropsKey] = root);
-        } catch (error$189) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$189);
-        }
-      break;
-    case 6:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4) {
-        if (null === finishedWork.stateNode)
-          throw Error(formatProdErrorMessage(162));
-        current = finishedWork.stateNode;
-        flags = finishedWork.memoizedProps;
-        try {
-          current.nodeValue = flags;
-        } catch (error$190) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$190);
+        for (var i = 0; i < updateQueue.length; i++) {
+          var check = updateQueue[i],
+            getSnapshot = check.getSnapshot;
+          check = check.value;
+          try {
+            if (!objectIs(getSnapshot(), check)) return !1;
+          } catch (error) {
+            return !1;
+          }
         }
+    }
+    updateQueue = node.child;
+    if (node.subtreeFlags & 16384 && null !== updateQueue)
+      (updateQueue.return = node), (node = updateQueue);
+    else {
+      if (node === finishedWork) break;
+      for (; null === node.sibling; ) {
+        if (null === node.return || node.return === finishedWork) return !0;
+        node = node.return;
       }
-      break;
-    case 3:
-      tagCaches = null;
-      hoistableRoot = currentHoistableRoot;
-      currentHoistableRoot = getHoistableRoot(root.containerInfo);
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      currentHoistableRoot = hoistableRoot;
-      commitReconciliationEffects(finishedWork);
-      if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
-        try {
-          retryIfBlockedOn(root.containerInfo);
-        } catch (error$191) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$191);
-        }
-      break;
-    case 4:
-      current = currentHoistableRoot;
-      currentHoistableRoot = getHoistableRoot(
-        finishedWork.stateNode.containerInfo
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+  return !0;
+}
+function markRootSuspended(root, suspendedLanes) {
+  suspendedLanes &= ~workInProgressRootPingedLanes;
+  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+  root.suspendedLanes |= suspendedLanes;
+  root.pingedLanes &= ~suspendedLanes;
+  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
+    var index$12 = 31 - clz32(suspendedLanes),
+      lane = 1 << index$12;
+    root[index$12] = -1;
+    suspendedLanes &= ~lane;
+  }
+}
+function performSyncWorkOnRoot(root) {
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  flushPassiveEffects();
+  var lanes = getNextLanes(root, 0);
+  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now()), null;
+  var exitStatus = renderRootSync(root, lanes);
+  if (0 !== root.tag && 2 === exitStatus) {
+    var originallyAttemptedLanes = lanes,
+      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
+        root,
+        originallyAttemptedLanes
       );
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      currentHoistableRoot = current;
-      break;
-    case 13:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      current = finishedWork.child;
-      current.flags & 8192 &&
-        null !== current.memoizedState &&
-        (null === current.alternate ||
-          null === current.alternate.memoizedState) &&
-        (globalMostRecentFallbackTime = now());
-      if (flags & 4) {
-        try {
-          if (null !== finishedWork.memoizedState) {
-            var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;
-            if ("function" === typeof suspenseCallback) {
-              var wakeables = finishedWork.updateQueue;
-              null !== wakeables && suspenseCallback(new Set(wakeables));
-            }
-          }
-        } catch (error$193) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$193);
+    0 !== errorRetryLanes &&
+      ((lanes = errorRetryLanes),
+      (exitStatus = recoverFromConcurrentError(
+        root,
+        originallyAttemptedLanes,
+        errorRetryLanes
+      )));
+  }
+  if (1 === exitStatus)
+    throw (
+      ((exitStatus = workInProgressRootFatalError),
+      prepareFreshStack(root, 0),
+      markRootSuspended(root, lanes),
+      ensureRootIsScheduled(root, now()),
+      exitStatus)
+    );
+  if (6 === exitStatus)
+    return (
+      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now()), null
+    );
+  root.finishedWork = root.current.alternate;
+  root.finishedLanes = lanes;
+  commitRoot(
+    root,
+    workInProgressRootRecoverableErrors,
+    workInProgressTransitions
+  );
+  ensureRootIsScheduled(root, now());
+  return null;
+}
+function batchedUpdates$1(fn, a) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  try {
+    return fn(a);
+  } finally {
+    (executionContext = prevExecutionContext),
+      0 === executionContext &&
+        (resetRenderTimer(),
+        includesLegacySyncCallbacks && flushSyncCallbacks());
+  }
+}
+function flushSync$1(fn) {
+  null !== rootWithPendingPassiveEffects &&
+    0 === rootWithPendingPassiveEffects.tag &&
+    0 === (executionContext & 6) &&
+    flushPassiveEffects();
+  var prevExecutionContext = executionContext;
+  executionContext |= 1;
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
+    previousPriority = currentUpdatePriority;
+  try {
+    if (
+      ((ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      fn)
+    )
+      return fn();
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (executionContext = prevExecutionContext),
+      0 === (executionContext & 6) && flushSyncCallbacks();
+  }
+}
+function resetWorkInProgressStack() {
+  if (null !== workInProgress) {
+    if (0 === workInProgressSuspendedReason)
+      var interruptedWork = workInProgress.return;
+    else
+      resetContextDependencies(),
+        resetHooksOnUnwind(),
+        (thenableState$1 = null),
+        (thenableIndexCounter$1 = 0),
+        (interruptedWork = workInProgress);
+    for (; null !== interruptedWork; )
+      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
+        (interruptedWork = interruptedWork.return);
+    workInProgress = null;
+  }
+}
+function prepareFreshStack(root, lanes) {
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  var timeoutHandle = root.timeoutHandle;
+  -1 !== timeoutHandle &&
+    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
+  resetWorkInProgressStack();
+  workInProgressRoot = root;
+  workInProgress = root = createWorkInProgress(root.current, null);
+  workInProgressRootRenderLanes = renderLanes = lanes;
+  workInProgressSuspendedReason = 0;
+  workInProgressThrownValue = null;
+  workInProgressRootDidAttachPingListener = !1;
+  workInProgressRootExitStatus = 0;
+  workInProgressRootFatalError = null;
+  workInProgressRootPingedLanes =
+    workInProgressRootInterleavedUpdatedLanes =
+    workInProgressRootSkippedLanes =
+      0;
+  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
+    null;
+  finishQueueingConcurrentUpdates();
+  return root;
+}
+function handleThrow(root, thrownValue) {
+  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+  ReactCurrentOwner.current = null;
+  if (thrownValue === SuspenseException) {
+    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
+    root = suspendedThenable;
+    suspendedThenable = null;
+    thrownValue = root;
+    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
+      ? 2
+      : 3;
+  } else
+    workInProgressSuspendedReason =
+      thrownValue === SelectiveHydrationException
+        ? 6
+        : null !== thrownValue &&
+          "object" === typeof thrownValue &&
+          "function" === typeof thrownValue.then
+        ? 4
+        : 1;
+  workInProgressThrownValue = thrownValue;
+  null === workInProgress &&
+    ((workInProgressRootExitStatus = 1),
+    (workInProgressRootFatalError = thrownValue));
+}
+function shouldAttemptToSuspendUntilDataResolves() {
+  if (
+    0 !== (workInProgressRootSkippedLanes & 268435455) ||
+    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
+  )
+    return !1;
+  if (
+    (workInProgressRootRenderLanes & 8388480) ===
+    workInProgressRootRenderLanes
+  )
+    return null === shellBoundary;
+  var handler = suspenseHandlerStackCursor.current;
+  return null !== handler &&
+    (workInProgressRootRenderLanes & 125829120) ===
+      workInProgressRootRenderLanes
+    ? handler === shellBoundary
+    : !1;
+}
+function pushDispatcher(container) {
+  container = getHoistableRoot(container);
+  lastCurrentDocument = container.ownerDocument || container;
+  previousDispatcher = Dispatcher$1.current;
+  Dispatcher$1.current = ReactDOMClientDispatcher;
+  container = ReactCurrentDispatcher.current;
+  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+  return null === container ? ContextOnlyDispatcher : container;
+}
+function pushCacheDispatcher() {
+  var prevCacheDispatcher = ReactCurrentCache.current;
+  ReactCurrentCache.current = DefaultCacheDispatcher;
+  return prevCacheDispatcher;
+}
+function renderDidSuspendDelayIfPossible() {
+  workInProgressRootExitStatus = 4;
+  null === workInProgressRoot ||
+    (0 === (workInProgressRootSkippedLanes & 268435455) &&
+      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
+    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+}
+function renderRootSync(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      prepareFreshStack(root, lanes);
+  a: do
+    try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            (workInProgressSuspendedReason = 0),
+              (workInProgressThrownValue = null),
+              unwindSuspendedUnitOfWork(lanes, thrownValue);
         }
-        current = finishedWork.updateQueue;
-        null !== current &&
-          ((finishedWork.updateQueue = null),
-          attachSuspenseRetryListeners(finishedWork, current));
       }
+      workLoopSync();
       break;
-    case 22:
-      flags & 512 &&
-        null !== current &&
-        safelyDetachRef(current, current.return);
-      domElement = null !== finishedWork.memoizedState;
-      newProps = null !== current && null !== current.memoizedState;
-      finishedWork.mode & 1
-        ? ((suspenseCallback = offscreenSubtreeIsHidden),
-          (wakeables = offscreenSubtreeWasHidden),
-          (offscreenSubtreeIsHidden = suspenseCallback || domElement),
-          (offscreenSubtreeWasHidden = wakeables || newProps),
-          recursivelyTraverseMutationEffects(root, finishedWork),
-          (offscreenSubtreeWasHidden = wakeables),
-          (offscreenSubtreeIsHidden = suspenseCallback))
-        : recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      root = finishedWork.stateNode;
-      root._current = finishedWork;
-      root._visibility &= -3;
-      root._visibility |= root._pendingVisibility & 2;
-      if (
-        flags & 8192 &&
-        ((root._visibility = domElement
-          ? root._visibility & -2
-          : root._visibility | 1),
-        domElement &&
-          ((root = offscreenSubtreeIsHidden || offscreenSubtreeWasHidden),
-          null === current ||
-            newProps ||
-            root ||
-            (0 !== (finishedWork.mode & 1) &&
-              recursivelyTraverseDisappearLayoutEffects(finishedWork))),
-        null === finishedWork.memoizedProps ||
-          "manual" !== finishedWork.memoizedProps.mode)
-      )
-        a: for (current = null, root = finishedWork; ; ) {
-          if (5 === root.tag || 26 === root.tag || 27 === root.tag) {
-            if (null === current) {
-              current = root;
-              try {
-                (hoistableRoot = root.stateNode),
-                  domElement
-                    ? ((maybeNodes = hoistableRoot.style),
-                      "function" === typeof maybeNodes.setProperty
-                        ? maybeNodes.setProperty("display", "none", "important")
-                        : (maybeNodes.display = "none"))
-                    : ((i = root.stateNode),
-                      (nextNode = root.memoizedProps.style),
-                      (nodeName =
-                        void 0 !== nextNode &&
-                        null !== nextNode &&
-                        nextNode.hasOwnProperty("display")
-                          ? nextNode.display
-                          : null),
-                      (i.style.display = dangerousStyleValue(
-                        "display",
-                        nodeName
-                      )));
-              } catch (error) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error
-                );
-              }
+    } catch (thrownValue$172) {
+      handleThrow(root, thrownValue$172);
+    }
+  while (1);
+  resetContextDependencies();
+  executionContext = prevExecutionContext;
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+}
+function workLoopSync() {
+  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+}
+function renderRootConcurrent(root, lanes) {
+  var prevExecutionContext = executionContext;
+  executionContext |= 2;
+  var prevDispatcher = pushDispatcher(root.containerInfo),
+    prevCacheDispatcher = pushCacheDispatcher();
+  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      resetRenderTimer(),
+      prepareFreshStack(root, lanes);
+  a: do
+    try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 1:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, thrownValue);
+            break;
+          case 2:
+            if (isThenableResolved(thrownValue)) {
+              workInProgressSuspendedReason = 0;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
             }
-          } else if (6 === root.tag) {
-            if (null === current)
-              try {
-                root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
-              } catch (error$174) {
-                captureCommitPhaseError(
-                  finishedWork,
-                  finishedWork.return,
-                  error$174
-                );
-              }
-          } else if (
-            ((22 !== root.tag && 23 !== root.tag) ||
-              null === root.memoizedState ||
-              root === finishedWork) &&
-            null !== root.child
-          ) {
-            root.child.return = root;
-            root = root.child;
-            continue;
-          }
-          if (root === finishedWork) break a;
-          for (; null === root.sibling; ) {
-            if (null === root.return || root.return === finishedWork) break a;
-            current === root && (current = null);
-            root = root.return;
-          }
-          current === root && (current = null);
-          root.sibling.return = root.return;
-          root = root.sibling;
+            lanes = function () {
+              2 === workInProgressSuspendedReason &&
+                workInProgressRoot === root &&
+                (workInProgressSuspendedReason = 5);
+              ensureRootIsScheduled(root, now());
+            };
+            thrownValue.then(lanes, lanes);
+            break a;
+          case 3:
+            workInProgressSuspendedReason = 5;
+            break a;
+          case 5:
+            isThenableResolved(thrownValue)
+              ? ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                replaySuspendedUnitOfWork(lanes))
+              : ((workInProgressSuspendedReason = 0),
+                (workInProgressThrownValue = null),
+                unwindSuspendedUnitOfWork(lanes, thrownValue));
+            break;
+          case 4:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            unwindSuspendedUnitOfWork(lanes, thrownValue);
+            break;
+          case 6:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            throw Error(formatProdErrorMessage(462));
         }
-      flags & 4 &&
-        ((current = finishedWork.updateQueue),
-        null !== current &&
-          ((flags = current.wakeables),
-          null !== flags &&
-            ((current.wakeables = null),
-            attachSuspenseRetryListeners(finishedWork, flags))));
+      }
+      workLoopConcurrent();
       break;
-    case 19:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 4 &&
-        ((current = finishedWork.updateQueue),
-        null !== current &&
-          ((finishedWork.updateQueue = null),
-          attachSuspenseRetryListeners(finishedWork, current)));
+    } catch (thrownValue$174) {
+      handleThrow(root, thrownValue$174);
+    }
+  while (1);
+  resetContextDependencies();
+  Dispatcher$1.current = previousDispatcher;
+  previousDispatcher = null;
+  ReactCurrentDispatcher.current = prevDispatcher;
+  ReactCurrentCache.current = prevCacheDispatcher;
+  executionContext = prevExecutionContext;
+  if (null !== workInProgress) return 0;
+  workInProgressRoot = null;
+  workInProgressRootRenderLanes = 0;
+  finishQueueingConcurrentUpdates();
+  return workInProgressRootExitStatus;
+}
+function workLoopConcurrent() {
+  for (; null !== workInProgress && !shouldYield(); )
+    performUnitOfWork(workInProgress);
+}
+function performUnitOfWork(unitOfWork) {
+  var next = beginWork(unitOfWork.alternate, unitOfWork, renderLanes);
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === next ? completeUnitOfWork(unitOfWork) : (workInProgress = next);
+  ReactCurrentOwner.current = null;
+}
+function replaySuspendedUnitOfWork(unitOfWork) {
+  var current = unitOfWork.alternate;
+  switch (unitOfWork.tag) {
+    case 2:
+      unitOfWork.tag = 0;
+    case 0:
+    case 11:
+      var Component = unitOfWork.type,
+        unresolvedProps = unitOfWork.pendingProps;
+      unresolvedProps =
+        unitOfWork.elementType === Component
+          ? unresolvedProps
+          : resolveDefaultProps(Component, unresolvedProps);
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unresolvedProps,
+        Component,
+        workInProgressRootRenderLanes
+      );
       break;
-    case 21:
-      recursivelyTraverseMutationEffects(root, finishedWork);
-      commitReconciliationEffects(finishedWork);
-      flags & 512 &&
-        (null !== current && safelyDetachRef(finishedWork, finishedWork.return),
-        safelyAttachRef(finishedWork, finishedWork.return));
-      flags & 4 && (finishedWork.stateNode[internalInstanceKey] = finishedWork);
+    case 15:
+      current = replayFunctionComponent(
+        current,
+        unitOfWork,
+        unitOfWork.pendingProps,
+        unitOfWork.type,
+        workInProgressRootRenderLanes
+      );
       break;
     default:
-      recursivelyTraverseMutationEffects(root, finishedWork),
-        commitReconciliationEffects(finishedWork);
+      unwindInterruptedWork(current, unitOfWork),
+        (unitOfWork = workInProgress =
+          resetWorkInProgress(unitOfWork, renderLanes)),
+        (current = beginWork(current, unitOfWork, renderLanes));
   }
+  unitOfWork.memoizedProps = unitOfWork.pendingProps;
+  null === current
+    ? completeUnitOfWork(unitOfWork)
+    : (workInProgress = current);
+  ReactCurrentOwner.current = null;
 }
-function commitReconciliationEffects(finishedWork) {
-  var flags = finishedWork.flags;
-  if (flags & 2) {
+function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
+  resetContextDependencies();
+  resetHooksOnUnwind();
+  thenableState$1 = null;
+  thenableIndexCounter$1 = 0;
+  var returnFiber = unitOfWork.return;
+  if (null === returnFiber || null === workInProgressRoot)
+    (workInProgressRootExitStatus = 1),
+      (workInProgressRootFatalError = thrownValue),
+      (workInProgress = null);
+  else {
     try {
-      if (27 !== finishedWork.tag) {
-        b: {
-          for (var parent = finishedWork.return; null !== parent; ) {
-            if (isHostParent(parent)) {
-              var JSCompiler_inline_result = parent;
-              break b;
+      a: {
+        var root = workInProgressRoot,
+          value = thrownValue;
+        thrownValue = workInProgressRootRenderLanes;
+        unitOfWork.flags |= 32768;
+        if (
+          null !== value &&
+          "object" === typeof value &&
+          "function" === typeof value.then
+        ) {
+          var wakeable = value;
+          if (enableLazyContextPropagation) {
+            var currentSourceFiber = unitOfWork.alternate;
+            null !== currentSourceFiber &&
+              propagateParentContextChanges(
+                currentSourceFiber,
+                unitOfWork,
+                thrownValue,
+                !0
+              );
+          }
+          var tag = unitOfWork.tag;
+          if (
+            0 === (unitOfWork.mode & 1) &&
+            (0 === tag || 11 === tag || 15 === tag)
+          ) {
+            var currentSource = unitOfWork.alternate;
+            currentSource
+              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
+                (unitOfWork.memoizedState = currentSource.memoizedState),
+                (unitOfWork.lanes = currentSource.lanes))
+              : ((unitOfWork.updateQueue = null),
+                (unitOfWork.memoizedState = null));
+          }
+          var suspenseBoundary = suspenseHandlerStackCursor.current;
+          if (null !== suspenseBoundary) {
+            switch (suspenseBoundary.tag) {
+              case 13:
+                unitOfWork.mode & 1 &&
+                  (null === shellBoundary
+                    ? renderDidSuspendDelayIfPossible()
+                    : null === suspenseBoundary.alternate &&
+                      0 === workInProgressRootExitStatus &&
+                      (workInProgressRootExitStatus = 3));
+                suspenseBoundary.flags &= -257;
+                markSuspenseBoundaryShouldCapture(
+                  suspenseBoundary,
+                  returnFiber,
+                  unitOfWork,
+                  root,
+                  thrownValue
+                );
+                var wakeables = suspenseBoundary.updateQueue;
+                null === wakeables
+                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
+                  : wakeables.add(wakeable);
+                break;
+              case 22:
+                if (suspenseBoundary.mode & 1) {
+                  suspenseBoundary.flags |= 65536;
+                  var offscreenQueue = suspenseBoundary.updateQueue;
+                  if (null === offscreenQueue) {
+                    var newOffscreenQueue = {
+                      transitions: null,
+                      markerInstances: null,
+                      wakeables: new Set([wakeable])
+                    };
+                    suspenseBoundary.updateQueue = newOffscreenQueue;
+                  } else {
+                    var wakeables$56 = offscreenQueue.wakeables;
+                    null === wakeables$56
+                      ? (offscreenQueue.wakeables = new Set([wakeable]))
+                      : wakeables$56.add(wakeable);
+                  }
+                  break;
+                }
+              default:
+                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
             }
-            parent = parent.return;
+            suspenseBoundary.mode & 1 &&
+              attachPingListener(root, wakeable, thrownValue);
+            break a;
+          } else if (1 === root.tag) {
+            attachPingListener(root, wakeable, thrownValue);
+            renderDidSuspendDelayIfPossible();
+            break a;
+          } else value = Error(formatProdErrorMessage(426));
+        } else if (
+          isHydrating &&
+          unitOfWork.mode & 1 &&
+          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
+        ) {
+          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
+          markSuspenseBoundaryShouldCapture(
+            wakeable,
+            returnFiber,
+            unitOfWork,
+            root,
+            thrownValue
+          );
+          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
+          break a;
+        }
+        root = value = createCapturedValueAtFiber(value, unitOfWork);
+        4 !== workInProgressRootExitStatus &&
+          (workInProgressRootExitStatus = 2);
+        null === workInProgressRootConcurrentErrors
+          ? (workInProgressRootConcurrentErrors = [root])
+          : workInProgressRootConcurrentErrors.push(root);
+        root = returnFiber;
+        do {
+          switch (root.tag) {
+            case 3:
+              var errorInfo = value;
+              root.flags |= 65536;
+              thrownValue &= -thrownValue;
+              root.lanes |= thrownValue;
+              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
+              enqueueCapturedUpdate(root, update);
+              break a;
+            case 1:
+              currentSourceFiber = value;
+              var ctor = root.type,
+                instance = root.stateNode;
+              if (
+                0 === (root.flags & 128) &&
+                ("function" === typeof ctor.getDerivedStateFromError ||
+                  (null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
+              ) {
+                root.flags |= 65536;
+                update = thrownValue & -thrownValue;
+                root.lanes |= update;
+                errorInfo = createClassErrorUpdate(
+                  root,
+                  currentSourceFiber,
+                  update
+                );
+                enqueueCapturedUpdate(root, errorInfo);
+                break a;
+              }
           }
-          throw Error(formatProdErrorMessage(160));
-        }
-        switch (JSCompiler_inline_result.tag) {
-          case 27:
-            var parent$jscomp$0 = JSCompiler_inline_result.stateNode,
-              before = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
-            break;
-          case 5:
-            var parent$175 = JSCompiler_inline_result.stateNode;
-            JSCompiler_inline_result.flags & 32 &&
-              (setTextContent(parent$175, ""),
-              (JSCompiler_inline_result.flags &= -33));
-            var before$176 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before$176, parent$175);
-            break;
-          case 3:
-          case 4:
-            var parent$177 = JSCompiler_inline_result.stateNode.containerInfo,
-              before$178 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNodeIntoContainer(
-              finishedWork,
-              before$178,
-              parent$177
-            );
-            break;
-          default:
-            throw Error(formatProdErrorMessage(161));
-        }
+          root = root.return;
+        } while (null !== root);
       }
     } catch (error) {
-      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      throw ((workInProgress = returnFiber), error);
     }
-    finishedWork.flags &= -3;
+    completeUnitOfWork(unitOfWork);
   }
-  flags & 4096 && (finishedWork.flags &= -4097);
 }
-function recursivelyTraverseLayoutEffects(root, parentFiber) {
-  if (parentFiber.subtreeFlags & 8772)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber),
-        (parentFiber = parentFiber.sibling);
+function completeUnitOfWork(unitOfWork) {
+  var completedWork = unitOfWork;
+  do {
+    var current = completedWork.alternate;
+    unitOfWork = completedWork.return;
+    if (0 === (completedWork.flags & 32768)) {
+      if (
+        ((current = completeWork(current, completedWork, renderLanes)),
+        null !== current)
+      ) {
+        workInProgress = current;
+        return;
+      }
+    } else {
+      current = unwindWork(current, completedWork);
+      if (null !== current) {
+        current.flags &= 16383;
+        workInProgress = current;
+        return;
+      }
+      if (null !== unitOfWork)
+        (unitOfWork.flags |= 32768),
+          (unitOfWork.subtreeFlags = 0),
+          (unitOfWork.deletions = null);
+      else {
+        workInProgressRootExitStatus = 6;
+        workInProgress = null;
+        return;
+      }
+    }
+    completedWork = completedWork.sibling;
+    if (null !== completedWork) {
+      workInProgress = completedWork;
+      return;
+    }
+    workInProgress = completedWork = unitOfWork;
+  } while (null !== completedWork);
+  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
 }
-function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var finishedWork = parentFiber;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 14:
-      case 15:
-        commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 1:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        var instance = finishedWork.stateNode;
-        if ("function" === typeof instance.componentWillUnmount) {
-          var current = finishedWork,
-            nearestMountedAncestor = finishedWork.return;
-          try {
-            var current$jscomp$0 = current;
-            instance.props = current$jscomp$0.memoizedProps;
-            instance.state = current$jscomp$0.memoizedState;
-            instance.componentWillUnmount();
-          } catch (error) {
-            captureCommitPhaseError(current, nearestMountedAncestor, error);
-          }
-        }
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 26:
-      case 27:
-      case 5:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      case 22:
-        safelyDetachRef(finishedWork, finishedWork.return);
-        null === finishedWork.memoizedState &&
-          recursivelyTraverseDisappearLayoutEffects(finishedWork);
-        break;
-      default:
-        recursivelyTraverseDisappearLayoutEffects(finishedWork);
+function commitRoot(root, recoverableErrors, transitions) {
+  var previousUpdateLanePriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig$1.transition;
+  try {
+    (ReactCurrentBatchConfig$1.transition = null),
+      (currentUpdatePriority = 2),
+      commitRootImpl(
+        root,
+        recoverableErrors,
+        transitions,
+        previousUpdateLanePriority
+      );
+  } finally {
+    (ReactCurrentBatchConfig$1.transition = prevTransition),
+      (currentUpdatePriority = previousUpdateLanePriority);
+  }
+  return null;
+}
+function commitRootImpl(
+  root,
+  recoverableErrors,
+  transitions,
+  renderPriorityLevel
+) {
+  do flushPassiveEffects();
+  while (null !== rootWithPendingPassiveEffects);
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+  var finishedWork = root.finishedWork,
+    lanes = root.finishedLanes;
+  if (null === finishedWork) return null;
+  root.finishedWork = null;
+  root.finishedLanes = 0;
+  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
+  root.callbackNode = null;
+  root.callbackPriority = 0;
+  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
+  remainingLanes |= concurrentlyUpdatedLanes;
+  markRootFinished(root, remainingLanes);
+  root === workInProgressRoot &&
+    ((workInProgress = workInProgressRoot = null),
+    (workInProgressRootRenderLanes = 0));
+  (0 === (finishedWork.subtreeFlags & 10256) &&
+    0 === (finishedWork.flags & 10256)) ||
+    rootDoesHavePassiveEffects ||
+    ((rootDoesHavePassiveEffects = !0),
+    (pendingPassiveEffectsRemainingLanes = remainingLanes),
+    (pendingPassiveTransitions = transitions),
+    scheduleCallback(NormalPriority$1, function () {
+      flushPassiveEffects();
+      return null;
+    }));
+  transitions = 0 !== (finishedWork.flags & 15990);
+  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
+    transitions = ReactCurrentBatchConfig$1.transition;
+    ReactCurrentBatchConfig$1.transition = null;
+    var previousPriority = currentUpdatePriority;
+    currentUpdatePriority = 2;
+    var prevExecutionContext = executionContext;
+    executionContext |= 4;
+    ReactCurrentOwner.current = null;
+    var shouldFireAfterActiveInstanceBlur$177 = commitBeforeMutationEffects(
+      root,
+      finishedWork
+    );
+    commitMutationEffectsOnFiber(finishedWork, root);
+    shouldFireAfterActiveInstanceBlur$177 &&
+      ((_enabled = !0),
+      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
+      (_enabled = !1));
+    restoreSelection(selectionInformation);
+    _enabled = !!eventsEnabled;
+    selectionInformation = eventsEnabled = null;
+    root.current = finishedWork;
+    commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
+    requestPaint();
+    executionContext = prevExecutionContext;
+    currentUpdatePriority = previousPriority;
+    ReactCurrentBatchConfig$1.transition = transitions;
+  } else root.current = finishedWork;
+  rootDoesHavePassiveEffects
+    ? ((rootDoesHavePassiveEffects = !1),
+      (rootWithPendingPassiveEffects = root),
+      (pendingPassiveEffectsLanes = lanes))
+    : releaseRootPooledCache(root, remainingLanes);
+  remainingLanes = root.pendingLanes;
+  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
+  ensureRootIsScheduled(root, now());
+  if (null !== recoverableErrors)
+    for (
+      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
+      finishedWork < recoverableErrors.length;
+      finishedWork++
+    )
+      (lanes = recoverableErrors[finishedWork]),
+        (remainingLanes = {
+          digest: lanes.digest,
+          componentStack: lanes.stack
+        }),
+        renderPriorityLevel(lanes.value, remainingLanes);
+  if (hasUncaughtError)
+    throw (
+      ((hasUncaughtError = !1),
+      (root = firstUncaughtError),
+      (firstUncaughtError = null),
+      root)
+    );
+  0 !== (pendingPassiveEffectsLanes & 3) &&
+    0 !== root.tag &&
+    flushPassiveEffects();
+  remainingLanes = root.pendingLanes;
+  0 !== (remainingLanes & 3)
+    ? root === rootWithNestedUpdates
+      ? nestedUpdateCount++
+      : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root))
+    : (nestedUpdateCount = 0);
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevRootTransitionCallbacks = root.transitionCallbacks;
+    null !== prevRootTransitionCallbacks &&
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+        null !== prevPendingTransitionCallbacks
+          ? ((currentPendingTransitionCallbacks = null),
+            scheduleCallback(IdlePriority, function () {
+              processTransitionCallbacks(
+                prevPendingTransitionCallbacks,
+                endTime,
+                prevRootTransitionCallbacks
+              );
+            }))
+          : (currentEndTime = endTime);
+      });
+  }
+  return null;
+}
+function releaseRootPooledCache(root, remainingLanes) {
+  0 === (root.pooledCacheLanes &= remainingLanes) &&
+    ((remainingLanes = root.pooledCache),
+    null != remainingLanes &&
+      ((root.pooledCache = null), releaseCache(remainingLanes)));
+}
+function flushPassiveEffects() {
+  if (null !== rootWithPendingPassiveEffects) {
+    var root$178 = rootWithPendingPassiveEffects,
+      remainingLanes = pendingPassiveEffectsRemainingLanes;
+    pendingPassiveEffectsRemainingLanes = 0;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    renderPriority = 32 > renderPriority ? 32 : renderPriority;
+    var prevTransition = ReactCurrentBatchConfig$1.transition,
+      previousPriority = currentUpdatePriority;
+    try {
+      return (
+        (ReactCurrentBatchConfig$1.transition = null),
+        (currentUpdatePriority = renderPriority),
+        flushPassiveEffectsImpl()
+      );
+    } finally {
+      (currentUpdatePriority = previousPriority),
+        (ReactCurrentBatchConfig$1.transition = prevTransition),
+        releaseRootPooledCache(root$178, remainingLanes);
     }
-    parentFiber = parentFiber.sibling;
   }
+  return !1;
 }
-function recursivelyTraverseReappearLayoutEffects(
-  finishedRoot$jscomp$0,
-  parentFiber,
-  includeWorkInProgressEffects
-) {
-  includeWorkInProgressEffects =
-    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var current = parentFiber.alternate,
-      finishedRoot = finishedRoot$jscomp$0,
-      finishedWork = parentFiber,
-      flags = finishedWork.flags;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 15:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        commitHookLayoutEffects(finishedWork, 4);
-        break;
-      case 1:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        finishedRoot = finishedWork.stateNode;
-        if ("function" === typeof finishedRoot.componentDidMount)
-          try {
-            finishedRoot.componentDidMount();
-          } catch (error) {
-            captureCommitPhaseError(finishedWork, finishedWork.return, error);
-          }
-        current = finishedWork.updateQueue;
-        if (null !== current) {
-          var hiddenCallbacks = current.shared.hiddenCallbacks;
-          if (null !== hiddenCallbacks)
-            for (
-              current.shared.hiddenCallbacks = null, current = 0;
-              current < hiddenCallbacks.length;
-              current++
-            )
-              callCallback(hiddenCallbacks[current], finishedRoot);
-        }
-        includeWorkInProgressEffects &&
-          flags & 64 &&
-          commitClassCallbacks(finishedWork);
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      case 26:
-      case 27:
-      case 5:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
-        includeWorkInProgressEffects &&
-          null === current &&
-          flags & 4 &&
-          commitHostComponentMount(finishedWork);
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      case 12:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
+function flushPassiveEffectsImpl() {
+  if (null === rootWithPendingPassiveEffects) return !1;
+  var transitions = pendingPassiveTransitions;
+  pendingPassiveTransitions = null;
+  var root = rootWithPendingPassiveEffects,
+    lanes = pendingPassiveEffectsLanes;
+  rootWithPendingPassiveEffects = null;
+  pendingPassiveEffectsLanes = 0;
+  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
+  var prevExecutionContext = executionContext;
+  executionContext |= 4;
+  commitPassiveUnmountOnFiber(root.current);
+  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
+  executionContext = prevExecutionContext;
+  flushSyncCallbacks();
+  if (enableTransitionTracing) {
+    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
+      prevRootTransitionCallbacks = root.transitionCallbacks,
+      prevEndTime = currentEndTime;
+    null !== prevPendingTransitionCallbacks &&
+      null !== prevRootTransitionCallbacks &&
+      null !== prevEndTime &&
+      ((currentEndTime = currentPendingTransitionCallbacks = null),
+      scheduleCallback(IdlePriority, function () {
+        processTransitionCallbacks(
+          prevPendingTransitionCallbacks,
+          prevEndTime,
+          prevRootTransitionCallbacks
         );
-        break;
-      case 13:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
+      }));
+  }
+  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
+    try {
+      injectedHook.onPostCommitFiberRoot(rendererID, root);
+    } catch (err) {}
+  return !0;
+}
+function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
+  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+  sourceFiber = requestEventTime();
+  null !== rootFiber &&
+    (markRootUpdated(rootFiber, 2, sourceFiber),
+    ensureRootIsScheduled(rootFiber, sourceFiber));
+}
+function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+  if (3 === sourceFiber.tag)
+    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+  else
+    for (
+      nearestMountedAncestor = skipUnmountedBoundaries
+        ? nearestMountedAncestor
+        : sourceFiber.return;
+      null !== nearestMountedAncestor;
+
+    ) {
+      if (3 === nearestMountedAncestor.tag) {
+        captureCommitPhaseErrorOnRoot(
+          nearestMountedAncestor,
+          sourceFiber,
+          error
         );
-        includeWorkInProgressEffects &&
-          flags & 4 &&
-          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
         break;
-      case 22:
-        null === finishedWork.memoizedState &&
-          recursivelyTraverseReappearLayoutEffects(
-            finishedRoot,
-            finishedWork,
-            includeWorkInProgressEffects
+      } else if (1 === nearestMountedAncestor.tag) {
+        var instance = nearestMountedAncestor.stateNode;
+        if (
+          "function" ===
+            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
+          ("function" === typeof instance.componentDidCatch &&
+            (null === legacyErrorBoundariesThatAlreadyFailed ||
+              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
+        ) {
+          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+          sourceFiber = createClassErrorUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
           );
-        safelyAttachRef(finishedWork, finishedWork.return);
-        break;
-      default:
-        recursivelyTraverseReappearLayoutEffects(
-          finishedRoot,
-          finishedWork,
-          includeWorkInProgressEffects
-        );
+          nearestMountedAncestor = enqueueUpdate(
+            nearestMountedAncestor,
+            sourceFiber,
+            2
+          );
+          sourceFiber = requestEventTime();
+          null !== nearestMountedAncestor &&
+            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
+            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
+          break;
+        }
+      }
+      nearestMountedAncestor = nearestMountedAncestor.return;
     }
-    parentFiber = parentFiber.sibling;
-  }
 }
-function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  try {
-    commitHookEffectListMount(hookFlags, finishedWork);
-  } catch (error) {
-    captureCommitPhaseError(finishedWork, finishedWork.return, error);
+function attachPingListener(root, wakeable, lanes) {
+  var pingCache = root.pingCache;
+  if (null === pingCache) {
+    pingCache = root.pingCache = new PossiblyWeakMap();
+    var threadIDs = new Set();
+    pingCache.set(wakeable, threadIDs);
+  } else
+    (threadIDs = pingCache.get(wakeable)),
+      void 0 === threadIDs &&
+        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
+  threadIDs.has(lanes) ||
+    ((workInProgressRootDidAttachPingListener = !0),
+    threadIDs.add(lanes),
+    (root = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
+    wakeable.then(root, root));
+}
+function pingSuspendedRoot(root, wakeable, pingedLanes) {
+  var pingCache = root.pingCache;
+  null !== pingCache && pingCache.delete(wakeable);
+  wakeable = requestEventTime();
+  root.pingedLanes |= root.suspendedLanes & pingedLanes;
+  workInProgressRoot === root &&
+    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
+    (4 === workInProgressRootExitStatus ||
+    (3 === workInProgressRootExitStatus &&
+      (workInProgressRootRenderLanes & 125829120) ===
+        workInProgressRootRenderLanes &&
+      500 > now() - globalMostRecentFallbackTime)
+      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
+      : (workInProgressRootPingedLanes |= pingedLanes));
+  ensureRootIsScheduled(root, wakeable);
+}
+function retryTimedOutBoundary(boundaryFiber, retryLane) {
+  0 === retryLane &&
+    (0 === (boundaryFiber.mode & 1)
+      ? (retryLane = 2)
+      : ((retryLane = nextRetryLane),
+        (nextRetryLane <<= 1),
+        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
+  var eventTime = requestEventTime();
+  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+  null !== boundaryFiber &&
+    (markRootUpdated(boundaryFiber, retryLane, eventTime),
+    ensureRootIsScheduled(boundaryFiber, eventTime));
+}
+function retryDehydratedSuspenseBoundary(boundaryFiber) {
+  var suspenseState = boundaryFiber.memoizedState,
+    retryLane = 0;
+  null !== suspenseState && (retryLane = suspenseState.retryLane);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
+}
+function resolveRetryWakeable(boundaryFiber, wakeable) {
+  var retryLane = 0;
+  switch (boundaryFiber.tag) {
+    case 13:
+      var retryCache = boundaryFiber.stateNode;
+      var suspenseState = boundaryFiber.memoizedState;
+      null !== suspenseState && (retryLane = suspenseState.retryLane);
+      break;
+    case 19:
+      retryCache = boundaryFiber.stateNode;
+      break;
+    case 22:
+      retryCache = boundaryFiber.stateNode._retryCache;
+      break;
+    default:
+      throw Error(formatProdErrorMessage(314));
   }
+  null !== retryCache && retryCache.delete(wakeable);
+  retryTimedOutBoundary(boundaryFiber, retryLane);
 }
-function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
-  var previousCache = null;
-  null !== current &&
-    null !== current.memoizedState &&
-    null !== current.memoizedState.cachePool &&
-    (previousCache = current.memoizedState.cachePool.pool);
-  current = null;
-  null !== finishedWork.memoizedState &&
-    null !== finishedWork.memoizedState.cachePool &&
-    (current = finishedWork.memoizedState.cachePool.pool);
-  current !== previousCache &&
-    (null != current && current.refCount++,
-    null != previousCache && releaseCache(previousCache));
-  if (enableTransitionTracing) {
-    current = finishedWork.updateQueue;
-    previousCache = null !== finishedWork.memoizedState;
-    if (null !== current) {
-      if (previousCache) {
-        var transitions = current.transitions;
-        null !== transitions &&
-          transitions.forEach(function (transition) {
-            null === instance._transitions &&
-              (instance._transitions = new Set());
-            instance._transitions.add(transition);
-          });
-        current = current.markerInstances;
-        null !== current &&
-          current.forEach(function (markerInstance) {
-            var markerTransitions = markerInstance.transitions;
-            null !== markerTransitions &&
-              markerTransitions.forEach(function (transition) {
-                null === instance._transitions
-                  ? (instance._transitions = new Set())
-                  : instance._transitions.has(transition) &&
-                    (null === markerInstance.pendingBoundaries &&
-                      (markerInstance.pendingBoundaries = new Map()),
-                    null === instance._pendingMarkers &&
-                      (instance._pendingMarkers = new Set()),
-                    instance._pendingMarkers.add(markerInstance));
-              });
-          });
+var beginWork;
+beginWork = function (current, workInProgress, renderLanes) {
+  if (null !== current)
+    if (current.memoizedProps !== workInProgress.pendingProps)
+      didReceiveUpdate = !0;
+    else {
+      if (
+        !checkScheduledUpdateOrContext(current, renderLanes) &&
+        0 === (workInProgress.flags & 128)
+      )
+        return (
+          (didReceiveUpdate = !1),
+          attemptEarlyBailoutIfNoScheduledUpdate(
+            current,
+            workInProgress,
+            renderLanes
+          )
+        );
+      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+    }
+  else
+    (didReceiveUpdate = !1),
+      isHydrating &&
+        0 !== (workInProgress.flags & 1048576) &&
+        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
+  workInProgress.lanes = 0;
+  switch (workInProgress.tag) {
+    case 2:
+      var Component = workInProgress.type;
+      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+      current = workInProgress.pendingProps;
+      prepareToReadContext(workInProgress, renderLanes);
+      current = renderWithHooks(
+        null,
+        workInProgress,
+        Component,
+        current,
+        void 0,
+        renderLanes
+      );
+      Component = checkDidRenderIdHook();
+      workInProgress.flags |= 1;
+      workInProgress.tag = 0;
+      isHydrating && Component && pushMaterializedTreeId(workInProgress);
+      reconcileChildren(null, workInProgress, current, renderLanes);
+      workInProgress = workInProgress.child;
+      return workInProgress;
+    case 16:
+      Component = workInProgress.elementType;
+      a: {
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+        current = workInProgress.pendingProps;
+        var init = Component._init;
+        Component = init(Component._payload);
+        workInProgress.type = Component;
+        init = workInProgress.tag = resolveLazyComponentTag(Component);
+        current = resolveDefaultProps(Component, current);
+        switch (init) {
+          case 0:
+            workInProgress = updateFunctionComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 1:
+            workInProgress = updateClassComponent(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 11:
+            workInProgress = updateForwardRef(
+              null,
+              workInProgress,
+              Component,
+              current,
+              renderLanes
+            );
+            break a;
+          case 14:
+            workInProgress = updateMemoComponent(
+              null,
+              workInProgress,
+              Component,
+              resolveDefaultProps(Component.type, current),
+              renderLanes
+            );
+            break a;
+        }
+        throw Error(formatProdErrorMessage(306, Component, ""));
+      }
+      return workInProgress;
+    case 0:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateFunctionComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 1:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateClassComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 3:
+      a: {
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        );
+        if (null === current) throw Error(formatProdErrorMessage(387));
+        Component = workInProgress.pendingProps;
+        var prevState = workInProgress.memoizedState;
+        init = prevState.element;
+        cloneUpdateQueue(current, workInProgress);
+        processUpdateQueue(workInProgress, Component, null, renderLanes);
+        var nextState = workInProgress.memoizedState,
+          root = workInProgress.stateNode;
+        enableTransitionTracing &&
+          push(transitionStack, workInProgressTransitions);
+        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
+        Component = nextState.cache;
+        pushProvider(workInProgress, CacheContext, Component);
+        Component !== prevState.cache &&
+          propagateContextChange(workInProgress, CacheContext, renderLanes);
+        Component = nextState.element;
+        if (prevState.isDehydrated)
+          if (
+            ((prevState = {
+              element: Component,
+              isDehydrated: !1,
+              cache: nextState.cache
+            }),
+            (workInProgress.updateQueue.baseState = prevState),
+            (workInProgress.memoizedState = prevState),
+            workInProgress.flags & 256)
+          ) {
+            init = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(423)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              init
+            );
+            break a;
+          } else if (Component !== init) {
+            init = createCapturedValueAtFiber(
+              Error(formatProdErrorMessage(424)),
+              workInProgress
+            );
+            workInProgress = mountHostRootWithoutHydrating(
+              current,
+              workInProgress,
+              Component,
+              renderLanes,
+              init
+            );
+            break a;
+          } else {
+            nextHydratableInstance = getNextHydratable(
+              workInProgress.stateNode.containerInfo.firstChild
+            );
+            hydrationParentFiber = workInProgress;
+            isHydrating = !0;
+            hydrationErrors = null;
+            rootOrSingletonContext = !0;
+            current = root.mutableSourceEagerHydrationData;
+            if (null != current)
+              for (init = 0; init < current.length; init += 2)
+                (prevState = current[init]),
+                  (prevState._workInProgressVersionPrimary = current[init + 1]),
+                  workInProgressSources.push(prevState);
+            renderLanes = mountChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            );
+            for (workInProgress.child = renderLanes; renderLanes; )
+              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
+                (renderLanes = renderLanes.sibling);
+          }
+        else {
+          resetHydrationState();
+          if (Component === init) {
+            workInProgress = bailoutOnAlreadyFinishedWork(
+              current,
+              workInProgress,
+              renderLanes
+            );
+            break a;
+          }
+          reconcileChildren(current, workInProgress, Component, renderLanes);
+        }
+        workInProgress = workInProgress.child;
       }
-      finishedWork.updateQueue = null;
-    }
-    commitTransitionProgress(finishedWork);
-    previousCache ||
-      ((instance._transitions = null), (instance._pendingMarkers = null));
-  }
-}
-function commitCachePassiveMountEffect(current, finishedWork) {
-  current = null;
-  null !== finishedWork.alternate &&
-    (current = finishedWork.alternate.memoizedState.cache);
-  finishedWork = finishedWork.memoizedState.cache;
-  finishedWork !== current &&
-    (finishedWork.refCount++, null != current && releaseCache(current));
-}
-function commitTracingMarkerPassiveMountEffect(finishedWork) {
-  var instance = finishedWork.stateNode;
-  null !== instance.transitions &&
-    null === instance.pendingBoundaries &&
-    (addMarkerCompleteCallbackToPendingTransition(
-      finishedWork.memoizedProps.name,
-      instance.transitions
-    ),
-    (instance.transitions = null),
-    (instance.pendingBoundaries = null),
-    (instance.aborts = null),
-    (instance.name = null));
-}
-function recursivelyTraversePassiveMountEffects(
-  root,
-  parentFiber,
-  committedLanes,
-  committedTransitions
-) {
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitPassiveMountOnFiber(
-        root,
-        parentFiber,
-        committedLanes,
-        committedTransitions
-      ),
-        (parentFiber = parentFiber.sibling);
-}
-function commitPassiveMountOnFiber(
-  finishedRoot,
-  finishedWork,
-  committedLanes,
-  committedTransitions
-) {
-  var flags = finishedWork.flags;
-  switch (finishedWork.tag) {
-    case 0:
+      return workInProgress;
+    case 26:
+      return (
+        markRef$1(current, workInProgress),
+        (renderLanes = workInProgress.memoizedState =
+          getResource(
+            workInProgress.type,
+            null === current ? null : current.memoizedProps,
+            workInProgress.pendingProps
+          )),
+        null !== current ||
+          isHydrating ||
+          null !== renderLanes ||
+          ((renderLanes = workInProgress.type),
+          (current = workInProgress.pendingProps),
+          (Component = getOwnerDocumentFromRootContainer(
+            rootInstanceStackCursor.current
+          )),
+          (Component = createHTMLElement(renderLanes, current, Component)),
+          (Component[internalInstanceKey] = workInProgress),
+          (Component[internalPropsKey] = current),
+          setInitialProperties(Component, renderLanes, current),
+          markNodeAsHoistable(Component),
+          (workInProgress.stateNode = Component)),
+        null
+      );
+    case 27:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          ((Component = workInProgress.stateNode =
+            resolveSingletonInstance(
+              workInProgress.type,
+              workInProgress.pendingProps,
+              rootInstanceStackCursor.current
+            )),
+          (hydrationParentFiber = workInProgress),
+          (rootOrSingletonContext = !0),
+          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
+        (Component = workInProgress.pendingProps.children),
+        null !== current || isHydrating
+          ? reconcileChildren(current, workInProgress, Component, renderLanes)
+          : (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            )),
+        markRef$1(current, workInProgress),
+        workInProgress.child
+      );
+    case 5:
+      return (
+        pushHostContext(workInProgress),
+        null === current &&
+          isHydrating &&
+          (((Component = workInProgress.pendingProps),
+          "script" === workInProgress.type
+            ? ((init = Component.onLoad),
+              (prevState = Component.onError),
+              (Component = !(Component.async && (init || prevState))))
+            : (Component = !0),
+          Component)
+            ? ((Component = nextHydratableInstance),
+              rootOrSingletonContext &&
+                advanceToFirstAttemptableInstance(workInProgress),
+              (init = nextHydratableInstance),
+              init)
+              ? tryHydrateInstance(workInProgress, init) ||
+                (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                (nextHydratableInstance = getNextHydratable(init.nextSibling)),
+                (prevState = hydrationParentFiber),
+                rootOrSingletonContext &&
+                  advanceToFirstAttemptableInstance(workInProgress),
+                nextHydratableInstance &&
+                tryHydrateInstance(workInProgress, nextHydratableInstance)
+                  ? deleteHydratableInstance(prevState, init)
+                  : (insertNonHydratedInstance(
+                      hydrationParentFiber,
+                      workInProgress
+                    ),
+                    (isHydrating = !1),
+                    (hydrationParentFiber = workInProgress),
+                    (nextHydratableInstance = Component)))
+              : (shouldClientRenderOnMismatch(workInProgress) &&
+                  throwOnHydrationMismatch(),
+                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+                (isHydrating = !1),
+                (hydrationParentFiber = workInProgress),
+                (nextHydratableInstance = Component))
+            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress))),
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (prevState = null !== current ? current.memoizedProps : null),
+        (root = init.children),
+        shouldSetTextContent(Component, init)
+          ? (root = null)
+          : null !== prevState &&
+            shouldSetTextContent(Component, prevState) &&
+            (workInProgress.flags |= 32),
+        markRef$1(current, workInProgress),
+        reconcileChildren(current, workInProgress, root, renderLanes),
+        workInProgress.child
+      );
+    case 6:
+      return (
+        null === current &&
+          isHydrating &&
+          (((renderLanes = "" !== workInProgress.pendingProps),
+          (current = nextHydratableInstance),
+          rootOrSingletonContext &&
+            renderLanes &&
+            advanceToFirstAttemptableTextInstance(),
+          (Component = nextHydratableInstance),
+          Component && renderLanes)
+            ? tryHydrateText(workInProgress, Component) ||
+              (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              (nextHydratableInstance = getNextHydratable(
+                Component.nextSibling
+              )),
+              (init = hydrationParentFiber),
+              rootOrSingletonContext &&
+                renderLanes &&
+                advanceToFirstAttemptableTextInstance(),
+              nextHydratableInstance &&
+              tryHydrateText(workInProgress, nextHydratableInstance)
+                ? deleteHydratableInstance(init, Component)
+                : (insertNonHydratedInstance(
+                    hydrationParentFiber,
+                    workInProgress
+                  ),
+                  (isHydrating = !1),
+                  (hydrationParentFiber = workInProgress),
+                  (nextHydratableInstance = current)))
+            : (shouldClientRenderOnMismatch(workInProgress) &&
+                throwOnHydrationMismatch(),
+              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
+              (isHydrating = !1),
+              (hydrationParentFiber = workInProgress),
+              (nextHydratableInstance = current))),
+        null
+      );
+    case 13:
+      return updateSuspenseComponent(current, workInProgress, renderLanes);
+    case 4:
+      return (
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        ),
+        (Component = workInProgress.pendingProps),
+        null === current
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              Component,
+              renderLanes
+            ))
+          : reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
     case 11:
-    case 15:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        updateForwardRef(current, workInProgress, Component, init, renderLanes)
       );
-      flags & 2048 && commitHookPassiveMountEffects(finishedWork, 9);
-      break;
-    case 3:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+    case 7:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps,
+          renderLanes
+        ),
+        workInProgress.child
       );
-      if (flags & 2048) {
-        flags = null;
-        null !== finishedWork.alternate &&
-          (flags = finishedWork.alternate.memoizedState.cache);
-        var nextCache = finishedWork.memoizedState.cache;
-        nextCache !== flags &&
-          (nextCache.refCount++, null != flags && releaseCache(flags));
-        if (enableTransitionTracing) {
-          var incompleteTransitions =
-            finishedWork.stateNode.incompleteTransitions;
-          null !== committedTransitions &&
-            (committedTransitions.forEach(function (transition) {
-              enableTransitionTracing &&
-                (null === currentPendingTransitionCallbacks &&
-                  (currentPendingTransitionCallbacks = {
-                    transitionStart: [],
-                    transitionProgress: null,
-                    transitionComplete: null,
-                    markerProgress: null,
-                    markerIncomplete: null,
-                    markerComplete: null
-                  }),
-                null === currentPendingTransitionCallbacks.transitionStart &&
-                  (currentPendingTransitionCallbacks.transitionStart = []),
-                currentPendingTransitionCallbacks.transitionStart.push(
-                  transition
-                ));
-            }),
-            clearTransitionsForLanes(finishedRoot, committedLanes));
-          incompleteTransitions.forEach(function (markerInstance, transition) {
-            var pendingBoundaries = markerInstance.pendingBoundaries;
-            if (null === pendingBoundaries || 0 === pendingBoundaries.size)
-              null === markerInstance.aborts &&
-                enableTransitionTracing &&
-                (null === currentPendingTransitionCallbacks &&
-                  (currentPendingTransitionCallbacks = {
-                    transitionStart: null,
-                    transitionProgress: null,
-                    transitionComplete: [],
-                    markerProgress: null,
-                    markerIncomplete: null,
-                    markerComplete: null
-                  }),
-                null === currentPendingTransitionCallbacks.transitionComplete &&
-                  (currentPendingTransitionCallbacks.transitionComplete = []),
-                currentPendingTransitionCallbacks.transitionComplete.push(
-                  transition
-                )),
-                incompleteTransitions.delete(transition);
-          });
-          clearTransitionsForLanes(finishedRoot, committedLanes);
-        }
+    case 8:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 12:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
+      );
+    case 10:
+      a: {
+        Component = workInProgress.type._context;
+        init = workInProgress.pendingProps;
+        prevState = workInProgress.memoizedProps;
+        root = init.value;
+        pushProvider(workInProgress, Component, root);
+        if (!enableLazyContextPropagation && null !== prevState)
+          if (objectIs(prevState.value, root)) {
+            if (prevState.children === init.children) {
+              workInProgress = bailoutOnAlreadyFinishedWork(
+                current,
+                workInProgress,
+                renderLanes
+              );
+              break a;
+            }
+          } else propagateContextChange(workInProgress, Component, renderLanes);
+        reconcileChildren(current, workInProgress, init.children, renderLanes);
+        workInProgress = workInProgress.child;
       }
-      break;
-    case 23:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+      return workInProgress;
+    case 9:
+      return (
+        (init = workInProgress.type),
+        (Component = workInProgress.pendingProps.children),
+        prepareToReadContext(workInProgress, renderLanes),
+        (init = readContext(init)),
+        (Component = Component(init)),
+        (workInProgress.flags |= 1),
+        reconcileChildren(current, workInProgress, Component, renderLanes),
+        workInProgress.child
+      );
+    case 14:
+      return (
+        (Component = workInProgress.type),
+        (init = resolveDefaultProps(Component, workInProgress.pendingProps)),
+        (init = resolveDefaultProps(Component.type, init)),
+        updateMemoComponent(
+          current,
+          workInProgress,
+          Component,
+          init,
+          renderLanes
+        )
+      );
+    case 15:
+      return updateSimpleMemoComponent(
+        current,
+        workInProgress,
+        workInProgress.type,
+        workInProgress.pendingProps,
+        renderLanes
+      );
+    case 17:
+      return (
+        (Component = workInProgress.type),
+        (init = workInProgress.pendingProps),
+        (init =
+          workInProgress.elementType === Component
+            ? init
+            : resolveDefaultProps(Component, init)),
+        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
+        (workInProgress.tag = 1),
+        prepareToReadContext(workInProgress, renderLanes),
+        constructClassInstance(workInProgress, Component, init),
+        mountClassInstance(workInProgress, Component, init, renderLanes),
+        finishClassComponent(
+          null,
+          workInProgress,
+          Component,
+          !0,
+          !1,
+          renderLanes
+        )
+      );
+    case 19:
+      return updateSuspenseListComponent(current, workInProgress, renderLanes);
+    case 21:
+      return (
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
       );
-      flags & 2048 &&
-        commitOffscreenPassiveMountEffects(
-          finishedWork.alternate,
-          finishedWork,
-          finishedWork.stateNode
-        );
-      break;
     case 22:
-      nextCache = finishedWork.stateNode;
-      null !== finishedWork.memoizedState
-        ? nextCache._visibility & 4
-          ? recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            )
-          : finishedWork.mode & 1
-          ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
-          : ((nextCache._visibility |= 4),
-            recursivelyTraversePassiveMountEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions
-            ))
-        : nextCache._visibility & 4
-        ? recursivelyTraversePassiveMountEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions
-          )
-        : ((nextCache._visibility |= 4),
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            0 !== (finishedWork.subtreeFlags & 10256)
-          ));
-      flags & 2048 &&
-        commitOffscreenPassiveMountEffects(
-          finishedWork.alternate,
-          finishedWork,
-          nextCache
-        );
-      break;
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 23:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
     case 24:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
+      return (
+        prepareToReadContext(workInProgress, renderLanes),
+        (Component = readContext(CacheContext)),
+        null === current
+          ? ((init = peekCacheFromPool()),
+            null === init &&
+              ((init = workInProgressRoot),
+              (prevState = createCache()),
+              (init.pooledCache = prevState),
+              prevState.refCount++,
+              null !== prevState && (init.pooledCacheLanes |= renderLanes),
+              (init = prevState)),
+            (workInProgress.memoizedState = { parent: Component, cache: init }),
+            initializeUpdateQueue(workInProgress),
+            pushProvider(workInProgress, CacheContext, init))
+          : (0 !== (current.lanes & renderLanes) &&
+              (cloneUpdateQueue(current, workInProgress),
+              processUpdateQueue(workInProgress, null, null, renderLanes)),
+            (init = current.memoizedState),
+            (prevState = workInProgress.memoizedState),
+            init.parent !== Component
+              ? ((init = { parent: Component, cache: Component }),
+                (workInProgress.memoizedState = init),
+                0 === workInProgress.lanes &&
+                  (workInProgress.memoizedState =
+                    workInProgress.updateQueue.baseState =
+                      init),
+                pushProvider(workInProgress, CacheContext, Component))
+              : ((Component = prevState.cache),
+                pushProvider(workInProgress, CacheContext, Component),
+                Component !== init.cache &&
+                  propagateContextChange(
+                    workInProgress,
+                    CacheContext,
+                    renderLanes
+                  ))),
+        reconcileChildren(
+          current,
+          workInProgress,
+          workInProgress.pendingProps.children,
+          renderLanes
+        ),
+        workInProgress.child
       );
-      flags & 2048 &&
-        commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-      break;
     case 25:
-      if (enableTransitionTracing) {
-        recursivelyTraversePassiveMountEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions
+      if (enableTransitionTracing)
+        return (
+          enableTransitionTracing
+            ? (null === current &&
+                ((Component = enableTransitionTracing
+                  ? transitionStack.current
+                  : null),
+                null !== Component &&
+                  ((Component = {
+                    tag: 1,
+                    transitions: new Set(Component),
+                    pendingBoundaries: null,
+                    name: workInProgress.pendingProps.name,
+                    aborts: null
+                  }),
+                  (workInProgress.stateNode = Component),
+                  (workInProgress.flags |= 2048))),
+              (Component = workInProgress.stateNode),
+              null !== Component &&
+                pushMarkerInstance(workInProgress, Component),
+              reconcileChildren(
+                current,
+                workInProgress,
+                workInProgress.pendingProps.children,
+                renderLanes
+              ),
+              (workInProgress = workInProgress.child))
+            : (workInProgress = null),
+          workInProgress
         );
-        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
-        break;
-      }
-    default:
-      recursivelyTraversePassiveMountEffects(
-        finishedRoot,
-        finishedWork,
-        committedLanes,
-        committedTransitions
-      );
   }
+  throw Error(formatProdErrorMessage(156, workInProgress.tag));
+};
+function scheduleCallback(priorityLevel, callback) {
+  return scheduleCallback$2(priorityLevel, callback);
 }
-function recursivelyTraverseReconnectPassiveEffects(
-  finishedRoot$jscomp$0,
-  parentFiber,
-  committedLanes$jscomp$0,
-  committedTransitions$jscomp$0,
-  includeWorkInProgressEffects
+function FiberNode(tag, pendingProps, key, mode) {
+  this.tag = tag;
+  this.key = key;
+  this.sibling =
+    this.child =
+    this.return =
+    this.stateNode =
+    this.type =
+    this.elementType =
+      null;
+  this.index = 0;
+  this.refCleanup = this.ref = null;
+  this.pendingProps = pendingProps;
+  this.dependencies =
+    this.memoizedState =
+    this.updateQueue =
+    this.memoizedProps =
+      null;
+  this.mode = mode;
+  this.subtreeFlags = this.flags = 0;
+  this.deletions = null;
+  this.childLanes = this.lanes = 0;
+  this.alternate = null;
+}
+function createFiber(tag, pendingProps, key, mode) {
+  return new FiberNode(tag, pendingProps, key, mode);
+}
+function shouldConstruct(Component) {
+  Component = Component.prototype;
+  return !(!Component || !Component.isReactComponent);
+}
+function resolveLazyComponentTag(Component) {
+  if ("function" === typeof Component)
+    return shouldConstruct(Component) ? 1 : 0;
+  if (void 0 !== Component && null !== Component) {
+    Component = Component.$$typeof;
+    if (Component === REACT_FORWARD_REF_TYPE) return 11;
+    if (Component === REACT_MEMO_TYPE) return 14;
+  }
+  return 2;
+}
+function createWorkInProgress(current, pendingProps) {
+  var workInProgress = current.alternate;
+  null === workInProgress
+    ? ((workInProgress = createFiber(
+        current.tag,
+        pendingProps,
+        current.key,
+        current.mode
+      )),
+      (workInProgress.elementType = current.elementType),
+      (workInProgress.type = current.type),
+      (workInProgress.stateNode = current.stateNode),
+      (workInProgress.alternate = current),
+      (current.alternate = workInProgress))
+    : ((workInProgress.pendingProps = pendingProps),
+      (workInProgress.type = current.type),
+      (workInProgress.flags = 0),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null));
+  workInProgress.flags = current.flags & 14680064;
+  workInProgress.childLanes = current.childLanes;
+  workInProgress.lanes = current.lanes;
+  workInProgress.child = current.child;
+  workInProgress.memoizedProps = current.memoizedProps;
+  workInProgress.memoizedState = current.memoizedState;
+  workInProgress.updateQueue = current.updateQueue;
+  pendingProps = current.dependencies;
+  workInProgress.dependencies =
+    null === pendingProps
+      ? null
+      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
+  workInProgress.sibling = current.sibling;
+  workInProgress.index = current.index;
+  workInProgress.ref = current.ref;
+  workInProgress.refCleanup = current.refCleanup;
+  return workInProgress;
+}
+function resetWorkInProgress(workInProgress, renderLanes) {
+  workInProgress.flags &= 14680066;
+  var current = workInProgress.alternate;
+  null === current
+    ? ((workInProgress.childLanes = 0),
+      (workInProgress.lanes = renderLanes),
+      (workInProgress.child = null),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.memoizedProps = null),
+      (workInProgress.memoizedState = null),
+      (workInProgress.updateQueue = null),
+      (workInProgress.dependencies = null),
+      (workInProgress.stateNode = null))
+    : ((workInProgress.childLanes = current.childLanes),
+      (workInProgress.lanes = current.lanes),
+      (workInProgress.child = current.child),
+      (workInProgress.subtreeFlags = 0),
+      (workInProgress.deletions = null),
+      (workInProgress.memoizedProps = current.memoizedProps),
+      (workInProgress.memoizedState = current.memoizedState),
+      (workInProgress.updateQueue = current.updateQueue),
+      (workInProgress.type = current.type),
+      (renderLanes = current.dependencies),
+      (workInProgress.dependencies =
+        null === renderLanes
+          ? null
+          : {
+              lanes: renderLanes.lanes,
+              firstContext: renderLanes.firstContext
+            }));
+  return workInProgress;
+}
+function createFiberFromTypeAndProps(
+  type,
+  key,
+  pendingProps,
+  owner,
+  mode,
+  lanes
 ) {
-  includeWorkInProgressEffects =
-    includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    var finishedRoot = finishedRoot$jscomp$0,
-      finishedWork = parentFiber,
-      committedLanes = committedLanes$jscomp$0,
-      committedTransitions = committedTransitions$jscomp$0,
-      flags = finishedWork.flags;
-    switch (finishedWork.tag) {
-      case 0:
-      case 11:
-      case 15:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+  var fiberTag = 2;
+  owner = type;
+  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
+  else if ("string" === typeof type)
+    fiberTag = isHostHoistableType(
+      type,
+      pendingProps,
+      contextStackCursor.current
+    )
+      ? 26
+      : "html" === type || "head" === type || "body" === type
+      ? 27
+      : 5;
+  else
+    a: switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = 8;
+        mode |= 8;
+        0 !== (mode & 1) && (mode |= 16);
+        break;
+      case REACT_PROFILER_TYPE:
+        return (
+          (type = createFiber(12, pendingProps, key, mode | 2)),
+          (type.elementType = REACT_PROFILER_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_SUSPENSE_TYPE:
+        return (
+          (type = createFiber(13, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_TYPE),
+          (type.lanes = lanes),
+          type
         );
-        commitHookPassiveMountEffects(finishedWork, 8);
-        break;
-      case 23:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+      case REACT_SUSPENSE_LIST_TYPE:
+        return (
+          (type = createFiber(19, pendingProps, key, mode)),
+          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
+          (type.lanes = lanes),
+          type
         );
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitOffscreenPassiveMountEffects(
-            finishedWork.alternate,
-            finishedWork,
-            finishedWork.stateNode
-          );
-        break;
-      case 22:
-        var instance$203 = finishedWork.stateNode;
-        null !== finishedWork.memoizedState
-          ? instance$203._visibility & 4
-            ? recursivelyTraverseReconnectPassiveEffects(
-                finishedRoot,
-                finishedWork,
-                committedLanes,
-                committedTransitions,
-                includeWorkInProgressEffects
-              )
-            : finishedWork.mode & 1
-            ? recursivelyTraverseAtomicPassiveEffects(
-                finishedRoot,
-                finishedWork
-              )
-            : ((instance$203._visibility |= 4),
-              recursivelyTraverseReconnectPassiveEffects(
-                finishedRoot,
-                finishedWork,
-                committedLanes,
-                committedTransitions,
-                includeWorkInProgressEffects
-              ))
-          : ((instance$203._visibility |= 4),
-            recursivelyTraverseReconnectPassiveEffects(
-              finishedRoot,
-              finishedWork,
-              committedLanes,
-              committedTransitions,
-              includeWorkInProgressEffects
-            ));
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitOffscreenPassiveMountEffects(
-            finishedWork.alternate,
-            finishedWork,
-            instance$203
-          );
-        break;
-      case 24:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+      case REACT_OFFSCREEN_TYPE:
+        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
+      case REACT_LEGACY_HIDDEN_TYPE:
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      case REACT_SCOPE_TYPE:
+        return (
+          (pendingProps = createFiber(21, pendingProps, key, mode)),
+          (pendingProps.type = type),
+          (pendingProps.elementType = type),
+          (pendingProps.lanes = lanes),
+          pendingProps
         );
-        includeWorkInProgressEffects &&
-          flags & 2048 &&
-          commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-        break;
-      case 25:
-        if (enableTransitionTracing) {
-          recursivelyTraverseReconnectPassiveEffects(
-            finishedRoot,
-            finishedWork,
-            committedLanes,
-            committedTransitions,
-            includeWorkInProgressEffects
+      case REACT_CACHE_TYPE:
+        return (
+          (type = createFiber(24, pendingProps, key, mode)),
+          (type.elementType = REACT_CACHE_TYPE),
+          (type.lanes = lanes),
+          type
+        );
+      case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing)
+          return (
+            (type = createFiber(25, pendingProps, key, mode)),
+            (type.elementType = REACT_TRACING_MARKER_TYPE),
+            (type.lanes = lanes),
+            (type.stateNode = {
+              tag: 1,
+              transitions: null,
+              pendingBoundaries: null,
+              aborts: null,
+              name: pendingProps.name
+            }),
+            type
           );
-          includeWorkInProgressEffects &&
-            flags & 2048 &&
-            commitTracingMarkerPassiveMountEffect(finishedWork);
+      case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = 8;
+          mode |= 4;
           break;
         }
       default:
-        recursivelyTraverseReconnectPassiveEffects(
-          finishedRoot,
-          finishedWork,
-          committedLanes,
-          committedTransitions,
-          includeWorkInProgressEffects
+        if ("object" === typeof type && null !== type)
+          switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+              fiberTag = 10;
+              break a;
+            case REACT_CONTEXT_TYPE:
+              fiberTag = 9;
+              break a;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = 11;
+              break a;
+            case REACT_MEMO_TYPE:
+              fiberTag = 14;
+              break a;
+            case REACT_LAZY_TYPE:
+              fiberTag = 16;
+              owner = null;
+              break a;
+          }
+        throw Error(
+          formatProdErrorMessage(130, null == type ? type : typeof type, "")
         );
     }
-    parentFiber = parentFiber.sibling;
-  }
-}
-function recursivelyTraverseAtomicPassiveEffects(
-  finishedRoot$jscomp$0,
-  parentFiber
-) {
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-      var finishedRoot = finishedRoot$jscomp$0,
-        finishedWork = parentFiber,
-        flags = finishedWork.flags;
-      switch (finishedWork.tag) {
-        case 22:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-          flags & 2048 &&
-            commitOffscreenPassiveMountEffects(
-              finishedWork.alternate,
-              finishedWork,
-              finishedWork.stateNode
-            );
-          break;
-        case 24:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-          flags & 2048 &&
-            commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
-          break;
-        default:
-          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
-      }
-      parentFiber = parentFiber.sibling;
-    }
-}
-function detachAlternateSiblings(parentFiber) {
-  var previousFiber = parentFiber.alternate;
-  if (
-    null !== previousFiber &&
-    ((parentFiber = previousFiber.child), null !== parentFiber)
-  ) {
-    previousFiber.child = null;
-    do
-      (previousFiber = parentFiber.sibling),
-        (parentFiber.sibling = null),
-        (parentFiber = previousFiber);
-    while (null !== parentFiber);
-  }
+  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
+  pendingProps.elementType = type;
+  pendingProps.type = owner;
+  pendingProps.lanes = lanes;
+  return pendingProps;
 }
-function recursivelyTraversePassiveUnmountEffects(parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (0 !== (parentFiber.flags & 16)) {
-    if (null !== deletions)
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i];
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    detachAlternateSiblings(parentFiber);
-  }
-  if (parentFiber.subtreeFlags & 10256)
-    for (parentFiber = parentFiber.child; null !== parentFiber; )
-      commitPassiveUnmountOnFiber(parentFiber),
-        (parentFiber = parentFiber.sibling);
+function createFiberFromFragment(elements, mode, lanes, key) {
+  elements = createFiber(7, elements, key, mode);
+  elements.lanes = lanes;
+  return elements;
 }
-function commitPassiveUnmountOnFiber(finishedWork) {
-  switch (finishedWork.tag) {
-    case 0:
-    case 11:
-    case 15:
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-      finishedWork.flags & 2048 &&
-        commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
-      break;
-    case 22:
-      var instance = finishedWork.stateNode;
-      null !== finishedWork.memoizedState &&
-      instance._visibility & 4 &&
-      (null === finishedWork.return || 13 !== finishedWork.return.tag)
-        ? ((instance._visibility &= -5),
-          recursivelyTraverseDisconnectPassiveEffects(finishedWork))
-        : recursivelyTraversePassiveUnmountEffects(finishedWork);
-      break;
-    default:
-      recursivelyTraversePassiveUnmountEffects(finishedWork);
-  }
+function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(22, pendingProps, key, mode);
+  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
+  pendingProps.lanes = lanes;
+  var primaryChildInstance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _retryCache: null,
+    _transitions: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(primaryChildInstance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(primaryChildInstance);
+    }
+  };
+  pendingProps.stateNode = primaryChildInstance;
+  return pendingProps;
 }
-function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
-  var deletions = parentFiber.deletions;
-  if (0 !== (parentFiber.flags & 16)) {
-    if (null !== deletions)
-      for (var i = 0; i < deletions.length; i++) {
-        var childToDelete = deletions[i];
-        nextEffect = childToDelete;
-        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-          childToDelete,
-          parentFiber
-        );
-      }
-    detachAlternateSiblings(parentFiber);
-  }
-  for (parentFiber = parentFiber.child; null !== parentFiber; ) {
-    deletions = parentFiber;
-    switch (deletions.tag) {
-      case 0:
-      case 11:
-      case 15:
-        commitHookEffectListUnmount(8, deletions, deletions.return);
-        recursivelyTraverseDisconnectPassiveEffects(deletions);
-        break;
-      case 22:
-        i = deletions.stateNode;
-        i._visibility & 4 &&
-          ((i._visibility &= -5),
-          recursivelyTraverseDisconnectPassiveEffects(deletions));
-        break;
-      default:
-        recursivelyTraverseDisconnectPassiveEffects(deletions);
+function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
+  pendingProps = createFiber(23, pendingProps, key, mode);
+  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
+  pendingProps.lanes = lanes;
+  var instance = {
+    _visibility: 1,
+    _pendingVisibility: 1,
+    _pendingMarkers: null,
+    _transitions: null,
+    _retryCache: null,
+    _current: null,
+    detach: function () {
+      return detachOffscreenInstance(instance);
+    },
+    attach: function () {
+      return attachOffscreenInstance(instance);
     }
-    parentFiber = parentFiber.sibling;
-  }
+  };
+  pendingProps.stateNode = instance;
+  return pendingProps;
 }
-function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
-  deletedSubtreeRoot,
-  nearestMountedAncestor$jscomp$0
+function createFiberFromText(content, mode, lanes) {
+  content = createFiber(6, content, null, mode);
+  content.lanes = lanes;
+  return content;
+}
+function createFiberFromPortal(portal, mode, lanes) {
+  mode = createFiber(
+    4,
+    null !== portal.children ? portal.children : [],
+    portal.key,
+    mode
+  );
+  mode.lanes = lanes;
+  mode.stateNode = {
+    containerInfo: portal.containerInfo,
+    pendingChildren: null,
+    implementation: portal.implementation
+  };
+  return mode;
+}
+function FiberRootNode(
+  containerInfo,
+  tag,
+  hydrate,
+  identifierPrefix,
+  onRecoverableError
 ) {
-  for (; null !== nextEffect; ) {
-    var fiber = nextEffect,
-      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
-    switch (fiber.tag) {
-      case 0:
-      case 11:
-      case 15:
-        commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
-        break;
-      case 23:
-      case 22:
-        null !== fiber.memoizedState &&
-          null !== fiber.memoizedState.cachePool &&
-          ((nearestMountedAncestor = fiber.memoizedState.cachePool.pool),
-          null != nearestMountedAncestor && nearestMountedAncestor.refCount++);
-        break;
-      case 13:
-        if (enableTransitionTracing) {
-          var offscreenFiber = fiber.child,
-            instance = offscreenFiber.stateNode,
-            transitions = instance._transitions;
-          if (null !== transitions) {
-            var abortReason = {
-              reason: "suspense",
-              name: fiber.memoizedProps.unstable_name || null
-            };
-            if (
-              null === fiber.memoizedState ||
-              null === fiber.memoizedState.dehydrated
-            )
-              abortParentMarkerTransitionsForDeletedFiber(
-                offscreenFiber,
-                abortReason,
-                transitions,
-                instance,
-                !0
-              ),
-                null !== nearestMountedAncestor &&
-                  abortParentMarkerTransitionsForDeletedFiber(
-                    nearestMountedAncestor,
-                    abortReason,
-                    transitions,
-                    instance,
-                    !1
-                  );
-          }
-        }
-        break;
-      case 24:
-        releaseCache(fiber.memoizedState.cache);
-        break;
-      case 25:
-        enableTransitionTracing &&
-          ((offscreenFiber = fiber.stateNode.transitions),
-          null !== offscreenFiber &&
-            ((instance = { reason: "marker", name: fiber.memoizedProps.name }),
-            abortParentMarkerTransitionsForDeletedFiber(
-              fiber,
-              instance,
-              offscreenFiber,
-              null,
-              !0
-            ),
-            null !== nearestMountedAncestor &&
-              abortParentMarkerTransitionsForDeletedFiber(
-                nearestMountedAncestor,
-                instance,
-                offscreenFiber,
-                null,
-                !1
-              )));
-    }
-    nearestMountedAncestor = fiber.child;
-    if (null !== nearestMountedAncestor)
-      (nearestMountedAncestor.return = fiber),
-        (nextEffect = nearestMountedAncestor);
-    else
-      a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
-        nearestMountedAncestor = nextEffect;
-        offscreenFiber = nearestMountedAncestor.sibling;
-        instance = nearestMountedAncestor.return;
-        detachFiberAfterEffects(nearestMountedAncestor);
-        if (nearestMountedAncestor === fiber) {
-          nextEffect = null;
-          break a;
-        }
-        if (null !== offscreenFiber) {
-          offscreenFiber.return = instance;
-          nextEffect = offscreenFiber;
-          break a;
-        }
-        nextEffect = instance;
-      }
-  }
+  this.tag = tag;
+  this.containerInfo = containerInfo;
+  this.finishedWork =
+    this.pingCache =
+    this.current =
+    this.pendingChildren =
+      null;
+  this.timeoutHandle = -1;
+  this.callbackNode = this.pendingContext = this.context = null;
+  this.callbackPriority = 0;
+  this.eventTimes = createLaneMap(0);
+  this.expirationTimes = createLaneMap(-1);
+  this.entangledLanes =
+    this.errorRecoveryDisabledLanes =
+    this.finishedLanes =
+    this.mutableReadLanes =
+    this.expiredLanes =
+    this.pingedLanes =
+    this.suspendedLanes =
+    this.pendingLanes =
+      0;
+  this.entanglements = createLaneMap(0);
+  this.hiddenUpdates = createLaneMap(null);
+  this.identifierPrefix = identifierPrefix;
+  this.onRecoverableError = onRecoverableError;
+  this.pooledCache = null;
+  this.pooledCacheLanes = 0;
+  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
+  this.incompleteTransitions = new Map();
+  if (enableTransitionTracing)
+    for (
+      this.transitionCallbacks = null,
+        containerInfo = this.transitionLanes = [],
+        tag = 0;
+      31 > tag;
+      tag++
+    )
+      containerInfo.push(null);
+}
+function createFiberRoot(
+  containerInfo,
+  tag,
+  hydrate,
+  initialChildren,
+  hydrationCallbacks,
+  isStrictMode,
+  concurrentUpdatesByDefaultOverride,
+  identifierPrefix,
+  onRecoverableError,
+  transitionCallbacks
+) {
+  containerInfo = new FiberRootNode(
+    containerInfo,
+    tag,
+    hydrate,
+    identifierPrefix,
+    onRecoverableError
+  );
+  containerInfo.hydrationCallbacks = hydrationCallbacks;
+  enableTransitionTracing &&
+    (containerInfo.transitionCallbacks = transitionCallbacks);
+  1 === tag
+    ? ((tag = 1),
+      !0 === isStrictMode && (tag |= 24),
+      concurrentUpdatesByDefaultOverride && (tag |= 32))
+    : (tag = 0);
+  isStrictMode = createFiber(3, null, null, tag);
+  containerInfo.current = isStrictMode;
+  isStrictMode.stateNode = containerInfo;
+  concurrentUpdatesByDefaultOverride = createCache();
+  concurrentUpdatesByDefaultOverride.refCount++;
+  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
+  concurrentUpdatesByDefaultOverride.refCount++;
+  isStrictMode.memoizedState = {
+    element: initialChildren,
+    isDehydrated: hydrate,
+    cache: concurrentUpdatesByDefaultOverride
+  };
+  initializeUpdateQueue(isStrictMode);
+  return containerInfo;
 }
-var DefaultCacheDispatcher = {
-    getCacheSignal: function () {
-      return readContext(CacheContext).controller.signal;
-    },
-    getCacheForType: function (resourceType) {
-      var cache = readContext(CacheContext),
-        cacheForType = cache.data.get(resourceType);
-      void 0 === cacheForType &&
-        ((cacheForType = resourceType()),
-        cache.data.set(resourceType, cacheForType));
-      return cacheForType;
-    }
-  },
-  COMPONENT_TYPE = 0,
-  HAS_PSEUDO_CLASS_TYPE = 1,
-  ROLE_TYPE = 2,
-  TEST_NAME_TYPE = 3,
-  TEXT_TYPE = 4;
-if ("function" === typeof Symbol && Symbol.for) {
-  var symbolFor = Symbol.for;
-  COMPONENT_TYPE = symbolFor("selector.component");
-  HAS_PSEUDO_CLASS_TYPE = symbolFor("selector.has_pseudo_class");
-  ROLE_TYPE = symbolFor("selector.role");
-  TEST_NAME_TYPE = symbolFor("selector.test_id");
-  TEXT_TYPE = symbolFor("selector.text");
+function createPortal$1(children, containerInfo, implementation) {
+  var key =
+    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+  return {
+    $$typeof: REACT_PORTAL_TYPE,
+    key: null == key ? null : "" + key,
+    children: children,
+    containerInfo: containerInfo,
+    implementation: implementation
+  };
 }
-function findFiberRootForHostRoot(hostRoot) {
-  var maybeFiber = getClosestInstanceFromNode(hostRoot) || null;
-  if (null != maybeFiber) {
-    if ("string" !== typeof maybeFiber.memoizedProps["data-testname"])
-      throw Error(formatProdErrorMessage(364));
-    return maybeFiber;
-  }
-  a: {
-    hostRoot = [hostRoot];
-    for (maybeFiber = 0; maybeFiber < hostRoot.length; ) {
-      var current = hostRoot[maybeFiber++];
-      if (current[internalContainerInstanceKey]) {
-        hostRoot = getInstanceFromNode$1(current);
-        break a;
-      }
-      hostRoot.push.apply(hostRoot, current.children);
-    }
-    hostRoot = null;
-  }
-  if (null === hostRoot) throw Error(formatProdErrorMessage(362));
-  return hostRoot.stateNode.current;
+function updateContainer(element, container, parentComponent, callback) {
+  parentComponent = container.current;
+  var lane = requestUpdateLane(parentComponent);
+  null === container.context
+    ? (container.context = emptyContextObject)
+    : (container.pendingContext = emptyContextObject);
+  container = createUpdate(lane);
+  container.payload = { element: element };
+  callback = void 0 === callback ? null : callback;
+  null !== callback && (container.callback = callback);
+  element = enqueueUpdate(parentComponent, container, lane);
+  null !== element &&
+    ((callback = requestEventTime()),
+    scheduleUpdateOnFiber(element, parentComponent, lane, callback),
+    entangleTransitions(element, parentComponent, lane));
+  return lane;
 }
-function matchSelector(fiber$jscomp$0, selector) {
-  var tag = fiber$jscomp$0.tag;
-  switch (selector.$$typeof) {
-    case COMPONENT_TYPE:
-      if (fiber$jscomp$0.type === selector.value) return !0;
-      break;
-    case HAS_PSEUDO_CLASS_TYPE:
-      a: {
-        selector = selector.value;
-        tag = [fiber$jscomp$0, 0];
-        for (fiber$jscomp$0 = 0; fiber$jscomp$0 < tag.length; ) {
-          var fiber = tag[fiber$jscomp$0++],
-            tag$jscomp$0 = fiber.tag,
-            selectorIndex = tag[fiber$jscomp$0++],
-            selector$jscomp$0 = selector[selectorIndex];
-          if (
-            (5 !== tag$jscomp$0 &&
-              26 !== tag$jscomp$0 &&
-              27 !== tag$jscomp$0) ||
-            !isHiddenSubtree(fiber)
-          ) {
-            for (
-              ;
-              null != selector$jscomp$0 &&
-              matchSelector(fiber, selector$jscomp$0);
-
-            )
-              selectorIndex++, (selector$jscomp$0 = selector[selectorIndex]);
-            if (selectorIndex === selector.length) {
-              selector = !0;
-              break a;
-            } else
-              for (fiber = fiber.child; null !== fiber; )
-                tag.push(fiber, selectorIndex), (fiber = fiber.sibling);
-          }
-        }
-        selector = !1;
+function attemptSynchronousHydration(fiber) {
+  switch (fiber.tag) {
+    case 3:
+      var root$180 = fiber.stateNode;
+      if (root$180.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$180.pendingLanes);
+        0 !== lanes &&
+          (markRootEntangled(root$180, lanes | 2),
+          ensureRootIsScheduled(root$180, now()),
+          0 === (executionContext & 6) &&
+            (resetRenderTimer(), flushSyncCallbacks()));
       }
-      return selector;
-    case ROLE_TYPE:
-      if (5 === tag || 26 === tag || 27 === tag)
-        if (
-          ((tag = fiber$jscomp$0.stateNode),
-          (selector = selector.value),
-          (fiber$jscomp$0 = (fiber$jscomp$0 = tag.getAttribute("role"))
-            ? fiber$jscomp$0.trim().split(" ")
-            : null),
-          (selector =
-            (null !== fiber$jscomp$0 &&
-              0 <= fiber$jscomp$0.indexOf(selector)) ||
-            selector === getImplicitRole(tag)
-              ? !0
-              : !1),
-          selector)
-        )
-          return !0;
       break;
-    case TEXT_TYPE:
-      if (5 === tag || 6 === tag || 26 === tag || 27 === tag) {
-        a: {
-          switch (fiber$jscomp$0.tag) {
-            case 26:
-            case 27:
-            case 5:
-              tag = "";
-              fiber$jscomp$0 = fiber$jscomp$0.stateNode.childNodes;
-              for (
-                selectorIndex = 0;
-                selectorIndex < fiber$jscomp$0.length;
-                selectorIndex++
-              )
-                (fiber = fiber$jscomp$0[selectorIndex]),
-                  fiber.nodeType === Node.TEXT_NODE &&
-                    (tag += fiber.textContent);
-              break a;
-            case 6:
-              tag = fiber$jscomp$0.stateNode.textContent;
-              break a;
-          }
-          tag = null;
+    case 13:
+      flushSync$1(function () {
+        var root = enqueueConcurrentRenderForLane(fiber, 2);
+        if (null !== root) {
+          var eventTime = requestEventTime();
+          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
         }
-        if (null !== tag && 0 <= tag.indexOf(selector.value)) return !0;
-      }
-      break;
-    case TEST_NAME_TYPE:
-      if (5 === tag || 26 === tag || 27 === tag)
-        if (
-          ((tag = fiber$jscomp$0.memoizedProps["data-testname"]),
-          "string" === typeof tag &&
-            tag.toLowerCase() === selector.value.toLowerCase())
-        )
-          return !0;
-      break;
-    default:
-      throw Error(formatProdErrorMessage(365));
+      }),
+        markRetryLaneIfNotHydrated(fiber, 2);
   }
-  return !1;
 }
-function selectorToString(selector) {
-  switch (selector.$$typeof) {
-    case COMPONENT_TYPE:
-      return (
-        "<" + (getComponentNameFromType(selector.value) || "Unknown") + ">"
-      );
-    case HAS_PSEUDO_CLASS_TYPE:
-      return ":has(" + (selectorToString(selector) || "") + ")";
-    case ROLE_TYPE:
-      return '[role="' + selector.value + '"]';
-    case TEXT_TYPE:
-      return '"' + selector.value + '"';
-    case TEST_NAME_TYPE:
-      return '[data-testname="' + selector.value + '"]';
-    default:
-      throw Error(formatProdErrorMessage(365));
+function markRetryLaneImpl(fiber, retryLane) {
+  fiber = fiber.memoizedState;
+  if (null !== fiber && null !== fiber.dehydrated) {
+    var a = fiber.retryLane;
+    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
   }
 }
-function findPaths(root, selectors) {
-  var matchingFibers = [];
-  root = [root, 0];
-  for (var index = 0; index < root.length; ) {
-    var fiber = root[index++],
-      tag = fiber.tag,
-      selectorIndex = root[index++],
-      selector = selectors[selectorIndex];
-    if ((5 !== tag && 26 !== tag && 27 !== tag) || !isHiddenSubtree(fiber)) {
-      for (; null != selector && matchSelector(fiber, selector); )
-        selectorIndex++, (selector = selectors[selectorIndex]);
-      if (selectorIndex === selectors.length) matchingFibers.push(fiber);
-      else
-        for (fiber = fiber.child; null !== fiber; )
-          root.push(fiber, selectorIndex), (fiber = fiber.sibling);
+function markRetryLaneIfNotHydrated(fiber, retryLane) {
+  markRetryLaneImpl(fiber, retryLane);
+  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
+}
+function attemptContinuousHydration(fiber) {
+  if (13 === fiber.tag) {
+    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
+    if (null !== root) {
+      var eventTime = requestEventTime();
+      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
     }
+    markRetryLaneIfNotHydrated(fiber, 134217728);
+  }
+}
+function emptyFindFiberByHostInstance() {
+  return null;
+}
+var isInsideEventHandler = !1;
+function batchedUpdates(fn, a, b) {
+  if (isInsideEventHandler) return fn(a, b);
+  isInsideEventHandler = !0;
+  try {
+    return batchedUpdates$1(fn, a, b);
+  } finally {
+    if (
+      ((isInsideEventHandler = !1),
+      null !== restoreTarget || null !== restoreQueue)
+    )
+      flushSync$1(), restoreStateIfNeeded();
+  }
+}
+function getListener(inst, registrationName) {
+  var stateNode = inst.stateNode;
+  if (null === stateNode) return null;
+  var props = getFiberCurrentPropsFromNode(stateNode);
+  if (null === props) return null;
+  stateNode = props[registrationName];
+  a: switch (registrationName) {
+    case "onClick":
+    case "onClickCapture":
+    case "onDoubleClick":
+    case "onDoubleClickCapture":
+    case "onMouseDown":
+    case "onMouseDownCapture":
+    case "onMouseMove":
+    case "onMouseMoveCapture":
+    case "onMouseUp":
+    case "onMouseUpCapture":
+    case "onMouseEnter":
+      (props = !props.disabled) ||
+        ((inst = inst.type),
+        (props = !(
+          "button" === inst ||
+          "input" === inst ||
+          "select" === inst ||
+          "textarea" === inst
+        )));
+      inst = !props;
+      break a;
+    default:
+      inst = !1;
   }
-  return matchingFibers;
+  if (inst) return null;
+  if (stateNode && "function" !== typeof stateNode)
+    throw Error(
+      formatProdErrorMessage(231, registrationName, typeof stateNode)
+    );
+  return stateNode;
 }
-function findAllNodes(hostRoot, selectors) {
-  hostRoot = findFiberRootForHostRoot(hostRoot);
-  hostRoot = findPaths(hostRoot, selectors);
-  selectors = [];
-  hostRoot = Array.from(hostRoot);
-  for (var index = 0; index < hostRoot.length; ) {
-    var node = hostRoot[index++],
-      tag = node.tag;
-    if (5 === tag || 26 === tag || 27 === tag)
-      isHiddenSubtree(node) || selectors.push(node.stateNode);
-    else
-      for (node = node.child; null !== node; )
-        hostRoot.push(node), (node = node.sibling);
+var passiveBrowserEventsSupported = !1;
+if (canUseDOM)
+  try {
+    var options = {};
+    Object.defineProperty(options, "passive", {
+      get: function () {
+        passiveBrowserEventsSupported = !0;
+      }
+    });
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (e) {
+    passiveBrowserEventsSupported = !1;
   }
-  return selectors;
-}
-var postPaintCallbackScheduled = !1,
-  callbacks = [];
-function schedulePostPaintCallback(callback) {
-  callbacks.push(callback);
-  postPaintCallbackScheduled ||
-    ((postPaintCallbackScheduled = !0),
-    requestPostPaintCallback(function (endTime) {
-      for (var i = 0; i < callbacks.length; i++) callbacks[i](endTime);
-      postPaintCallbackScheduled = !1;
-      callbacks = [];
-    }));
-}
-var ceil = Math.ceil,
-  PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
-  ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
-  ReactCurrentCache = ReactSharedInternals.ReactCurrentCache,
-  ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner,
-  ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
-  executionContext = 0,
-  workInProgressRoot = null,
-  workInProgress = null,
-  workInProgressRootRenderLanes = 0,
-  workInProgressSuspendedReason = 0,
-  workInProgressThrownValue = null,
-  workInProgressRootDidAttachPingListener = !1,
-  renderLanes = 0,
-  workInProgressRootExitStatus = 0,
-  workInProgressRootFatalError = null,
-  workInProgressRootSkippedLanes = 0,
-  workInProgressRootInterleavedUpdatedLanes = 0,
-  workInProgressRootPingedLanes = 0,
-  workInProgressRootConcurrentErrors = null,
-  workInProgressRootRecoverableErrors = null,
-  globalMostRecentFallbackTime = 0,
-  workInProgressRootRenderTargetTime = Infinity,
-  workInProgressTransitions = null,
-  currentPendingTransitionCallbacks = null,
-  currentEndTime = null;
-function addMarkerProgressCallbackToPendingTransition(
-  markerName,
-  transitions,
-  pendingBoundaries
+var hasScheduledReplayAttempt = !1,
+  queuedDiscreteEvents = [],
+  queuedFocus = null,
+  queuedDrag = null,
+  queuedMouse = null,
+  queuedPointers = new Map(),
+  queuedPointerCaptures = new Map(),
+  queuedExplicitHydrationTargets = [],
+  discreteReplayableEvents =
+    "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
+      " "
+    );
+function createQueuedReplayableEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
 ) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: new Map(),
-        markerIncomplete: null,
-        markerComplete: null
-      }),
-    null === currentPendingTransitionCallbacks.markerProgress &&
-      (currentPendingTransitionCallbacks.markerProgress = new Map()),
-    currentPendingTransitionCallbacks.markerProgress.set(markerName, {
-      pendingBoundaries: pendingBoundaries,
-      transitions: transitions
-    }));
-}
-function addMarkerCompleteCallbackToPendingTransition(markerName, transitions) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: null,
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: new Map()
-      }),
-    null === currentPendingTransitionCallbacks.markerComplete &&
-      (currentPendingTransitionCallbacks.markerComplete = new Map()),
-    currentPendingTransitionCallbacks.markerComplete.set(
-      markerName,
-      transitions
-    ));
+  return {
+    blockedOn: blockedOn,
+    domEventName: domEventName,
+    eventSystemFlags: eventSystemFlags,
+    nativeEvent: nativeEvent,
+    targetContainers: [targetContainer]
+  };
 }
-function addTransitionProgressCallbackToPendingTransition(
-  transition,
-  boundaries
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
 ) {
-  enableTransitionTracing &&
-    (null === currentPendingTransitionCallbacks &&
-      (currentPendingTransitionCallbacks = {
-        transitionStart: null,
-        transitionProgress: new Map(),
-        transitionComplete: null,
-        markerProgress: null,
-        markerIncomplete: null,
-        markerComplete: null
-      }),
-    null === currentPendingTransitionCallbacks.transitionProgress &&
-      (currentPendingTransitionCallbacks.transitionProgress = new Map()),
-    currentPendingTransitionCallbacks.transitionProgress.set(
-      transition,
-      boundaries
-    ));
-}
-function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now() + 500;
+  if (
+    !enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay &&
+    ((blockedOn = createQueuedReplayableEvent(
+      blockedOn,
+      domEventName,
+      eventSystemFlags,
+      targetContainer,
+      nativeEvent
+    )),
+    queuedDiscreteEvents.push(blockedOn),
+    1 === queuedDiscreteEvents.length)
+  )
+    for (; null !== blockedOn.blockedOn; ) {
+      domEventName = getInstanceFromNode$1(blockedOn.blockedOn);
+      if (null === domEventName) break;
+      attemptSynchronousHydration(domEventName);
+      if (null === blockedOn.blockedOn) replayUnblockedEvents();
+      else break;
+    }
 }
-var hasUncaughtError = !1,
-  firstUncaughtError = null,
-  legacyErrorBoundariesThatAlreadyFailed = null,
-  rootDoesHavePassiveEffects = !1,
-  rootWithPendingPassiveEffects = null,
-  pendingPassiveEffectsLanes = 0,
-  pendingPassiveEffectsRemainingLanes = 0,
-  pendingPassiveTransitions = null,
-  nestedUpdateCount = 0,
-  rootWithNestedUpdates = null,
-  currentEventTime = -1,
-  currentEventTransitionLane = 0;
-function requestEventTime() {
-  return 0 !== (executionContext & 6)
-    ? now()
-    : -1 !== currentEventTime
-    ? currentEventTime
-    : (currentEventTime = now());
+function clearIfContinuousEvent(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "focusin":
+    case "focusout":
+      queuedFocus = null;
+      break;
+    case "dragenter":
+    case "dragleave":
+      queuedDrag = null;
+      break;
+    case "mouseover":
+    case "mouseout":
+      queuedMouse = null;
+      break;
+    case "pointerover":
+    case "pointerout":
+      queuedPointers.delete(nativeEvent.pointerId);
+      break;
+    case "gotpointercapture":
+    case "lostpointercapture":
+      queuedPointerCaptures.delete(nativeEvent.pointerId);
+  }
 }
-function requestUpdateLane(fiber) {
-  if (0 === (fiber.mode & 1)) return 2;
+function accumulateOrCreateContinuousQueuedReplayableEvent(
+  existingQueuedEvent,
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
   if (
-    !deferRenderPhaseUpdateToNextBatch &&
-    0 !== (executionContext & 2) &&
-    0 !== workInProgressRootRenderLanes
-  )
-    return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
-  if (null !== ReactCurrentBatchConfig$1.transition)
-    return (
-      0 === currentEventTransitionLane &&
-        (currentEventTransitionLane = claimNextTransitionLane()),
-      currentEventTransitionLane
+    null === existingQueuedEvent ||
+    existingQueuedEvent.nativeEvent !== nativeEvent
+  )
+    return (
+      (existingQueuedEvent = createQueuedReplayableEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )),
+      null !== blockedOn &&
+        ((blockedOn = getInstanceFromNode$1(blockedOn)),
+        null !== blockedOn && attemptContinuousHydration(blockedOn)),
+      existingQueuedEvent
     );
-  fiber = currentUpdatePriority;
-  if (0 !== fiber) return fiber;
-  fiber = window.event;
-  fiber = void 0 === fiber ? 32 : getEventPriority(fiber.type);
-  return fiber;
+  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+  blockedOn = existingQueuedEvent.targetContainers;
+  null !== targetContainer &&
+    -1 === blockedOn.indexOf(targetContainer) &&
+    blockedOn.push(targetContainer);
+  return existingQueuedEvent;
 }
-function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
-  2 === workInProgressSuspendedReason &&
-    root === workInProgressRoot &&
-    (prepareFreshStack(root, 0),
-    markRootSuspended(root, workInProgressRootRenderLanes));
-  markRootUpdated(root, lane, eventTime);
-  if (0 === (executionContext & 2) || root !== workInProgressRoot) {
-    if (enableTransitionTracing) {
-      var transition = ReactCurrentBatchConfig.transition;
-      if (
-        null !== transition &&
-        null != transition.name &&
-        (-1 === transition.startTime && (transition.startTime = now()),
-        enableTransitionTracing)
-      ) {
-        var transitionLanesMap = root.transitionLanes,
-          index$15 = 31 - clz32(lane),
-          transitions = transitionLanesMap[index$15];
-        null === transitions && (transitions = new Set());
-        transitions.add(transition);
-        transitionLanesMap[index$15] = transitions;
-      }
-    }
-    if (root === workInProgressRoot) {
-      if (deferRenderPhaseUpdateToNextBatch || 0 === (executionContext & 2))
-        workInProgressRootInterleavedUpdatedLanes |= lane;
-      4 === workInProgressRootExitStatus &&
-        markRootSuspended(root, workInProgressRootRenderLanes);
-    }
-    ensureRootIsScheduled(root, eventTime);
-    2 === lane &&
-      0 === executionContext &&
-      0 === (fiber.mode & 1) &&
-      (resetRenderTimer(), includesLegacySyncCallbacks && flushSyncCallbacks());
+function queueIfContinuousEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  switch (domEventName) {
+    case "focusin":
+      return (
+        (queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedFocus,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "dragenter":
+      return (
+        (queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedDrag,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "mouseover":
+      return (
+        (queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedMouse,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        !0
+      );
+    case "pointerover":
+      var pointerId = nativeEvent.pointerId;
+      queuedPointers.set(
+        pointerId,
+        accumulateOrCreateContinuousQueuedReplayableEvent(
+          queuedPointers.get(pointerId) || null,
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
+      );
+      return !0;
+    case "gotpointercapture":
+      return (
+        (pointerId = nativeEvent.pointerId),
+        queuedPointerCaptures.set(
+          pointerId,
+          accumulateOrCreateContinuousQueuedReplayableEvent(
+            queuedPointerCaptures.get(pointerId) || null,
+            blockedOn,
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          )
+        ),
+        !0
+      );
   }
+  return !1;
 }
-function ensureRootIsScheduled(root, currentTime) {
-  var existingCallbackNode = root.callbackNode;
-  markStarvedLanesAsExpired(root, currentTime);
-  var nextLanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
-  );
-  if (0 === nextLanes)
-    null !== existingCallbackNode && cancelCallback$1(existingCallbackNode),
-      (root.callbackNode = null),
-      (root.callbackPriority = 0);
-  else if (2 === workInProgressSuspendedReason && workInProgressRoot === root)
-    (root.callbackPriority = 0), (root.callbackNode = null);
-  else if (
-    ((currentTime = nextLanes & -nextLanes),
-    root.callbackPriority !== currentTime)
-  ) {
-    null != existingCallbackNode && cancelCallback$1(existingCallbackNode);
-    if (0 !== (currentTime & 3))
-      0 === root.tag
-        ? scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root))
-        : scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root)),
-        scheduleMicrotask(function () {
-          0 === (executionContext & 6) && flushSyncCallbacks();
-        }),
-        (existingCallbackNode = null);
-    else {
-      switch (lanesToEventPriority(nextLanes)) {
-        case 2:
-          existingCallbackNode = ImmediatePriority;
-          break;
-        case 8:
-          existingCallbackNode = UserBlockingPriority;
-          break;
-        case 32:
-          existingCallbackNode = NormalPriority$1;
-          break;
-        case 536870912:
-          existingCallbackNode = IdlePriority;
-          break;
-        default:
-          existingCallbackNode = NormalPriority$1;
+function attemptExplicitHydrationTarget(queuedTarget) {
+  var targetInst = getClosestInstanceFromNode(queuedTarget.target);
+  if (null !== targetInst) {
+    var nearestMounted = getNearestMountedFiber(targetInst);
+    if (null !== nearestMounted)
+      if (((targetInst = nearestMounted.tag), 13 === targetInst)) {
+        if (
+          ((targetInst = getSuspenseInstanceFromFiber(nearestMounted)),
+          null !== targetInst)
+        ) {
+          queuedTarget.blockedOn = targetInst;
+          runWithPriority(queuedTarget.priority, function () {
+            if (13 === nearestMounted.tag) {
+              var lane = requestUpdateLane(nearestMounted),
+                root = enqueueConcurrentRenderForLane(nearestMounted, lane);
+              if (null !== root) {
+                var eventTime = requestEventTime();
+                scheduleUpdateOnFiber(root, nearestMounted, lane, eventTime);
+              }
+              markRetryLaneIfNotHydrated(nearestMounted, lane);
+            }
+          });
+          return;
+        }
+      } else if (
+        3 === targetInst &&
+        nearestMounted.stateNode.current.memoizedState.isDehydrated
+      ) {
+        queuedTarget.blockedOn =
+          3 === nearestMounted.tag
+            ? nearestMounted.stateNode.containerInfo
+            : null;
+        return;
       }
-      existingCallbackNode = scheduleCallback(
-        existingCallbackNode,
-        performConcurrentWorkOnRoot.bind(null, root)
-      );
-    }
-    root.callbackPriority = currentTime;
-    root.callbackNode = existingCallbackNode;
   }
+  queuedTarget.blockedOn = null;
 }
-function performConcurrentWorkOnRoot(root, didTimeout) {
-  currentEventTime = -1;
-  currentEventTransitionLane = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var originalCallbackNode = root.callbackNode;
-  if (flushPassiveEffects() && root.callbackNode !== originalCallbackNode)
-    return null;
-  var lanes = getNextLanes(
-    root,
-    root === workInProgressRoot ? workInProgressRootRenderLanes : 0
-  );
-  if (0 === lanes) return null;
-  didTimeout =
-    includesBlockingLane(root, lanes) ||
-    0 !== (lanes & root.expiredLanes) ||
-    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
-      ? renderRootSync(root, lanes)
-      : renderRootConcurrent(root, lanes);
-  if (0 !== didTimeout) {
-    if (2 === didTimeout) {
-      var originallyAttemptedLanes = lanes,
-        errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-          root,
-          originallyAttemptedLanes
-        );
-      0 !== errorRetryLanes &&
-        ((lanes = errorRetryLanes),
-        (didTimeout = recoverFromConcurrentError(
-          root,
-          originallyAttemptedLanes,
-          errorRetryLanes
-        )));
-    }
-    if (1 === didTimeout)
-      throw (
-        ((originalCallbackNode = workInProgressRootFatalError),
-        prepareFreshStack(root, 0),
-        markRootSuspended(root, lanes),
-        ensureRootIsScheduled(root, now()),
-        originalCallbackNode)
+function attemptReplayContinuousQueuedEvent(queuedEvent) {
+  if (null !== queuedEvent.blockedOn) return !1;
+  for (
+    var targetContainers = queuedEvent.targetContainers;
+    0 < targetContainers.length;
+
+  ) {
+    var targetContainer = targetContainers[0],
+      nextBlockedOn = findInstanceBlockingEvent(
+        queuedEvent.domEventName,
+        queuedEvent.eventSystemFlags,
+        targetContainer,
+        queuedEvent.nativeEvent
       );
-    if (6 === didTimeout) markRootSuspended(root, lanes);
-    else {
-      errorRetryLanes = !includesBlockingLane(root, lanes);
-      originallyAttemptedLanes = root.current.alternate;
-      if (
-        errorRetryLanes &&
-        !isRenderConsistentWithExternalStores(originallyAttemptedLanes)
-      ) {
-        didTimeout = renderRootSync(root, lanes);
-        if (2 === didTimeout) {
-          errorRetryLanes = lanes;
-          var errorRetryLanes$213 = getLanesToRetrySynchronouslyOnError(
-            root,
-            errorRetryLanes
-          );
-          0 !== errorRetryLanes$213 &&
-            ((lanes = errorRetryLanes$213),
-            (didTimeout = recoverFromConcurrentError(
-              root,
-              errorRetryLanes,
-              errorRetryLanes$213
-            )));
+    if (null === nextBlockedOn)
+      enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay
+        ? ((nextBlockedOn = queuedEvent.nativeEvent),
+          (currentReplayingEvent = targetContainer =
+            new nextBlockedOn.constructor(nextBlockedOn.type, nextBlockedOn)),
+          nextBlockedOn.target.dispatchEvent(targetContainer))
+        : ((currentReplayingEvent = queuedEvent.nativeEvent),
+          dispatchEventForPluginEventSystem(
+            queuedEvent.domEventName,
+            queuedEvent.eventSystemFlags,
+            queuedEvent.nativeEvent,
+            return_targetInst,
+            targetContainer
+          )),
+        (currentReplayingEvent = null);
+    else
+      return (
+        (targetContainers = getInstanceFromNode$1(nextBlockedOn)),
+        null !== targetContainers &&
+          attemptContinuousHydration(targetContainers),
+        (queuedEvent.blockedOn = nextBlockedOn),
+        !1
+      );
+    targetContainers.shift();
+  }
+  return !0;
+}
+function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+  attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+}
+function replayUnblockedEvents() {
+  hasScheduledReplayAttempt = !1;
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay)
+    for (; 0 < queuedDiscreteEvents.length; ) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
+      if (null !== nextDiscreteEvent.blockedOn) {
+        nextDiscreteEvent = getInstanceFromNode$1(nextDiscreteEvent.blockedOn);
+        if (null !== nextDiscreteEvent && 13 === nextDiscreteEvent.tag) {
+          var root = enqueueConcurrentRenderForLane(nextDiscreteEvent, 2);
+          if (null !== root) {
+            var eventTime = requestEventTime();
+            scheduleUpdateOnFiber(root, nextDiscreteEvent, 2, eventTime);
+          }
+          markRetryLaneIfNotHydrated(nextDiscreteEvent, 2);
         }
-        if (1 === didTimeout)
-          throw (
-            ((originalCallbackNode = workInProgressRootFatalError),
-            prepareFreshStack(root, 0),
-            markRootSuspended(root, lanes),
-            ensureRootIsScheduled(root, now()),
-            originalCallbackNode)
-          );
+        break;
       }
-      root.finishedWork = originallyAttemptedLanes;
-      root.finishedLanes = lanes;
-      switch (didTimeout) {
-        case 0:
-        case 1:
-          throw Error(formatProdErrorMessage(345));
-        case 2:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 3:
-          markRootSuspended(root, lanes);
-          if (
-            (lanes & 125829120) === lanes &&
-            ((lanes = globalMostRecentFallbackTime + 500 - now()), 10 < lanes)
-          ) {
-            if (0 !== getNextLanes(root, 0)) break;
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
-          }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 4:
-          markRootSuspended(root, lanes);
-          if ((lanes & 8388480) === lanes) break;
-          didTimeout = root.eventTimes;
-          for (originallyAttemptedLanes = -1; 0 < lanes; )
-            (errorRetryLanes$213 = 31 - clz32(lanes)),
-              (errorRetryLanes = 1 << errorRetryLanes$213),
-              (errorRetryLanes$213 = didTimeout[errorRetryLanes$213]),
-              errorRetryLanes$213 > originallyAttemptedLanes &&
-                (originallyAttemptedLanes = errorRetryLanes$213),
-              (lanes &= ~errorRetryLanes);
-          lanes = originallyAttemptedLanes;
-          lanes = now() - lanes;
-          lanes =
-            (120 > lanes
-              ? 120
-              : 480 > lanes
-              ? 480
-              : 1080 > lanes
-              ? 1080
-              : 1920 > lanes
-              ? 1920
-              : 3e3 > lanes
-              ? 3e3
-              : 4320 > lanes
-              ? 4320
-              : 1960 * ceil(lanes / 1960)) - lanes;
-          if (10 < lanes) {
-            root.timeoutHandle = scheduleTimeout(
-              commitRoot.bind(
-                null,
-                root,
-                workInProgressRootRecoverableErrors,
-                workInProgressTransitions
-              ),
-              lanes
-            );
-            break;
-          }
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
-          break;
-        case 5:
-          commitRoot(
-            root,
-            workInProgressRootRecoverableErrors,
-            workInProgressTransitions
-          );
+      for (root = nextDiscreteEvent.targetContainers; 0 < root.length; ) {
+        eventTime = root[0];
+        var nextBlockedOn = findInstanceBlockingEvent(
+          nextDiscreteEvent.domEventName,
+          nextDiscreteEvent.eventSystemFlags,
+          eventTime,
+          nextDiscreteEvent.nativeEvent
+        );
+        if (null === nextBlockedOn)
+          (currentReplayingEvent = nextDiscreteEvent.nativeEvent),
+            dispatchEventForPluginEventSystem(
+              nextDiscreteEvent.domEventName,
+              nextDiscreteEvent.eventSystemFlags,
+              nextDiscreteEvent.nativeEvent,
+              return_targetInst,
+              eventTime
+            ),
+            (currentReplayingEvent = null);
+        else {
+          nextDiscreteEvent.blockedOn = nextBlockedOn;
           break;
-        default:
-          throw Error(formatProdErrorMessage(329));
+        }
+        root.shift();
       }
+      null === nextDiscreteEvent.blockedOn && queuedDiscreteEvents.shift();
     }
+  null !== queuedFocus &&
+    attemptReplayContinuousQueuedEvent(queuedFocus) &&
+    (queuedFocus = null);
+  null !== queuedDrag &&
+    attemptReplayContinuousQueuedEvent(queuedDrag) &&
+    (queuedDrag = null);
+  null !== queuedMouse &&
+    attemptReplayContinuousQueuedEvent(queuedMouse) &&
+    (queuedMouse = null);
+  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+}
+function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+  queuedEvent.blockedOn === unblocked &&
+    ((queuedEvent.blockedOn = null),
+    hasScheduledReplayAttempt ||
+      ((hasScheduledReplayAttempt = !0),
+      Scheduler.unstable_scheduleCallback(
+        Scheduler.unstable_NormalPriority,
+        replayUnblockedEvents
+      )));
+}
+function retryIfBlockedOn(unblocked) {
+  function unblock(queuedEvent) {
+    return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+  }
+  if (0 < queuedDiscreteEvents.length) {
+    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked);
+    for (var i = 1; i < queuedDiscreteEvents.length; i++) {
+      var queuedEvent$jscomp$0 = queuedDiscreteEvents[i];
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
+    }
+  }
+  null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+  null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+  null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+  queuedPointers.forEach(unblock);
+  queuedPointerCaptures.forEach(unblock);
+  for (i = 0; i < queuedExplicitHydrationTargets.length; i++)
+    (queuedEvent$jscomp$0 = queuedExplicitHydrationTargets[i]),
+      queuedEvent$jscomp$0.blockedOn === unblocked &&
+        (queuedEvent$jscomp$0.blockedOn = null);
+  for (
+    ;
+    0 < queuedExplicitHydrationTargets.length &&
+    ((i = queuedExplicitHydrationTargets[0]), null === i.blockedOn);
+
+  )
+    attemptExplicitHydrationTarget(i),
+      null === i.blockedOn && queuedExplicitHydrationTargets.shift();
+}
+var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
+  _enabled = !0;
+function createEventListenerWrapperWithPriority(
+  targetContainer,
+  domEventName,
+  eventSystemFlags
+) {
+  switch (getEventPriority(domEventName)) {
+    case 2:
+      var listenerWrapper = dispatchDiscreteEvent;
+      break;
+    case 8:
+      listenerWrapper = dispatchContinuousEvent;
+      break;
+    default:
+      listenerWrapper = dispatchEvent;
+  }
+  return listenerWrapper.bind(
+    null,
+    domEventName,
+    eventSystemFlags,
+    targetContainer
+  );
+}
+function dispatchDiscreteEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
+) {
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 2),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
   }
-  ensureRootIsScheduled(root, now());
-  return root.callbackNode === originalCallbackNode
-    ? performConcurrentWorkOnRoot.bind(null, root)
-    : null;
 }
-function recoverFromConcurrentError(
-  root,
-  originallyAttemptedLanes,
-  errorRetryLanes
+function dispatchContinuousEvent(
+  domEventName,
+  eventSystemFlags,
+  container,
+  nativeEvent
 ) {
-  var errorsFromFirstAttempt = workInProgressRootConcurrentErrors,
-    wasRootDehydrated = root.current.memoizedState.isDehydrated;
-  wasRootDehydrated && (prepareFreshStack(root, errorRetryLanes).flags |= 256);
-  errorRetryLanes = renderRootSync(root, errorRetryLanes);
-  if (2 !== errorRetryLanes) {
-    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated)
-      return (
-        (root.errorRecoveryDisabledLanes |= originallyAttemptedLanes),
-        (workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes),
-        4
-      );
-    root = workInProgressRootRecoverableErrors;
-    workInProgressRootRecoverableErrors = errorsFromFirstAttempt;
-    null !== root && queueRecoverableErrors(root);
+  var previousPriority = currentUpdatePriority,
+    prevTransition = ReactCurrentBatchConfig.transition;
+  ReactCurrentBatchConfig.transition = null;
+  try {
+    (currentUpdatePriority = 8),
+      dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+  } finally {
+    (currentUpdatePriority = previousPriority),
+      (ReactCurrentBatchConfig.transition = prevTransition);
   }
-  return errorRetryLanes;
 }
-function queueRecoverableErrors(errors) {
-  null === workInProgressRootRecoverableErrors
-    ? (workInProgressRootRecoverableErrors = errors)
-    : workInProgressRootRecoverableErrors.push.apply(
-        workInProgressRootRecoverableErrors,
-        errors
+function dispatchEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (_enabled)
+    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+      var blockedOn = findInstanceBlockingEvent(
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
       );
-}
-function isRenderConsistentWithExternalStores(finishedWork) {
-  for (var node = finishedWork; ; ) {
-    if (node.flags & 16384) {
-      var updateQueue = node.updateQueue;
-      if (
-        null !== updateQueue &&
-        ((updateQueue = updateQueue.stores), null !== updateQueue)
+      if (null === blockedOn)
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          clearIfContinuousEvent(domEventName, nativeEvent);
+      else if (
+        queueIfContinuousEvent(
+          blockedOn,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )
       )
-        for (var i = 0; i < updateQueue.length; i++) {
-          var check = updateQueue[i],
-            getSnapshot = check.getSnapshot;
-          check = check.value;
-          try {
-            if (!objectIs(getSnapshot(), check)) return !1;
-          } catch (error) {
-            return !1;
+        nativeEvent.stopPropagation();
+      else if (
+        (clearIfContinuousEvent(domEventName, nativeEvent),
+        eventSystemFlags & 4 &&
+          -1 < discreteReplayableEvents.indexOf(domEventName))
+      ) {
+        for (; null !== blockedOn; ) {
+          var fiber = getInstanceFromNode$1(blockedOn);
+          null !== fiber && attemptSynchronousHydration(fiber);
+          fiber = findInstanceBlockingEvent(
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          );
+          null === fiber &&
+            dispatchEventForPluginEventSystem(
+              domEventName,
+              eventSystemFlags,
+              nativeEvent,
+              return_targetInst,
+              targetContainer
+            );
+          if (fiber === blockedOn) break;
+          blockedOn = fiber;
+        }
+        null !== blockedOn && nativeEvent.stopPropagation();
+      } else
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
+    } else
+      a: if (
+        (blockedOn = 0 === (eventSystemFlags & 4)) &&
+        0 < queuedDiscreteEvents.length &&
+        -1 < discreteReplayableEvents.indexOf(domEventName)
+      )
+        queueDiscreteEvent(
+          null,
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        );
+      else if (
+        ((fiber = findInstanceBlockingEvent(
+          domEventName,
+          eventSystemFlags,
+          targetContainer,
+          nativeEvent
+        )),
+        null === fiber)
+      )
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          blockedOn && clearIfContinuousEvent(domEventName, nativeEvent);
+      else {
+        if (blockedOn) {
+          if (-1 < discreteReplayableEvents.indexOf(domEventName)) {
+            queueDiscreteEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            );
+            break a;
           }
+          if (
+            queueIfContinuousEvent(
+              fiber,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            )
+          )
+            break a;
+          clearIfContinuousEvent(domEventName, nativeEvent);
         }
-    }
-    updateQueue = node.child;
-    if (node.subtreeFlags & 16384 && null !== updateQueue)
-      (updateQueue.return = node), (node = updateQueue);
-    else {
-      if (node === finishedWork) break;
-      for (; null === node.sibling; ) {
-        if (null === node.return || node.return === finishedWork) return !0;
-        node = node.return;
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          null,
+          targetContainer
+        );
       }
-      node.sibling.return = node.return;
-      node = node.sibling;
-    }
-  }
-  return !0;
 }
-function markRootSuspended(root, suspendedLanes) {
-  suspendedLanes &= ~workInProgressRootPingedLanes;
-  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
-  root.suspendedLanes |= suspendedLanes;
-  root.pingedLanes &= ~suspendedLanes;
-  for (root = root.expirationTimes; 0 < suspendedLanes; ) {
-    var index$12 = 31 - clz32(suspendedLanes),
-      lane = 1 << index$12;
-    root[index$12] = -1;
-    suspendedLanes &= ~lane;
-  }
-}
-function performSyncWorkOnRoot(root) {
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  flushPassiveEffects();
-  var lanes = getNextLanes(root, 0);
-  if (0 === (lanes & 3)) return ensureRootIsScheduled(root, now()), null;
-  var exitStatus = renderRootSync(root, lanes);
-  if (0 !== root.tag && 2 === exitStatus) {
-    var originallyAttemptedLanes = lanes,
-      errorRetryLanes = getLanesToRetrySynchronouslyOnError(
-        root,
-        originallyAttemptedLanes
-      );
-    0 !== errorRetryLanes &&
-      ((lanes = errorRetryLanes),
-      (exitStatus = recoverFromConcurrentError(
-        root,
-        originallyAttemptedLanes,
-        errorRetryLanes
-      )));
-  }
-  if (1 === exitStatus)
-    throw (
-      ((exitStatus = workInProgressRootFatalError),
-      prepareFreshStack(root, 0),
-      markRootSuspended(root, lanes),
-      ensureRootIsScheduled(root, now()),
-      exitStatus)
-    );
-  if (6 === exitStatus)
-    return (
-      markRootSuspended(root, lanes), ensureRootIsScheduled(root, now()), null
-    );
-  root.finishedWork = root.current.alternate;
-  root.finishedLanes = lanes;
-  commitRoot(
-    root,
-    workInProgressRootRecoverableErrors,
-    workInProgressTransitions
-  );
-  ensureRootIsScheduled(root, now());
+var return_targetInst = null;
+function findInstanceBlockingEvent(
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  return_targetInst = null;
+  domEventName = getEventTarget(nativeEvent);
+  domEventName = getClosestInstanceFromNode(domEventName);
+  if (null !== domEventName)
+    if (
+      ((eventSystemFlags = getNearestMountedFiber(domEventName)),
+      null === eventSystemFlags)
+    )
+      domEventName = null;
+    else if (
+      ((targetContainer = eventSystemFlags.tag), 13 === targetContainer)
+    ) {
+      domEventName = getSuspenseInstanceFromFiber(eventSystemFlags);
+      if (null !== domEventName) return domEventName;
+      domEventName = null;
+    } else if (3 === targetContainer) {
+      if (eventSystemFlags.stateNode.current.memoizedState.isDehydrated)
+        return 3 === eventSystemFlags.tag
+          ? eventSystemFlags.stateNode.containerInfo
+          : null;
+      domEventName = null;
+    } else eventSystemFlags !== domEventName && (domEventName = null);
+  return_targetInst = domEventName;
   return null;
 }
-function batchedUpdates(fn, a) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
-  try {
-    return fn(a);
-  } finally {
-    (executionContext = prevExecutionContext),
-      0 === executionContext &&
-        (resetRenderTimer(),
-        includesLegacySyncCallbacks && flushSyncCallbacks());
+function getEventPriority(domEventName) {
+  switch (domEventName) {
+    case "cancel":
+    case "click":
+    case "close":
+    case "contextmenu":
+    case "copy":
+    case "cut":
+    case "auxclick":
+    case "dblclick":
+    case "dragend":
+    case "dragstart":
+    case "drop":
+    case "focusin":
+    case "focusout":
+    case "input":
+    case "invalid":
+    case "keydown":
+    case "keypress":
+    case "keyup":
+    case "mousedown":
+    case "mouseup":
+    case "paste":
+    case "pause":
+    case "play":
+    case "pointercancel":
+    case "pointerdown":
+    case "pointerup":
+    case "ratechange":
+    case "reset":
+    case "resize":
+    case "seeked":
+    case "submit":
+    case "touchcancel":
+    case "touchend":
+    case "touchstart":
+    case "volumechange":
+    case "change":
+    case "selectionchange":
+    case "textInput":
+    case "compositionstart":
+    case "compositionend":
+    case "compositionupdate":
+    case "beforeblur":
+    case "afterblur":
+    case "beforeinput":
+    case "blur":
+    case "fullscreenchange":
+    case "focus":
+    case "hashchange":
+    case "popstate":
+    case "select":
+    case "selectstart":
+      return 2;
+    case "drag":
+    case "dragenter":
+    case "dragexit":
+    case "dragleave":
+    case "dragover":
+    case "mousemove":
+    case "mouseout":
+    case "mouseover":
+    case "pointermove":
+    case "pointerout":
+    case "pointerover":
+    case "scroll":
+    case "toggle":
+    case "touchmove":
+    case "wheel":
+    case "mouseenter":
+    case "mouseleave":
+    case "pointerenter":
+    case "pointerleave":
+      return 8;
+    case "message":
+      switch (getCurrentPriorityLevel()) {
+        case ImmediatePriority:
+          return 2;
+        case UserBlockingPriority:
+          return 8;
+        case NormalPriority$1:
+        case LowPriority:
+          return 32;
+        case IdlePriority:
+          return 536870912;
+        default:
+          return 32;
+      }
+    default:
+      return 32;
   }
 }
-function flushSync$1(fn) {
-  null !== rootWithPendingPassiveEffects &&
-    0 === rootWithPendingPassiveEffects.tag &&
-    0 === (executionContext & 6) &&
-    flushPassiveEffects();
-  var prevExecutionContext = executionContext;
-  executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
-    previousPriority = currentUpdatePriority;
-  try {
-    if (
-      ((ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      fn)
-    )
-      return fn();
-  } finally {
-    (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
-      (executionContext = prevExecutionContext),
-      0 === (executionContext & 6) && flushSyncCallbacks();
-  }
+function addEventBubbleListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, !1);
+  return listener;
 }
-function resetWorkInProgressStack() {
-  if (null !== workInProgress) {
-    if (0 === workInProgressSuspendedReason)
-      var interruptedWork = workInProgress.return;
-    else
-      resetContextDependencies(),
-        resetHooksOnUnwind(),
-        (thenableState$1 = null),
-        (thenableIndexCounter$1 = 0),
-        (interruptedWork = workInProgress);
-    for (; null !== interruptedWork; )
-      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
-        (interruptedWork = interruptedWork.return);
-    workInProgress = null;
-  }
+function addEventCaptureListener(target, eventType, listener) {
+  target.addEventListener(eventType, listener, !0);
+  return listener;
 }
-function prepareFreshStack(root, lanes) {
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  var timeoutHandle = root.timeoutHandle;
-  -1 !== timeoutHandle &&
-    ((root.timeoutHandle = -1), cancelTimeout(timeoutHandle));
-  resetWorkInProgressStack();
-  workInProgressRoot = root;
-  workInProgress = root = createWorkInProgress(root.current, null);
-  workInProgressRootRenderLanes = renderLanes = lanes;
-  workInProgressSuspendedReason = 0;
-  workInProgressThrownValue = null;
-  workInProgressRootDidAttachPingListener = !1;
-  workInProgressRootExitStatus = 0;
-  workInProgressRootFatalError = null;
-  workInProgressRootPingedLanes =
-    workInProgressRootInterleavedUpdatedLanes =
-    workInProgressRootSkippedLanes =
-      0;
-  workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors =
-    null;
-  finishQueueingConcurrentUpdates();
-  return root;
+function addEventCaptureListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, {
+    capture: !0,
+    passive: passive
+  });
+  return listener;
 }
-function handleThrow(root, thrownValue) {
-  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
-  ReactCurrentOwner.current = null;
-  if (thrownValue === SuspenseException) {
-    if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
-    root = suspendedThenable;
-    suspendedThenable = null;
-    thrownValue = root;
-    workInProgressSuspendedReason = shouldAttemptToSuspendUntilDataResolves()
-      ? 2
-      : 3;
-  } else
-    workInProgressSuspendedReason =
-      thrownValue === SelectiveHydrationException
-        ? 6
-        : null !== thrownValue &&
-          "object" === typeof thrownValue &&
-          "function" === typeof thrownValue.then
-        ? 4
-        : 1;
-  workInProgressThrownValue = thrownValue;
-  null === workInProgress &&
-    ((workInProgressRootExitStatus = 1),
-    (workInProgressRootFatalError = thrownValue));
+function addEventBubbleListenerWithPassiveFlag(
+  target,
+  eventType,
+  listener,
+  passive
+) {
+  target.addEventListener(eventType, listener, { passive: passive });
+  return listener;
 }
-function shouldAttemptToSuspendUntilDataResolves() {
-  if (
-    0 !== (workInProgressRootSkippedLanes & 268435455) ||
-    0 !== (workInProgressRootInterleavedUpdatedLanes & 268435455)
-  )
-    return !1;
-  if (
-    (workInProgressRootRenderLanes & 8388480) ===
-    workInProgressRootRenderLanes
-  )
-    return null === shellBoundary;
-  var handler = suspenseHandlerStackCursor.current;
-  return null !== handler &&
-    (workInProgressRootRenderLanes & 125829120) ===
-      workInProgressRootRenderLanes
-    ? handler === shellBoundary
-    : !1;
+var root = null,
+  startText = null,
+  fallbackText = null;
+function getData() {
+  if (fallbackText) return fallbackText;
+  var start,
+    startValue = startText,
+    startLength = startValue.length,
+    end,
+    endValue = "value" in root ? root.value : root.textContent,
+    endLength = endValue.length;
+  for (
+    start = 0;
+    start < startLength && startValue[start] === endValue[start];
+    start++
+  );
+  var minEnd = startLength - start;
+  for (
+    end = 1;
+    end <= minEnd &&
+    startValue[startLength - end] === endValue[endLength - end];
+    end++
+  );
+  return (fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0));
 }
-function pushDispatcher(container) {
-  container = getHoistableRoot(container);
-  lastCurrentDocument = container.ownerDocument || container;
-  previousDispatcher = Dispatcher$1.current;
-  Dispatcher$1.current = ReactDOMClientDispatcher;
-  container = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = ContextOnlyDispatcher;
-  return null === container ? ContextOnlyDispatcher : container;
+function getEventCharCode(nativeEvent) {
+  var keyCode = nativeEvent.keyCode;
+  "charCode" in nativeEvent
+    ? ((nativeEvent = nativeEvent.charCode),
+      0 === nativeEvent && 13 === keyCode && (nativeEvent = 13))
+    : (nativeEvent = keyCode);
+  10 === nativeEvent && (nativeEvent = 13);
+  return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
 }
-function pushCacheDispatcher() {
-  var prevCacheDispatcher = ReactCurrentCache.current;
-  ReactCurrentCache.current = DefaultCacheDispatcher;
-  return prevCacheDispatcher;
+function functionThatReturnsTrue() {
+  return !0;
 }
-function renderDidSuspendDelayIfPossible() {
-  workInProgressRootExitStatus = 4;
-  null === workInProgressRoot ||
-    (0 === (workInProgressRootSkippedLanes & 268435455) &&
-      0 === (workInProgressRootInterleavedUpdatedLanes & 268435455)) ||
-    markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes);
+function functionThatReturnsFalse() {
+  return !1;
 }
-function renderRootSync(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
-      prepareFreshStack(root, lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
-        lanes = workInProgress;
-        var thrownValue = workInProgressThrownValue;
-        switch (workInProgressSuspendedReason) {
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            (workInProgressSuspendedReason = 0),
-              (workInProgressThrownValue = null),
-              unwindSuspendedUnitOfWork(lanes, thrownValue);
-        }
-      }
-      workLoopSync();
-      break;
-    } catch (thrownValue$216) {
-      handleThrow(root, thrownValue$216);
+function createSyntheticEvent(Interface) {
+  function SyntheticBaseEvent(
+    reactName,
+    reactEventType,
+    targetInst,
+    nativeEvent,
+    nativeEventTarget
+  ) {
+    this._reactName = reactName;
+    this._targetInst = targetInst;
+    this.type = reactEventType;
+    this.nativeEvent = nativeEvent;
+    this.target = nativeEventTarget;
+    this.currentTarget = null;
+    for (var propName in Interface)
+      Interface.hasOwnProperty(propName) &&
+        ((reactName = Interface[propName]),
+        (this[propName] = reactName
+          ? reactName(nativeEvent)
+          : nativeEvent[propName]));
+    this.isDefaultPrevented = (
+      null != nativeEvent.defaultPrevented
+        ? nativeEvent.defaultPrevented
+        : !1 === nativeEvent.returnValue
+    )
+      ? functionThatReturnsTrue
+      : functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  }
+  assign(SyntheticBaseEvent.prototype, {
+    preventDefault: function () {
+      this.defaultPrevented = !0;
+      var event = this.nativeEvent;
+      event &&
+        (event.preventDefault
+          ? event.preventDefault()
+          : "unknown" !== typeof event.returnValue && (event.returnValue = !1),
+        (this.isDefaultPrevented = functionThatReturnsTrue));
+    },
+    stopPropagation: function () {
+      var event = this.nativeEvent;
+      event &&
+        (event.stopPropagation
+          ? event.stopPropagation()
+          : "unknown" !== typeof event.cancelBubble &&
+            (event.cancelBubble = !0),
+        (this.isPropagationStopped = functionThatReturnsTrue));
+    },
+    persist: function () {},
+    isPersistent: functionThatReturnsTrue
+  });
+  return SyntheticBaseEvent;
+}
+var EventInterface = {
+    eventPhase: 0,
+    bubbles: 0,
+    cancelable: 0,
+    timeStamp: function (event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: 0,
+    isTrusted: 0
+  },
+  SyntheticEvent = createSyntheticEvent(EventInterface),
+  UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }),
+  SyntheticUIEvent = createSyntheticEvent(UIEventInterface),
+  lastMovementX,
+  lastMovementY,
+  lastMouseEvent,
+  MouseEventInterface = assign({}, UIEventInterface, {
+    screenX: 0,
+    screenY: 0,
+    clientX: 0,
+    clientY: 0,
+    pageX: 0,
+    pageY: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    getModifierState: getEventModifierState,
+    button: 0,
+    buttons: 0,
+    relatedTarget: function (event) {
+      return void 0 === event.relatedTarget
+        ? event.fromElement === event.srcElement
+          ? event.toElement
+          : event.fromElement
+        : event.relatedTarget;
+    },
+    movementX: function (event) {
+      if ("movementX" in event) return event.movementX;
+      event !== lastMouseEvent &&
+        (lastMouseEvent && "mousemove" === event.type
+          ? ((lastMovementX = event.screenX - lastMouseEvent.screenX),
+            (lastMovementY = event.screenY - lastMouseEvent.screenY))
+          : (lastMovementY = lastMovementX = 0),
+        (lastMouseEvent = event));
+      return lastMovementX;
+    },
+    movementY: function (event) {
+      return "movementY" in event ? event.movementY : lastMovementY;
     }
-  while (1);
-  resetContextDependencies();
-  executionContext = prevExecutionContext;
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  if (null !== workInProgress) throw Error(formatProdErrorMessage(261));
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
+  }),
+  SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface),
+  DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }),
+  SyntheticDragEvent = createSyntheticEvent(DragEventInterface),
+  FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }),
+  SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface),
+  AnimationEventInterface = assign({}, EventInterface, {
+    animationName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface),
+  ClipboardEventInterface = assign({}, EventInterface, {
+    clipboardData: function (event) {
+      return "clipboardData" in event
+        ? event.clipboardData
+        : window.clipboardData;
+    }
+  }),
+  SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface),
+  CompositionEventInterface = assign({}, EventInterface, { data: 0 }),
+  SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface),
+  normalizeKey = {
+    Esc: "Escape",
+    Spacebar: " ",
+    Left: "ArrowLeft",
+    Up: "ArrowUp",
+    Right: "ArrowRight",
+    Down: "ArrowDown",
+    Del: "Delete",
+    Win: "OS",
+    Menu: "ContextMenu",
+    Apps: "ContextMenu",
+    Scroll: "ScrollLock",
+    MozPrintableKey: "Unidentified"
+  },
+  translateToKey = {
+    8: "Backspace",
+    9: "Tab",
+    12: "Clear",
+    13: "Enter",
+    16: "Shift",
+    17: "Control",
+    18: "Alt",
+    19: "Pause",
+    20: "CapsLock",
+    27: "Escape",
+    32: " ",
+    33: "PageUp",
+    34: "PageDown",
+    35: "End",
+    36: "Home",
+    37: "ArrowLeft",
+    38: "ArrowUp",
+    39: "ArrowRight",
+    40: "ArrowDown",
+    45: "Insert",
+    46: "Delete",
+    112: "F1",
+    113: "F2",
+    114: "F3",
+    115: "F4",
+    116: "F5",
+    117: "F6",
+    118: "F7",
+    119: "F8",
+    120: "F9",
+    121: "F10",
+    122: "F11",
+    123: "F12",
+    144: "NumLock",
+    145: "ScrollLock",
+    224: "Meta"
+  },
+  modifierKeyToProp = {
+    Alt: "altKey",
+    Control: "ctrlKey",
+    Meta: "metaKey",
+    Shift: "shiftKey"
+  };
+function modifierStateGetter(keyArg) {
+  var nativeEvent = this.nativeEvent;
+  return nativeEvent.getModifierState
+    ? nativeEvent.getModifierState(keyArg)
+    : (keyArg = modifierKeyToProp[keyArg])
+    ? !!nativeEvent[keyArg]
+    : !1;
 }
-function workLoopSync() {
-  for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+function getEventModifierState() {
+  return modifierStateGetter;
 }
-function renderRootConcurrent(root, lanes) {
-  var prevExecutionContext = executionContext;
-  executionContext |= 2;
-  var prevDispatcher = pushDispatcher(root.containerInfo),
-    prevCacheDispatcher = pushCacheDispatcher();
-  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
-      resetRenderTimer(),
-      prepareFreshStack(root, lanes);
-  a: do
-    try {
-      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
-        lanes = workInProgress;
-        var thrownValue = workInProgressThrownValue;
-        switch (workInProgressSuspendedReason) {
-          case 1:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, thrownValue);
-            break;
-          case 2:
-            if (isThenableResolved(thrownValue)) {
-              workInProgressSuspendedReason = 0;
-              workInProgressThrownValue = null;
-              replaySuspendedUnitOfWork(lanes);
-              break;
-            }
-            lanes = function () {
-              2 === workInProgressSuspendedReason &&
-                workInProgressRoot === root &&
-                (workInProgressSuspendedReason = 5);
-              ensureRootIsScheduled(root, now());
-            };
-            thrownValue.then(lanes, lanes);
-            break a;
-          case 3:
-            workInProgressSuspendedReason = 5;
-            break a;
-          case 5:
-            isThenableResolved(thrownValue)
-              ? ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                replaySuspendedUnitOfWork(lanes))
-              : ((workInProgressSuspendedReason = 0),
-                (workInProgressThrownValue = null),
-                unwindSuspendedUnitOfWork(lanes, thrownValue));
-            break;
-          case 4:
-            workInProgressSuspendedReason = 0;
-            workInProgressThrownValue = null;
-            unwindSuspendedUnitOfWork(lanes, thrownValue);
-            break;
-          case 6:
-            resetWorkInProgressStack();
-            workInProgressRootExitStatus = 6;
-            break a;
-          default:
-            throw Error(formatProdErrorMessage(462));
-        }
+var KeyboardEventInterface = assign({}, UIEventInterface, {
+    key: function (nativeEvent) {
+      if (nativeEvent.key) {
+        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+        if ("Unidentified" !== key) return key;
       }
-      workLoopConcurrent();
-      break;
-    } catch (thrownValue$218) {
-      handleThrow(root, thrownValue$218);
+      return "keypress" === nativeEvent.type
+        ? ((nativeEvent = getEventCharCode(nativeEvent)),
+          13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent))
+        : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type
+        ? translateToKey[nativeEvent.keyCode] || "Unidentified"
+        : "";
+    },
+    code: 0,
+    location: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    altKey: 0,
+    metaKey: 0,
+    repeat: 0,
+    locale: 0,
+    getModifierState: getEventModifierState,
+    charCode: function (event) {
+      return "keypress" === event.type ? getEventCharCode(event) : 0;
+    },
+    keyCode: function (event) {
+      return "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
+    },
+    which: function (event) {
+      return "keypress" === event.type
+        ? getEventCharCode(event)
+        : "keydown" === event.type || "keyup" === event.type
+        ? event.keyCode
+        : 0;
     }
-  while (1);
-  resetContextDependencies();
-  Dispatcher$1.current = previousDispatcher;
-  previousDispatcher = null;
-  ReactCurrentDispatcher.current = prevDispatcher;
-  ReactCurrentCache.current = prevCacheDispatcher;
-  executionContext = prevExecutionContext;
-  if (null !== workInProgress) return 0;
-  workInProgressRoot = null;
-  workInProgressRootRenderLanes = 0;
-  finishQueueingConcurrentUpdates();
-  return workInProgressRootExitStatus;
-}
-function workLoopConcurrent() {
-  for (; null !== workInProgress && !shouldYield(); )
-    performUnitOfWork(workInProgress);
+  }),
+  SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface),
+  PointerEventInterface = assign({}, MouseEventInterface, {
+    pointerId: 0,
+    width: 0,
+    height: 0,
+    pressure: 0,
+    tangentialPressure: 0,
+    tiltX: 0,
+    tiltY: 0,
+    twist: 0,
+    pointerType: 0,
+    isPrimary: 0
+  }),
+  SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface),
+  TouchEventInterface = assign({}, UIEventInterface, {
+    touches: 0,
+    targetTouches: 0,
+    changedTouches: 0,
+    altKey: 0,
+    metaKey: 0,
+    ctrlKey: 0,
+    shiftKey: 0,
+    getModifierState: getEventModifierState
+  }),
+  SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface),
+  TransitionEventInterface = assign({}, EventInterface, {
+    propertyName: 0,
+    elapsedTime: 0,
+    pseudoElement: 0
+  }),
+  SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface),
+  WheelEventInterface = assign({}, MouseEventInterface, {
+    deltaX: function (event) {
+      return "deltaX" in event
+        ? event.deltaX
+        : "wheelDeltaX" in event
+        ? -event.wheelDeltaX
+        : 0;
+    },
+    deltaY: function (event) {
+      return "deltaY" in event
+        ? event.deltaY
+        : "wheelDeltaY" in event
+        ? -event.wheelDeltaY
+        : "wheelDelta" in event
+        ? -event.wheelDelta
+        : 0;
+    },
+    deltaZ: 0,
+    deltaMode: 0
+  }),
+  SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface),
+  END_KEYCODES = [9, 13, 27, 32],
+  canUseCompositionEvent = canUseDOM && "CompositionEvent" in window,
+  documentMode = null;
+canUseDOM &&
+  "documentMode" in document &&
+  (documentMode = document.documentMode);
+var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode,
+  useFallbackCompositionData =
+    canUseDOM &&
+    (!canUseCompositionEvent ||
+      (documentMode && 8 < documentMode && 11 >= documentMode)),
+  SPACEBAR_CHAR = String.fromCharCode(32),
+  hasSpaceKeypress = !1;
+function isFallbackCompositionEnd(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "keyup":
+      return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
+    case "keydown":
+      return 229 !== nativeEvent.keyCode;
+    case "keypress":
+    case "mousedown":
+    case "focusout":
+      return !0;
+    default:
+      return !1;
+  }
 }
-function performUnitOfWork(unitOfWork) {
-  var next = beginWork(unitOfWork.alternate, unitOfWork, renderLanes);
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === next ? completeUnitOfWork(unitOfWork) : (workInProgress = next);
-  ReactCurrentOwner.current = null;
+function getDataFromCustomEvent(nativeEvent) {
+  nativeEvent = nativeEvent.detail;
+  return "object" === typeof nativeEvent && "data" in nativeEvent
+    ? nativeEvent.data
+    : null;
 }
-function replaySuspendedUnitOfWork(unitOfWork) {
-  var current = unitOfWork.alternate;
-  switch (unitOfWork.tag) {
-    case 2:
-      unitOfWork.tag = 0;
-    case 0:
-    case 11:
-      var Component = unitOfWork.type,
-        unresolvedProps = unitOfWork.pendingProps;
-      unresolvedProps =
-        unitOfWork.elementType === Component
-          ? unresolvedProps
-          : resolveDefaultProps(Component, unresolvedProps);
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unresolvedProps,
-        Component,
-        workInProgressRootRenderLanes
-      );
-      break;
-    case 15:
-      current = replayFunctionComponent(
-        current,
-        unitOfWork,
-        unitOfWork.pendingProps,
-        unitOfWork.type,
-        workInProgressRootRenderLanes
+var isComposing = !1;
+function getNativeBeforeInputChars(domEventName, nativeEvent) {
+  switch (domEventName) {
+    case "compositionend":
+      return getDataFromCustomEvent(nativeEvent);
+    case "keypress":
+      if (32 !== nativeEvent.which) return null;
+      hasSpaceKeypress = !0;
+      return SPACEBAR_CHAR;
+    case "textInput":
+      return (
+        (domEventName = nativeEvent.data),
+        domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName
       );
-      break;
     default:
-      unwindInterruptedWork(current, unitOfWork),
-        (unitOfWork = workInProgress =
-          resetWorkInProgress(unitOfWork, renderLanes)),
-        (current = beginWork(current, unitOfWork, renderLanes));
+      return null;
   }
-  unitOfWork.memoizedProps = unitOfWork.pendingProps;
-  null === current
-    ? completeUnitOfWork(unitOfWork)
-    : (workInProgress = current);
-  ReactCurrentOwner.current = null;
 }
-function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
-  resetContextDependencies();
-  resetHooksOnUnwind();
-  thenableState$1 = null;
-  thenableIndexCounter$1 = 0;
-  var returnFiber = unitOfWork.return;
-  if (null === returnFiber || null === workInProgressRoot)
-    (workInProgressRootExitStatus = 1),
-      (workInProgressRootFatalError = thrownValue),
-      (workInProgress = null);
-  else {
-    try {
-      a: {
-        var root = workInProgressRoot,
-          value = thrownValue;
-        thrownValue = workInProgressRootRenderLanes;
-        unitOfWork.flags |= 32768;
-        if (
-          null !== value &&
-          "object" === typeof value &&
-          "function" === typeof value.then
-        ) {
-          var wakeable = value;
-          if (enableLazyContextPropagation) {
-            var currentSourceFiber = unitOfWork.alternate;
-            null !== currentSourceFiber &&
-              propagateParentContextChanges(
-                currentSourceFiber,
-                unitOfWork,
-                thrownValue,
-                !0
-              );
-          }
-          var tag = unitOfWork.tag;
-          if (
-            0 === (unitOfWork.mode & 1) &&
-            (0 === tag || 11 === tag || 15 === tag)
-          ) {
-            var currentSource = unitOfWork.alternate;
-            currentSource
-              ? ((unitOfWork.updateQueue = currentSource.updateQueue),
-                (unitOfWork.memoizedState = currentSource.memoizedState),
-                (unitOfWork.lanes = currentSource.lanes))
-              : ((unitOfWork.updateQueue = null),
-                (unitOfWork.memoizedState = null));
-          }
-          var suspenseBoundary = suspenseHandlerStackCursor.current;
-          if (null !== suspenseBoundary) {
-            switch (suspenseBoundary.tag) {
-              case 13:
-                unitOfWork.mode & 1 &&
-                  (null === shellBoundary
-                    ? renderDidSuspendDelayIfPossible()
-                    : null === suspenseBoundary.alternate &&
-                      0 === workInProgressRootExitStatus &&
-                      (workInProgressRootExitStatus = 3));
-                suspenseBoundary.flags &= -257;
-                markSuspenseBoundaryShouldCapture(
-                  suspenseBoundary,
-                  returnFiber,
-                  unitOfWork,
-                  root,
-                  thrownValue
-                );
-                var wakeables = suspenseBoundary.updateQueue;
-                null === wakeables
-                  ? (suspenseBoundary.updateQueue = new Set([wakeable]))
-                  : wakeables.add(wakeable);
-                break;
-              case 22:
-                if (suspenseBoundary.mode & 1) {
-                  suspenseBoundary.flags |= 65536;
-                  var offscreenQueue = suspenseBoundary.updateQueue;
-                  if (null === offscreenQueue) {
-                    var newOffscreenQueue = {
-                      transitions: null,
-                      markerInstances: null,
-                      wakeables: new Set([wakeable])
-                    };
-                    suspenseBoundary.updateQueue = newOffscreenQueue;
-                  } else {
-                    var wakeables$100 = offscreenQueue.wakeables;
-                    null === wakeables$100
-                      ? (offscreenQueue.wakeables = new Set([wakeable]))
-                      : wakeables$100.add(wakeable);
-                  }
-                  break;
-                }
-              default:
-                throw Error(formatProdErrorMessage(435, suspenseBoundary.tag));
-            }
-            suspenseBoundary.mode & 1 &&
-              attachPingListener(root, wakeable, thrownValue);
-            break a;
-          } else if (1 === root.tag) {
-            attachPingListener(root, wakeable, thrownValue);
-            renderDidSuspendDelayIfPossible();
-            break a;
-          } else value = Error(formatProdErrorMessage(426));
-        } else if (
-          isHydrating &&
-          unitOfWork.mode & 1 &&
-          ((wakeable = suspenseHandlerStackCursor.current), null !== wakeable)
-        ) {
-          0 === (wakeable.flags & 65536) && (wakeable.flags |= 256);
-          markSuspenseBoundaryShouldCapture(
-            wakeable,
-            returnFiber,
-            unitOfWork,
-            root,
-            thrownValue
-          );
-          queueHydrationError(createCapturedValueAtFiber(value, unitOfWork));
-          break a;
-        }
-        root = value = createCapturedValueAtFiber(value, unitOfWork);
-        4 !== workInProgressRootExitStatus &&
-          (workInProgressRootExitStatus = 2);
-        null === workInProgressRootConcurrentErrors
-          ? (workInProgressRootConcurrentErrors = [root])
-          : workInProgressRootConcurrentErrors.push(root);
-        root = returnFiber;
-        do {
-          switch (root.tag) {
-            case 3:
-              var errorInfo = value;
-              root.flags |= 65536;
-              thrownValue &= -thrownValue;
-              root.lanes |= thrownValue;
-              var update = createRootErrorUpdate(root, errorInfo, thrownValue);
-              enqueueCapturedUpdate(root, update);
-              break a;
-            case 1:
-              currentSourceFiber = value;
-              var ctor = root.type,
-                instance = root.stateNode;
-              if (
-                0 === (root.flags & 128) &&
-                ("function" === typeof ctor.getDerivedStateFromError ||
-                  (null !== instance &&
-                    "function" === typeof instance.componentDidCatch &&
-                    (null === legacyErrorBoundariesThatAlreadyFailed ||
-                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))))
-              ) {
-                root.flags |= 65536;
-                update = thrownValue & -thrownValue;
-                root.lanes |= update;
-                errorInfo = createClassErrorUpdate(
-                  root,
-                  currentSourceFiber,
-                  update
-                );
-                enqueueCapturedUpdate(root, errorInfo);
-                break a;
-              }
-          }
-          root = root.return;
-        } while (null !== root);
+function getFallbackBeforeInputChars(domEventName, nativeEvent) {
+  if (isComposing)
+    return "compositionend" === domEventName ||
+      (!canUseCompositionEvent &&
+        isFallbackCompositionEnd(domEventName, nativeEvent))
+      ? ((domEventName = getData()),
+        (fallbackText = startText = root = null),
+        (isComposing = !1),
+        domEventName)
+      : null;
+  switch (domEventName) {
+    case "paste":
+      return null;
+    case "keypress":
+      if (
+        !(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) ||
+        (nativeEvent.ctrlKey && nativeEvent.altKey)
+      ) {
+        if (nativeEvent.char && 1 < nativeEvent.char.length)
+          return nativeEvent.char;
+        if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
       }
-    } catch (error) {
-      throw ((workInProgress = returnFiber), error);
+      return null;
+    case "compositionend":
+      return useFallbackCompositionData && "ko" !== nativeEvent.locale
+        ? null
+        : nativeEvent.data;
+    default:
+      return null;
+  }
+}
+var supportedInputTypes = {
+  color: !0,
+  date: !0,
+  datetime: !0,
+  "datetime-local": !0,
+  email: !0,
+  month: !0,
+  number: !0,
+  password: !0,
+  range: !0,
+  search: !0,
+  tel: !0,
+  text: !0,
+  time: !0,
+  url: !0,
+  week: !0
+};
+function isTextInputElement(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return "input" === nodeName
+    ? !!supportedInputTypes[elem.type]
+    : "textarea" === nodeName
+    ? !0
+    : !1;
+}
+function createAndAccumulateChangeEvent(
+  dispatchQueue,
+  inst,
+  nativeEvent,
+  target
+) {
+  enqueueStateRestore(target);
+  inst = accumulateTwoPhaseListeners(inst, "onChange");
+  0 < inst.length &&
+    ((nativeEvent = new SyntheticEvent(
+      "onChange",
+      "change",
+      null,
+      nativeEvent,
+      target
+    )),
+    dispatchQueue.push({ event: nativeEvent, listeners: inst }));
+}
+var activeElement$1 = null,
+  activeElementInst$1 = null;
+function runEventInBatch(dispatchQueue) {
+  processDispatchQueue(dispatchQueue, 0);
+}
+function getInstIfValueChanged(targetInst) {
+  var targetNode = getNodeFromInstance(targetInst);
+  if (updateValueIfChanged(targetNode)) return targetInst;
+}
+function getTargetInstForChangeEvent(domEventName, targetInst) {
+  if ("change" === domEventName) return targetInst;
+}
+var isInputEventSupported = !1;
+if (canUseDOM) {
+  var JSCompiler_inline_result$jscomp$294;
+  if (canUseDOM) {
+    var isSupported$jscomp$inline_1518 = "oninput" in document;
+    if (!isSupported$jscomp$inline_1518) {
+      var element$jscomp$inline_1519 = document.createElement("div");
+      element$jscomp$inline_1519.setAttribute("oninput", "return;");
+      isSupported$jscomp$inline_1518 =
+        "function" === typeof element$jscomp$inline_1519.oninput;
     }
-    completeUnitOfWork(unitOfWork);
-  }
+    JSCompiler_inline_result$jscomp$294 = isSupported$jscomp$inline_1518;
+  } else JSCompiler_inline_result$jscomp$294 = !1;
+  isInputEventSupported =
+    JSCompiler_inline_result$jscomp$294 &&
+    (!document.documentMode || 9 < document.documentMode);
 }
-function completeUnitOfWork(unitOfWork) {
-  var completedWork = unitOfWork;
-  do {
-    var current = completedWork.alternate;
-    unitOfWork = completedWork.return;
-    if (0 === (completedWork.flags & 32768)) {
-      if (
-        ((current = completeWork(current, completedWork, renderLanes)),
-        null !== current)
-      ) {
-        workInProgress = current;
-        return;
-      }
-    } else {
-      current = unwindWork(current, completedWork);
-      if (null !== current) {
-        current.flags &= 16383;
-        workInProgress = current;
-        return;
-      }
-      if (null !== unitOfWork)
-        (unitOfWork.flags |= 32768),
-          (unitOfWork.subtreeFlags = 0),
-          (unitOfWork.deletions = null);
-      else {
-        workInProgressRootExitStatus = 6;
-        workInProgress = null;
-        return;
-      }
-    }
-    completedWork = completedWork.sibling;
-    if (null !== completedWork) {
-      workInProgress = completedWork;
-      return;
-    }
-    workInProgress = completedWork = unitOfWork;
-  } while (null !== completedWork);
-  0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+function stopWatchingForValueChange() {
+  activeElement$1 &&
+    (activeElement$1.detachEvent("onpropertychange", handlePropertyChange),
+    (activeElementInst$1 = activeElement$1 = null));
 }
-function commitRoot(root, recoverableErrors, transitions) {
-  var previousUpdateLanePriority = currentUpdatePriority,
-    prevTransition = ReactCurrentBatchConfig.transition;
-  try {
-    (ReactCurrentBatchConfig.transition = null),
-      (currentUpdatePriority = 2),
-      commitRootImpl(
-        root,
-        recoverableErrors,
-        transitions,
-        previousUpdateLanePriority
-      );
-  } finally {
-    (ReactCurrentBatchConfig.transition = prevTransition),
-      (currentUpdatePriority = previousUpdateLanePriority);
+function handlePropertyChange(nativeEvent) {
+  if (
+    "value" === nativeEvent.propertyName &&
+    getInstIfValueChanged(activeElementInst$1)
+  ) {
+    var dispatchQueue = [];
+    createAndAccumulateChangeEvent(
+      dispatchQueue,
+      activeElementInst$1,
+      nativeEvent,
+      getEventTarget(nativeEvent)
+    );
+    batchedUpdates(runEventInBatch, dispatchQueue);
   }
-  return null;
 }
-function commitRootImpl(
-  root,
-  recoverableErrors,
-  transitions,
-  renderPriorityLevel
-) {
-  do flushPassiveEffects();
-  while (null !== rootWithPendingPassiveEffects);
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
-  var finishedWork = root.finishedWork,
-    lanes = root.finishedLanes;
-  if (null === finishedWork) return null;
-  root.finishedWork = null;
-  root.finishedLanes = 0;
-  if (finishedWork === root.current) throw Error(formatProdErrorMessage(177));
-  root.callbackNode = null;
-  root.callbackPriority = 0;
-  var remainingLanes = finishedWork.lanes | finishedWork.childLanes;
-  remainingLanes |= concurrentlyUpdatedLanes;
-  markRootFinished(root, remainingLanes);
-  root === workInProgressRoot &&
-    ((workInProgress = workInProgressRoot = null),
-    (workInProgressRootRenderLanes = 0));
-  (0 === (finishedWork.subtreeFlags & 10256) &&
-    0 === (finishedWork.flags & 10256)) ||
-    rootDoesHavePassiveEffects ||
-    ((rootDoesHavePassiveEffects = !0),
-    (pendingPassiveEffectsRemainingLanes = remainingLanes),
-    (pendingPassiveTransitions = transitions),
-    scheduleCallback(NormalPriority$1, function () {
-      flushPassiveEffects();
-      return null;
-    }));
-  transitions = 0 !== (finishedWork.flags & 15990);
-  if (0 !== (finishedWork.subtreeFlags & 15990) || transitions) {
-    transitions = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = null;
-    var previousPriority = currentUpdatePriority;
-    currentUpdatePriority = 2;
-    var prevExecutionContext = executionContext;
-    executionContext |= 4;
-    ReactCurrentOwner.current = null;
-    var shouldFireAfterActiveInstanceBlur$221 = commitBeforeMutationEffects(
-      root,
-      finishedWork
-    );
-    commitMutationEffectsOnFiber(finishedWork, root);
-    shouldFireAfterActiveInstanceBlur$221 &&
-      ((_enabled = !0),
-      dispatchAfterDetachedBlur(selectionInformation.focusedElem),
-      (_enabled = !1));
-    restoreSelection(selectionInformation);
-    _enabled = !!eventsEnabled;
-    selectionInformation = eventsEnabled = null;
-    root.current = finishedWork;
-    commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
-    requestPaint();
-    executionContext = prevExecutionContext;
-    currentUpdatePriority = previousPriority;
-    ReactCurrentBatchConfig.transition = transitions;
-  } else root.current = finishedWork;
-  rootDoesHavePassiveEffects
-    ? ((rootDoesHavePassiveEffects = !1),
-      (rootWithPendingPassiveEffects = root),
-      (pendingPassiveEffectsLanes = lanes))
-    : releaseRootPooledCache(root, remainingLanes);
-  remainingLanes = root.pendingLanes;
-  0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
-  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
-  ensureRootIsScheduled(root, now());
-  if (null !== recoverableErrors)
-    for (
-      renderPriorityLevel = root.onRecoverableError, finishedWork = 0;
-      finishedWork < recoverableErrors.length;
-      finishedWork++
-    )
-      (lanes = recoverableErrors[finishedWork]),
-        (remainingLanes = {
-          digest: lanes.digest,
-          componentStack: lanes.stack
-        }),
-        renderPriorityLevel(lanes.value, remainingLanes);
-  if (hasUncaughtError)
-    throw (
-      ((hasUncaughtError = !1),
-      (root = firstUncaughtError),
-      (firstUncaughtError = null),
-      root)
-    );
-  0 !== (pendingPassiveEffectsLanes & 3) &&
-    0 !== root.tag &&
-    flushPassiveEffects();
-  remainingLanes = root.pendingLanes;
-  0 !== (remainingLanes & 3)
-    ? root === rootWithNestedUpdates
-      ? nestedUpdateCount++
-      : ((nestedUpdateCount = 0), (rootWithNestedUpdates = root))
-    : (nestedUpdateCount = 0);
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevRootTransitionCallbacks = root.transitionCallbacks;
-    null !== prevRootTransitionCallbacks &&
-      schedulePostPaintCallback(function (endTime) {
-        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
-        null !== prevPendingTransitionCallbacks
-          ? ((currentPendingTransitionCallbacks = null),
-            scheduleCallback(IdlePriority, function () {
-              processTransitionCallbacks(
-                prevPendingTransitionCallbacks,
-                endTime,
-                prevRootTransitionCallbacks
-              );
-            }))
-          : (currentEndTime = endTime);
-      });
+function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
+  "focusin" === domEventName
+    ? (stopWatchingForValueChange(),
+      (activeElement$1 = target),
+      (activeElementInst$1 = targetInst),
+      activeElement$1.attachEvent("onpropertychange", handlePropertyChange))
+    : "focusout" === domEventName && stopWatchingForValueChange();
+}
+function getTargetInstForInputEventPolyfill(domEventName) {
+  if (
+    "selectionchange" === domEventName ||
+    "keyup" === domEventName ||
+    "keydown" === domEventName
+  )
+    return getInstIfValueChanged(activeElementInst$1);
+}
+function getTargetInstForClickEvent(domEventName, targetInst) {
+  if ("click" === domEventName) return getInstIfValueChanged(targetInst);
+}
+function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
+  if ("input" === domEventName || "change" === domEventName)
+    return getInstIfValueChanged(targetInst);
+}
+function getLeafNode(node) {
+  for (; node && node.firstChild; ) node = node.firstChild;
+  return node;
+}
+function getNodeForCharacterOffset(root, offset) {
+  var node = getLeafNode(root);
+  root = 0;
+  for (var nodeEnd; node; ) {
+    if (3 === node.nodeType) {
+      nodeEnd = root + node.textContent.length;
+      if (root <= offset && nodeEnd >= offset)
+        return { node: node, offset: offset - root };
+      root = nodeEnd;
+    }
+    a: {
+      for (; node; ) {
+        if (node.nextSibling) {
+          node = node.nextSibling;
+          break a;
+        }
+        node = node.parentNode;
+      }
+      node = void 0;
+    }
+    node = getLeafNode(node);
   }
-  return null;
 }
-function releaseRootPooledCache(root, remainingLanes) {
-  0 === (root.pooledCacheLanes &= remainingLanes) &&
-    ((remainingLanes = root.pooledCache),
-    null != remainingLanes &&
-      ((root.pooledCache = null), releaseCache(remainingLanes)));
+function containsNode(outerNode, innerNode) {
+  return outerNode && innerNode
+    ? outerNode === innerNode
+      ? !0
+      : outerNode && 3 === outerNode.nodeType
+      ? !1
+      : innerNode && 3 === innerNode.nodeType
+      ? containsNode(outerNode, innerNode.parentNode)
+      : "contains" in outerNode
+      ? outerNode.contains(innerNode)
+      : outerNode.compareDocumentPosition
+      ? !!(outerNode.compareDocumentPosition(innerNode) & 16)
+      : !1
+    : !1;
 }
-function flushPassiveEffects() {
-  if (null !== rootWithPendingPassiveEffects) {
-    var root$222 = rootWithPendingPassiveEffects,
-      remainingLanes = pendingPassiveEffectsRemainingLanes;
-    pendingPassiveEffectsRemainingLanes = 0;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
-    renderPriority = 32 > renderPriority ? 32 : renderPriority;
-    var prevTransition = ReactCurrentBatchConfig.transition,
-      previousPriority = currentUpdatePriority;
+function getActiveElementDeep() {
+  for (
+    var win = window, element = getActiveElement();
+    element instanceof win.HTMLIFrameElement;
+
+  ) {
     try {
-      return (
-        (ReactCurrentBatchConfig.transition = null),
-        (currentUpdatePriority = renderPriority),
-        flushPassiveEffectsImpl()
-      );
-    } finally {
-      (currentUpdatePriority = previousPriority),
-        (ReactCurrentBatchConfig.transition = prevTransition),
-        releaseRootPooledCache(root$222, remainingLanes);
+      var JSCompiler_inline_result =
+        "string" === typeof element.contentWindow.location.href;
+    } catch (err) {
+      JSCompiler_inline_result = !1;
     }
+    if (JSCompiler_inline_result) win = element.contentWindow;
+    else break;
+    element = getActiveElement(win.document);
   }
-  return !1;
-}
-function flushPassiveEffectsImpl() {
-  if (null === rootWithPendingPassiveEffects) return !1;
-  var transitions = pendingPassiveTransitions;
-  pendingPassiveTransitions = null;
-  var root = rootWithPendingPassiveEffects,
-    lanes = pendingPassiveEffectsLanes;
-  rootWithPendingPassiveEffects = null;
-  pendingPassiveEffectsLanes = 0;
-  if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
-  var prevExecutionContext = executionContext;
-  executionContext |= 4;
-  commitPassiveUnmountOnFiber(root.current);
-  commitPassiveMountOnFiber(root, root.current, lanes, transitions);
-  executionContext = prevExecutionContext;
-  flushSyncCallbacks();
-  if (enableTransitionTracing) {
-    var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks,
-      prevRootTransitionCallbacks = root.transitionCallbacks,
-      prevEndTime = currentEndTime;
-    null !== prevPendingTransitionCallbacks &&
-      null !== prevRootTransitionCallbacks &&
-      null !== prevEndTime &&
-      ((currentEndTime = currentPendingTransitionCallbacks = null),
-      scheduleCallback(IdlePriority, function () {
-        processTransitionCallbacks(
-          prevPendingTransitionCallbacks,
-          prevEndTime,
-          prevRootTransitionCallbacks
-        );
-      }));
-  }
-  if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
-    try {
-      injectedHook.onPostCommitFiberRoot(rendererID, root);
-    } catch (err) {}
-  return !0;
+  return element;
 }
-function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
-  sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-  sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
-  rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
-  sourceFiber = requestEventTime();
-  null !== rootFiber &&
-    (markRootUpdated(rootFiber, 2, sourceFiber),
-    ensureRootIsScheduled(rootFiber, sourceFiber));
+function hasSelectionCapabilities(elem) {
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return (
+    nodeName &&
+    (("input" === nodeName &&
+      ("text" === elem.type ||
+        "search" === elem.type ||
+        "tel" === elem.type ||
+        "url" === elem.type ||
+        "password" === elem.type)) ||
+      "textarea" === nodeName ||
+      "true" === elem.contentEditable)
+  );
 }
-function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
-  if (3 === sourceFiber.tag)
-    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
-  else
-    for (
-      nearestMountedAncestor = skipUnmountedBoundaries
-        ? nearestMountedAncestor
-        : sourceFiber.return;
-      null !== nearestMountedAncestor;
-
-    ) {
-      if (3 === nearestMountedAncestor.tag) {
-        captureCommitPhaseErrorOnRoot(
-          nearestMountedAncestor,
-          sourceFiber,
-          error
+function restoreSelection(priorSelectionInformation) {
+  var curFocusedElem = getActiveElementDeep(),
+    priorFocusedElem = priorSelectionInformation.focusedElem,
+    priorSelectionRange = priorSelectionInformation.selectionRange;
+  if (
+    curFocusedElem !== priorFocusedElem &&
+    priorFocusedElem &&
+    priorFocusedElem.ownerDocument &&
+    containsNode(
+      priorFocusedElem.ownerDocument.documentElement,
+      priorFocusedElem
+    )
+  ) {
+    if (
+      null !== priorSelectionRange &&
+      hasSelectionCapabilities(priorFocusedElem)
+    )
+      if (
+        ((curFocusedElem = priorSelectionRange.start),
+        (priorSelectionInformation = priorSelectionRange.end),
+        void 0 === priorSelectionInformation &&
+          (priorSelectionInformation = curFocusedElem),
+        "selectionStart" in priorFocusedElem)
+      )
+        (priorFocusedElem.selectionStart = curFocusedElem),
+          (priorFocusedElem.selectionEnd = Math.min(
+            priorSelectionInformation,
+            priorFocusedElem.value.length
+          ));
+      else if (
+        ((priorSelectionInformation =
+          ((curFocusedElem = priorFocusedElem.ownerDocument || document) &&
+            curFocusedElem.defaultView) ||
+          window),
+        priorSelectionInformation.getSelection)
+      ) {
+        priorSelectionInformation = priorSelectionInformation.getSelection();
+        var length = priorFocusedElem.textContent.length,
+          start = Math.min(priorSelectionRange.start, length);
+        priorSelectionRange =
+          void 0 === priorSelectionRange.end
+            ? start
+            : Math.min(priorSelectionRange.end, length);
+        !priorSelectionInformation.extend &&
+          start > priorSelectionRange &&
+          ((length = priorSelectionRange),
+          (priorSelectionRange = start),
+          (start = length));
+        length = getNodeForCharacterOffset(priorFocusedElem, start);
+        var endMarker = getNodeForCharacterOffset(
+          priorFocusedElem,
+          priorSelectionRange
         );
-        break;
-      } else if (1 === nearestMountedAncestor.tag) {
-        var instance = nearestMountedAncestor.stateNode;
-        if (
-          "function" ===
-            typeof nearestMountedAncestor.type.getDerivedStateFromError ||
-          ("function" === typeof instance.componentDidCatch &&
-            (null === legacyErrorBoundariesThatAlreadyFailed ||
-              !legacyErrorBoundariesThatAlreadyFailed.has(instance)))
-        ) {
-          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
-          sourceFiber = createClassErrorUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          nearestMountedAncestor = enqueueUpdate(
-            nearestMountedAncestor,
-            sourceFiber,
-            2
-          );
-          sourceFiber = requestEventTime();
-          null !== nearestMountedAncestor &&
-            (markRootUpdated(nearestMountedAncestor, 2, sourceFiber),
-            ensureRootIsScheduled(nearestMountedAncestor, sourceFiber));
-          break;
-        }
+        length &&
+          endMarker &&
+          (1 !== priorSelectionInformation.rangeCount ||
+            priorSelectionInformation.anchorNode !== length.node ||
+            priorSelectionInformation.anchorOffset !== length.offset ||
+            priorSelectionInformation.focusNode !== endMarker.node ||
+            priorSelectionInformation.focusOffset !== endMarker.offset) &&
+          ((curFocusedElem = curFocusedElem.createRange()),
+          curFocusedElem.setStart(length.node, length.offset),
+          priorSelectionInformation.removeAllRanges(),
+          start > priorSelectionRange
+            ? (priorSelectionInformation.addRange(curFocusedElem),
+              priorSelectionInformation.extend(
+                endMarker.node,
+                endMarker.offset
+              ))
+            : (curFocusedElem.setEnd(endMarker.node, endMarker.offset),
+              priorSelectionInformation.addRange(curFocusedElem)));
       }
-      nearestMountedAncestor = nearestMountedAncestor.return;
-    }
+    curFocusedElem = [];
+    for (
+      priorSelectionInformation = priorFocusedElem;
+      (priorSelectionInformation = priorSelectionInformation.parentNode);
+
+    )
+      1 === priorSelectionInformation.nodeType &&
+        curFocusedElem.push({
+          element: priorSelectionInformation,
+          left: priorSelectionInformation.scrollLeft,
+          top: priorSelectionInformation.scrollTop
+        });
+    "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
+    for (
+      priorFocusedElem = 0;
+      priorFocusedElem < curFocusedElem.length;
+      priorFocusedElem++
+    )
+      (priorSelectionInformation = curFocusedElem[priorFocusedElem]),
+        (priorSelectionInformation.element.scrollLeft =
+          priorSelectionInformation.left),
+        (priorSelectionInformation.element.scrollTop =
+          priorSelectionInformation.top);
+  }
+}
+var skipSelectionChangeEvent =
+    canUseDOM && "documentMode" in document && 11 >= document.documentMode,
+  activeElement = null,
+  activeElementInst = null,
+  lastSelection = null,
+  mouseDown = !1;
+function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
+  var doc =
+    nativeEventTarget.window === nativeEventTarget
+      ? nativeEventTarget.document
+      : 9 === nativeEventTarget.nodeType
+      ? nativeEventTarget
+      : nativeEventTarget.ownerDocument;
+  mouseDown ||
+    null == activeElement ||
+    activeElement !== getActiveElement(doc) ||
+    ((doc = activeElement),
+    "selectionStart" in doc && hasSelectionCapabilities(doc)
+      ? (doc = { start: doc.selectionStart, end: doc.selectionEnd })
+      : ((doc = (
+          (doc.ownerDocument && doc.ownerDocument.defaultView) ||
+          window
+        ).getSelection()),
+        (doc = {
+          anchorNode: doc.anchorNode,
+          anchorOffset: doc.anchorOffset,
+          focusNode: doc.focusNode,
+          focusOffset: doc.focusOffset
+        })),
+    (lastSelection && shallowEqual(lastSelection, doc)) ||
+      ((lastSelection = doc),
+      (doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect")),
+      0 < doc.length &&
+        ((nativeEvent = new SyntheticEvent(
+          "onSelect",
+          "select",
+          null,
+          nativeEvent,
+          nativeEventTarget
+        )),
+        dispatchQueue.push({ event: nativeEvent, listeners: doc }),
+        (nativeEvent.target = activeElement))));
 }
-function attachPingListener(root, wakeable, lanes) {
-  var pingCache = root.pingCache;
-  if (null === pingCache) {
-    pingCache = root.pingCache = new PossiblyWeakMap();
-    var threadIDs = new Set();
-    pingCache.set(wakeable, threadIDs);
-  } else
-    (threadIDs = pingCache.get(wakeable)),
-      void 0 === threadIDs &&
-        ((threadIDs = new Set()), pingCache.set(wakeable, threadIDs));
-  threadIDs.has(lanes) ||
-    ((workInProgressRootDidAttachPingListener = !0),
-    threadIDs.add(lanes),
-    (root = pingSuspendedRoot.bind(null, root, wakeable, lanes)),
-    wakeable.then(root, root));
+function makePrefixMap(styleProp, eventName) {
+  var prefixes = {};
+  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+  prefixes["Webkit" + styleProp] = "webkit" + eventName;
+  prefixes["Moz" + styleProp] = "moz" + eventName;
+  return prefixes;
 }
-function pingSuspendedRoot(root, wakeable, pingedLanes) {
-  var pingCache = root.pingCache;
-  null !== pingCache && pingCache.delete(wakeable);
-  wakeable = requestEventTime();
-  root.pingedLanes |= root.suspendedLanes & pingedLanes;
-  workInProgressRoot === root &&
-    (workInProgressRootRenderLanes & pingedLanes) === pingedLanes &&
-    (4 === workInProgressRootExitStatus ||
-    (3 === workInProgressRootExitStatus &&
-      (workInProgressRootRenderLanes & 125829120) ===
-        workInProgressRootRenderLanes &&
-      500 > now() - globalMostRecentFallbackTime)
-      ? 0 === (executionContext & 2) && prepareFreshStack(root, 0)
-      : (workInProgressRootPingedLanes |= pingedLanes));
-  ensureRootIsScheduled(root, wakeable);
+var vendorPrefixes = {
+    animationend: makePrefixMap("Animation", "AnimationEnd"),
+    animationiteration: makePrefixMap("Animation", "AnimationIteration"),
+    animationstart: makePrefixMap("Animation", "AnimationStart"),
+    transitionend: makePrefixMap("Transition", "TransitionEnd")
+  },
+  prefixedEventNames = {},
+  style = {};
+canUseDOM &&
+  ((style = document.createElement("div").style),
+  "AnimationEvent" in window ||
+    (delete vendorPrefixes.animationend.animation,
+    delete vendorPrefixes.animationiteration.animation,
+    delete vendorPrefixes.animationstart.animation),
+  "TransitionEvent" in window ||
+    delete vendorPrefixes.transitionend.transition);
+function getVendorPrefixedEventName(eventName) {
+  if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
+  if (!vendorPrefixes[eventName]) return eventName;
+  var prefixMap = vendorPrefixes[eventName],
+    styleProp;
+  for (styleProp in prefixMap)
+    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
+      return (prefixedEventNames[eventName] = prefixMap[styleProp]);
+  return eventName;
 }
-function retryTimedOutBoundary(boundaryFiber, retryLane) {
-  0 === retryLane &&
-    (0 === (boundaryFiber.mode & 1)
-      ? (retryLane = 2)
-      : ((retryLane = nextRetryLane),
-        (nextRetryLane <<= 1),
-        0 === (nextRetryLane & 125829120) && (nextRetryLane = 8388608)));
-  var eventTime = requestEventTime();
-  boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
-  null !== boundaryFiber &&
-    (markRootUpdated(boundaryFiber, retryLane, eventTime),
-    ensureRootIsScheduled(boundaryFiber, eventTime));
+var ANIMATION_END = getVendorPrefixedEventName("animationend"),
+  ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"),
+  ANIMATION_START = getVendorPrefixedEventName("animationstart"),
+  TRANSITION_END = getVendorPrefixedEventName("transitionend"),
+  topLevelEventsToReactNames = new Map(),
+  simpleEventPluginEvents =
+    "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
+      " "
+    );
+topLevelEventsToReactNames.set("beforeblur", null);
+topLevelEventsToReactNames.set("afterblur", null);
+function registerSimpleEvent(domEventName, reactName) {
+  topLevelEventsToReactNames.set(domEventName, reactName);
+  registerTwoPhaseEvent(reactName, [domEventName]);
 }
-function retryDehydratedSuspenseBoundary(boundaryFiber) {
-  var suspenseState = boundaryFiber.memoizedState,
-    retryLane = 0;
-  null !== suspenseState && (retryLane = suspenseState.retryLane);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
+for (
+  var i$jscomp$inline_1559 = 0;
+  i$jscomp$inline_1559 < simpleEventPluginEvents.length;
+  i$jscomp$inline_1559++
+) {
+  var eventName$jscomp$inline_1560 =
+      simpleEventPluginEvents[i$jscomp$inline_1559],
+    domEventName$jscomp$inline_1561 =
+      eventName$jscomp$inline_1560.toLowerCase(),
+    capitalizedEvent$jscomp$inline_1562 =
+      eventName$jscomp$inline_1560[0].toUpperCase() +
+      eventName$jscomp$inline_1560.slice(1);
+  registerSimpleEvent(
+    domEventName$jscomp$inline_1561,
+    "on" + capitalizedEvent$jscomp$inline_1562
+  );
 }
-function resolveRetryWakeable(boundaryFiber, wakeable) {
-  var retryLane = 0;
-  switch (boundaryFiber.tag) {
-    case 13:
-      var retryCache = boundaryFiber.stateNode;
-      var suspenseState = boundaryFiber.memoizedState;
-      null !== suspenseState && (retryLane = suspenseState.retryLane);
-      break;
-    case 19:
-      retryCache = boundaryFiber.stateNode;
-      break;
-    case 22:
-      retryCache = boundaryFiber.stateNode._retryCache;
-      break;
-    default:
-      throw Error(formatProdErrorMessage(314));
-  }
-  null !== retryCache && retryCache.delete(wakeable);
-  retryTimedOutBoundary(boundaryFiber, retryLane);
+registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+registerSimpleEvent("dblclick", "onDoubleClick");
+registerSimpleEvent("focusin", "onFocus");
+registerSimpleEvent("focusout", "onBlur");
+registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+registerTwoPhaseEvent(
+  "onChange",
+  "change click focusin focusout input keydown keyup selectionchange".split(" ")
+);
+registerTwoPhaseEvent(
+  "onSelect",
+  "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
+    " "
+  )
+);
+registerTwoPhaseEvent("onBeforeInput", [
+  "compositionend",
+  "keypress",
+  "textInput",
+  "paste"
+]);
+registerTwoPhaseEvent(
+  "onCompositionEnd",
+  "compositionend focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionStart",
+  "compositionstart focusout keydown keypress keyup mousedown".split(" ")
+);
+registerTwoPhaseEvent(
+  "onCompositionUpdate",
+  "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
+);
+var mediaEventTypes =
+    "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
+      " "
+    ),
+  nonDelegatedEvents = new Set(
+    "cancel close invalid load scroll toggle".split(" ").concat(mediaEventTypes)
+  );
+function executeDispatch(event, listener, currentTarget) {
+  var type = event.type || "unknown-event";
+  event.currentTarget = currentTarget;
+  invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+  event.currentTarget = null;
 }
-var beginWork;
-beginWork = function (current, workInProgress, renderLanes) {
-  if (null !== current)
-    if (current.memoizedProps !== workInProgress.pendingProps)
-      didReceiveUpdate = !0;
-    else {
-      if (
-        !checkScheduledUpdateOrContext(current, renderLanes) &&
-        0 === (workInProgress.flags & 128)
-      )
-        return (
-          (didReceiveUpdate = !1),
-          attemptEarlyBailoutIfNoScheduledUpdate(
-            current,
-            workInProgress,
-            renderLanes
-          )
-        );
-      didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
-    }
-  else
-    (didReceiveUpdate = !1),
-      isHydrating &&
-        0 !== (workInProgress.flags & 1048576) &&
-        pushTreeId(workInProgress, treeForkCount, workInProgress.index);
-  workInProgress.lanes = 0;
-  switch (workInProgress.tag) {
-    case 2:
-      var Component = workInProgress.type;
-      resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-      current = workInProgress.pendingProps;
-      prepareToReadContext(workInProgress, renderLanes);
-      current = renderWithHooks(
-        null,
-        workInProgress,
-        Component,
-        current,
-        void 0,
-        renderLanes
-      );
-      Component = checkDidRenderIdHook();
-      workInProgress.flags |= 1;
-      workInProgress.tag = 0;
-      isHydrating && Component && pushMaterializedTreeId(workInProgress);
-      reconcileChildren(null, workInProgress, current, renderLanes);
-      workInProgress = workInProgress.child;
-      return workInProgress;
-    case 16:
-      Component = workInProgress.elementType;
-      a: {
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
-        current = workInProgress.pendingProps;
-        var init = Component._init;
-        Component = init(Component._payload);
-        workInProgress.type = Component;
-        init = workInProgress.tag = resolveLazyComponentTag(Component);
-        current = resolveDefaultProps(Component, current);
-        switch (init) {
-          case 0:
-            workInProgress = updateFunctionComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 1:
-            workInProgress = updateClassComponent(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
-            break a;
-          case 11:
-            workInProgress = updateForwardRef(
-              null,
-              workInProgress,
-              Component,
-              current,
-              renderLanes
-            );
+function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+  eventSystemFlags = 0 !== (eventSystemFlags & 4);
+  for (var i = 0; i < dispatchQueue.length; i++) {
+    var _dispatchQueue$i = dispatchQueue[i],
+      event = _dispatchQueue$i.event;
+    _dispatchQueue$i = _dispatchQueue$i.listeners;
+    a: {
+      var previousInstance = void 0;
+      if (eventSystemFlags)
+        for (
+          var i$jscomp$0 = _dispatchQueue$i.length - 1;
+          0 <= i$jscomp$0;
+          i$jscomp$0--
+        ) {
+          var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0],
+            instance = _dispatchListeners$i.instance,
+            currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
             break a;
-          case 14:
-            workInProgress = updateMemoComponent(
-              null,
-              workInProgress,
-              Component,
-              resolveDefaultProps(Component.type, current),
-              renderLanes
-            );
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
+        }
+      else
+        for (
+          i$jscomp$0 = 0;
+          i$jscomp$0 < _dispatchQueue$i.length;
+          i$jscomp$0++
+        ) {
+          _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
+          instance = _dispatchListeners$i.instance;
+          currentTarget = _dispatchListeners$i.currentTarget;
+          _dispatchListeners$i = _dispatchListeners$i.listener;
+          if (instance !== previousInstance && event.isPropagationStopped())
             break a;
+          executeDispatch(event, _dispatchListeners$i, currentTarget);
+          previousInstance = instance;
         }
-        throw Error(formatProdErrorMessage(306, Component, ""));
-      }
-      return workInProgress;
-    case 0:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateFunctionComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 1:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateClassComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
+    }
+  }
+  if (hasRethrowError)
+    throw (
+      ((dispatchQueue = rethrowError),
+      (hasRethrowError = !1),
+      (rethrowError = null),
+      dispatchQueue)
+    );
+}
+function listenToNonDelegatedEvent(domEventName, targetElement) {
+  var listenerSet = getEventListenerSet(targetElement),
+    listenerSetKey = domEventName + "__bubble";
+  listenerSet.has(listenerSetKey) ||
+    (addTrappedEventListener(targetElement, domEventName, 2, !1),
+    listenerSet.add(listenerSetKey));
+}
+function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+  var eventSystemFlags = 0;
+  isCapturePhaseListener && (eventSystemFlags |= 4);
+  addTrappedEventListener(
+    target,
+    domEventName,
+    eventSystemFlags,
+    isCapturePhaseListener
+  );
+}
+var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+function listenToAllSupportedEvents(rootContainerElement) {
+  if (!rootContainerElement[listeningMarker]) {
+    rootContainerElement[listeningMarker] = !0;
+    allNativeEvents.forEach(function (domEventName) {
+      "selectionchange" !== domEventName &&
+        (nonDelegatedEvents.has(domEventName) ||
+          listenToNativeEvent(domEventName, !1, rootContainerElement),
+        listenToNativeEvent(domEventName, !0, rootContainerElement));
+    });
+    var ownerDocument =
+      9 === rootContainerElement.nodeType
+        ? rootContainerElement
+        : rootContainerElement.ownerDocument;
+    null === ownerDocument ||
+      ownerDocument[listeningMarker] ||
+      ((ownerDocument[listeningMarker] = !0),
+      listenToNativeEvent("selectionchange", !1, ownerDocument));
+  }
+}
+function addTrappedEventListener(
+  targetContainer,
+  domEventName,
+  eventSystemFlags,
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
+) {
+  eventSystemFlags = createEventListenerWrapperWithPriority(
+    targetContainer,
+    domEventName,
+    eventSystemFlags
+  );
+  var isPassiveListener = void 0;
+  !passiveBrowserEventsSupported ||
+    ("touchstart" !== domEventName &&
+      "touchmove" !== domEventName &&
+      "wheel" !== domEventName) ||
+    (isPassiveListener = !0);
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
+    var originalListener = eventSystemFlags;
+    eventSystemFlags = function () {
+      targetContainer.removeEventListener(
+        domEventName,
+        unsubscribeListener,
+        isCapturePhaseListener
       );
-    case 3:
-      a: {
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
-        );
-        if (null === current) throw Error(formatProdErrorMessage(387));
-        Component = workInProgress.pendingProps;
-        var prevState = workInProgress.memoizedState;
-        init = prevState.element;
-        cloneUpdateQueue(current, workInProgress);
-        processUpdateQueue(workInProgress, Component, null, renderLanes);
-        var nextState = workInProgress.memoizedState,
-          root = workInProgress.stateNode;
-        enableTransitionTracing &&
-          push(transitionStack, workInProgressTransitions);
-        enableTransitionTracing && pushRootMarkerInstance(workInProgress);
-        Component = nextState.cache;
-        pushProvider(workInProgress, CacheContext, Component);
-        Component !== prevState.cache &&
-          propagateContextChange(workInProgress, CacheContext, renderLanes);
-        Component = nextState.element;
-        if (prevState.isDehydrated)
-          if (
-            ((prevState = {
-              element: Component,
-              isDehydrated: !1,
-              cache: nextState.cache
-            }),
-            (workInProgress.updateQueue.baseState = prevState),
-            (workInProgress.memoizedState = prevState),
-            workInProgress.flags & 256)
-          ) {
-            init = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(423)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              init
-            );
-            break a;
-          } else if (Component !== init) {
-            init = createCapturedValueAtFiber(
-              Error(formatProdErrorMessage(424)),
-              workInProgress
-            );
-            workInProgress = mountHostRootWithoutHydrating(
-              current,
-              workInProgress,
-              Component,
-              renderLanes,
-              init
-            );
-            break a;
-          } else {
-            nextHydratableInstance = getNextHydratable(
-              workInProgress.stateNode.containerInfo.firstChild
-            );
-            hydrationParentFiber = workInProgress;
-            isHydrating = !0;
-            hydrationErrors = null;
-            rootOrSingletonContext = !0;
-            current = root.mutableSourceEagerHydrationData;
-            if (null != current)
-              for (init = 0; init < current.length; init += 2)
-                (prevState = current[init]),
-                  (prevState._workInProgressVersionPrimary = current[init + 1]),
-                  workInProgressSources.push(prevState);
-            renderLanes = mountChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            );
-            for (workInProgress.child = renderLanes; renderLanes; )
-              (renderLanes.flags = (renderLanes.flags & -3) | 4096),
-                (renderLanes = renderLanes.sibling);
-          }
-        else {
-          resetHydrationState();
-          if (Component === init) {
-            workInProgress = bailoutOnAlreadyFinishedWork(
-              current,
-              workInProgress,
-              renderLanes
-            );
-            break a;
+      for (
+        var _len = arguments.length, p = Array(_len), _key = 0;
+        _key < _len;
+        _key++
+      )
+        p[_key] = arguments[_key];
+      return originalListener.apply(this, p);
+    };
+  }
+  var unsubscribeListener = isCapturePhaseListener
+    ? void 0 !== isPassiveListener
+      ? addEventCaptureListenerWithPassiveFlag(
+          targetContainer,
+          domEventName,
+          eventSystemFlags,
+          isPassiveListener
+        )
+      : addEventCaptureListener(targetContainer, domEventName, eventSystemFlags)
+    : void 0 !== isPassiveListener
+    ? addEventBubbleListenerWithPassiveFlag(
+        targetContainer,
+        domEventName,
+        eventSystemFlags,
+        isPassiveListener
+      )
+    : addEventBubbleListener(targetContainer, domEventName, eventSystemFlags);
+}
+function dispatchEventForPluginEventSystem(
+  domEventName,
+  eventSystemFlags,
+  nativeEvent,
+  targetInst$jscomp$0,
+  targetContainer
+) {
+  var ancestorInst = targetInst$jscomp$0;
+  if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
+    if (
+      enableLegacyFBSupport &&
+      "click" === domEventName &&
+      0 === (eventSystemFlags & 20) &&
+      nativeEvent !== currentReplayingEvent
+    ) {
+      addTrappedEventListener(targetContainer, domEventName, 16, !1, !0);
+      return;
+    }
+    if (null !== targetInst$jscomp$0)
+      a: for (;;) {
+        if (null === targetInst$jscomp$0) return;
+        var nodeTag = targetInst$jscomp$0.tag;
+        if (3 === nodeTag || 4 === nodeTag) {
+          var container = targetInst$jscomp$0.stateNode.containerInfo;
+          if (
+            container === targetContainer ||
+            (8 === container.nodeType &&
+              container.parentNode === targetContainer)
+          )
+            break;
+          if (4 === nodeTag)
+            for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
+              var grandTag = nodeTag.tag;
+              if (3 === grandTag || 4 === grandTag)
+                if (
+                  ((grandTag = nodeTag.stateNode.containerInfo),
+                  grandTag === targetContainer ||
+                    (8 === grandTag.nodeType &&
+                      grandTag.parentNode === targetContainer))
+                )
+                  return;
+              nodeTag = nodeTag.return;
+            }
+          for (; null !== container; ) {
+            nodeTag = getClosestInstanceFromNode(container);
+            if (null === nodeTag) return;
+            grandTag = nodeTag.tag;
+            if (
+              5 === grandTag ||
+              6 === grandTag ||
+              26 === grandTag ||
+              27 === grandTag
+            ) {
+              targetInst$jscomp$0 = ancestorInst = nodeTag;
+              continue a;
+            }
+            container = container.parentNode;
           }
-          reconcileChildren(current, workInProgress, Component, renderLanes);
         }
-        workInProgress = workInProgress.child;
+        targetInst$jscomp$0 = targetInst$jscomp$0.return;
       }
-      return workInProgress;
-    case 26:
-      return (
-        markRef$1(current, workInProgress),
-        (renderLanes = workInProgress.memoizedState =
-          getResource(
-            workInProgress.type,
-            null === current ? null : current.memoizedProps,
-            workInProgress.pendingProps
-          )),
-        null !== current ||
-          isHydrating ||
-          null !== renderLanes ||
-          ((renderLanes = workInProgress.type),
-          (current = workInProgress.pendingProps),
-          (Component = getOwnerDocumentFromRootContainer(
-            rootInstanceStackCursor.current
-          )),
-          (Component = createHTMLElement(renderLanes, current, Component)),
-          (Component[internalInstanceKey] = workInProgress),
-          (Component[internalPropsKey] = current),
-          setInitialProperties(Component, renderLanes, current),
-          markNodeAsHoistable(Component),
-          (workInProgress.stateNode = Component)),
-        null
-      );
-    case 27:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          ((Component = workInProgress.stateNode =
-            resolveSingletonInstance(
-              workInProgress.type,
-              workInProgress.pendingProps,
-              rootInstanceStackCursor.current
-            )),
-          (hydrationParentFiber = workInProgress),
-          (rootOrSingletonContext = !0),
-          (nextHydratableInstance = getNextHydratable(Component.firstChild))),
-        (Component = workInProgress.pendingProps.children),
-        null !== current || isHydrating
-          ? reconcileChildren(current, workInProgress, Component, renderLanes)
-          : (workInProgress.child = reconcileChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            )),
-        markRef$1(current, workInProgress),
-        workInProgress.child
-      );
-    case 5:
-      return (
-        pushHostContext(workInProgress),
-        null === current &&
-          isHydrating &&
-          (((Component = workInProgress.pendingProps),
-          "script" === workInProgress.type
-            ? ((init = Component.onLoad),
-              (prevState = Component.onError),
-              (Component = !(Component.async && (init || prevState))))
-            : (Component = !0),
-          Component)
-            ? ((Component = nextHydratableInstance),
-              rootOrSingletonContext &&
-                advanceToFirstAttemptableInstance(workInProgress),
-              (init = nextHydratableInstance),
-              init)
-              ? tryHydrateInstance(workInProgress, init) ||
-                (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                (nextHydratableInstance = getNextHydratable(init.nextSibling)),
-                (prevState = hydrationParentFiber),
-                rootOrSingletonContext &&
-                  advanceToFirstAttemptableInstance(workInProgress),
-                nextHydratableInstance &&
-                tryHydrateInstance(workInProgress, nextHydratableInstance)
-                  ? deleteHydratableInstance(prevState, init)
-                  : (insertNonHydratedInstance(
-                      hydrationParentFiber,
-                      workInProgress
-                    ),
-                    (isHydrating = !1),
-                    (hydrationParentFiber = workInProgress),
-                    (nextHydratableInstance = Component)))
-              : (shouldClientRenderOnMismatch(workInProgress) &&
-                  throwOnHydrationMismatch(),
-                insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-                (isHydrating = !1),
-                (hydrationParentFiber = workInProgress),
-                (nextHydratableInstance = Component))
-            : ((workInProgress.flags = (workInProgress.flags & -4097) | 2),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress))),
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (prevState = null !== current ? current.memoizedProps : null),
-        (root = init.children),
-        shouldSetTextContent(Component, init)
-          ? (root = null)
-          : null !== prevState &&
-            shouldSetTextContent(Component, prevState) &&
-            (workInProgress.flags |= 32),
-        markRef$1(current, workInProgress),
-        reconcileChildren(current, workInProgress, root, renderLanes),
-        workInProgress.child
-      );
-    case 6:
-      return (
-        null === current &&
-          isHydrating &&
-          (((renderLanes = "" !== workInProgress.pendingProps),
-          (current = nextHydratableInstance),
-          rootOrSingletonContext &&
-            renderLanes &&
-            advanceToFirstAttemptableTextInstance(),
-          (Component = nextHydratableInstance),
-          Component && renderLanes)
-            ? tryHydrateText(workInProgress, Component) ||
-              (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              (nextHydratableInstance = getNextHydratable(
-                Component.nextSibling
+  }
+  batchedUpdates(function () {
+    var targetInst = ancestorInst,
+      nativeEventTarget = getEventTarget(nativeEvent),
+      dispatchQueue = [];
+    a: {
+      var reactName = topLevelEventsToReactNames.get(domEventName);
+      if (void 0 !== reactName) {
+        var SyntheticEventCtor = SyntheticEvent,
+          reactEventType = domEventName;
+        switch (domEventName) {
+          case "keypress":
+            if (0 === getEventCharCode(nativeEvent)) break a;
+          case "keydown":
+          case "keyup":
+            SyntheticEventCtor = SyntheticKeyboardEvent;
+            break;
+          case "focusin":
+            reactEventType = "focus";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "focusout":
+            reactEventType = "blur";
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "beforeblur":
+          case "afterblur":
+            SyntheticEventCtor = SyntheticFocusEvent;
+            break;
+          case "click":
+            if (2 === nativeEvent.button) break a;
+          case "auxclick":
+          case "dblclick":
+          case "mousedown":
+          case "mousemove":
+          case "mouseup":
+          case "mouseout":
+          case "mouseover":
+          case "contextmenu":
+            SyntheticEventCtor = SyntheticMouseEvent;
+            break;
+          case "drag":
+          case "dragend":
+          case "dragenter":
+          case "dragexit":
+          case "dragleave":
+          case "dragover":
+          case "dragstart":
+          case "drop":
+            SyntheticEventCtor = SyntheticDragEvent;
+            break;
+          case "touchcancel":
+          case "touchend":
+          case "touchmove":
+          case "touchstart":
+            SyntheticEventCtor = SyntheticTouchEvent;
+            break;
+          case ANIMATION_END:
+          case ANIMATION_ITERATION:
+          case ANIMATION_START:
+            SyntheticEventCtor = SyntheticAnimationEvent;
+            break;
+          case TRANSITION_END:
+            SyntheticEventCtor = SyntheticTransitionEvent;
+            break;
+          case "scroll":
+            SyntheticEventCtor = SyntheticUIEvent;
+            break;
+          case "wheel":
+            SyntheticEventCtor = SyntheticWheelEvent;
+            break;
+          case "copy":
+          case "cut":
+          case "paste":
+            SyntheticEventCtor = SyntheticClipboardEvent;
+            break;
+          case "gotpointercapture":
+          case "lostpointercapture":
+          case "pointercancel":
+          case "pointerdown":
+          case "pointermove":
+          case "pointerout":
+          case "pointerover":
+          case "pointerup":
+            SyntheticEventCtor = SyntheticPointerEvent;
+        }
+        var inCapturePhase = 0 !== (eventSystemFlags & 4);
+        eventSystemFlags & 1
+          ? ((inCapturePhase = accumulateEventHandleNonManagedNodeListeners(
+              reactEventType,
+              targetContainer,
+              inCapturePhase
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
               )),
-              (init = hydrationParentFiber),
-              rootOrSingletonContext &&
-                renderLanes &&
-                advanceToFirstAttemptableTextInstance(),
-              nextHydratableInstance &&
-              tryHydrateText(workInProgress, nextHydratableInstance)
-                ? deleteHydratableInstance(init, Component)
-                : (insertNonHydratedInstance(
-                    hydrationParentFiber,
-                    workInProgress
-                  ),
-                  (isHydrating = !1),
-                  (hydrationParentFiber = workInProgress),
-                  (nextHydratableInstance = current)))
-            : (shouldClientRenderOnMismatch(workInProgress) &&
-                throwOnHydrationMismatch(),
-              insertNonHydratedInstance(hydrationParentFiber, workInProgress),
-              (isHydrating = !1),
-              (hydrationParentFiber = workInProgress),
-              (nextHydratableInstance = current))),
-        null
-      );
-    case 13:
-      return updateSuspenseComponent(current, workInProgress, renderLanes);
-    case 4:
-      return (
-        pushHostContainer(
-          workInProgress,
-          workInProgress.stateNode.containerInfo
-        ),
-        (Component = workInProgress.pendingProps),
-        null === current
-          ? (workInProgress.child = reconcileChildFibers(
-              workInProgress,
-              null,
-              Component,
-              renderLanes
-            ))
-          : reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 11:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        updateForwardRef(current, workInProgress, Component, init, renderLanes)
-      );
-    case 7:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 8:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 12:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 10:
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })))
+          : ((inCapturePhase = accumulateSinglePhaseListeners(
+              targetInst,
+              reactName,
+              nativeEvent.type,
+              inCapturePhase,
+              !inCapturePhase && "scroll" === domEventName,
+              nativeEvent
+            )),
+            0 < inCapturePhase.length &&
+              ((reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              dispatchQueue.push({
+                event: reactName,
+                listeners: inCapturePhase
+              })));
+      }
+    }
+    if (0 === (eventSystemFlags & 7)) {
       a: {
-        Component = workInProgress.type._context;
-        init = workInProgress.pendingProps;
-        prevState = workInProgress.memoizedProps;
-        root = init.value;
-        pushProvider(workInProgress, Component, root);
-        if (!enableLazyContextPropagation && null !== prevState)
-          if (objectIs(prevState.value, root)) {
-            if (prevState.children === init.children) {
-              workInProgress = bailoutOnAlreadyFinishedWork(
-                current,
-                workInProgress,
-                renderLanes
+        reactName =
+          "mouseover" === domEventName || "pointerover" === domEventName;
+        SyntheticEventCtor =
+          "mouseout" === domEventName || "pointerout" === domEventName;
+        if (
+          reactName &&
+          nativeEvent !== currentReplayingEvent &&
+          (reactEventType =
+            nativeEvent.relatedTarget || nativeEvent.fromElement) &&
+          (getClosestInstanceFromNode(reactEventType) ||
+            reactEventType[internalContainerInstanceKey])
+        )
+          break a;
+        if (SyntheticEventCtor || reactName) {
+          reactName =
+            nativeEventTarget.window === nativeEventTarget
+              ? nativeEventTarget
+              : (reactName = nativeEventTarget.ownerDocument)
+              ? reactName.defaultView || reactName.parentWindow
+              : window;
+          if (SyntheticEventCtor) {
+            if (
+              ((reactEventType =
+                nativeEvent.relatedTarget || nativeEvent.toElement),
+              (SyntheticEventCtor = targetInst),
+              (reactEventType = reactEventType
+                ? getClosestInstanceFromNode(reactEventType)
+                : null),
+              null !== reactEventType)
+            ) {
+              inCapturePhase = getNearestMountedFiber(reactEventType);
+              var tag = reactEventType.tag;
+              if (
+                reactEventType !== inCapturePhase ||
+                (5 !== tag && 27 !== tag && 6 !== tag)
+              )
+                reactEventType = null;
+            }
+          } else (SyntheticEventCtor = null), (reactEventType = targetInst);
+          if (SyntheticEventCtor !== reactEventType) {
+            tag = SyntheticMouseEvent;
+            var leaveEventType = "onMouseLeave",
+              enterEventType = "onMouseEnter",
+              eventTypePrefix = "mouse";
+            if ("pointerout" === domEventName || "pointerover" === domEventName)
+              (tag = SyntheticPointerEvent),
+                (leaveEventType = "onPointerLeave"),
+                (enterEventType = "onPointerEnter"),
+                (eventTypePrefix = "pointer");
+            inCapturePhase =
+              null == SyntheticEventCtor
+                ? reactName
+                : getNodeFromInstance(SyntheticEventCtor);
+            var toNode =
+              null == reactEventType
+                ? reactName
+                : getNodeFromInstance(reactEventType);
+            reactName = new tag(
+              leaveEventType,
+              eventTypePrefix + "leave",
+              SyntheticEventCtor,
+              nativeEvent,
+              nativeEventTarget
+            );
+            reactName.target = inCapturePhase;
+            reactName.relatedTarget = toNode;
+            leaveEventType = null;
+            getClosestInstanceFromNode(nativeEventTarget) === targetInst &&
+              ((tag = new tag(
+                enterEventType,
+                eventTypePrefix + "enter",
+                reactEventType,
+                nativeEvent,
+                nativeEventTarget
+              )),
+              (tag.target = toNode),
+              (tag.relatedTarget = inCapturePhase),
+              (leaveEventType = tag));
+            inCapturePhase = leaveEventType;
+            if (SyntheticEventCtor && reactEventType)
+              b: {
+                tag = SyntheticEventCtor;
+                enterEventType = reactEventType;
+                eventTypePrefix = 0;
+                for (toNode = tag; toNode; toNode = getParent(toNode))
+                  eventTypePrefix++;
+                toNode = 0;
+                for (
+                  leaveEventType = enterEventType;
+                  leaveEventType;
+                  leaveEventType = getParent(leaveEventType)
+                )
+                  toNode++;
+                for (; 0 < eventTypePrefix - toNode; )
+                  (tag = getParent(tag)), eventTypePrefix--;
+                for (; 0 < toNode - eventTypePrefix; )
+                  (enterEventType = getParent(enterEventType)), toNode--;
+                for (; eventTypePrefix--; ) {
+                  if (
+                    tag === enterEventType ||
+                    (null !== enterEventType &&
+                      tag === enterEventType.alternate)
+                  )
+                    break b;
+                  tag = getParent(tag);
+                  enterEventType = getParent(enterEventType);
+                }
+                tag = null;
+              }
+            else tag = null;
+            null !== SyntheticEventCtor &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                reactName,
+                SyntheticEventCtor,
+                tag,
+                !1
               );
-              break a;
-            }
-          } else propagateContextChange(workInProgress, Component, renderLanes);
-        reconcileChildren(current, workInProgress, init.children, renderLanes);
-        workInProgress = workInProgress.child;
+            null !== reactEventType &&
+              null !== inCapturePhase &&
+              accumulateEnterLeaveListenersForEvent(
+                dispatchQueue,
+                inCapturePhase,
+                reactEventType,
+                tag,
+                !0
+              );
+          }
+        }
       }
-      return workInProgress;
-    case 9:
-      return (
-        (init = workInProgress.type),
-        (Component = workInProgress.pendingProps.children),
-        prepareToReadContext(workInProgress, renderLanes),
-        (init = readContext(init)),
-        (Component = Component(init)),
-        (workInProgress.flags |= 1),
-        reconcileChildren(current, workInProgress, Component, renderLanes),
-        workInProgress.child
-      );
-    case 14:
-      return (
-        (Component = workInProgress.type),
-        (init = resolveDefaultProps(Component, workInProgress.pendingProps)),
-        (init = resolveDefaultProps(Component.type, init)),
-        updateMemoComponent(
-          current,
-          workInProgress,
-          Component,
-          init,
-          renderLanes
-        )
-      );
-    case 15:
-      return updateSimpleMemoComponent(
-        current,
-        workInProgress,
-        workInProgress.type,
-        workInProgress.pendingProps,
-        renderLanes
-      );
-    case 17:
-      return (
-        (Component = workInProgress.type),
-        (init = workInProgress.pendingProps),
-        (init =
-          workInProgress.elementType === Component
-            ? init
-            : resolveDefaultProps(Component, init)),
-        resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress),
-        (workInProgress.tag = 1),
-        prepareToReadContext(workInProgress, renderLanes),
-        constructClassInstance(workInProgress, Component, init),
-        mountClassInstance(workInProgress, Component, init, renderLanes),
-        finishClassComponent(
-          null,
-          workInProgress,
-          Component,
-          !0,
-          !1,
-          renderLanes
+      a: {
+        reactName = targetInst ? getNodeFromInstance(targetInst) : window;
+        SyntheticEventCtor =
+          reactName.nodeName && reactName.nodeName.toLowerCase();
+        if (
+          "select" === SyntheticEventCtor ||
+          ("input" === SyntheticEventCtor && "file" === reactName.type)
         )
-      );
-    case 19:
-      return updateSuspenseListComponent(current, workInProgress, renderLanes);
-    case 21:
-      return (
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
-        ),
-        workInProgress.child
-      );
-    case 22:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 23:
-      return updateOffscreenComponent(current, workInProgress, renderLanes);
-    case 24:
-      return (
-        prepareToReadContext(workInProgress, renderLanes),
-        (Component = readContext(CacheContext)),
-        null === current
-          ? ((init = peekCacheFromPool()),
-            null === init &&
-              ((init = workInProgressRoot),
-              (prevState = createCache()),
-              (init.pooledCache = prevState),
-              prevState.refCount++,
-              null !== prevState && (init.pooledCacheLanes |= renderLanes),
-              (init = prevState)),
-            (workInProgress.memoizedState = { parent: Component, cache: init }),
-            initializeUpdateQueue(workInProgress),
-            pushProvider(workInProgress, CacheContext, init))
-          : (0 !== (current.lanes & renderLanes) &&
-              (cloneUpdateQueue(current, workInProgress),
-              processUpdateQueue(workInProgress, null, null, renderLanes)),
-            (init = current.memoizedState),
-            (prevState = workInProgress.memoizedState),
-            init.parent !== Component
-              ? ((init = { parent: Component, cache: Component }),
-                (workInProgress.memoizedState = init),
-                0 === workInProgress.lanes &&
-                  (workInProgress.memoizedState =
-                    workInProgress.updateQueue.baseState =
-                      init),
-                pushProvider(workInProgress, CacheContext, Component))
-              : ((Component = prevState.cache),
-                pushProvider(workInProgress, CacheContext, Component),
-                Component !== init.cache &&
-                  propagateContextChange(
-                    workInProgress,
-                    CacheContext,
-                    renderLanes
-                  ))),
-        reconcileChildren(
-          current,
-          workInProgress,
-          workInProgress.pendingProps.children,
-          renderLanes
+          var getTargetInstFunc = getTargetInstForChangeEvent;
+        else if (isTextInputElement(reactName))
+          if (isInputEventSupported)
+            getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+          else {
+            getTargetInstFunc = getTargetInstForInputEventPolyfill;
+            var handleEventFunc = handleEventsForInputEventPolyfill;
+          }
+        else
+          (SyntheticEventCtor = reactName.nodeName),
+            !SyntheticEventCtor ||
+            "input" !== SyntheticEventCtor.toLowerCase() ||
+            ("checkbox" !== reactName.type && "radio" !== reactName.type)
+              ? enableCustomElementPropertySupport &&
+                targetInst &&
+                isCustomComponent(
+                  targetInst.elementType,
+                  targetInst.memoizedProps
+                ) &&
+                (getTargetInstFunc = getTargetInstForChangeEvent)
+              : (getTargetInstFunc = getTargetInstForClickEvent);
+        if (
+          getTargetInstFunc &&
+          (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))
+        ) {
+          createAndAccumulateChangeEvent(
+            dispatchQueue,
+            getTargetInstFunc,
+            nativeEvent,
+            nativeEventTarget
+          );
+          break a;
+        }
+        handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
+        "focusout" === domEventName &&
+          (handleEventFunc = reactName._wrapperState) &&
+          handleEventFunc.controlled &&
+          "number" === reactName.type &&
+          (disableInputAttributeSyncing ||
+            setDefaultValue(reactName, "number", reactName.value));
+      }
+      handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
+      switch (domEventName) {
+        case "focusin":
+          if (
+            isTextInputElement(handleEventFunc) ||
+            "true" === handleEventFunc.contentEditable
+          )
+            (activeElement = handleEventFunc),
+              (activeElementInst = targetInst),
+              (lastSelection = null);
+          break;
+        case "focusout":
+          lastSelection = activeElementInst = activeElement = null;
+          break;
+        case "mousedown":
+          mouseDown = !0;
+          break;
+        case "contextmenu":
+        case "mouseup":
+        case "dragend":
+          mouseDown = !1;
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+          break;
+        case "selectionchange":
+          if (skipSelectionChangeEvent) break;
+        case "keydown":
+        case "keyup":
+          constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+      }
+      var fallbackData;
+      if (canUseCompositionEvent)
+        b: {
+          switch (domEventName) {
+            case "compositionstart":
+              var eventType = "onCompositionStart";
+              break b;
+            case "compositionend":
+              eventType = "onCompositionEnd";
+              break b;
+            case "compositionupdate":
+              eventType = "onCompositionUpdate";
+              break b;
+          }
+          eventType = void 0;
+        }
+      else
+        isComposing
+          ? isFallbackCompositionEnd(domEventName, nativeEvent) &&
+            (eventType = "onCompositionEnd")
+          : "keydown" === domEventName &&
+            229 === nativeEvent.keyCode &&
+            (eventType = "onCompositionStart");
+      eventType &&
+        (useFallbackCompositionData &&
+          "ko" !== nativeEvent.locale &&
+          (isComposing || "onCompositionStart" !== eventType
+            ? "onCompositionEnd" === eventType &&
+              isComposing &&
+              (fallbackData = getData())
+            : ((root = nativeEventTarget),
+              (startText = "value" in root ? root.value : root.textContent),
+              (isComposing = !0))),
+        (handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType)),
+        0 < handleEventFunc.length &&
+          ((eventType = new SyntheticCompositionEvent(
+            eventType,
+            domEventName,
+            null,
+            nativeEvent,
+            nativeEventTarget
+          )),
+          dispatchQueue.push({ event: eventType, listeners: handleEventFunc }),
+          fallbackData
+            ? (eventType.data = fallbackData)
+            : ((fallbackData = getDataFromCustomEvent(nativeEvent)),
+              null !== fallbackData && (eventType.data = fallbackData))));
+      if (
+        (fallbackData = canUseTextInputEvent
+          ? getNativeBeforeInputChars(domEventName, nativeEvent)
+          : getFallbackBeforeInputChars(domEventName, nativeEvent))
+      )
+        (targetInst = accumulateTwoPhaseListeners(targetInst, "onBeforeInput")),
+          0 < targetInst.length &&
+            ((nativeEventTarget = new SyntheticCompositionEvent(
+              "onBeforeInput",
+              "beforeinput",
+              null,
+              nativeEvent,
+              nativeEventTarget
+            )),
+            dispatchQueue.push({
+              event: nativeEventTarget,
+              listeners: targetInst
+            }),
+            (nativeEventTarget.data = fallbackData));
+    }
+    processDispatchQueue(dispatchQueue, eventSystemFlags);
+  });
+}
+function createDispatchListener(instance, listener, currentTarget) {
+  return {
+    instance: instance,
+    listener: listener,
+    currentTarget: currentTarget
+  };
+}
+function accumulateSinglePhaseListeners(
+  targetFiber,
+  reactName,
+  nativeEventType,
+  inCapturePhase,
+  accumulateTargetOnly,
+  nativeEvent
+) {
+  reactName = inCapturePhase
+    ? null !== reactName
+      ? reactName + "Capture"
+      : null
+    : reactName;
+  for (
+    var listeners = [], instance = targetFiber, lastHostComponent = null;
+    null !== instance;
+
+  ) {
+    var _instance = instance;
+    targetFiber = _instance.stateNode;
+    _instance = _instance.tag;
+    (5 !== _instance && 26 !== _instance && 27 !== _instance) ||
+    null === targetFiber
+      ? 21 === _instance &&
+        null !== lastHostComponent &&
+        null !== targetFiber &&
+        ((targetFiber = targetFiber[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }))
+      : ((lastHostComponent = targetFiber),
+        (targetFiber =
+          lastHostComponent[internalEventHandlerListenersKey] || null),
+        null !== targetFiber &&
+          targetFiber.forEach(function (entry) {
+            entry.type === nativeEventType &&
+              entry.capture === inCapturePhase &&
+              listeners.push(
+                createDispatchListener(
+                  instance,
+                  entry.callback,
+                  lastHostComponent
+                )
+              );
+          }),
+        null !== reactName &&
+          ((targetFiber = getListener(instance, reactName)),
+          null != targetFiber &&
+            listeners.push(
+              createDispatchListener(instance, targetFiber, lastHostComponent)
+            )));
+    if (accumulateTargetOnly) break;
+    "beforeblur" === nativeEvent.type &&
+      ((targetFiber = nativeEvent._detachedInterceptFiber),
+      null === targetFiber ||
+        (targetFiber !== instance && targetFiber !== instance.alternate) ||
+        (listeners = []));
+    instance = instance.return;
+  }
+  return listeners;
+}
+function accumulateTwoPhaseListeners(targetFiber, reactName) {
+  for (
+    var captureName = reactName + "Capture", listeners = [];
+    null !== targetFiber;
+
+  ) {
+    var _instance2 = targetFiber,
+      stateNode = _instance2.stateNode;
+    _instance2 = _instance2.tag;
+    (5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2) ||
+      null === stateNode ||
+      ((_instance2 = getListener(targetFiber, captureName)),
+      null != _instance2 &&
+        listeners.unshift(
+          createDispatchListener(targetFiber, _instance2, stateNode)
         ),
-        workInProgress.child
-      );
-    case 25:
-      if (enableTransitionTracing)
-        return (
-          enableTransitionTracing
-            ? (null === current &&
-                ((Component = enableTransitionTracing
-                  ? transitionStack.current
-                  : null),
-                null !== Component &&
-                  ((Component = {
-                    tag: 1,
-                    transitions: new Set(Component),
-                    pendingBoundaries: null,
-                    name: workInProgress.pendingProps.name,
-                    aborts: null
-                  }),
-                  (workInProgress.stateNode = Component),
-                  (workInProgress.flags |= 2048))),
-              (Component = workInProgress.stateNode),
-              null !== Component &&
-                pushMarkerInstance(workInProgress, Component),
-              reconcileChildren(
-                current,
-                workInProgress,
-                workInProgress.pendingProps.children,
-                renderLanes
-              ),
-              (workInProgress = workInProgress.child))
-            : (workInProgress = null),
-          workInProgress
+      (_instance2 = getListener(targetFiber, reactName)),
+      null != _instance2 &&
+        listeners.push(
+          createDispatchListener(targetFiber, _instance2, stateNode)
+        ));
+    targetFiber = targetFiber.return;
+  }
+  return listeners;
+}
+function getParent(inst) {
+  if (null === inst) return null;
+  do inst = inst.return;
+  while (inst && 5 !== inst.tag && 27 !== inst.tag);
+  return inst ? inst : null;
+}
+function accumulateEnterLeaveListenersForEvent(
+  dispatchQueue,
+  event,
+  target,
+  common,
+  inCapturePhase
+) {
+  for (
+    var registrationName = event._reactName, listeners = [];
+    null !== target && target !== common;
+
+  ) {
+    var _instance3 = target,
+      alternate = _instance3.alternate,
+      stateNode = _instance3.stateNode;
+    _instance3 = _instance3.tag;
+    if (null !== alternate && alternate === common) break;
+    (5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3) ||
+      null === stateNode ||
+      ((alternate = stateNode),
+      inCapturePhase
+        ? ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.unshift(
+              createDispatchListener(target, stateNode, alternate)
+            ))
+        : inCapturePhase ||
+          ((stateNode = getListener(target, registrationName)),
+          null != stateNode &&
+            listeners.push(
+              createDispatchListener(target, stateNode, alternate)
+            )));
+    target = target.return;
+  }
+  0 !== listeners.length &&
+    dispatchQueue.push({ event: event, listeners: listeners });
+}
+function accumulateEventHandleNonManagedNodeListeners(
+  reactEventType,
+  currentTarget,
+  inCapturePhase
+) {
+  var listeners = [],
+    eventListeners = currentTarget[internalEventHandlerListenersKey] || null;
+  null !== eventListeners &&
+    eventListeners.forEach(function (entry) {
+      entry.type === reactEventType &&
+        entry.capture === inCapturePhase &&
+        listeners.push(
+          createDispatchListener(null, entry.callback, currentTarget)
         );
+    });
+  return listeners;
+}
+var NORMALIZE_NEWLINES_REGEX = /\r\n?/g,
+  NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+function normalizeMarkupForTextOrAttribute(markup) {
+  return ("string" === typeof markup ? markup : "" + markup)
+    .replace(NORMALIZE_NEWLINES_REGEX, "\n")
+    .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
+}
+function getOwnerDocumentFromRootContainer(rootContainerElement) {
+  return 9 === rootContainerElement.nodeType
+    ? rootContainerElement
+    : rootContainerElement.ownerDocument;
+}
+function noop() {}
+function createHTMLElement(type, props, ownerDocument) {
+  return "string" === typeof props.is
+    ? ownerDocument.createElement(type, { is: props.is })
+    : ownerDocument.createElement(type);
+}
+function setInitialProperties(domElement, tag, rawProps) {
+  var isCustomComponentTag = isCustomComponent(tag, rawProps);
+  switch (tag) {
+    case "dialog":
+      listenToNonDelegatedEvent("cancel", domElement);
+      listenToNonDelegatedEvent("close", domElement);
+      var props = rawProps;
+      break;
+    case "iframe":
+    case "object":
+    case "embed":
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
+    case "video":
+    case "audio":
+      for (props = 0; props < mediaEventTypes.length; props++)
+        listenToNonDelegatedEvent(mediaEventTypes[props], domElement);
+      props = rawProps;
+      break;
+    case "source":
+      listenToNonDelegatedEvent("error", domElement);
+      props = rawProps;
+      break;
+    case "img":
+    case "image":
+    case "link":
+      listenToNonDelegatedEvent("error", domElement);
+      listenToNonDelegatedEvent("load", domElement);
+      props = rawProps;
+      break;
+    case "details":
+      listenToNonDelegatedEvent("toggle", domElement);
+      props = rawProps;
+      break;
+    case "input":
+      initWrapperState$2(domElement, rawProps);
+      props = getHostProps$2(domElement, rawProps);
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    case "option":
+      props = rawProps;
+      break;
+    case "select":
+      domElement._wrapperState = { wasMultiple: !!rawProps.multiple };
+      props = assign({}, rawProps, { value: void 0 });
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    case "textarea":
+      initWrapperState(domElement, rawProps);
+      props = getHostProps(domElement, rawProps);
+      listenToNonDelegatedEvent("invalid", domElement);
+      break;
+    default:
+      props = rawProps;
+  }
+  assertValidProps(tag, props);
+  var nextProps = props,
+    propKey;
+  for (propKey in nextProps)
+    if (nextProps.hasOwnProperty(propKey)) {
+      var nextProp = nextProps[propKey];
+      "style" === propKey
+        ? setValueForStyles(domElement, nextProp)
+        : "dangerouslySetInnerHTML" === propKey
+        ? ((nextProp = nextProp ? nextProp.__html : void 0),
+          null != nextProp &&
+            (disableIEWorkarounds
+              ? (domElement.innerHTML = nextProp)
+              : setInnerHTML$1(domElement, nextProp)))
+        : "children" === propKey
+        ? "string" === typeof nextProp
+          ? "body" === tag ||
+            ("textarea" === tag && "" === nextProp) ||
+            setTextContent(domElement, nextProp)
+          : "number" === typeof nextProp &&
+            "body" !== tag &&
+            setTextContent(domElement, "" + nextProp)
+        : "suppressContentEditableWarning" !== propKey &&
+          "suppressHydrationWarning" !== propKey &&
+          "autoFocus" !== propKey &&
+          (registrationNameDependencies.hasOwnProperty(propKey)
+            ? null != nextProp &&
+              "onScroll" === propKey &&
+              listenToNonDelegatedEvent("scroll", domElement)
+            : null != nextProp &&
+              setValueForProperty(
+                domElement,
+                propKey,
+                nextProp,
+                isCustomComponentTag
+              ));
+    }
+  switch (tag) {
+    case "input":
+      track(domElement);
+      postMountWrapper$3(domElement, rawProps, !1);
+      break;
+    case "textarea":
+      track(domElement);
+      postMountWrapper(domElement);
+      break;
+    case "option":
+      null != rawProps.value &&
+        domElement.setAttribute("value", "" + getToStringValue(rawProps.value));
+      break;
+    case "select":
+      domElement.multiple = !!rawProps.multiple;
+      tag = rawProps.value;
+      null != tag
+        ? updateOptions(domElement, !!rawProps.multiple, tag, !1)
+        : null != rawProps.defaultValue &&
+          updateOptions(
+            domElement,
+            !!rawProps.multiple,
+            rawProps.defaultValue,
+            !0
+          );
+      break;
+    default:
+      "function" === typeof props.onClick && (domElement.onclick = noop);
+  }
+}
+function updateProperties(
+  domElement,
+  updatePayload,
+  tag,
+  lastRawProps,
+  nextRawProps
+) {
+  "input" === tag &&
+    "radio" === nextRawProps.type &&
+    null != nextRawProps.name &&
+    updateChecked(domElement, nextRawProps);
+  isCustomComponent(tag, lastRawProps);
+  lastRawProps = isCustomComponent(tag, nextRawProps);
+  for (var i = 0; i < updatePayload.length; i += 2) {
+    var propKey = updatePayload[i],
+      propValue = updatePayload[i + 1];
+    "style" === propKey
+      ? setValueForStyles(domElement, propValue)
+      : "dangerouslySetInnerHTML" === propKey
+      ? disableIEWorkarounds
+        ? (domElement.innerHTML = propValue)
+        : setInnerHTML$1(domElement, propValue)
+      : "children" === propKey
+      ? setTextContent(domElement, propValue)
+      : setValueForProperty(domElement, propKey, propValue, lastRawProps);
+  }
+  switch (tag) {
+    case "input":
+      updateWrapper$1(domElement, nextRawProps);
+      break;
+    case "textarea":
+      updateWrapper(domElement, nextRawProps);
+      break;
+    case "select":
+      (updatePayload = domElement._wrapperState.wasMultiple),
+        (domElement._wrapperState.wasMultiple = !!nextRawProps.multiple),
+        (tag = nextRawProps.value),
+        null != tag
+          ? updateOptions(domElement, !!nextRawProps.multiple, tag, !1)
+          : updatePayload !== !!nextRawProps.multiple &&
+            (null != nextRawProps.defaultValue
+              ? updateOptions(
+                  domElement,
+                  !!nextRawProps.multiple,
+                  nextRawProps.defaultValue,
+                  !0
+                )
+              : updateOptions(
+                  domElement,
+                  !!nextRawProps.multiple,
+                  nextRawProps.multiple ? [] : "",
+                  !1
+                ));
+  }
+}
+var Dispatcher$1 = Internals.Dispatcher,
+  lastCurrentDocument = null,
+  previousDispatcher = null,
+  ReactDOMClientDispatcher = {
+    prefetchDNS: prefetchDNS$1,
+    preconnect: preconnect$1,
+    preload: preload$1,
+    preinit: preinit$1
+  },
+  preloadPropsMap = new Map(),
+  preconnectsSet = new Set();
+function getHoistableRoot(container) {
+  return "function" === typeof container.getRootNode
+    ? container.getRootNode()
+    : container.ownerDocument;
+}
+function getCurrentResourceRoot() {
+  var currentContainer = rootInstanceStackCursor.current;
+  return currentContainer ? getHoistableRoot(currentContainer) : null;
+}
+function getDocumentForPreloads() {
+  var root = getCurrentResourceRoot();
+  if (root) return root.ownerDocument || root;
+  try {
+    return lastCurrentDocument || window.document;
+  } catch (error) {
+    return null;
+  }
+}
+function preconnectAs(rel, crossOrigin, href) {
+  var ownerDocument = getDocumentForPreloads();
+  if ("string" === typeof href && href && ownerDocument) {
+    var limitedEscapedHref =
+      escapeSelectorAttributeValueInsideDoubleQuotes(href);
+    limitedEscapedHref =
+      'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
+    "string" === typeof crossOrigin &&
+      (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
+    preconnectsSet.has(limitedEscapedHref) ||
+      (preconnectsSet.add(limitedEscapedHref),
+      (rel = { rel: rel, crossOrigin: crossOrigin, href: href }),
+      null === ownerDocument.querySelector(limitedEscapedHref) &&
+        ((crossOrigin = ownerDocument.createElement("link")),
+        setInitialProperties(crossOrigin, "link", rel),
+        markNodeAsHoistable(crossOrigin),
+        ownerDocument.head.appendChild(crossOrigin)));
+  }
+}
+function prefetchDNS$1(href) {
+  preconnectAs("dns-prefetch", null, href);
+}
+function preconnect$1(href, options) {
+  preconnectAs(
+    "preconnect",
+    null == options || "string" !== typeof options.crossOrigin
+      ? null
+      : "use-credentials" === options.crossOrigin
+      ? "use-credentials"
+      : "",
+    href
+  );
+}
+function preload$1(href, options) {
+  var ownerDocument = getDocumentForPreloads();
+  if (
+    "string" === typeof href &&
+    href &&
+    "object" === typeof options &&
+    null !== options &&
+    ownerDocument
+  ) {
+    var as = options.as,
+      limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href),
+      key = (limitedEscapedHref =
+        'link[rel="preload"][as="' +
+        as +
+        '"][href="' +
+        limitedEscapedHref +
+        '"]');
+    switch (as) {
+      case "style":
+        key = getStyleKey(href);
+        break;
+      case "script":
+        key = getScriptKey(href);
+    }
+    preloadPropsMap.has(key) ||
+      ((href = {
+        href: href,
+        rel: "preload",
+        as: as,
+        crossOrigin: "font" === as ? "" : options.crossOrigin,
+        integrity: options.integrity,
+        type: options.type
+      }),
+      preloadPropsMap.set(key, href),
+      null === ownerDocument.querySelector(limitedEscapedHref) &&
+        ((options = ownerDocument.createElement("link")),
+        setInitialProperties(options, "link", href),
+        markNodeAsHoistable(options),
+        ownerDocument.head.appendChild(options)));
   }
-  throw Error(formatProdErrorMessage(156, workInProgress.tag));
-};
-function scheduleCallback(priorityLevel, callback) {
-  return scheduleCallback$2(priorityLevel, callback);
-}
-function FiberNode(tag, pendingProps, key, mode) {
-  this.tag = tag;
-  this.key = key;
-  this.sibling =
-    this.child =
-    this.return =
-    this.stateNode =
-    this.type =
-    this.elementType =
-      null;
-  this.index = 0;
-  this.refCleanup = this.ref = null;
-  this.pendingProps = pendingProps;
-  this.dependencies =
-    this.memoizedState =
-    this.updateQueue =
-    this.memoizedProps =
-      null;
-  this.mode = mode;
-  this.subtreeFlags = this.flags = 0;
-  this.deletions = null;
-  this.childLanes = this.lanes = 0;
-  this.alternate = null;
-}
-function createFiber(tag, pendingProps, key, mode) {
-  return new FiberNode(tag, pendingProps, key, mode);
 }
-function shouldConstruct(Component) {
-  Component = Component.prototype;
-  return !(!Component || !Component.isReactComponent);
+function preinit$1(href, options) {
+  if (
+    "string" === typeof href &&
+    href &&
+    "object" === typeof options &&
+    null !== options
+  ) {
+    var resourceRoot = getCurrentResourceRoot(),
+      as = options.as;
+    if (resourceRoot)
+      switch (as) {
+        case "style":
+          as = getResourcesFromRoot(resourceRoot).hoistableStyles;
+          var key$197 = getStyleKey(href),
+            precedence = options.precedence || "default",
+            resource = as.get(key$197);
+          if (resource) break;
+          resource = resourceRoot.querySelector(
+            getStylesheetSelectorFromKey(key$197)
+          );
+          resource ||
+            ((href = {
+              rel: "stylesheet",
+              href: href,
+              "data-precedence": precedence,
+              crossOrigin: options.crossOrigin
+            }),
+            (options = preloadPropsMap.get(key$197)) &&
+              adoptPreloadPropsForStylesheet(href, options),
+            (resource = (
+              resourceRoot.ownerDocument || resourceRoot
+            ).createElement("link")),
+            markNodeAsHoistable(resource),
+            setInitialProperties(resource, "link", href),
+            insertStylesheet(resource, precedence, resourceRoot));
+          resource = { type: "stylesheet", instance: resource, count: 1 };
+          as.set(key$197, resource);
+          break;
+        case "script":
+          (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
+            (key$197 = getScriptKey(href)),
+            (precedence = as.get(key$197)),
+            precedence ||
+              ((precedence = resourceRoot.querySelector(
+                "script[async]" + key$197
+              )),
+              precedence ||
+                ((href = {
+                  src: href,
+                  async: !0,
+                  crossOrigin: options.crossOrigin,
+                  integrity: options.integrity
+                }),
+                (options = preloadPropsMap.get(key$197)) &&
+                  adoptPreloadPropsForScript(href, options),
+                (options = resourceRoot.ownerDocument || resourceRoot),
+                (precedence = options.createElement("script")),
+                markNodeAsHoistable(precedence),
+                setInitialProperties(precedence, "link", href),
+                options.head.appendChild(precedence)),
+              (precedence = { type: "script", instance: precedence, count: 1 }),
+              as.set(key$197, precedence));
+      }
+    else if ("style" === as || "script" === as)
+      if ((resourceRoot = getDocumentForPreloads())) {
+        key$197 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+        precedence = key$197 =
+          'link[rel="preload"][as="' + as + '"][href="' + key$197 + '"]';
+        switch (as) {
+          case "style":
+            precedence = getStyleKey(href);
+            break;
+          case "script":
+            precedence = getScriptKey(href);
+        }
+        preloadPropsMap.has(precedence) ||
+          ((href = {
+            href: href,
+            rel: "preload",
+            as: as,
+            crossOrigin: "font" === as ? "" : options.crossOrigin,
+            integrity: options.integrity
+          }),
+          preloadPropsMap.set(precedence, href),
+          null === resourceRoot.querySelector(key$197) &&
+            ((options = resourceRoot.createElement("link")),
+            setInitialProperties(options, "link", href),
+            markNodeAsHoistable(options),
+            resourceRoot.head.appendChild(options)));
+      }
+  }
 }
-function resolveLazyComponentTag(Component) {
-  if ("function" === typeof Component)
-    return shouldConstruct(Component) ? 1 : 0;
-  if (void 0 !== Component && null !== Component) {
-    Component = Component.$$typeof;
-    if (Component === REACT_FORWARD_REF_TYPE) return 11;
-    if (Component === REACT_MEMO_TYPE) return 14;
+function getResource(type, currentProps, pendingProps) {
+  currentProps = getCurrentResourceRoot();
+  if (!currentProps) throw Error(formatProdErrorMessage(446));
+  switch (type) {
+    case "meta":
+    case "title":
+      return null;
+    case "style":
+      return "string" === typeof pendingProps.precedence &&
+        "string" === typeof pendingProps.href
+        ? ((pendingProps = getStyleKey(pendingProps.href)),
+          (currentProps = getResourcesFromRoot(currentProps).hoistableStyles),
+          (type = currentProps.get(pendingProps)),
+          type ||
+            ((type = { type: "style", instance: null, count: 0 }),
+            currentProps.set(pendingProps, type)),
+          type)
+        : { type: "void", instance: null, count: 0 };
+    case "link":
+      if (
+        "stylesheet" === pendingProps.rel &&
+        "string" === typeof pendingProps.href &&
+        "string" === typeof pendingProps.precedence
+      ) {
+        var key$204 = getStyleKey(pendingProps.href),
+          styles$205 = getResourcesFromRoot(currentProps).hoistableStyles;
+        type = styles$205.get(key$204);
+        type ||
+          ((currentProps = currentProps.ownerDocument || currentProps),
+          (type = { type: "stylesheet", instance: null, count: 0 }),
+          styles$205.set(key$204, type),
+          preloadPropsMap.has(key$204) ||
+            ((pendingProps = {
+              rel: "preload",
+              as: "style",
+              href: pendingProps.href,
+              crossOrigin: pendingProps.crossOrigin,
+              integrity: pendingProps.integrity,
+              media: pendingProps.media,
+              hrefLang: pendingProps.hrefLang,
+              referrerPolicy: pendingProps.referrerPolicy
+            }),
+            preloadPropsMap.set(key$204, pendingProps),
+            currentProps.querySelector(getStylesheetSelectorFromKey(key$204)) ||
+              null !==
+                currentProps.querySelector(
+                  'link[rel="preload"][as="style"][' + key$204 + "]"
+                ) ||
+              ((key$204 = currentProps.createElement("link")),
+              setInitialProperties(key$204, "link", pendingProps),
+              markNodeAsHoistable(key$204),
+              currentProps.head.appendChild(key$204))));
+        return type;
+      }
+      return null;
+    case "script":
+      return "string" === typeof pendingProps.src && !0 === pendingProps.async
+        ? ((pendingProps = getScriptKey(pendingProps.src)),
+          (currentProps = getResourcesFromRoot(currentProps).hoistableScripts),
+          (type = currentProps.get(pendingProps)),
+          type ||
+            ((type = { type: "script", instance: null, count: 0 }),
+            currentProps.set(pendingProps, type)),
+          type)
+        : { type: "void", instance: null, count: 0 };
+    default:
+      throw Error(formatProdErrorMessage(444, type));
   }
-  return 2;
 }
-function createWorkInProgress(current, pendingProps) {
-  var workInProgress = current.alternate;
-  null === workInProgress
-    ? ((workInProgress = createFiber(
-        current.tag,
-        pendingProps,
-        current.key,
-        current.mode
-      )),
-      (workInProgress.elementType = current.elementType),
-      (workInProgress.type = current.type),
-      (workInProgress.stateNode = current.stateNode),
-      (workInProgress.alternate = current),
-      (current.alternate = workInProgress))
-    : ((workInProgress.pendingProps = pendingProps),
-      (workInProgress.type = current.type),
-      (workInProgress.flags = 0),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null));
-  workInProgress.flags = current.flags & 14680064;
-  workInProgress.childLanes = current.childLanes;
-  workInProgress.lanes = current.lanes;
-  workInProgress.child = current.child;
-  workInProgress.memoizedProps = current.memoizedProps;
-  workInProgress.memoizedState = current.memoizedState;
-  workInProgress.updateQueue = current.updateQueue;
-  pendingProps = current.dependencies;
-  workInProgress.dependencies =
-    null === pendingProps
-      ? null
-      : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
-  workInProgress.sibling = current.sibling;
-  workInProgress.index = current.index;
-  workInProgress.ref = current.ref;
-  workInProgress.refCleanup = current.refCleanup;
-  return workInProgress;
+function getStyleKey(href) {
+  return 'href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
 }
-function resetWorkInProgress(workInProgress, renderLanes) {
-  workInProgress.flags &= 14680066;
-  var current = workInProgress.alternate;
-  null === current
-    ? ((workInProgress.childLanes = 0),
-      (workInProgress.lanes = renderLanes),
-      (workInProgress.child = null),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.memoizedProps = null),
-      (workInProgress.memoizedState = null),
-      (workInProgress.updateQueue = null),
-      (workInProgress.dependencies = null),
-      (workInProgress.stateNode = null))
-    : ((workInProgress.childLanes = current.childLanes),
-      (workInProgress.lanes = current.lanes),
-      (workInProgress.child = current.child),
-      (workInProgress.subtreeFlags = 0),
-      (workInProgress.deletions = null),
-      (workInProgress.memoizedProps = current.memoizedProps),
-      (workInProgress.memoizedState = current.memoizedState),
-      (workInProgress.updateQueue = current.updateQueue),
-      (workInProgress.type = current.type),
-      (renderLanes = current.dependencies),
-      (workInProgress.dependencies =
-        null === renderLanes
-          ? null
-          : {
-              lanes: renderLanes.lanes,
-              firstContext: renderLanes.firstContext
-            }));
-  return workInProgress;
+function getStylesheetSelectorFromKey(key) {
+  return 'link[rel="stylesheet"][' + key + "]";
+}
+function getScriptKey(src) {
+  return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
 }
-function createFiberFromTypeAndProps(
-  type,
-  key,
-  pendingProps,
-  owner,
-  mode,
-  lanes
-) {
-  var fiberTag = 2;
-  owner = type;
-  if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
-  else if ("string" === typeof type)
-    fiberTag = isHostHoistableType(
-      type,
-      pendingProps,
-      contextStackCursor.current
-    )
-      ? 26
-      : "html" === type || "head" === type || "body" === type
-      ? 27
-      : 5;
-  else
-    a: switch (type) {
-      case REACT_FRAGMENT_TYPE:
-        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
-      case REACT_STRICT_MODE_TYPE:
-        fiberTag = 8;
-        mode |= 8;
-        0 !== (mode & 1) && (mode |= 16);
-        break;
-      case REACT_PROFILER_TYPE:
-        return (
-          (type = createFiber(12, pendingProps, key, mode | 2)),
-          (type.elementType = REACT_PROFILER_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_TYPE:
-        return (
-          (type = createFiber(13, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_SUSPENSE_LIST_TYPE:
-        return (
-          (type = createFiber(19, pendingProps, key, mode)),
-          (type.elementType = REACT_SUSPENSE_LIST_TYPE),
-          (type.lanes = lanes),
-          type
-        );
-      case REACT_OFFSCREEN_TYPE:
-        return createFiberFromOffscreen(pendingProps, mode, lanes, key);
-      case REACT_LEGACY_HIDDEN_TYPE:
-        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
-      case REACT_SCOPE_TYPE:
-        return (
-          (pendingProps = createFiber(21, pendingProps, key, mode)),
-          (pendingProps.type = type),
-          (pendingProps.elementType = type),
-          (pendingProps.lanes = lanes),
-          pendingProps
+function acquireResource(hoistableRoot, resource, props) {
+  resource.count++;
+  if (null === resource.instance)
+    switch (resource.type) {
+      case "style":
+        var key = getStyleKey(props.href);
+        if ((key = hoistableRoot.querySelector("style[data-" + key + "]")))
+          return (resource.instance = key), markNodeAsHoistable(key), key;
+        var styleProps = assign({}, props, {
+          "data-href": props.href,
+          "data-precedence": props.precedence,
+          href: null,
+          precedence: null
+        });
+        key = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
+          "style"
         );
-      case REACT_CACHE_TYPE:
-        return (
-          (type = createFiber(24, pendingProps, key, mode)),
-          (type.elementType = REACT_CACHE_TYPE),
-          (type.lanes = lanes),
-          type
+        markNodeAsHoistable(key);
+        setInitialProperties(key, "style", styleProps);
+        insertStylesheet(key, props.precedence, hoistableRoot);
+        return (resource.instance = key);
+      case "stylesheet":
+        styleProps = getStyleKey(props.href);
+        var instance$211 = hoistableRoot.querySelector(
+          getStylesheetSelectorFromKey(styleProps)
         );
-      case REACT_TRACING_MARKER_TYPE:
-        if (enableTransitionTracing)
+        if (instance$211)
           return (
-            (type = createFiber(25, pendingProps, key, mode)),
-            (type.elementType = REACT_TRACING_MARKER_TYPE),
-            (type.lanes = lanes),
-            (type.stateNode = {
-              tag: 1,
-              transitions: null,
-              pendingBoundaries: null,
-              aborts: null,
-              name: pendingProps.name
-            }),
-            type
+            (resource.instance = instance$211),
+            markNodeAsHoistable(instance$211),
+            instance$211
           );
-      case REACT_DEBUG_TRACING_MODE_TYPE:
-        if (enableDebugTracing) {
-          fiberTag = 8;
-          mode |= 4;
-          break;
-        }
-      default:
-        if ("object" === typeof type && null !== type)
-          switch (type.$$typeof) {
-            case REACT_PROVIDER_TYPE:
-              fiberTag = 10;
-              break a;
-            case REACT_CONTEXT_TYPE:
-              fiberTag = 9;
-              break a;
-            case REACT_FORWARD_REF_TYPE:
-              fiberTag = 11;
-              break a;
-            case REACT_MEMO_TYPE:
-              fiberTag = 14;
-              break a;
-            case REACT_LAZY_TYPE:
-              fiberTag = 16;
-              owner = null;
-              break a;
+        key = assign({}, props, {
+          "data-precedence": props.precedence,
+          precedence: null
+        });
+        (styleProps = preloadPropsMap.get(styleProps)) &&
+          adoptPreloadPropsForStylesheet(key, styleProps);
+        instance$211 = (
+          hoistableRoot.ownerDocument || hoistableRoot
+        ).createElement("link");
+        markNodeAsHoistable(instance$211);
+        var linkInstance = instance$211;
+        linkInstance._p = new Promise(function (resolve, reject) {
+          linkInstance.onload = resolve;
+          linkInstance.onerror = reject;
+        }).then(
+          function () {
+            return (linkInstance._p.s = "l");
+          },
+          function () {
+            return (linkInstance._p.s = "e");
           }
-        throw Error(
-          formatProdErrorMessage(130, null == type ? type : typeof type, "")
         );
+        setInitialProperties(instance$211, "link", key);
+        insertStylesheet(instance$211, props.precedence, hoistableRoot);
+        return (resource.instance = instance$211);
+      case "script":
+        instance$211 = getScriptKey(props.src);
+        if (
+          (styleProps = hoistableRoot.querySelector(
+            "script[async]" + instance$211
+          ))
+        )
+          return (
+            (resource.instance = styleProps),
+            markNodeAsHoistable(styleProps),
+            styleProps
+          );
+        key = props;
+        if ((styleProps = preloadPropsMap.get(instance$211)))
+          (key = assign({}, props)),
+            adoptPreloadPropsForScript(key, styleProps);
+        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+        styleProps = hoistableRoot.createElement("script");
+        markNodeAsHoistable(styleProps);
+        setInitialProperties(styleProps, "link", key);
+        hoistableRoot.head.appendChild(styleProps);
+        return (resource.instance = styleProps);
+      case "void":
+        return null;
+      default:
+        throw Error(formatProdErrorMessage(443, resource.type));
     }
-  pendingProps = createFiber(fiberTag, pendingProps, key, mode);
-  pendingProps.elementType = type;
-  pendingProps.type = owner;
-  pendingProps.lanes = lanes;
-  return pendingProps;
+  return resource.instance;
 }
-function createFiberFromFragment(elements, mode, lanes, key) {
-  elements = createFiber(7, elements, key, mode);
-  elements.lanes = lanes;
-  return elements;
+function insertStylesheet(instance, precedence, root) {
+  for (
+    var nodes = root.querySelectorAll(
+        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
+      ),
+      last = nodes.length ? nodes[nodes.length - 1] : null,
+      prior = last,
+      i = 0;
+    i < nodes.length;
+    i++
+  ) {
+    var node = nodes[i];
+    if (node.dataset.precedence === precedence) prior = node;
+    else if (prior !== last) break;
+  }
+  prior
+    ? prior.parentNode.insertBefore(instance, prior.nextSibling)
+    : ((precedence = 9 === root.nodeType ? root.head : root),
+      precedence.insertBefore(instance, precedence.firstChild));
 }
-function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(22, pendingProps, key, mode);
-  pendingProps.elementType = REACT_OFFSCREEN_TYPE;
-  pendingProps.lanes = lanes;
-  var primaryChildInstance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _retryCache: null,
-    _transitions: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(primaryChildInstance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(primaryChildInstance);
+function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+  null == stylesheetProps.crossOrigin &&
+    (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
+  null == stylesheetProps.referrerPolicy &&
+    (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
+  null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
+}
+function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+  null == scriptProps.crossOrigin &&
+    (scriptProps.crossOrigin = preloadProps.crossOrigin);
+  null == scriptProps.referrerPolicy &&
+    (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
+  null == scriptProps.integrity &&
+    (scriptProps.referrerPolicy = preloadProps.integrity);
+}
+var tagCaches = null;
+function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+  if (null === tagCaches) {
+    var cache = new Map();
+    var caches = (tagCaches = new Map());
+    caches.set(ownerDocument, cache);
+  } else
+    (caches = tagCaches),
+      (cache = caches.get(ownerDocument)),
+      cache || ((cache = new Map()), caches.set(ownerDocument, cache));
+  if (cache.has(type)) return cache;
+  cache.set(type, null);
+  ownerDocument = ownerDocument.getElementsByTagName(type);
+  for (caches = 0; caches < ownerDocument.length; caches++) {
+    var node = ownerDocument[caches];
+    if (
+      !(
+        node[internalHoistableMarker] ||
+        node[internalInstanceKey] ||
+        ("link" === type && "stylesheet" === node.getAttribute("rel"))
+      ) &&
+      "http://www.w3.org/2000/svg" !== node.namespaceURI
+    ) {
+      var nodeKey = node.getAttribute(keyAttribute) || "";
+      nodeKey = type + nodeKey;
+      var existing = cache.get(nodeKey);
+      existing ? existing.push(node) : cache.set(nodeKey, [node]);
     }
-  };
-  pendingProps.stateNode = primaryChildInstance;
-  return pendingProps;
+  }
+  return cache;
 }
-function createFiberFromLegacyHidden(pendingProps, mode, lanes, key) {
-  pendingProps = createFiber(23, pendingProps, key, mode);
-  pendingProps.elementType = REACT_LEGACY_HIDDEN_TYPE;
-  pendingProps.lanes = lanes;
-  var instance = {
-    _visibility: 1,
-    _pendingVisibility: 1,
-    _pendingMarkers: null,
-    _transitions: null,
-    _retryCache: null,
-    _current: null,
-    detach: function () {
-      return detachOffscreenInstance(instance);
-    },
-    attach: function () {
-      return attachOffscreenInstance(instance);
+function mountHoistable(hoistableRoot, type, instance) {
+  hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+  hoistableRoot.head.insertBefore(
+    instance,
+    "title" === type ? hoistableRoot.querySelector("head > title") : null
+  );
+}
+var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
+function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
+  return value.replace(
+    escapeSelectorAttributeValueInsideDoubleQuotesRegex,
+    function (ch) {
+      return "\\" + ch.charCodeAt(0).toString(16);
     }
-  };
-  pendingProps.stateNode = instance;
-  return pendingProps;
+  );
 }
-function createFiberFromText(content, mode, lanes) {
-  content = createFiber(6, content, null, mode);
-  content.lanes = lanes;
-  return content;
+var eventsEnabled = null,
+  selectionInformation = null;
+function beforeActiveInstanceBlur(internalInstanceHandle) {
+  _enabled = !0;
+  var target = selectionInformation.focusedElem,
+    event = createEvent("beforeblur", !0);
+  event._detachedInterceptFiber = internalInstanceHandle;
+  target.dispatchEvent(event);
+  _enabled = !1;
 }
-function createFiberFromPortal(portal, mode, lanes) {
-  mode = createFiber(
-    4,
-    null !== portal.children ? portal.children : [],
-    portal.key,
-    mode
+function shouldSetTextContent(type, props) {
+  return (
+    "textarea" === type ||
+    "noscript" === type ||
+    "string" === typeof props.children ||
+    "number" === typeof props.children ||
+    ("object" === typeof props.dangerouslySetInnerHTML &&
+      null !== props.dangerouslySetInnerHTML &&
+      null != props.dangerouslySetInnerHTML.__html)
   );
-  mode.lanes = lanes;
-  mode.stateNode = {
-    containerInfo: portal.containerInfo,
-    pendingChildren: null,
-    implementation: portal.implementation
-  };
-  return mode;
 }
-function FiberRootNode(
-  containerInfo,
-  tag,
-  hydrate,
-  identifierPrefix,
-  onRecoverableError
-) {
-  this.tag = tag;
-  this.containerInfo = containerInfo;
-  this.finishedWork =
-    this.pingCache =
-    this.current =
-    this.pendingChildren =
-      null;
-  this.timeoutHandle = -1;
-  this.callbackNode = this.pendingContext = this.context = null;
-  this.callbackPriority = 0;
-  this.eventTimes = createLaneMap(0);
-  this.expirationTimes = createLaneMap(-1);
-  this.entangledLanes =
-    this.errorRecoveryDisabledLanes =
-    this.finishedLanes =
-    this.mutableReadLanes =
-    this.expiredLanes =
-    this.pingedLanes =
-    this.suspendedLanes =
-    this.pendingLanes =
-      0;
-  this.entanglements = createLaneMap(0);
-  this.hiddenUpdates = createLaneMap(null);
-  this.identifierPrefix = identifierPrefix;
-  this.onRecoverableError = onRecoverableError;
-  this.pooledCache = null;
-  this.pooledCacheLanes = 0;
-  this.hydrationCallbacks = this.mutableSourceEagerHydrationData = null;
-  this.incompleteTransitions = new Map();
-  if (enableTransitionTracing)
-    for (
-      this.transitionCallbacks = null,
-        containerInfo = this.transitionLanes = [],
-        tag = 0;
-      31 > tag;
-      tag++
-    )
-      containerInfo.push(null);
+var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
+  cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
+  localPromise = "function" === typeof Promise ? Promise : void 0,
+  localRequestAnimationFrame =
+    "function" === typeof requestAnimationFrame
+      ? requestAnimationFrame
+      : scheduleTimeout;
+function getInstanceFromScope(scopeInstance) {
+  scopeInstance = scopeInstance[internalInstanceKey] || null;
+  return scopeInstance;
+}
+var scheduleMicrotask =
+  "function" === typeof queueMicrotask
+    ? queueMicrotask
+    : "undefined" !== typeof localPromise
+    ? function (callback) {
+        return localPromise
+          .resolve(null)
+          .then(callback)
+          .catch(handleErrorInNextTick);
+      }
+    : scheduleTimeout;
+function handleErrorInNextTick(error) {
+  setTimeout(function () {
+    throw error;
+  });
+}
+function createEvent(type, bubbles) {
+  var event = document.createEvent("Event");
+  event.initEvent(type, bubbles, !1);
+  return event;
+}
+function dispatchAfterDetachedBlur(target) {
+  var event = createEvent("afterblur", !1);
+  event.relatedTarget = target;
+  document.dispatchEvent(event);
+}
+function clearSuspenseBoundary(parentInstance, suspenseInstance) {
+  var node = suspenseInstance,
+    depth = 0;
+  do {
+    var nextNode = node.nextSibling;
+    parentInstance.removeChild(node);
+    if (nextNode && 8 === nextNode.nodeType)
+      if (((node = nextNode.data), "/$" === node)) {
+        if (0 === depth) {
+          parentInstance.removeChild(nextNode);
+          retryIfBlockedOn(suspenseInstance);
+          return;
+        }
+        depth--;
+      } else ("$" !== node && "$?" !== node && "$!" !== node) || depth++;
+    node = nextNode;
+  } while (node);
+  retryIfBlockedOn(suspenseInstance);
+}
+function clearContainerSparingly(container) {
+  var nextNode = container.firstChild;
+  nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
+  for (; nextNode; ) {
+    var node = nextNode;
+    nextNode = nextNode.nextSibling;
+    switch (node.nodeName) {
+      case "HTML":
+      case "HEAD":
+      case "BODY":
+        clearContainerSparingly(node);
+        detachDeletedInstance(node);
+        continue;
+      case "STYLE":
+        continue;
+      case "LINK":
+        if ("stylesheet" === node.rel.toLowerCase()) continue;
+    }
+    container.removeChild(node);
+  }
+}
+function shouldSkipHydratableForInstance(instance, type, props) {
+  if (1 !== instance.nodeType) return !1;
+  if (
+    instance.nodeName.toLowerCase() !== type.toLowerCase() ||
+    instance[internalHoistableMarker]
+  )
+    return !0;
+  switch (type) {
+    case "meta":
+      if (!instance.hasAttribute("itemprop")) return !0;
+      break;
+    case "link":
+      type = instance.getAttribute("rel");
+      if (
+        ("stylesheet" === type && instance.hasAttribute("data-precedence")) ||
+        type !== props.rel ||
+        instance.getAttribute("href") !==
+          (null == props.href ? null : props.href) ||
+        instance.getAttribute("crossorigin") !==
+          (null == props.crossOrigin ? null : props.crossOrigin) ||
+        instance.getAttribute("title") !==
+          (null == props.title ? null : props.title)
+      )
+        return !0;
+      break;
+    case "style":
+      if (instance.hasAttribute("data-precedence")) return !0;
+      break;
+    case "script":
+      if (
+        ((type = instance.getAttribute("src")) &&
+          instance.hasAttribute("async") &&
+          !instance.hasAttribute("itemprop")) ||
+        type !== (null == props.src ? null : props.src) ||
+        instance.getAttribute("type") !==
+          (null == props.type ? null : props.type) ||
+        instance.getAttribute("crossorigin") !==
+          (null == props.crossOrigin ? null : props.crossOrigin)
+      )
+        return !0;
+  }
+  return !1;
+}
+function getNextHydratable(node) {
+  for (; null != node; node = node.nextSibling) {
+    var nodeType = node.nodeType;
+    if (1 === nodeType || 3 === nodeType) break;
+    if (8 === nodeType) {
+      nodeType = node.data;
+      if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType) break;
+      if ("/$" === nodeType) return null;
+    }
+  }
+  return node;
+}
+function getParentSuspenseInstance(targetInstance) {
+  targetInstance = targetInstance.previousSibling;
+  for (var depth = 0; targetInstance; ) {
+    if (8 === targetInstance.nodeType) {
+      var data = targetInstance.data;
+      if ("$" === data || "$!" === data || "$?" === data) {
+        if (0 === depth) return targetInstance;
+        depth--;
+      } else "/$" === data && depth++;
+    }
+    targetInstance = targetInstance.previousSibling;
+  }
+  return null;
 }
-function createFiberRoot(
-  containerInfo,
-  tag,
-  hydrate,
-  initialChildren,
-  hydrationCallbacks,
-  isStrictMode,
-  concurrentUpdatesByDefaultOverride,
-  identifierPrefix,
-  onRecoverableError,
-  transitionCallbacks
-) {
-  containerInfo = new FiberRootNode(
-    containerInfo,
-    tag,
-    hydrate,
-    identifierPrefix,
-    onRecoverableError
-  );
-  containerInfo.hydrationCallbacks = hydrationCallbacks;
-  enableTransitionTracing &&
-    (containerInfo.transitionCallbacks = transitionCallbacks);
-  1 === tag
-    ? ((tag = 1),
-      !0 === isStrictMode && (tag |= 24),
-      concurrentUpdatesByDefaultOverride && (tag |= 32))
-    : (tag = 0);
-  isStrictMode = createFiber(3, null, null, tag);
-  containerInfo.current = isStrictMode;
-  isStrictMode.stateNode = containerInfo;
-  concurrentUpdatesByDefaultOverride = createCache();
-  concurrentUpdatesByDefaultOverride.refCount++;
-  containerInfo.pooledCache = concurrentUpdatesByDefaultOverride;
-  concurrentUpdatesByDefaultOverride.refCount++;
-  isStrictMode.memoizedState = {
-    element: initialChildren,
-    isDehydrated: hydrate,
-    cache: concurrentUpdatesByDefaultOverride
-  };
-  initializeUpdateQueue(isStrictMode);
-  return containerInfo;
+function getBoundingRect(node) {
+  node = node.getBoundingClientRect();
+  return { x: node.left, y: node.top, width: node.width, height: node.height };
 }
-function createPortal$1(children, containerInfo, implementation) {
-  var key =
-    3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+function isHiddenSubtree(fiber) {
+  return 5 === fiber.tag && !0 === fiber.memoizedProps.hidden;
+}
+function setFocusIfFocusable(node) {
+  function handleFocus() {
+    didFocus = !0;
+  }
+  var didFocus = !1;
+  try {
+    node.addEventListener("focus", handleFocus),
+      (node.focus || HTMLElement.prototype.focus).call(node);
+  } finally {
+    node.removeEventListener("focus", handleFocus);
+  }
+  return didFocus;
+}
+function setupIntersectionObserver(targets, callback, options) {
+  var rectRatioCache = new Map();
+  targets.forEach(function (target) {
+    rectRatioCache.set(target, { rect: getBoundingRect(target), ratio: 0 });
+  });
+  var observer = new IntersectionObserver(function (entries) {
+    entries.forEach(function (entry) {
+      var boundingClientRect = entry.boundingClientRect;
+      rectRatioCache.set(entry.target, {
+        rect: {
+          x: boundingClientRect.left,
+          y: boundingClientRect.top,
+          width: boundingClientRect.width,
+          height: boundingClientRect.height
+        },
+        ratio: entry.intersectionRatio
+      });
+    });
+    callback(Array.from(rectRatioCache.values()));
+  }, options);
+  targets.forEach(function (target) {
+    observer.observe(target);
+  });
   return {
-    $$typeof: REACT_PORTAL_TYPE,
-    key: null == key ? null : "" + key,
-    children: children,
-    containerInfo: containerInfo,
-    implementation: implementation
+    disconnect: function () {
+      return observer.disconnect();
+    },
+    observe: function (target) {
+      rectRatioCache.set(target, { rect: getBoundingRect(target), ratio: 0 });
+      observer.observe(target);
+    },
+    unobserve: function (target) {
+      rectRatioCache.delete(target);
+      observer.unobserve(target);
+    }
   };
 }
-function updateContainer(element, container, parentComponent, callback) {
-  parentComponent = container.current;
-  var lane = requestUpdateLane(parentComponent);
-  null === container.context
-    ? (container.context = emptyContextObject)
-    : (container.pendingContext = emptyContextObject);
-  container = createUpdate(lane);
-  container.payload = { element: element };
-  callback = void 0 === callback ? null : callback;
-  null !== callback && (container.callback = callback);
-  element = enqueueUpdate(parentComponent, container, lane);
-  null !== element &&
-    ((callback = requestEventTime()),
-    scheduleUpdateOnFiber(element, parentComponent, lane, callback),
-    entangleTransitions(element, parentComponent, lane));
-  return lane;
+function requestPostPaintCallback(callback) {
+  localRequestAnimationFrame(function () {
+    localRequestAnimationFrame(function (time) {
+      return callback(time);
+    });
+  });
 }
-function markRetryLaneImpl(fiber, retryLane) {
-  fiber = fiber.memoizedState;
-  if (null !== fiber && null !== fiber.dehydrated) {
-    var a = fiber.retryLane;
-    fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+function isHostHoistableType(type, props, hostContext) {
+  if ("http://www.w3.org/2000/svg" === hostContext || null != props.itemProp)
+    return !1;
+  switch (type) {
+    case "meta":
+    case "title":
+      return !0;
+    case "style":
+      if (
+        "string" !== typeof props.precedence ||
+        "string" !== typeof props.href ||
+        "" === props.href
+      )
+        break;
+      return !0;
+    case "link":
+      if (
+        "string" !== typeof props.rel ||
+        "string" !== typeof props.href ||
+        "" === props.href ||
+        props.onLoad ||
+        props.onError
+      )
+        break;
+      switch (props.rel) {
+        case "stylesheet":
+          return (
+            (type = props.disabled),
+            "string" === typeof props.precedence && null == type
+          );
+        default:
+          return !0;
+      }
+    case "script":
+      if (
+        !0 === props.async &&
+        !props.onLoad &&
+        !props.onError &&
+        "string" === typeof props.src &&
+        props.src
+      )
+        return !0;
   }
+  return !1;
 }
-function markRetryLaneIfNotHydrated(fiber, retryLane) {
-  markRetryLaneImpl(fiber, retryLane);
-  (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
-}
-function emptyFindFiberByHostInstance() {
-  return null;
+function resolveSingletonInstance(type, props, rootContainerInstance) {
+  props = getOwnerDocumentFromRootContainer(rootContainerInstance);
+  switch (type) {
+    case "html":
+      type = props.documentElement;
+      if (!type) throw Error(formatProdErrorMessage(452));
+      return type;
+    case "head":
+      type = props.head;
+      if (!type) throw Error(formatProdErrorMessage(453));
+      return type;
+    case "body":
+      type = props.body;
+      if (!type) throw Error(formatProdErrorMessage(454));
+      return type;
+    default:
+      throw Error(formatProdErrorMessage(451));
+  }
 }
 var Dispatcher = Internals.Dispatcher,
   defaultOnRecoverableError =
@@ -15489,7 +15555,7 @@ function ReactDOMHydrationRoot(internalRoot) {
 }
 ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
   if (target) {
-    var updatePriority = getCurrentUpdatePriority();
+    var updatePriority = currentUpdatePriority;
     target = { blockedOn: null, target: target, priority: updatePriority };
     for (
       var i = 0;
@@ -15533,115 +15599,25 @@ function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
         listenerSet.add(listenerSetKey));
     } else throw Error(formatProdErrorMessage(369));
 }
-_attemptSynchronousHydration = function (fiber) {
-  switch (fiber.tag) {
-    case 3:
-      var root$224 = fiber.stateNode;
-      if (root$224.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$224.pendingLanes);
-        0 !== lanes &&
-          (markRootEntangled(root$224, lanes | 2),
-          ensureRootIsScheduled(root$224, now()),
-          0 === (executionContext & 6) &&
-            (resetRenderTimer(), flushSyncCallbacks()));
-      }
-      break;
-    case 13:
-      flushSync$1(function () {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        if (null !== root) {
-          var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-        }
-      }),
-        markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptDiscreteHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 2);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 2, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 2);
-  }
-};
-attemptContinuousHydration$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var root = enqueueConcurrentRenderForLane(fiber, 134217728);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, 134217728, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, 134217728);
-  }
-};
-attemptHydrationAtCurrentPriority$1 = function (fiber) {
-  if (13 === fiber.tag) {
-    var lane = requestUpdateLane(fiber),
-      root = enqueueConcurrentRenderForLane(fiber, lane);
-    if (null !== root) {
-      var eventTime = requestEventTime();
-      scheduleUpdateOnFiber(root, fiber, lane, eventTime);
-    }
-    markRetryLaneIfNotHydrated(fiber, lane);
-  }
-};
-getCurrentUpdatePriority = function () {
-  return currentUpdatePriority;
-};
-attemptHydrationAtPriority = runWithPriority;
-restoreImpl = function (domElement, tag, props) {
-  switch (tag) {
-    case "input":
-      updateWrapper$1(domElement, props);
-      tag = props.name;
-      if ("radio" === props.type && null != tag) {
-        for (props = domElement; props.parentNode; ) props = props.parentNode;
-        props = props.querySelectorAll(
-          "input[name=" + JSON.stringify("" + tag) + '][type="radio"]'
-        );
-        for (tag = 0; tag < props.length; tag++) {
-          var otherNode = props[tag];
-          if (otherNode !== domElement && otherNode.form === domElement.form) {
-            var otherProps = getFiberCurrentPropsFromNode(otherNode);
-            if (!otherProps) throw Error(formatProdErrorMessage(90));
-            updateValueIfChanged(otherNode);
-            updateWrapper$1(otherNode, otherProps);
-          }
-        }
-      }
-      break;
-    case "textarea":
-      updateWrapper(domElement, props);
-      break;
-    case "select":
-      (tag = props.value),
-        null != tag && updateOptions(domElement, !!props.multiple, tag, !1);
-  }
-};
-batchedUpdatesImpl = batchedUpdates;
-flushSyncImpl = flushSync$1;
 Internals.Events = [
   getInstanceFromNode$1,
   getNodeFromInstance,
   getFiberCurrentPropsFromNode,
   enqueueStateRestore,
   restoreStateIfNeeded,
-  batchedUpdates
+  batchedUpdates$1
 ];
-var devToolsConfig$jscomp$inline_1749 = {
+var devToolsConfig$jscomp$inline_1738 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-modern-9bafe2f6",
+  version: "18.3.0-www-modern-addde25e",
   rendererPackageName: "react-dom"
 };
 var internals$jscomp$inline_2149 = {
-  bundleType: devToolsConfig$jscomp$inline_1749.bundleType,
-  version: devToolsConfig$jscomp$inline_1749.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1749.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1749.rendererConfig,
+  bundleType: devToolsConfig$jscomp$inline_1738.bundleType,
+  version: devToolsConfig$jscomp$inline_1738.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1738.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1738.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -15658,14 +15634,14 @@ var internals$jscomp$inline_2149 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1749.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1738.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-modern-9bafe2f6"
+  reconcilerVersion: "18.3.0-www-modern-addde25e"
 };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
   var hook$jscomp$inline_2150 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
@@ -15954,7 +15930,7 @@ exports.preload = function () {
   var dispatcher = Internals.Dispatcher.current;
   dispatcher && dispatcher.preload.apply(this, arguments);
 };
-exports.unstable_batchedUpdates = batchedUpdates;
+exports.unstable_batchedUpdates = batchedUpdates$1;
 exports.unstable_createEventHandle = function (type, options) {
   function eventHandle(target, callback) {
     if ("function" !== typeof callback)
@@ -15987,18 +15963,18 @@ exports.unstable_createEventHandle = function (type, options) {
 exports.unstable_flushControlled = function (fn) {
   var prevExecutionContext = executionContext;
   executionContext |= 1;
-  var prevTransition = ReactCurrentBatchConfig.transition,
+  var prevTransition = ReactCurrentBatchConfig$1.transition,
     previousPriority = currentUpdatePriority;
   try {
-    (ReactCurrentBatchConfig.transition = null),
+    (ReactCurrentBatchConfig$1.transition = null),
       (currentUpdatePriority = 2),
       fn();
   } finally {
     (currentUpdatePriority = previousPriority),
-      (ReactCurrentBatchConfig.transition = prevTransition),
+      (ReactCurrentBatchConfig$1.transition = prevTransition),
       (executionContext = prevExecutionContext),
       0 === executionContext && (resetRenderTimer(), flushSyncCallbacks());
   }
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-modern-9bafe2f6";
+exports.version = "18.3.0-www-modern-addde25e";
diff --git a/compiled/facebook-www/ReactTestRenderer-dev.modern.js b/compiled/facebook-www/ReactTestRenderer-dev.modern.js
index 44e08c2c5a916..543dd5262465d 100644
--- a/compiled/facebook-www/ReactTestRenderer-dev.modern.js
+++ b/compiled/facebook-www/ReactTestRenderer-dev.modern.js
@@ -23947,7 +23947,7 @@ function createFiberRoot(
   return root;
 }
 
-var ReactVersion = "18.3.0-www-modern-9bafe2f6";
+var ReactVersion = "18.3.0-www-modern-addde25e";
 
 // Might add PROFILE later.